Eingang:

Zwei Zeichenfolgen (HINWEIS: Die Reihenfolge der Eingabe ist wichtig).

Ausgabe:

Beide Wörter / Sätze beginnen in Zeilen mit einer Leerzeile dazwischen. Sie gehen horizontal nebeneinander. Wenn sie jedoch denselben Charakter an derselben Position haben, kreuzen sie sich und gehen dann „nebeneinander“ weiter.

Verwirrend, sagst du? Nennen wir ein Beispiel:

Eingabe: Words crossing over& Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

_{Entschuldigen Sie den schlechten MS-Lack.}

Herausforderungsregeln:

• Wir gehen immer zuerst eine gerade Linie zurück, nachdem wir überquert haben, bevor wir wieder überqueren können (siehe Testfall oben {1} - wo ingist gleich, aber nachdem wir überquert haben i, müssen wir zuerst zurückgehen geradeaus gehen (also ignorieren n), bevor wir wieder weiter gehen können g).
• Die Eingaben können unterschiedlich lang sein. In diesem Fall geht die längere Eingabe in einer geraden Linie weiter (siehe Testfälle 1, 2, 4 und 6).
• Beide Eingänge können gleich sein (siehe Testfall 3).
• Die Eingaben enthalten keine Tabulatoren oder Zeilenumbrüche.
• Leerzeichen werden als gleiche Zeichen ignoriert (als Randzeichen) . In diesem Fall wird das nächste (nicht-Leerzeichen-) Zeichen (falls vorhanden) gekreuzt (siehe Testfälle 3, 5 und 6).
• Die Eingaben dürfen keine benachbarten Zeichen (keine Leerzeichen) an derselben Position enthalten. In diesem Fall bewegen sich beide nur horizontal in einer geraden Linie (siehe Testfälle 2).
• Auch wenn das erste Zeichen gleich ist, beginnen wir immer zwei Zeilen auseinander (siehe Testfälle 3 & 6).
• Nachgestellte Leerzeichen und eine einzelne nachgestellte neue Zeile sind optional.
• Sie können davon ausgehen, dass die Eingaben nur druckbare ASCII-Zeichen enthalten (ohne Zeilenumbrüche und Tabulatoren).
• Die Eingänge sind fallempfindlich, so Aund anicht gleich sind , und werden nicht überkreuzen (siehe Testfall 7).
• Beide Eingangslängen betragen immer mindestens 2.
• Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen. Kann eine einzelne Zeichenfolge mit Zeilenumbrüchen sein. ein String-Array / eine Liste; gedruckt nach STDOUT; 2D-Array von Zeichen; etc.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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

Online testen! Übernimmt die Eingabe als Array von zwei Zeichenfolgen.

Ich bin ein totaler Trottel ... y ®ist millionenfach einfacher mit zwei unterschiedlich langen Saiten zu spielen als U¬íV¬@...

Erläuterung

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 ist eine Variable, die festhält, in welchem ​​Zustand wir uns befinden:

• B % 4 == 0 bedeutet das erste Wort oben, aber bereit zu wechseln;
• B % 4 == 1 bedeutet, wir haben gerade gewechselt;
• B % 4 == 2 bedeutet zweites Wort oben, aber bereit zu wechseln;
• B % 4 == 3 Das heißt, wir sind gerade zurückgekehrt.

Bzufällig voreingestellt auf 11; da 11 % 4 == 3hat die erste Spalte immer das erste Wort oben. Wir erhöhen Bjedes Mal, wenn die Wörter die Positionen tauschen oder wenn es ungerade ist (mit 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⌷⍵}

Probieren Sie es online!

Kohle , 69 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＡＥ⮌θιθＡＥ⮌ηιη        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 dank 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]))

Probieren Sie es 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]]

Probieren Sie es online!

Wie es funktioniert:

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

Testfälle:

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}

Probieren Sie es online!

⍵⍀⍨¯1*⍳4 gibt die Matrix an:

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

(Die Punkte stehen für Leerzeichen.) Die Spalten werden um unterschiedliche Beträge gedreht, sodass die ersten drei Zeilen wie das gewünschte Ergebnis aussehen - daher die3↑ fast am Anfang. Der Rest des Algorithmus berechnet die Rotationsbeträge.

Innerhalb der Parens: 3↑⍵Erstellt eine Matrix wie

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

und 2=⌿vergleicht seine Zeilen paarweise, dh die erste Zeichenfolge mit der zweiten Zeichenfolge und die zweite Zeichenfolge mit der Zeile mit allen Leerzeichen.

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

Wir sind daran interessiert, wo ersteres wahr (1) und letzteres falsch (0) ist, also reduzieren wir mit >⌿, um einen booleschen Vektor mit dem Namen zu erhalten a.

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

Jetzt müssen wir in jedem Abschnitt von 1 s die geraden Vorkommen auf Null setzen, da keine zwei Drehungen nebeneinander auftreten können. Zuerst erhalten wir eine Nummerierung wie:

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

durch, grob gesagt, ersetzt a[i]mit , a[i]*max(a[i-1]+1, a[i])bis das Ergebnis stabilisiert: {⍵⌈a×1+1,¯1↓⍵}⍣≡, und wir nehmen diese mod 2:2|

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

Jetzt wissen wir, wo die Drehungen auftreten werden. Wir kopieren jeweils 1nach links - 2∨/ (paarweise "oder"):

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

und berechnen Sie die Teilsummen - +\

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

Das gibt uns die Säulendrehungsbeträge, die wir am Anfang benötigten. Modulo 4 ist impliziert.

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

Probieren Sie es online!

# Perl 5 , 234 Bytes

Behebung des Fehlers, auf den Kevin hingewiesen hat

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

Probieren Sie es online!

05AB1E , 31 Bytes

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

Port der Japt -Antwort von @ETHproductions , aber mit zwei kleinen Unterschieden:
1) Ich nehme die Eingabe als 2D-Liste von Zeichen anstelle einer Liste von Zeichenfolgen.
2) In counter_variable05AB1E ist standardmäßig 0 anstelle von 11 (oder 3) wie inB in Japt, also NĀwird das als zusätzliche Kontrolle in die Karte eingefügt (und ich drehe nach rechts statt nach links).

Probieren Sie es online oder überprüfen Sie alle Testfälle .

Erläuterung:

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