Ingresso:

Due stringhe (NOTA: l'ordine di input è importante).

Produzione:

Entrambe le parole / frasi iniziano su righe con una riga vuota tra loro. 'Camminano' orizzontalmente 'uno accanto all'altro'. Ma quando hanno lo stesso personaggio nella stessa posizione, si incrociano e poi continuano a camminare "uno accanto all'altro".

Confuso dici? Facciamo un esempio:

Input: Words crossing over& Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

_{Scusa la brutta vernice MS ..}

Regole della sfida:

• Ritorniamo sempre a camminare su una linea retta dopo aver "attraversato" prima di poter incrociare di nuovo (vedere il caso di prova sopra {1} - dove ingè uguale, ma dopo aver attraversato i, dobbiamo prima tornare indietro camminare dritto (ignorando così n), prima di poter attraversare di nuovo g).
• Gli ingressi possono avere una lunghezza diversa, nel qual caso quello più lungo continua a camminare in linea retta (vedere i casi di test 1, 2, 4 e 6).
• Entrambi gli ingressi possono essere uguali (vedi test case 3).
• Gli input non conterranno alcuna scheda né nuova riga.
• Gli spazi vengono ignorati come caratteri uguali (come un caso limite) , nel qual caso il carattere successivo (non spaziale) dopo quello - se presente - viene invece attraversato (vedi casi di test 3, 5 e 6).
• Gli ingressi non possono avere caratteri adiacenti (non spaziali) nella stessa posizione, nel qual caso entrambi camminano semplicemente in linea retta in orizzontale (vedere i casi di test 2).
• Anche se il primo carattere è uguale, iniziamo sempre a separare due righe (vedere i casi di test 3 e 6).
• Gli spazi finali e una singola nuova riga finale sono facoltativi.
• Puoi presumere che gli input conterranno solo caratteri ASCII stampabili (nuove righe e schede escluse).
• Gli ingressi sono case-sensitive, quindi Ae anon sono uguali, e non attraversare (vedi caso di test 7).
• Entrambe le lunghezze degli ingressi saranno sempre almeno 2.
• Input e output possono essere in qualsiasi formato ragionevole. Può essere una singola stringa con new-line; una stringa-array / elenco; stampato su STDOUT; Matrice 2D di caratteri; eccetera.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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 byte

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

Provalo online! Accetta l'input come una matrice di due stringhe.

Sono un idiota totale ... y ®è un milione di volte più facile da usare su due stringhe di diversa lunghezza rispetto a U¬íV¬@...

Spiegazione

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 è una variabile che tiene traccia dello stato in cui ci troviamo:

• B % 4 == 0 significa prima parola in alto, ma pronto a cambiare;
• B % 4 == 1 significa che siamo appena passati;
• B % 4 == 2 significa seconda parola in alto, ma pronto a cambiare;
• B % 4 == 3 significa che siamo appena tornati.

Bsembra essere preimpostato su 11; poiché 11 % 4 == 3, la prima colonna ha sempre la prima parola in cima. Aumentiamo Bogni volta che le parole cambiano posizione, o ogni volta che è dispari (con B=c2).

APL (Dyalog) , 64 byte

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

Provalo online!

Carbone , 69 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＡＥ⮌θιθＡＥ⮌ηιη        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 byte

^{-1 byte grazie a 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]))

Provalo online!

Haskell, 142 138 byte

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]]

Provalo online!

Come funziona:

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 byte

(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)

Ungolfed:

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

Casi test:

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 byte

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

Provalo online!

⍵⍀⍨¯1*⍳4 dà la matrice:

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

(i punti rappresentano gli spazi). Le sue colonne saranno ruotate di diverse quantità in modo che le prime tre righe finiscano per apparire come il risultato desiderato, quindi 3↑vicino all'inizio. Il resto dell'algoritmo calcola gli importi di rotazione.

All'interno dei genitori: 3↑⍵crea una matrice simile

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

e 2=⌿confronta le sue righe in coppia, ovvero prima stringa contro seconda stringa e seconda stringa contro la riga di tutti gli spazi.

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

Siamo interessati a dove il primo è vero (1) e il secondo falso (0), quindi riduciamo con >⌿per ottenere un vettore booleano chiamato a.

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

Ora, in ogni tratto di 1-s abbiamo bisogno di azzerare le occorrenze pari perché non possono esserci due colpi di scena l'uno accanto all'altro. Innanzitutto otteniamo una numerazione come:

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

a proposito, rimpiazzando, fino a[i]a a[i]*max(a[i-1]+1, a[i])quando il risultato si stabilizza:, {⍵⌈a×1+1,¯1↓⍵}⍣≡e prendiamo quel mod 2:2|

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

Ora sappiamo dove si verificheranno i colpi di scena. Copiamo ciascuno 1a sinistra - 2∨/ (a coppie "o"):

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

e calcolare le somme parziali - +\

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

Questo ci dà gli importi di rotazione della colonna di cui avevamo bisogno all'inizio. Modulo 4 è implicito.

Perl 5 , 211 byte

@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''}

Provalo online!

# Perl 5 , 234 byte

risolto il bug segnalato da Kevin

@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}

Provalo online!

05AB1E , 31 byte

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

Porto di @ETHproductions Japt risposta s' , ma con due piccole differenze:
1) Prendo l'ingresso come un elenco di personaggi 2D, invece di lista di stringhe.
2) In counter_variable05AB1E è 0 per impostazione predefinita, invece di 11 (o 3) come Bin Japt, quindi NĀviene aggiunto come controllo aggiuntivo all'interno della mappa (e io giro verso destra anziché a sinistra).

Provalo online o verifica tutti i casi di test .

Spiegazione:

ζ                  # 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)