Reorganizar la string dada para maximizar la ocurrencia de la string t

Dadas dos strings binarias s y t . La tarea es reorganizar la string s de tal manera que la aparición de la string t como una substring en s sea máxima.

Ejemplos:

Entrada: s = “101101”, t = “110”
Salida: 110110

Entrada: s = “10”, t = “11100”
Salida: 10

Entrada: s = “11000100”, t = “101”
Salida: 10101000

Enfoque: si no podemos hacer ninguna aparición de la string t en la string s , genere cualquier permutación de s . De lo contrario, comience la string reorganizada con t . Ahora haremos que la siguiente ocurrencia de la string t en la string s sea lo más izquierda posible para maximizar el conteo de ocurrencias. Para lograr esto buscaremos el mayor sufijo de la string t que coincida con el prefijo de la string t
de la misma longitud. Se puede encontrar por función de prefijo, función Z o hashes.

A continuación se muestra la implementación del enfoque anterior:

# Python3 implementation of the approach 
from collections import defaultdict
  
# Function to return the length of maximum 
# proper suffix which is also proper prefix
def Prefix_Array(t):
    m = len(t)
    arr =[-1]*m
    k =-1
    for i in range(1, m):
        while k>-1 and t[k + 1]!= t[i]:
            k = arr[k]
        if t[k + 1]== t[i]:
            k+= 1
        arr[i]= k
    return arr[-1]
  
# Function to return the rearranged string
def Rearranged(ds, dt):
    check = Prefix_Array(t)
  
    # If there is no proper suffix which is 
    # also a proper prefix
    if check ==-1:
        if ds['1']<dt['1'] or ds['0']<dt['0']:
            return s
  
        # If count of 1's in string t is 0
        if dt['1']== 0 and ds['0']!= 0:
            n = ds['0']//dt['0']
            temp = t * n
            ds['0']-= n * dt['0']
            while ds['1']>0:
                temp+='1'
                ds['1']-= 1
            while ds['0']>0:
                temp+='0'
                ds['0']-= 1
  
            # Return the rearranged string
            return temp
  
        # If count of 0's in string t is 0 
        if dt['0']== 0 and ds['1']!= 0:
            n = ds['1']//dt['1']
            temp = t * n
            ds['1']-= n * dt['1']
            while ds['1']>0:
                temp+='1'
                ds['1']-= 1
            while ds['0']>0:
                temp+='0'
                ds['0']-= 1
                  
            # Return the rearranged string
            return temp
              
        # If both 1's and 0's are present in
        # string t
        m1 = ds['1']//dt['1']
        m2 = ds['0']//dt['0']
        n = min(m1, m2)
        temp = t * n
        ds['1']-= n * dt['1']
        ds['0']-= n * dt['0']
        while ds['1']>0:
            temp+='1'
            ds['1']-= 1
        while ds['0']>0:
                temp+='0'
                ds['0']-= 1
        return temp
  
    # If there is a suffix which is 
    # also a prefix in string t
    else:
        if ds['1']<dt['1'] or ds['0']<dt['0']:
            return s
  
        # Append the remaining string each time
        r = t[check + 1:]
        dr = defaultdict(int)
        for v in r:
            dr[v]+= 1
        temp = t
        ds['1']-= dt['1']
        ds['0']-= dt['0']
  
        # If we can't form the string t
        # by the remaining 0's and 1's
        if ds['1']<dr['1'] or ds['0']<dr['0']:
            while ds['1']>0:
                temp+='1'
                ds['1']-= 1
            while ds['0']>0:
                temp+='0'
                ds['0']-= 1
            return temp
  
        # If count of 1's in string r is 0
        if dr['1']== 0 and ds['0']!= 0:
            n = ds['0']//dr['0']
            temp+= r * n
            ds['0']-= n * dr['0']
            while ds['1']>0:
                temp+='1'
                ds['1']-= 1
            while ds['0']>0:
                temp+='0'
                ds['0']-= 1
            return temp
  
        # If count of 0's in string r is 0
        if dr['0']== 0 and ds['1']!= 0:
            n = ds['1']//dr['1']
            temp+= r * n
            ds['1']-= n * dr['1']
            while ds['1']>0:
                temp+='1'
                ds['1']-= 1
            while ds['0']>0:
                temp+='0'
                ds['0']-= 1
            return temp
  
        # If string r have both 0's and 1's
        m1 = ds['1']//dr['1']
        m2 = ds['0']//dr['0']
        n = min(m1, m2)
        temp+= r * n
        ds['1']-= n * dr['1']
        ds['0']-= n * dr['0']
        while ds['1']>0:
            temp+='1'
            ds['1']-= 1
        while ds['0']>0:
                temp+='0'
                ds['0']-= 1
        return temp
  
# Driver code
if __name__=="__main__":
    s ="10101000"
    t ="101"
  
    # Count of 0's and 1's in string s
    ds = defaultdict(int)
  
    # Count of 0's and 1's in string t
    dt = defaultdict(int)
    for i in s:
        ds[i]= ds[i]+1
    for i in t:
        dt[i]= dt[i]+1
    print(Rearranged(ds, dt))
Producción:

10101000

Publicación traducida automáticamente

Artículo escrito por saurabh sisodia y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *