Entrada:

Dos cadenas (NOTA: el orden de entrada es importante).

Salida:

Ambas palabras / oraciones comienzan en líneas con una línea vacía entre ellas. 'Caminan' horizontalmente 'uno al lado del otro'. Pero cuando tienen el mismo personaje en la misma posición, se cruzan y luego continúan caminando 'uno al lado del otro'.

Confuso que dices? Pongamos un ejemplo:

Entrada: Words crossing over& Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

_{Disculpe la mala pintura de MS ...}

Reglas de desafío:

• Siempre volvemos a caminar en línea recta después de haber 'cruzado' antes de que podamos cruzar de nuevo (ver caso de prueba arriba {1} - donde inges igual, pero después de haber cruzado i, primero tenemos que regresar caminando en línea recta (ignorando así n), antes de que podamos cruzar de nuevo g).
• Las entradas pueden ser de diferente longitud, en cuyo caso el más largo continúa caminando en línea recta (ver casos de prueba 1, 2, 4 y 6).
• Ambas entradas pueden ser iguales (ver caso de prueba 3).
• Las entradas no contendrán pestañas ni líneas nuevas.
• Los espacios se ignoran como caracteres que son iguales (como un caso de borde) , en cuyo caso el siguiente carácter (sin espacio) después de eso, si lo hay, se cruza (ver casos de prueba 3, 5 y 6).
• Las entradas no pueden tener caracteres adyacentes (sin espacio) en la misma posición, en cuyo caso ambos simplemente caminan en línea recta horizontalmente (ver casos de prueba 2).
• Incluso si el primer carácter es igual, siempre comenzamos dos líneas separadas (ver casos de prueba 3 y 6).
• Los espacios finales y una nueva línea final son opcionales.
• Puede suponer que las entradas solo contendrán caracteres ASCII imprimibles (se excluyen las nuevas líneas y pestañas).
• Las entradas son mayúsculas y minúsculas, de modo Ay ano son iguales, y no cruzar (ver caso de prueba 7).
• Ambas longitudes de entrada siempre serán al menos 2.
• La entrada y salida pueden estar en cualquier formato razonable. Puede ser una sola cadena con nuevas líneas; un conjunto de cadenas / lista; impreso en STDOUT; Matriz 2D de personajes; etc.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

1. Input: "Words crossing over" & "Ducks quacking"

1. Output:
Word  quack n 
    s      i g
Duck  cross n  over

2. Input: "bananas" & "ananas"

2. Output:
bananas

ananas

3. Input: "I see my twin!" & "I see my twin!"

3. Output:
I  e   y  w n 
  s e m  t i !
I  e   y  w n 

4. Input: "Is the weather nice?" & "Not really, no.."

4. Output:
Is th ally, no..
     e
Not r  weather nice?

5. Input: "Codegolf & Programming Puzzles" & "The golfer might solve puzzles"

5. Output:
Code o f & Programming P z l s
    g l                 u z e
The  o fer might solve p z l s

6. Input: "Can you turn the lights off?" & "Can you try to solve this?"

6. Output:
C n  o   urn the  ve  s off?
 a  y u t        l   t 
C n  o   ry to so igh his?

7. Input: "one Ampere" & "two apples"

7. Output:
one Am les
      p
two ap ere

8. Input: "Words crossing" & "Words Quacking"

8. Output:
W r s cross n 
 o d       i g
W r s Quack n 

Japt , 56 47 33 bytes

y ®m+S éBv ©ZꬩZx ?°B:B=c2)¯3÷y

¡Pruébelo en línea! Toma la entrada como una matriz de dos cadenas.

Soy un completo imbécil ... y ®es un millón de veces más fácil de usar en dos cadenas de diferente longitud que U¬íV¬@...

Explicación

y ®   m+S éBv © Zê¬ © Zx ?° B:B= c2)¯  3à ·  y
y mZ{Zm+S éBv &&Zêq &&Zx ?++B:B=Bc2)s0,3} qR y

              Implicit: U = array of two strings
y             Transpose U, padding the shorter string with spaces in the process.
mZ{        }  Map each pair of chars Z by this function: (we'll call the chars X and Y)
  Zm+S          Append a space to each char, giving X + " " + Y + " ".
  Bv            If B is divisible by 2
  &&Zêq           and Z is a palindrome (X and Y are the same)
  &&Zx ?          and Z.trim() is not empty (X and Y are not spaces):
    ++B           Increment B. B is now odd; the top and bottom strings are swapping.
  :             Otherwise:
    B=Bc2         Ceiling B to a multiple of 2. (0 -> 0, 1 -> 2, 2 -> 2, etc.)
  é       )     Rotate the string generated earlier this many chars to the right.
  s0,3          Take only the first 3 chars of the result.
qR            Join the resulting array of strings with newlines.
y             Transpose rows with columns.
              Implicit: output result of last expression

B es una variable que realiza un seguimiento de en qué estado estamos:

• B % 4 == 0 significa primera palabra en la parte superior, pero listo para cambiar;
• B % 4 == 1 significa que acabamos de cambiar;
• B % 4 == 2 significa segunda palabra en la parte superior, pero listo para cambiar;
• B % 4 == 3 significa que acabamos de regresar.

Bpasa a estar preestablecido a 11; desde entonces 11 % 4 == 3, la primera columna siempre tiene la primera palabra en la parte superior. Incrementamos Bcada vez que las palabras intercambian posiciones, o cada vez que es extraño (con B=c2).

APL (Dyalog) , 64 bytes

{C←⎕UCS⋄1↓e⊖' '⍪1 0 1⍀⍵⊖⍨≠\e←C(2/⊃l)⎕R(l←C⌽⍳2)C(0@0=⌿⍵)∧' '≠1⌷⍵}

Pruébalo en línea!

Carbón , 69 bytes

ＡＥ⮌θιθＡＥ⮌ηιηＷ∧θη«Ａ⊟θεＡ⊟ηδＡ∧¬∨φ⁼ε ⁼εδφ¿φ«εＡθδＡηθＡδη»«↑↓ε↓↗δ»»¿θ↑↓↑⮌⁺θη

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＡＥ⮌θιθＡＥ⮌ηιη        Turn the input strings into arrays and reverse them
Ｗ∧θη«               While both valus still have characters left
     Ａ⊟θεＡ⊟ηδ       Extract the next pair of characters
     Ａ∧¬∨φ⁼ε ⁼εδφ   Determine whether this is a crossing point
     ¿φ«εＡθδＡηθＡδη  If so then print the character and switch the value
      »«↑↓ε↓↗δ»»     Otherwise print the two characters apart
¿θ↑↓                Move to print any remaining characters accordingly
↑⮌⁺θη               Print any remaining characters

Python 2 , 217 210 bytes

^{-1 byte thanks to officialaimm}

a,b=map(list,input())
n=max(len(a),len(b))
c=[' ']*n
a=(a+c)[:n]
b=(b+c)[:n]
for i in range(1,n):
 if a[i]==b[i]!=' '==c[i-1]:c[i]=a[i];a[i]=b[i]=' ';a[i:],b[i:]=b[i:],a[i:]
print'\n'.join(map(''.join,[a,c,b]))

Try it online!

Haskell, 142 138 bytes

g(a:b)f(c:d)|f>0,a==c,a>' '=[' ',a,' ']:g d 0b|1<2=[a,' ',c]:g b 1d
g[]_[]=[]
g b f d=g(max" "b)f$max" "d
a&b=[[j!!i|j<-g a 0b]|i<-[0..2]]

Try it online!

Cómo funciona:

g                    -- function g constructs a list of lists of three characters
                     --   the 1st char belongs to the upper line,
                     --   the 2nd char to the middle line and
                     --   the 3rd char to the lower line
      f              -- flag f indicates if crossing is allowed or not
 (a:b) (c:d)         -- strings to cross
  |f>0               -- if crossing is allowed
      ,a==c          -- and both strings start with the same char
           ,a>' '    --   that is not a space
   =[' ',a,' ']      -- return space for upper/lower line and char a for the middle line
      :g d 0b        -- and go on with crossing disabled and strings swapped
 |1<2=               -- else
   [a,' ',c]         -- keep chars in their lines and
      :g b 1d        --  go on with crossing enabled

g[]_[]=[]            -- base case: stop when both strings are empty

g b f d=             -- if exactly one string runs out of characters
 g(max" "b)f$max" "d --   replace it with a single space and retry

a&b=                 -- main function
          i<-[0..2]  -- for each line i from [0,1,2]    
       j<-g a 0b     -- walk through the result of a call to g with crossing disabled
    j!!i             -- and pick the char for the current line  

JavaScript (ES6), 112 bytes

(a,b,c='',g=([a,...A],[b,...B],w)=>a?w&a==b&a>' '?' '+g(B,A,c+=a):a+g(A,B,1,c+=' '):'')=>g(a,b)+`
`+c+`
`+g(b,a)

Sin golf:

f=
(a,b,                                    //the inputs
 c='',                                   //c will hold the middle sentence
 g=([a,...A],[b,...B],w)=>               //define a function to walk through the strings
                                         //w will be false if we're at the beginning,
                                         //... or if we've just done a swap
     a?                                  //are there any letters left?
       w&a==b&a>' '?' '+g(B,A,c+=a):     //if we haven't just swapped and the letters match,
                                         //... add the current letter to c 
                                         //... and recurse swapping the strings
                    a+g(A,B,1,c+=' '):   //else add a space to c and continue processing
                    ''
)=>
g(a,b)+'\n'+                             //call g with a, b
c+'\n'+                                  //output c
g(b,a)                                   //call g with b, a

Casos de prueba:

f=
(a,b,c='',g=([a,...A],[b,...B],w)=>a?w&a==b&a>' '?' '+g(B,A,c+=a):a+g(A,B,1,c+=' '):'')=>g(a,b)+`
`+c+`
`+g(b,a)

console.log(f('Words crossing over','Ducks quacking'));
console.log('____________');
console.log(f('bananas','ananas'));
console.log('____________');
console.log(f('I see my twin!', 'I see my twin!'));
console.log('____________');
console.log(f('Is the weather nice?', 'Not really, no..'));
console.log('____________');
console.log(f('Codegolf & Programming Puzzles', 'The golfer might solve puzzles'));
console.log('____________');
console.log(f('Can you turn the lights off?', 'Can you try to solve this?'));
console.log('____________');
console.log(f('one Ampere', 'two apples'))
console.log('____________');
console.log(f('Words crossing','Words Quacking'));
console.log('____________');

APL (Dyalog) , 50 bytes

{3↑(0,+\2∨/2|{⍵⌈a×1+1,¯1↓⍵}⍣≡a←>⌿2=⌿3↑⍵)⊖⍵⍀⍨¯1*⍳4}

Pruébalo en línea!

⍵⍀⍨¯1*⍳4 da la matriz:

Words.crossing.over
...................
Ducks.quacking.....
...................

(los puntos representan espacios). Sus columnas se rotarán en diferentes cantidades para que las primeras tres filas terminen pareciéndose al resultado deseado, de ahí el3↑ el comienzo cercano. El resto del algoritmo calcula las cantidades de rotación.

Dentro de los padres: 3↑⍵crea una matriz como

Words.crossing.over
Ducks.quacking.....
...................

y 2=⌿compara sus filas por pares, es decir, la primera cadena frente a la segunda cadena y la segunda cadena frente a la fila de todos los espacios.

0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1

Estamos interesados ​​en que el primero sea verdadero (1) y el segundo falso (0), por lo que reducimos con >⌿para obtener un vector booleano llamado a.

0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0

Ahora, en cada tramo de 1 s necesitamos poner a cero las ocurrencias pares porque no pueden ocurrir dos giros uno al lado del otro. Primero obtenemos una numeración como:

0 0 0 0 1 0 0 0 0 0 0 1 2 3 0 0 0 0 0

hablando libremente, reemplazando a[i]con a[i]*max(a[i-1]+1, a[i])hasta que el resultado se estabilice: {⍵⌈a×1+1,¯1↓⍵}⍣≡y tomamos ese mod 2:2|

0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0

Ahora sabemos dónde ocurrirán los giros. Copiamos cada uno 1a la izquierda - 2∨/ (en parejas "o"):

0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 0 0 0 0

y calcular las sumas parciales - +\

0 0 0 0 1 2 2 2 2 2 2 3 4 5 6 6 6 6 6

Eso nos da las cantidades de rotación de columna que necesitábamos al principio. El módulo 4 está implícito.

Perl 5 , 211 bytes

@a=map[/./g],<>;$b=1;($f,@{$r[$i]})=$a[0][$i]eq$a[1][$i]&&$f&&$a[0][$i]ne$"?(0,$",$a[0][$i],$",$t=$b++):(1,$a[$t%2][$i],$",$a[$b%2][$i]),$i++while$a[0][$i]||$a[1][$i];for$i(0..2){print$r[$_][$i]for 0..$#r;say''}

Pruébalo en línea!

# Perl 5 , 234 bytes

reparó el error que Kevin señaló

@a=map[/./g],<>;$l=@{$a[0]}>@{$a[1]}?@{$a[0]}:@{$a[1]};$b=1;@{$r[$_]}=$a[0][$_]eq$a[1][$_]&&$_&&$r[$_-1][1]eq$"&&$a[0][$_]ne$"?($",$a[0][$_],$",$t=$b++):($a[$t%2][$_],$",$a[$b%2][$_])for 0..$l;for$i(0..2){print$r[$_][$i]for 0..$l;say}

Pruébalo en línea!

05AB1E , 31 bytes

ζεËNĀ¾Èyðå_Pi¼ë¾É½}yð«S¾._¨}øJ»

Puerto de @ETHproductions respuesta Japt 's , pero con dos diferencias menores:
1) que toma la entrada como una lista de personajes 2D en lugar de lista de cadenas.
2) En counter_variable05AB1E es 0 por defecto, en lugar de 11 (o 3) como Ben Japt, entonces elNĀ se agrega como verificación adicional dentro del mapa (y giro hacia la derecha en lugar de hacia la izquierda).

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ζ                  # Zip/transpose (swapping rows/columns) the (implicit) input-list
                   # with space filler by default to create pairs
 ε          }      # Map each pair `y` to:
  Ë                #  Check if both values in the pair are equal
  NĀ               #  Check if the map-index is not 0
  ¾È               #  Check if the counter_variable is even
  yðå_             #  Check if the pair contains no spaces " "
  Pi               #  If all checks are truthy:
    ¼              #   Increase the counter_variable by 1:
   ë               #  Else:
    ¾É             #   Check if the counter_variable is odd
      ½            #   And if it is: increase the counter_variable by 1
   }               #  Close the if-else
    yð«            #  Add a space after both characters in the pair
       S           #  Convert it to a list of characters (implicitly flattens)
        ¾._        #  Rotate this list the counter_variable amount of times towards the right
           ¨       #  And then remove the last character
             ø     # Zip/transpose; swapping rows/columns
              J    # Join each inner character-list to a single string
               »   # Join everything by newlines (and output implicitly)