입력:

두 개의 문자열 (참고 : 입력 순서가 중요합니다).

산출:

두 단어 / 문장 사이에 빈 줄이 하나있는 줄에서 시작합니다. 그들은 '서로 옆으로'가로로 걷습니다. 그러나 같은 위치에 같은 인물이 있으면 서로 교차 한 다음 '서로 옆으로'계속 걷는다.

혼란스러워? 예를 들어 보자.

입력 : Words crossing over& Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

_{나쁜 MS 페인트 실례합니다 ..}

도전 규칙 :

• 우리는 다시 교차하기 전에 '교차'한 후에 항상 직선으로 돌아갑니다 ({1} 위의 테스트 사례 참조- ing동일한 곳 이지만 교차 한 후에 i는 먼저 돌아 가야합니다) n우리가 다시 교차하기 전에 똑바로 걷는 (따라서 무시 g).
• 입력은 길이가 다를 수 있으며,이 경우 더 긴 입력은 직선으로 계속 걸어갑니다 (테스트 사례 1, 2, 4 및 6 참조).
• 두 입력 모두 동일 할 수 있습니다 (테스트 사례 3 참조).
• 입력에는 탭이나 줄 바꿈이 포함되지 않습니다.
• 공백은 (가장자리 문자와 같은) 문자로 무시됩니다 .이 경우 공백이 아닌 다음 문자 (있는 경우)가 대신 교차합니다 (테스트 사례 3, 5 및 6 참조).
• 입력은 동일한 위치에 전혀 (공백이 아닌) 인접한 문자를 가질 수 없습니다.이 경우 둘 다 직선으로 수평으로 걷습니다 (테스트 사례 2 참조).
• 첫 번째 문자가 같더라도 항상 두 줄로 시작합니다 (테스트 사례 3 및 6 참조).
• 후행 공백과 단일 후행 줄 바꾸기는 선택 사항입니다.
• 입력에 인쇄 가능한 ASCII 문자 만 포함되어 있다고 가정 할 수 있습니다 (줄 바꾸기 및 탭 제외).
• 입력은 그래서, 대소 문자를 구분 A과 a동일하지 않고, (테스트 케이스 7 참조) 교차하지 않을 것이다.
• 두 입력 길이는 항상 2 이상입니다.
• 입력 및 출력은 임의의 합리적인 형식 일 수 있습니다. 줄 바꿈이있는 단일 문자열 일 수 있습니다. 문자열 배열 / 목록; STDOUT에 인쇄; 문자의 2D 배열; 기타

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

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 바이트

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

온라인으로 테스트하십시오! 입력을 두 문자열의 배열로 가져옵니다.

나는 총 바보입니다 ... y ®보다 두 개의 다른 길이의 문자열에서 사용하기가 백만 배 더 쉽습니다 U¬íV¬@...

설명

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 현재 상태를 추적하는 변수입니다.

• B % 4 == 0 첫 단어는 위에 있지만 전환 할 준비가되어 있음을 의미합니다.
• B % 4 == 1 우리가 방금 전환했음을 의미합니다.
• B % 4 == 2 두 번째 단어는 위에 있지만 전환 할 준비가되어 있음을 의미합니다.
• B % 4 == 3 다시 전환했음을 의미합니다.

B로 미리 설정되어 있습니다 11; 이후 11 % 4 == 3첫 번째 열에는 항상 첫 번째 단어가 맨 위에옵니다. 우리는 증가 B단어가 포지션 교체를 언제든지, 또는 (어떤 시간은 홀수이다 B=c2).

APL (Dyalog) , 64 바이트

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

온라인으로 사용해보십시오!

숯 , 69 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

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

파이썬 2 , 217210 바이트

^{officialaimm 덕분에 -1 바이트}

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

온라인으로 사용해보십시오!

하스켈 142 138 바이트

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

온라인으로 사용해보십시오!

작동 방식 :

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  

자바 스크립트 (ES6), 112 바이트

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

언 골프 드 :

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

테스트 사례 :

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 바이트

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

온라인으로 사용해보십시오!

⍵⍀⍨¯1*⍳4 매트릭스를 제공합니다.

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

점은 공백을 나타냅니다. 열이 다른 양만큼 회전되므로 처음 세 행은 원하는 결과처럼 보입니다.3↑ . 나머지 알고리즘은 회 전량을 계산합니다.

괄호 안에서 : 3↑⍵같은 행렬을 만듭니다

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

그리고 2=⌿해당 행이 페어 번째 문자열 및 모든 스페이스 행 VS 번째 문자열 VS 제 문자열 즉 비교한다.

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

우리는 전자가 true (1)이고 후자가 false (0) 인 곳에 관심이 있으므로 >⌿이라는 boolean vector를 얻기 위해 축소 a합니다.

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

이제는 1 초마다 두 번의 꼬임이 발생하지 않기 때문에 짝수 발생을 제로화해야합니다. 먼저 다음과 같은 번호를 얻습니다.

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

에 의해 느슨하게 교체, 말하기 a[i]와 a[i]*max(a[i-1]+1, a[i])결과가 안정 될 때까지 {⍵⌈a×1+1,¯1↓⍵}⍣≡, 우리는 모드 2를 가지고 :2|

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

이제 비틀림이 발생할 위치를 알았습니다. 우리는 각각 1왼쪽에- 2∨/ (쌍으로 "또는") 복사합니다 :

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

부분 합을 계산합니다- +\

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

이를 통해 처음에 필요한 열 회전 양을 얻을 수 있습니다. 모듈로 4가 내포되어 있습니다.

펄 5 , 211 바이트

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

온라인으로 사용해보십시오!

# Perl 5 , 234 바이트

케빈이 지적한 버그 수정

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

온라인으로 사용해보십시오!

05AB1E , 31 바이트

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

@ETHproductions 의 Japt 답변 포트 이지만 두 가지 사소한 차이점이 있습니다.
1) 입력을 문자열 목록 대신 2D 문자 목록으로 가져갑니다.
2) counter_variablein 05AB1E는 기본적 B으로 Japt 와 같이 11 (또는 3) 대신 0 이므로 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)