문제는 동일한 길이의 두 문자열이 주어지면 다른 모든 문자를 바꾸고 결과 문자열을 순서대로 출력 / 반환하는 프로그램이나 함수를 작성하는 것입니다.

예

"Hello," "world!" --> "Hollo!" "werld,"
"code" "golf" --> "codf" "gole"
"happy" "angry" --> "hnpry" "aagpy"
"qwerty" "dvorak" --> "qvertk" "dworay"
"1, 2, 3" "a, b, c" --> "1, b, 3" "a, 2, c"
"3.141592653589" "2.718281828459" --> "3.111291623489" "2.748582858559"
"DJMcMayhem" "trichoplax" --> "DrMcMoylex" "tJichapham"
"Doorknob" "Downgoat" --> "Doonkoot" "Dowrgnab"
"Halloween" "Challenge" --> "Hhlloeegn" "Caallwnee"

규칙

• 문자열은 ASCII 문자 (32-126) 만 포함합니다.
• 문자열은 항상 같은 길이이며 절대로 비어 있지 않습니다.
• 별도의 매개 변수, 배열의 항목, 하나 이상의 줄 바꿈으로 구분 된, 심지어 연결된 모든 형식으로 입력을 허용 할 수 있습니다. 유일한 제한은 하나 개의 문자열이 다른 전에 완벽하게 제공해야한다는 것입니다 (예 a1\nb2\nc3를 위해 "abc", "123"유효하지 않습니다).
• 출력은 순서대로 (즉, 첫 번째 또는 두 번째 문자에서 스왑을 시작할 수 있음), 위에서 언급 한 유효한 형식 일 수 있습니다. (2 줄짜리 배열, 줄 바꿈으로 분리, 연결 등)

채점

이것은 code-golf 이므로 각 언어에 대한 가장 짧은 바이트 단위의 코드가 이깁니다.

하스켈, 37 바이트

l=(,):flip(,):l
(unzip.).zipWith3($)l

두 문자열을 압축하여 문자를 교대로 바꾸고 압축을 풉니 다.

37 바이트 재귀 대안 :

(a:b)?(c:d)=a:d?b
e?_=e
a%b=(a?b,b?a)

파이썬, 42 바이트 I / O 골프

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

두 목록의 다른 모든 문자를 바꿉니다. 두 개의 문자 목록을 입력으로 받아서 이를 수정하여 출력 합니다 .

l=list('cat')
m=list('dog')    
print l,m

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

f(l,m)
print l,m

준다

['c', 'a', 't'] ['d', 'o', 'g']
['c', 'o', 't'] ['d', 'a', 'g']

Vim, 18 , 17 바이트

qqyljvPkvPll@qq@q

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

이전 버전과의 호환성 때문에 V 인터프리터를 사용합니다. 입력은 다음 형식으로 제공됩니다.

string1
string2

설명:

 qq                 " Start recording in register 'q'
   yl               " Yank one letter
     j              " Move down a row
      vP            " Swap the yanked letter and the letter under the cursor
        k           " Move back up a row
         vP         " Swap the yanked letter and the letter under the cursor
           ll       " Move two letters to the right. This will throw an error once we're done
             @q     " Call macro 'q' recursively
               q    " Stop recording.
                @q  " Start the recursive loop

하스켈, 41 바이트

(a:b)#(c:d)=(a,c):d#b
_#_=[]
(unzip.).(#)

문자열과 쌍을 반환합니다. 사용 예 : ( (unzip.).(#) ) "Hello," "world!"-> ("Hollo!","werld,").

간단한 재귀 접근 : 각 문자열의 첫 번째 문자를 쌍으로 가져 와서 (나머지) 문자열을 교환하여 재귀 호출을 추가하십시오. unzip쌍 목록에서 목록 쌍을 만듭니다.

05AB1E , 11 10 바이트

øvyNFÀ}})ø

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

설명

입력 = ["code", "golf"]예제로 사용됩니다.

ø             # zip strings into list of pairs
              # STACK: ['cg', 'oo', 'dl', 'ef']
 vy           # for each pair
   NFÀ        # rotate left index times
      }}      # end-if, end-loop
              # STACK: 'cg, 'oo', 'dl', 'fe'
        )ø    # wrap in list and zip
              # OUTPUT: ['codf', 'gole']

펄, 48 바이트

바이트 수에는 47 바이트의 코드와 -p플래그가 포함됩니다.

say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer

로 실행 -p하고 -E플래그를 지정하십시오. 각 문자열을 다른 줄에 기대하십시오.

perl -pE 'say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer' <<< "Hello
World"

설명 :

-p: 입력을 캡처 $_하여 마지막에 인쇄합니다. (첫 번째 문자열을 가져 와서 인쇄하려면)
<>: 입력 줄을 가져옵니다. (두 번째 문자열을 얻기 위해).
=~: 정규식에 적용 <>: (외측 정규식의 문자로 대체 ). 그리고 우리 는 내부 정규 표현식에서 캡처 한 캐릭터 의 결과를 추가 합니다 . 당신은 알아 차렸을 것입니다s%%%geer 여기서 r수정 된 문자열 덕분에 반환됩니다 (그리고 덕분에 인쇄 say).
정규식 :
.\K(.)두 글자를 발견하고,이 코드의 평가 결과와 두번째 대체한다 "s/.{$-[0]}\\K(.)/$1/;\$1":
첫 번째 부분은, s/.{$-[0]}\\K(.)/$1/정규식에 적용 $_: .{$-[0]}이후 (외부 정규식과 같은 점에 도착하는 첫 문자를 생략 $-[0]포함 첫 번째 캡처 그룹의 색인 (이 경우 대체 할 문자의 색인)을 입력 한 다음(.)$1$1"s/.{$-[0]}\\K(.)/$1/;\$1"
$1 우리가 놀 수 있도록, 우리는 두 문자열 (그래서 두 개의 서로 다른 문자)로 대체하려는 문자를 참조 /ee회 정규식의 오른쪽을 평가 정규식의 수정 : 첫 번째 만 대체 할 $1것을 ISN 앞에 오지 않습니다 \.

파이썬, 55 바이트

lambda a,b:[(-~len(a)/2*s)[::len(a)+1]for s in a+b,b+a]

슬라이싱!

58 바이트 :

def f(a,b):n=len(a);print[(s*n)[:n*n:n+1]for s in a+b,b+a]

64 바이트 :

f=lambda a,b,s='',t='':a and f(b[1:],a[1:],s+a[0],t+b[0])or[s,t]

두 문자열의 문자를 sand에 재귀 적으로 누적 t하고 끝에 쌍을 출력합니다. 각 재귀 호출마다 입력 문자열을 전환하여 대체를 수행합니다. 공백으로 구분 된 문자열을 출력하는 길이는 같습니다.

lambda a,b,s='',t=' ':a and f(b[1:],a[1:],s+a[0],t+b[0])or s+t

이것은 두 개의 가능한 각 문자열을 첫 번째 문자열로 사용하여 각 문자열에서 문자를 번갈아가는 다른 재귀 전략을 좁 힙니다. (65 바이트)

g=lambda a,b:a and a[0]+g(b[1:],a[1:])
lambda a,b:(g(a,b),g(b,a))

MATL , 11 10 9 8 바이트

1 바이트 할인 된 ETHproduction 덕분에!

"@X@YS&h

입력은 다음과 같은 두 문자열을 포함하는 2D 배열 ['Halloween'; 'Challenge']입니다. 출력 문자열은 역순입니다.

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

설명

        % Input 2D array implicitly
"       % For each column
  @     %   Push current column
  X@    %   Push iteration index, starting at 1
  YS    %   Circularly shift the column by that amount
  &h    %   Concatenate horizontally with (concatenated) previous columns
        % End implicitly
        % Display implicitly

이전 버전 : 9 바이트

tZyP:1&YS

설명

        % Take input implicitly
t       % Duplicate 
        % STACK: ['Halloween'; 'Challenge'], ['Halloween'; 'Challenge']
Zy      % Size
        % STACK: ['Halloween'; 'Challenge'], [2 9]
P       % Flip array
        % STACK: ['Halloween'; 'Challenge'], [9 2]
:       % Range. Uses first element of the array as input
        % STACK: ['Halloween'; 'Challenge'], [1 2 3 4 5 6 7 8 9]
1&YS    % Circularly shift each column by those amounts respectively
        % STACK: [Caallwnee';'Hhlloeegn']
        % Display implicitly

젤리 , 5 바이트

żṚż¥/

입력은 별도의 인수로, 출력은 연결됩니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

żṚż¥/  Main link. Left argument: s (string). Right argument: t (string)

ż      Zipwith; yield the array of pairs of corresponding characters of s and t.
   ¥   Combine the two links to the left into a dyadic chain:
 Ṛ         Reverse the chain's left argument.
  ż        Zip the result with the chain's right argument.
    /  Reduce the return value of the initial ż by the quicklink Ṛż¥.

젤리 , 9 8 6 바이트

2 바이트를 절약 해 준 Dennis 에게 감사 합니다!

Zṙ"J$Z

젤리 사용 인코딩을 .

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

V , 12 바이트

lòyljvPkvPll

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

너무 흥미롭지는 않지만 vim 답변의 직접 포트이므로 05AB1E와 경쟁 할 수는 있습니다.

파이크, 9 바이트

,Fo2%I_(,

여기 사용해보십시오!

          - o = 0
,         -   transpose(input)
 F     (  -  for i in ^:
  o2%     -    (o++ %2)
     I_   -   if ^: i = reverse(i)
        , - transpose(^)

자바 스크립트 (ES6), 51 54

편집하다thx @Neil으로 저장된 3 바이트

어레이 입 / 출력 기능

p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

나는 이것을 더 좋아하지만 55 (입력 2 문자열, 출력 배열)

(a,b)=>[...a].reduce(([p,q],c,i)=>[q+c,p+b[i]],['',''])

테스트

f=
p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

function go() {
  var a=A.value, b=B.value
  if (a.length == b.length)
    O.textContent = f([a,b]).join('\n')
  else
    O.textContent = '- different length -'
    
}

go()

<input id=A value='Hello,'><input id=B value='world!'>
<button onclick='go()'>go</button><pre id=O></pre>

Pyth, 8 바이트

C.e_FbkC

온라인으로 사용해보십시오 : 데모

단어를 전치하고 각 문자 쌍 '현재 색인'-시간을 반대로 바꾸고 다시 전치합니다.

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

f=([c,...s],[d,...t],o="",p="")=>c?f(t,s,o+c,p+d):[o,p]

대체 문자를 대체하기 위해 regexp를 사용하여 영리한 작업을 원했지만 결국 67 57 바이트가 소요되었습니다.

a=>a.map((s,i)=>a[+!i].replace(/.(.?)/g,(_,c,j)=>s[j]+c))

펄, 40 바이트

에 +1 포함 -n

STDIN에서 문자열을 줄로 제공

interlace.pl
hello
world
^D

interlace.pl

#!/usr/bin/perl -n
s/./${1&$.+pos}[pos]=$&/seg}{print@0,@1

자바, 132 103 100 바이트

배열을 반환하고 (다른 개선 사항 중에서) 29 바이트를 절약 할 것을 제안 해 주신 Kevin Cruijssen에게 감사합니다! 또한 3 바이트 Olivier Grégoire!

char[]c(char[]s,int l){for(int o=l;o-->0;)if(o%2>0){char t=s[o];s[o]=s[l+o+1];s[l+o+1]=t;}return s;}

다음과 같이 호출됩니다.

public static void main(String[] args) {
    System.out.println(c("Hello,world!".toCharArray(), 5)); // 5 is the length of each "String"
}

산출:

Hollo,werld!

입력은 기본적으로 어떤 방식 으로든 (이 경우 쉼표로 구분 된 단일 문자열 배열의 문자열) 형식과 매우 관대 한 출력 규칙의 형식을 이용할 수 있습니다.

C, 124 바이트

main(c,v)char**v;{char a[99],b[99];for(c=0;v[1][c]^0;++c){a[c]=v[1+c%2][c];b[c]=v[2-c%2][c];}a[c]=0;b[c]=0;puts(a);puts(b);}

전화 :

program.exe string1 string2

문자열 길이는 98 자로 제한됩니다.

옥타브 , 64 61 바이트

@(x)reshape(x((t=1:end)+(2*mod(t,2)-1).*(mod(t-1,4)>1)),2,[])

각 문자열을 행으로 2D char 배열을 입력하고 동일한 형식으로 출력을 생성하는 익명 함수.

Ideone에서 사용해보십시오 .

라켓 208 바이트

(let((sl string->list)(ls list->string)(r reverse))(let p((s(sl s))(t(sl t))(u'())(v'())(g #t))(if(null? s)
(list(ls(r u))(ls(r v)))(p(cdr s)(cdr t)(cons(car(if g s t))u)(cons(car(if g t s))v)(if g #f #t)))))

언 골프 드 :

(define (f s t)
  (let ((sl string->list)                ; create short names of fns
        (ls list->string)
        (r reverse))
    (let loop ((s (sl s))                ; convert string to lists
               (t (sl t))
               (u '())                   ; create empty new lists
               (v '())
               (g #t))                   ; a boolean flag
      (if (null? s)                      ; if done, return new lists converted back to strings
          (list (ls (r u))
                (ls (r v)))
          (loop (rest s)
                (rest t)                 ; keep adding chars to new lists alternately
                (cons (first (if g s t)) u) 
                (cons (first (if g t s)) v)
                (if g #f #t))            ; alternate the boolean flag
          ))))

테스트 :

(f "abcdef" "123456")

산출:

'("a2c4e6" "1b3d5f")

위는 재귀 버전입니다.

반복 버전 :

(let*((sl string->list)(ls list->string)(r reverse)(s(sl s))(t(sl t))(l'())(k'())(p(λ(a b g)(set! l(cons(if g a b)l))
(set! k(cons(if g b a)k)))))(for((i s)(j t)(n(in-naturals)))(p i j(if(= 0(modulo n 2)) #t #f)))(list(ls(r l))(ls(r k))))

언 골프 드 :

(define (f s t)
  (let* ((sl string->list)              ; create short form of fn names
         (ls list->string)
         (r reverse)

         (s (sl s))                     ; convert strings to lists
         (t (sl t))

         (l '())                        ; create empty lists for new sequences
         (k '())

         (p (λ(a b g)                   ; fn to add chars to one or other list
              (set! l (cons (if g a b) l))
              (set! k (cons (if g b a) k)))))

    (for ((i s)(j t)(n (in-naturals)))  ; loop with both strings
          (p i j                        ; add to new lists alternately
             (if (= 0 (modulo n 2)) #t #f)))

    (list (ls (r l))                  ; convert reversed lists to strings
          (ls (r k)))))

PowerShell v2 +, 82 바이트

param($a,$b)$i=0;[char[]]$a|%{$c+=($_,$b[$i])[$i%2];$d+=($b[$i],$_)[$i++%2]};$c;$d

아직도 골프를 치고 ... 치고있다. 다른 답변과 같은 정규 표현식을 사용하지 않으면이 문제를 해결할 수없는 것 같습니다 (복사 알고리즘에 대한 부).

우리가 가지고 그래서 $a및 $b문자열, 세트 인덱스로 $i에 0, 주조 $aA와 char-array 및 루프를 통해 보내 |%{...}. 반복 할 때마다, 우리는 문자열 합치에있는 거 $c와 $d배열 - 선택에 색인에 의해 (즉, 그것은 너무 번갈아 앞뒤로). 그런 다음, 우리는 떠날 $c및 $d파이프 라인에, 그리고 암시를 통해 출력은 Write-Output프로그램 완료시 발생합니다.

리스프 , 120 자 (-v1 플래그의 경우 +3)

가독성을 위해 2로 줄 바꿈 :

#P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
     (js-bridge #C,J::(index (index P (& (+ I J) 1)) J))))))

-v1깃발을 요구합니다run.js일부 함수는 아직 표준 라이브러리의 일부가 아니기 .

샘플 사용법 :

(
    (def f #P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
                (js-bridge #C,J::(index (index P (& (+ I J) 1)) J)))))))
    (print (f (list "Hello," "world!")))
)

이런 종류의 하이라이트는 표준 라이브러리에서 충분한 시간을 보내지 않았습니다. 사용해야js-bridge/1두 번 하고 긴 정규식 양식 하고 맵을 사용하여 호출 invoke/*하면 이보다 훨씬 오래 걸립니다.

내 표준 라이브러리에서 작업 할 시간이 더 많다고 생각합니다.

PHP, 79 바이트

for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][+$i]??" $y";

이전 버전 PHP, 82 바이트

for(;$i<strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])$x.=$a[1+$i%2][$i];echo"$x $y";

C, 54 52 바이트

f(char*a,char*b,char*c){while(*c++=*a++,*c++=*b++);}

출력을 가정 c 에 이미 원하는 길이가 있다고 .

용법:

main(){
 char a[]="123456";
 char b[]="abcdef";
 char c[sizeof(a)+sizeof(b)-1];
 f(a,b,c);
 puts(c);

}

출력을 생성해야한다고 주장하면 91 바이트 솔루션이 있습니다.

char*g(char*a,char*b){char*c=malloc(2*strlen(a)),*d=c;while(*c++=*a++,*c++=*b++);return d;}

용법:

main(){
 char a[]="123456";
 char b[]="abcdef";
 puts(g(a,b));
}

C, 150 바이트

헤더 파일의 일반적인 생략과 main()반환 유형 및 반환 문을 사용했습니다. 경고가 발생하지만 문제없이 컴파일됩니다. 또한 변수 식으로 배열 선언을 허용하는 GCC 관련 트릭을 사용했습니다.

프로그램은 명령 행에서 문자열을 예상하므로 프로그램을로 실행해야합니다 ./a.out string1 string2.

main(int a,char**v){int x=strlen(v[1]);char s[x],t[x],c;strcpy(s,v[1]);strcpy(t,v[2]);for(a=0;a<x;++a)if(a%2)c=s[a],s[a]=t[a],t[a]=c;puts(s),puts(t);}

아니면 좀 더 알기 쉽게

main(int a,char**v){
    int x=strlen(v[1]);
    char s[x],t[x],c;
    strcpy(s,v[1]);strcpy(t,v[2]);
    for(a=0;a<x;++a)
        if(a%2)c=s[a],s[a]=t[a],t[a]=c;
    puts(s),puts(t);
}

수학, 51 바이트

입력을 동일한 형식의 출력으로 두 개의 문자 배열로 배열합니다. 이 함수는 단순히 (mod 2) 연산을 사용하여 새 배열을 구성합니다.

Table[#[[Mod[j+i,2]+1,j]],{i,2},{j,Length@#[[1]]}]&

QBasic 4.5, 172 바이트

그렇다, 이것은 ol 'QBasic에 고통스러워한다 ...

DEFSTR A-D:INPUT A,B
IF LEN(A)MOD 2=1 THEN A=A+" ":B=B+" "
FOR x=1 TO LEN(A) STEP 2
C=C+MID$(A,x,1)+MID$(B,x+1,1):D=D+MID$(B,x,1)+MID$(A,x+1,1):NEXT:?RTRIM$(C),RTRIM$(D)

재미있는 사실 : DEFSTR이제 A대신 사용할 수 있기 때문에 비용보다 많은 바이트 를 절약했습니다 a$.

QBIC , 112 바이트

QBIC은 많은 QBasic 상용구를 간소화 할 수 있지만 MID$QBIC에는 하위 문자열 기능이 없기 때문에 여전히 주요 엔진을 QBasic에서 수행해야합니다. 여전히 60 바이트를 절약합니다.

;;_LA|~a%2=1|A=A+@ | B=B+C][1,a,2|X=X+$MID$(A$,b,1)+MID$(B$,b+1,1):Y$=Y$+MID$(B$,b,1)+MID$(A$,b+1,1)|]?_tX|,_tY|

자바, 68 바이트

(a,b)->{for(int i=a.length;--i>0;){char t=a[--i];a[i]=b[i];b[i]=t;}}

언 골프 및 테스트

import java.util.Arrays;
import java.util.Collection;
import java.util.function.BiConsumer;

public class Main {

  static BiConsumer<char[], char[]> func = (left, right) -> {
      for (int i = left.length; --i > 0;) {
        char temp = left[--i];
        left[i] = right[i];
        right[i] = temp;
      }
    };

  public static void main(String[] args) {
    test("Hello,","world!", "Hollo!", "werld,");
    test("code", "golf", "codf", "gole");
    test("happy", "angry", "hnpry", "aagpy");
  }

  private static void test(String left, String right, String x, String y) {
    char[] leftChars = left.toCharArray();
    char[] rightChars = right.toCharArray();
    func.accept(leftChars, rightChars);
    Collection mixed = Arrays.asList(new String(leftChars), new String(rightChars));
    if (mixed.containsAll(Arrays.asList(x, y))) {
      System.out.println("OK");
    } else {
      System.out.printf("NOK: %s, %s -> %s%n", left, right, mixed);
    }
  }
}

APL, 12

{↓(⍳⍴⊃⍵)⊖↑⍵}

설명 : {...}은 함수를 정의합니다. ⍵가 올바른 인수입니다. 테이크 (↑)는 두 문자열에서 행렬을 만든 다음 각 열 (⊖)을 n 번 회전합니다. 여기서 n은 괄호 (⍳⍴⊃⍵) 부분입니다. 그것은 첫 번째 인수 길이의 이오타로 정의됩니다. (예 : 길이 = 5 ==> 1 2 3 4 5). 따라서 첫 번째 열은 한 번 회전하고 두 번째 열은 원래 위치로 돌아가고 세 번째 열은 세 번 회전합니다.

tryapl.org 에서 사용해보십시오