Thử thách của bạn là viết một chương trình hoặc hàm, khi được cho hai chuỗi có độ dài bằng nhau, hoán đổi mọi ký tự khác và xuất / trả về chuỗi kết quả theo thứ tự.

Ví dụ

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

Quy tắc

• Các chuỗi sẽ chỉ chứa ký tự ASCII (32-126).
• Các chuỗi sẽ luôn có cùng độ dài và sẽ không bao giờ trống.
• Bạn có thể chấp nhận đầu vào ở bất kỳ định dạng phù hợp nào: các tham số riêng biệt, các mục trong một mảng, được phân tách bằng một hoặc nhiều dòng mới, thậm chí được nối. Hạn chế duy nhất là một chuỗi phải đến đầy đủ trước chuỗi kia (ví dụ:a1\nb2\nc3 cho "abc", "123"là không hợp lệ).
• Đầu ra có thể theo thứ tự (nghĩa là bạn có thể bắt đầu hoán đổi từ char thứ nhất hoặc thứ hai) và ở bất kỳ định dạng hợp lệ nào được đề cập ở trên. (Mảng 2 mục, được phân tách bằng (các) dòng mới, được nối, v.v.)

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.

Haskell, 37 byte

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

Kéo hai chuỗi, luân phiên hoán đổi các ký tự, sau đó giải nén chúng.

Một thay thế đệ quy 37 byte:

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

Python, 42 byte với chơi gôn I / O

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

Hoán đổi mọi nhân vật khác của hai danh sách. Đưa vào làm hai danh sách các ký tự và đầu ra bằng cách sửa đổi chúng .

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

cho

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

Vim, 18 , 17 byte

qqyljvPkvPll@qq@q

Hãy thử trực tuyến!

Điều này sử dụng trình thông dịch V vì khả năng tương thích ngược. Đầu vào có định dạng này:

string1
string2

Giải trình:

 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

Haskell, 41 byte

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

Trả về một cặp với các chuỗi. Ví dụ sử dụng: ( (unzip.).(#) ) "Hello," "world!"-> ("Hollo!","werld,").

Cách tiếp cận đệ quy đơn giản: lấy char đầu tiên của mỗi chuỗi thành một cặp và nối thêm một cuộc gọi đệ quy với các chuỗi (phần còn lại) được hoán đổi. unziplàm cho một cặp danh sách ra khỏi danh sách các cặp.

05AB1E , 11 10 byte

øvyNFÀ}})ø

Hãy thử trực tuyến!

Giải trình

đầu vào = ["code", "golf"]được sử dụng làm ví dụ.

ø             # 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']

Perl, 48 byte

Bytecount bao gồm 47 byte mã và -pcờ.

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

Chạy với -pvà -Ecờ. Mong đợi mỗi chuỗi trên một dòng khác nhau:

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

Giải thích :

-p: chụp đầu vào $_và in nó ở cuối. (để lấy và in chuỗi đầu tiên)
<>: lấy một dòng đầu vào. (để có được chuỗi thứ hai).
=~: áp dụng biểu thức chính quy cho <>: s%%%geer, trong đó nhờ rchuỗi được sửa đổi được trả về (và sau đó được in nhờ say).
Regex:
.\K(.)tìm thấy hai ký tự và sẽ thay thế ký tự thứ hai bằng kết quả đánh giá mã này "s/.{$-[0]}\\K(.)/$1/;\$1":
Phần thứ nhất, s/.{$-[0]}\\K(.)/$1/áp dụng một biểu thức chính để $_: .{$-[0]}bỏ qua các ký tự đầu tiên để có cùng điểm với biểu thức chính bên ngoài (vì $-[0]có chứa chỉ mục của nhóm chụp đầu tiên, vì vậy trong trường hợp đó, chỉ mục của các ký tự sẽ thay thế), và sau đó chúng tôi chụp một char với(.)và thay thế nó bằng ký tự của regex bên ngoài ( $1). Và sau đó chúng tôi thêm vào $1để kết quả của Bạn có thể nhận thấy rằng tham chiếu đến ký tự mà chúng tôi muốn thay thế trong cả hai chuỗi (vì vậy hai ký tự khác nhau), vì vậy chúng tôi chơi với công cụ sửa đổi của biểu thức chính xác để đánh giá bên phải của biểu thức chính hai lần: cái đầu tiên sẽ chỉ thay thế cái không có trước ."s/.{$-[0]}\\K(.)/$1/;\$1" là nhân vật chúng ta đã bắt trong regex bên trong.
$1/ee$1\

Python, 55 byte

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

Cắt lát!

58 byte:

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

64 byte:

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

Đệ quy tích lũy các ký tự của hai chuỗi vào svà t, và xuất ra cặp của chúng ở cuối. Việc xen kẽ được thực hiện bằng cách chuyển đổi chuỗi đầu vào mỗi cuộc gọi đệ quy. Xuất ra một chuỗi được phân tách bằng dấu cách có cùng độ dài:

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

Điều này đã đánh bại một chiến lược đệ quy khác nhau là lấy các ký tự xen kẽ từ mỗi chuỗi, với mỗi chuỗi có thể là hai chuỗi đầu tiên. (65 byte)

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 byte

Cảm ơn ETHproductions đã tắt 1 byte!

"@X@YS&h

Đầu vào là một mảng 2D chứa hai chuỗi, chẳng hạn như : ['Halloween'; 'Challenge']. Các chuỗi đầu ra theo thứ tự ngược lại.

Hãy thử trực tuyến!

Giải trình

        % 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

Phiên bản cũ: 9 byte

tZyP:1&YS

Giải trình

        % 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

Thạch , 5 byte

żṚż¥/

Đầu vào là các đối số riêng biệt, đầu ra được nối.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

żṚż¥/  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 Ṛż¥.

Thạch , 9 8 6 byte

Cảm ơn Dennis vì đã tiết kiệm 2 byte!

Zṙ"J$Z

Sử dụng mã hóa Jelly .

Hãy thử trực tuyến!

V , 12 byte

lòyljvPkvPll

Hãy thử trực tuyến!

Không có gì quá thú vị, chỉ là một cổng trực tiếp của câu trả lời vim của tôi để tôi có thể cạnh tranh với (nhưng không đánh bại) 05AB1E.

Pyke, 9 byte

,Fo2%I_(,

Hãy thử nó ở đây!

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

JavaScript (ES6), 51 54

Chỉnh sửa 3 byte đã lưu thx @Neil

Chức năng với đầu vào / đầu ra mảng

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

Tôi thích cái này hơn, nhưng nó 55 (2 chuỗi ở đầu vào, mảng ở đầu ra)

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

Kiểm tra

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>

Bình thường, 8 byte

C.e_FbkC

Dùng thử trực tuyến: Trình diễn

Chuyển đổi các từ, đảo ngược từng cặp chữ cái 'chỉ số hiện tại', hoán đổi lại.

JavaScript (ES6), 55 byte

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

Tôi muốn làm điều gì đó thông minh bằng cách sử dụng regrec để thay thế các ký tự thay thế nhưng cuối cùng lại mất 67 57 byte:

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

Perl, 40 byte

Bao gồm +1 cho -n

Đưa chuỗi dưới dạng dòng trên STDIN

interlace.pl
hello
world
^D

interlace.pl

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

Java, 132 103 100 byte

Cảm ơn Kevin Cruijssen đã đề xuất trả lại mảng (trong số các cải tiến khác) và tiết kiệm 29 byte! Ngoài ra Olivier Grégoire cho 3 byte!

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

Được gọi như thế này:

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

Đầu ra:

Hollo,werld!

Lợi dụng thực tế là đầu vào về cơ bản có thể được định dạng theo bất kỳ cách nào (trong trường hợp này là một chuỗi char duy nhất được phân định bằng dấu phẩy) và quy tắc đầu ra khá dễ chịu.

C, 124 byte

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);}

Gọi với:

program.exe string1 string2

Độ dài chuỗi được giới hạn trong 98 ký tự.

Octave , 64 61 byte

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

Hàm ẩn danh nhập một mảng char 2D với mỗi chuỗi liên tiếp và tạo đầu ra theo cùng định dạng.

Hãy thử nó tại Ideone .

Vợt 208 byte

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

Ung dung:

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

Kiểm tra:

(f "abcdef" "123456")

Đầu ra:

'("a2c4e6" "1b3d5f")

Trên đây là phiên bản đệ quy.

Phiên bản lặp:

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

Ung dung:

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

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

Vẫn đang chơi gôn ... Không. Dường như không thể đánh golf điều này xuống mà không sử dụng biểu thức chính quy như các câu trả lời khác (boo về sao chép thuật toán).

Vì vậy, chúng tôi lấy $avà $blàm chuỗi, đặt chỉ mục $ithành 0, truyền $adưới dạng char-array và gửi nó qua một vòng lặp |%{...}. Mỗi lần lặp, chúng ta nối chuỗi $cvà lên $dbằng cách lập chỉ mục vào một mảng chọn (nghĩa là nó sẽ luân phiên qua lại). Sau đó, chúng tôi rời khỏi $cvà $dtrên đường ống dẫn, và đầu ra thông qua ngầm Write-Outputxảy ra khi hoàn thành chương trình.

Tiếng Litva , 120 ký tự (+3 cho cờ -v1)

Dòng chia làm 2 để dễ đọc:

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

Yêu cầu -v1cờrun.js như một số chức năng chưa phải là một phần của thư viện tiêu chuẩn.

Sử dụng mẫu:

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

Đây là loại điểm nổi bật mà tôi đã không dành đủ thời gian cho thư viện tiêu chuẩn. Phải sử dụng js-bridge/1hai lần và hình thức regex dài, cũng như gọi bản đồ bằng cách sử dụng invoke/*tất cả các đóng góp cho việc này dài hơn nhiều so với nó cần phải có.

Thời gian để làm việc trên thư viện tiêu chuẩn của tôi nhiều hơn tôi nghĩ.

PHP, 79 byte

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

Phiên bản trước PHP, 82 byte

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

C, 54 52 byte

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

Giả sử đầu ra cđã có độ dài mong muốn.

Sử dụng:

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

}

Nếu bạn khăng khăng tạo đầu ra, đây là giải pháp 91 byte :

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

Sử dụng:

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

C, 150 byte

Tôi đã sử dụng các thiếu sót điển hình của các tệp tiêu đề và main() loại trả về và câu lệnh trả về. Nó ném một cảnh báo, nhưng biên dịch mà không có vấn đề. Tôi cũng đã sử dụng một thủ thuật dành riêng cho GCC cho phép khai báo mảng với các biểu thức biến.

Chương trình mong đợi các chuỗi từ dòng lệnh, và do đó, chương trình nên được chạy với ./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);}

Hoặc rõ ràng hơn,

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);
}

Toán học, 51 byte

Đưa đầu vào thành một mảng gồm hai mảng ký tự, với đầu ra có cùng định dạng. Hàm chỉ đơn giản là xây dựng mảng mới bằng cách sử dụng thao tác (mod 2).

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

QBasic 4.5, 172 byte

Ôi, cái này trở nên đau đớn với 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)

Sự thật thú vị: Sử dụng DEFSTRtiết kiệm nhiều byte hơn chi phí vì bây giờ tôi có thể sử dụng Athay vì a$.

QBIC , 112 byte

QBIC có thể hợp lý hóa rất nhiều nồi hơi QBasic, nhưng MID$động cơ chính vẫn cần được thực hiện trong QBasic vì QBIC thiếu chức năng chuỗi con. Tuy nhiên, tiết kiệm cho tôi 60 byte.

;;_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|

Java, 68 byte

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

Thử thách và thử nghiệm

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

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

Giải thích: {...} định nghĩa một hàm, là đối số đúng. Take (↑) tạo ra một ma trận trong hai chuỗi, sau đó xoay mỗi cột (⊖) n lần, trong đó n là phần trong ngoặc đơn (⍳⍴⊃⍵). Điều đó được định nghĩa là iota về độ dài của đối số đầu tiên. (Ví dụ: chiều dài = 5 ==> 1 2 3 4 5). Vì vậy, cột đầu tiên được xoay một lần, lần thứ hai hai lần (quay trở lại vị trí ban đầu), cột thứ ba ba lần, v.v ...

Dùng thử tại tryapl.org