Desafío

Dada una cadena que describe una regla de corte y otra cadena, corte partes de la segunda cadena usando la regla descrita por la primera cadena.

Ambas cadenas consistirán en letras a-zo A-Z, cualquiera que elija (no tienen que estar representadas de la misma manera). La forma en que se modificará la segunda cadena se describe a continuación:

Algoritmo

Tome la primera secuencia e imagine llenar los espacios entre letras no adyacentes (crecientes) con =; por ejemplo, abcfg=> abc==fg. Luego, alinee las dos cadenas y devuelva todos los caracteres de la primera cadena que no estén por encima de un signo igual. Por ejemplo, dado abcfgy qrstuvwcomo entradas:

qrstuvw - Modify
abc==fg - Modifier

qrs--vw -> qrsvw

Si el modificador es más corto después de rellenar con signos iguales, se deben incluir todos los caracteres finales en la segunda cadena. Si el modificador es más largo, los caracteres finales se ignoran.

No se garantiza que el modificador esté ordenado.

Casos de prueba

abcfg, qrstuvw -> qrsvw
abqrs, qwertyuiopasdfghjklzxcvbnm -> qwjklzxcvbnm
za, qr -> qr
azazaz, qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq -> qmn

Implementación de referencia (utilizada para generar casos de prueba) -> TIO

Reglas

• Se aplican lagunas estándar
• Puede tomar la entrada como dos cadenas, dos listas de caracteres, una matriz de caracteres, etc. (se acepta cualquier otro formato razonable)
• Puede generar una cadena o una lista de caracteres (o algún otro formato estándar para cadenas)
• Este es el código de golf , por lo que la respuesta más corta en bytes en cada idioma se declara ganador de su idioma. No se aceptarán respuestas.
• Cualquiera de las cadenas puede estar vacía.

¡Feliz golf!

_{^{Inspirado por los dos desafíos recientes de Kevin Cruijssen, "Allí, lo arreglé (con cinta / cuerda )"}}

JavaScript (ES6), 81 80 bytes

Toma entrada en la sintaxis de curry (modify)(modifier).

s=>g=([c,...a],d=i=0,x=s[k=parseInt(c,36),i+=c?d&&(k-d+26)%26:1])=>x?x+g(a,k):''

Pruébalo en línea!

Comentado

s =>                       // outer function, taking the string s to modify
  g = (                    // recursive inner function g(), taking:
    [c, ...a],             //   c = current modifier character; a[] = remaining characters
    d = i = 0,             //   d = code of previous modifier character; i = pointer in s
    x = s[                 //   x = i-th character of s
      k = parseInt(c, 36), //     k = code of the current modifier character in [10..35]
      i += c ?             //     update i; if c is defined:
        d &&               //       if d = 0, let i unchanged
        (k - d + 26) % 26  //       otherwise, add the difference between k and d (mod 26)
      :                    //     else:
        1                  //       just pick the next character by adding 1
    ]                      //   end of character lookup in s
  ) =>                     //
    x ?                    // if x is defined:
      x + g(a, k)          //   append x and do a recursive call to g()
    :                      // else:
      ''                   //   stop recursion

Python 3 , 99 bytes

lambda a,b:[x for x,y in zip(a,''.join(d+(ord(c)+~ord(d))%26*'='for c,d in zip(b[1:],b))+a)if'='<y]

Pruébalo en línea!

05AB1E , 20 17 bytes

ćsv¹Ç¥Nè<yú«}SðÊÏ

Pruébalo en línea!

Calcula la distancia ASCII entre cada carácter, anteponiendo tantos espacios si es positivo. La distancia negativa da como resultado la adición de 0 espacios, según la especificación. Después de eso, presiono todos los caracteres en los mismos índices en la cadena 2 que los espacios en la primera cadena manipulada.

Input: [azaz,qwertyuiopasdfghjklzxcvbnm]
--------------------------------------------------------------------------------

ćs                # Remove head, swap                           | [a, zaz]
  v               # Iterate...                                  | ............
   ¹Ç¥            # Push deltas between each char of string 1   | [a,[25,-25,25,-25]]
      Nè          # Push delta at index...                      | [a, 25]
        <         # Decrement (for 1-indexed answer)            | [a, 24]
         y        # Push current char in iteration...           | [a, 24, z]
          ú       # Append b spaces to a...                     | [a, '(spaces)z']
           «      # Concat                                      | [a(spaces)z]
            }     # End loop.                                   | [a(spaces)za(spaces)z]
             SðÊ  # Split, push 1 for non-space elements.       | [Long array of 1/0]
                Ï # Push chars from 2 that aren't spaces in 1.  | ['qmn']

90% seguro de que puedo perder otros 2-3 bytes al no usar espacios, pero presionando el carácter en el índice N. Todavía trabajando en esta variante en este momento ... Lo que mi "mejor idea" terminó como:

05AB1E , 18 bytes

Ç¥ε1‚Z}ηO0¸ìʒ²g‹}è

Pruébalo en línea!

Siento que me falta algo, si ves mejoras ε1‚Z}, ʒ²g‹}o 0¸ìlmk ...

Ç¥ε1‚Z}ηO0¸ìètenía 13 años, pero cuando envuelve n > |input_2|a input_2[n%|input_2|]...

Stax , 15 bytes

Ç«|¢Äα•è@╟╣i`vF

Ejecutar y depurarlo

Esta es la representación ascii.

:-Z+{v0|Mt|cB]pFp

1. Obtenga diferencias por pares.
2. Anteponer un cero.
3. Para cada diferencia, repite
   4. Resta 1 y toma el máximo con cero.
   5. Elimina esa cantidad de caracteres del comienzo de la cadena.
   6. Pare si la cadena está vacía.
4. Imprime el resto de la cadena.

Jalea , 14 bytes

OI’R¬⁸żFḣL}aḟ0

Un enlace diádico que acepta el modificador como una lista de caracteres a la izquierda y la lista de caracteres para modificar a la derecha que devuelve una lista de caracteres.

Pruébalo en línea!

¿Cómo?

OI’R¬⁸żFḣL}aḟ0 - Link list of characters Modifier, list of characters InStr
               -                       e.g.  ['a','c','g','a'], ['n','m','l','k','j']
O              - ordinals of Modifier        [97,99,103,97]
 I             - incremental differences     [2,4,-6]
  ’            - decrement                   [1,3,-7]
   R           - range                       [[1],[1,2,3],[]]
    ¬          - NOT (vectorises)            [[0],[0,0,0],[]]
     ⁸         - chain's left argument, Modifier
      ż        - zip together                [['a',[0]],['c',[0,0,0]],['g',[]],['a']]
       F       - flatten                     ['a',0,'c',0,0,0,'g','a']
         L}    - length of right (InStr)     5
        ḣ      - head to index               ['a',0,'c',0,0] (if shorter or equal, no effect)
           a   - AND with InStr (vectorises) ['n',0,'l',0,0]
            ḟ0 - filter out zeros            ['n','l']

JavaScript (ES6), 79 bytes

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

Utiliza el mismo algoritmo para calcular la distancia entre letras que mi última respuesta .

Casos de prueba:

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

console.log(f('abcfg','qrstuvw')) // -> qrsvw
console.log(f('abqrs','qwertyuiopasdfghjklzxcvbnm')) // -> qwjklzxcvbnm
console.log(f('za','qr')) // -> qr
console.log(f('azazaz','qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq')) // -> qmn

APL (Dyalog Classic) , 35 34 32 bytes

{⍵∩⍨⊃¨↓∘⍵¨+\0,1⌈(-2-/⎕ucs⍺),=⍨⍵}

Pruébalo en línea!

K (ngn / k) , 27 24 25 bytes

{y[+\0,1|1_-':x,!#y]^" "}

Pruébalo en línea!

{y[+\0,1|1_-':x,!#y]^" "}

{                       } function with x and y as arguments
                 #y       the length of y
                !#y       0 1 2 ... (#y)-1
              x,          x concatenated with
           -':            differences between pairs
         1_               rm extra leading item
       1|                 max between 1 and
     0,                   prepend 0
   +\                     partial sums
 y[                ]      index y with that
                    ^" "  rm spaces due to out-of-bounds indexing

Haskell , 49 bytes

(x:r)#(y:n:s)=x:drop(length[y..n]-2)r#(n:s)
r#_=r

Pruébalo en línea!

Perl 5 , 45 bytes

s/./v0.$;x(ord($')-1-ord$&)/eg;$_|=<>;s/\W//g

Pruébalo en línea!

Ruby , 68 64 bytes

->m,z,i=1{z[i,[0,m[i].ord+~m[i-1].ord].max]&&='';m[i+=1]?redo:z}

Pruébalo en línea!

Carbón , 29 28 bytes

⭆η×ιＩ§⁺⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1⭆η1κ

Pruébalo en línea! El enlace es a la versión detallada del código. Según mi respuesta a There, lo arreglé con cinta adhesiva. Explicación:

       ⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1        Fix it with tape, but map to 1s and 0s
      ⁺                 ⭆η1     Append extra 1s just in case
⭆η                              Map over the second string
     §                     κ    Get the character from the fixed string
    Ｉ                           Cast to integer
  ×ι                            Repeat the current character that many times
                                Implicitly print

Nota: Esto debe ser de 28 bytes, pero Andestá roto en el momento de la escritura.

Java 8, 117 bytes

a->b->{for(int i=0,j;++i<a.length;b=j>0&b.length()>=i+j?b.substring(0,i)+b.substring(i+j):b)j=a[i]+~a[i-1];return b;}

Explicación:

Pruébalo en línea.

a->b->{                   // Method with char-array + String parameters and String return
  for(int i=0,j;++i<a.length;
                          //  Loop `i` in range [1; length_of_array)
      b=                  //    After every iteration: change the String-input to:
        j>0               //     If `j` is larger than 0,
        &b.length()>=i+j? //     and the length of `b` is larger or equal to `i+j`:
         b.substring(0,i) //      Take the substring [0; i)
         +b.substring(i+j)//      + the substring [i+j; end_of_string]
        :                 //     Else:
         b)               //      Leave `b` the same
    j=a[i]+~a[i-1];       //   Set `j` to the difference between two adjacent chars - 1
  return b;}              //  Return the modified input-String