Contribution:

Deux chaînes (REMARQUE: l'ordre d'entrée est important).

Sortie:

Les deux mots / phrases commencent sur des lignes avec une ligne vide entre eux. Ils «marchent» horizontalement «côte à côte». Mais quand ils ont le même personnage à la même position, ils se croisent, puis continuent de marcher «côte à côte».

Vous confondez-vous dire? Donnons un exemple:

Entrée: Words crossing over& Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

_{Excusez la mauvaise peinture MS ..}

Règles du défi:

• Nous revenons toujours en premier en marchant en ligne droite après avoir `` traversé '' avant de pouvoir traverser à nouveau (voir cas de test ci-dessus {1} - où ingest égal, mais après avoir traversé i, nous devons d'abord revenir en arrière marcher droit (ignorant ainsi n), avant de pouvoir croiser à nouveau g).
• Les entrées peuvent être de longueur différente, auquel cas la plus longue continue de marcher en ligne droite (voir les cas de test 1, 2, 4 et 6).
• Les deux entrées peuvent être identiques (voir le cas de test 3).
• Les entrées ne contiennent aucun onglet ni nouvelle ligne.
• Les espaces sont ignorés en tant que caractères identiques (comme un cas de bord) , auquel cas le caractère suivant (non-espace) après cela - le cas échéant - se croise à la place (voir les cas de test 3, 5 et 6).
• Les entrées ne peuvent avoir aucun caractère adjacent (non-espace) sur la même position, auquel cas les deux marchent simplement en ligne droite horizontalement (voir les cas de test 2).
• Même si le premier caractère est égal, nous commençons toujours par séparer deux lignes (voir cas de test 3 & 6).
• Les espaces de fin et une seule nouvelle ligne de fin sont facultatifs.
• Vous pouvez supposer que les entrées ne contiendront que des caractères ASCII imprimables (nouvelles lignes et tabulations exclues).
• Les entrées sont sensibles à la casse, de sorte que Aet ane sont pas égaux, et ne seront pas traverser (voir le cas du test 7).
• Les deux longueurs d'entrée seront toujours au moins égales à 2.
• L'entrée et la sortie peuvent être dans n'importe quel format raisonnable. Peut être une chaîne unique avec des nouvelles lignes; un tableau / liste de chaînes; imprimé sur STDOUT; Tableau 2D de caractères; etc.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de 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 octets

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

Testez-le en ligne! Prend l'entrée comme un tableau de deux chaînes.

Je suis un crétin total ... y ®est un million de fois plus facile à utiliser sur deux cordes de longueur différente que U¬íV¬@...

Explication

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 est une variable qui garde la trace de l'état dans lequel nous nous trouvons:

• B % 4 == 0 signifie le premier mot en haut, mais prêt à basculer;
• B % 4 == 1 signifie que nous venons de changer;
• B % 4 == 2 signifie deuxième mot en haut, mais prêt à basculer;
• B % 4 == 3 signifie que nous venons de revenir.

Bse trouve être préréglé sur 11; depuis 11 % 4 == 3, la première colonne a toujours le premier mot en haut. Nous incrémentons Bchaque fois que les mots changent de position, ou chaque fois que c'est impair (avec B=c2).

APL (Dyalog) , 64 octets

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

Essayez-le en ligne!

Fusain , 69 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

^{-1 octet grâce à 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]))

Essayez-le en ligne!

Haskell, 142 138 octets

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

Essayez-le en ligne!

Comment ça marche:

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 octets

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

Non 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

Cas de 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 octets

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

Essayez-le en ligne!

⍵⍀⍨¯1*⍳4 donne la matrice:

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

(les points représentent des espaces). Ses colonnes seront pivotées de différentes quantités, de sorte que les trois premières lignes finissent par ressembler au résultat souhaité - d'où 3↑le début du début. Le reste de l'algorithme calcule les quantités de rotation.

Dans les parens: 3↑⍵crée une matrice comme

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

et 2=⌿compare ses lignes deux à deux, c'est-à-dire la première chaîne par rapport à la deuxième chaîne et la deuxième chaîne par rapport à la ligne tous espaces.

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

Nous voulons savoir où le premier est vrai (1) et le second faux (0), donc nous réduisons avec >⌿pour obtenir un vecteur booléen nommé a.

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

Maintenant, dans chaque tronçon de 1 s, nous devons mettre à zéro les occurrences paires, car deux torsions ne peuvent pas se produire l'une à côté de l'autre. On obtient d'abord une numérotation comme:

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

par, en gros, en remplaçant a[i]par a[i]*max(a[i-1]+1, a[i])jusqu'à ce que le résultat se stabilise:, {⍵⌈a×1+1,¯1↓⍵}⍣≡et nous prenons ce mod 2:2|

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

Nous savons maintenant où les rebondissements se produiront. Nous copions chacun 1à gauche - 2∨/ (par paire "ou"):

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

et calculer les sommes partielles - +\

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

Cela nous donne les montants de rotation des colonnes dont nous avions besoin au début. Modulo 4 est implicite.

Perl 5 , 211 octets

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

Essayez-le en ligne!

# Perl 5 , 234 octets

correction du bug signalé par 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}

Essayez-le en ligne!

05AB1E , 31 octets

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

Port de @ETHproductions Japt s » réponse , mais avec deux différences mineures:
1) Je prends l'entrée comme une liste 2D de caractères au lieu de la liste des chaînes.
2) Le counter_variabledans 05AB1E est 0 par défaut, au lieu de 11 (ou 3) comme Bdans Japt, donc le NĀest ajouté comme vérification supplémentaire à l'intérieur de la carte (et je tourne vers la droite au lieu de la gauche).

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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