Buradaki zorluk, eşit uzunlukta iki dize verildiğinde diğer karakterlerin her birini değiştiren ve çıkan dizeleri her iki sırada veren / veren bir program veya işlev yazmaktır.

Örnekler

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

kurallar

• Dizeler yalnızca ASCII karakterlerini (32-126) içerecektir.
• Dizeler her zaman aynı uzunlukta olacak ve asla boş olmayacak.
• Herhangi bir uygun formattaki girişi kabul edebilirsiniz: ayrı parametreler, bir dizideki öğeler, bir veya daha fazla yeni satırla ayrılmış, hatta birleştirilmiş bile. Tek kısıtlama tek dize diğer öncesinde tam gelmesi gerektiğini (örneğin a1\nb2\nc3için "abc", "123"geçersiz).
• Çıktı iki sırada olabilir (yani birinci veya ikinci karakterden değiş tokuş etmeye başlayabilirsiniz) ve yukarıda belirtilen herhangi bir geçerli biçimde olabilir. (2 satırlı dizi, yeni satırlarla ayrılmış, birleştirilmiş, vb.)

puanlama

Bu kod golf , yani her dil için bayt cinsinden en kısa kod kazanır.

Haskell, 37 bayt

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

İki dizeyi sıkıştırır, sırayla karakterleri değiştirir, ardından çıkarır.

37 bayt özyinelemeli bir alternatif:

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

Python, G / Ç golf ile birlikte 42 bayt

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

İki listenin diğer karakterlerini değiştirir. Girdi olarak iki karakter listesi alır ve bunları değiştirerek çıktılar .

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

verir

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

Vim, 18 , 17 bayt

qqyljvPkvPll@qq@q

Çevrimiçi deneyin!

Bu V yorumlayıcısını geriye dönük uyumluluk nedeniyle kullanır. Giriş bu biçimde gelir:

string1
string2

Açıklama:

 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 bayt

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

Dizelerle bir çift döndürür. Kullanım örneği: ( (unzip.).(#) ) "Hello," "world!"->("Hollo!","werld,") .

Basit özyinelemeli yaklaşım: her dizenin ilk karakterini bir çift olarak alın ve (geri kalanı) dizeleri değiştirilmiş olarak özyinelemeli bir çağrı ekleyin. unzipçift ​​listesinden bir çift liste oluşturur.

05AB1E , 11 10 bayt

øvyNFÀ}})ø

Çevrimiçi deneyin!

açıklama

input = ["code", "golf"]örnek olarak kullanılır.

ø             # 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 bayt

Bayt sayısı, 47 bayt kod ve -pbayrağını içerir.

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

İle koş -pve -Ebayrak. Her dize farklı bir satırda bekleyin:

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

Açıklamalar :

-p: girişi yakalar $_ve sonunda yazdırır. (ilk dizgeyi almak ve yazdırmak için)
<>: bir satır girdi olsun. (ikinci dizgeyi almak için).
=~: İçin bir normal ifade uygulamak <>: s%%%geernereye sayesinde rmodifiye dize döndürülür (ve sonra sayesinde yazdırılır say).
Regex:
.\K(.)iki karakter bulur ve bu kodun değerlendirilmesi sonucunda ikinci bir yerini alacak "s/.{$-[0]}\\K(.)/$1/;\$1":
ilk bölümü, s/.{$-[0]}\\K(.)/$1/regex için geçerlidir $_: .{$-[0]}beri (dış regex ile aynı noktaya gelmek için ilk karakterlerini atlar $-[0]içeriyor ilk yakalama grubunun dizini, bu durumda değiştirilecek karakterlerin dizini) ve sonra bir karakter yakalayacağız(.) ve onu dış regex'in ( $1) karakteriyle değiştirir . Ve sonra şunu ekleriz $1ki, sonuç "s/.{$-[0]}\\K(.)/$1/;\$1"iç regex'te yakaladığımız karakterdir.
Fark etmişsinizdir$1her iki dizede de değiştirmek istediğimiz karaktere (yani iki farklı karaktere) bakın, bu nedenle /eeregex'in sağ tarafını iki kez değerlendiren regex'in değiştiricisi ile oynarız : ilki, yalnızca $1önce gelenlerin yerine geçecektir . \.

Python, 55 bayt

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

Dilimleme!

58 bayt:

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

64 bayt:

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

İki dizenin karakterlerini tekrar tekrar biriktirir s ve tve sonunda bunların çifti çıkarır. Değiştirme işlemi, her tekrarlamalı aramada giriş dizgileri değiştirilerek yapılır. Boşluğa ayrılmış bir dizgenin çıktısı aynı uzunluktaydı:

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

Bu, her iki dizgiden birer birer karakter olarak karakter dizilerini sırayla değiştiren farklı bir özyinelemeli stratejiyi dar bir şekilde attı. (65 bayt)

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 bayt

1 byte kapalı ETHproductions sayesinde!

"@X@YS&h

Giriş, aşağıdaki gibi iki dizeyi içeren bir 2D dizisidir: ['Halloween'; 'Challenge'] . Çıkış dizeleri ters sıradadır.

Çevrimiçi deneyin!

açıklama

        % 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

Eski versiyon: 9 bayt

tZyP:1&YS

açıklama

        % 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

Jöle , 5 bayt

żṚż¥/

Giriş ayrı argümanlar gibidir, çıktı birleştirildi.

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

Jöle , 9 8 6 bayt

2 bayt kaydettiğiniz için Dennis'e teşekkürler !

Zṙ"J$Z

Jelly kodlamasını kullanır .

Çevrimiçi deneyin!

V , 12 bayt

lòyljvPkvPll

Çevrimiçi deneyin!

Çok ilginç bir şey yok, sadece vim cevabımın doğrudan bir limanı, böylece 05AB1E ile rekabet edebiliyorum (ama yenemiyorum).

Pyke, 9 bayt

,Fo2%I_(,

Burada dene!

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

JavaScript (ES6), 51 54

Düzenle3 bayt thx @Neil kaydetti

Dizi giriş / çıkışlı fonksiyon

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

Bunu daha çok seviyorum, ama 55 (girişte 2 karakter, çıktıda dizi)

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

Ölçek

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 bayt

C.e_FbkC

Çevrimiçi deneyin: Gösteri

Kelimeleri çevirir, her bir harf çiftinin 'geçerli indeks' 'zamanını tersine çevirir, tekrar değiştirir.

JavaScript (ES6), 55 bayt

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

Alternatif karakterleri değiştirmek için regexp kullanarak zekice bir şey yapmak istedim ancak bu, 67 57 bayt aldı:

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

Perl, 40 bayt

İçin +1 içerir -n

Dizeleri STDIN'de çizgi olarak ver

interlace.pl
hello
world
^D

interlace.pl

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

Java, 132 103 100 bayt

Diziyi döndürmeyi (diğer geliştirmelerin yanı sıra) önerdiğiniz ve 29 bayt kaydettiğiniz için teşekkür ederiz. Ayrıca 3 bayt için 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;}

Böyle denir:

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

Çıktı:

Hollo,werld!

Girdilerin temelde herhangi bir şekilde biçimlendirilebilmesinden (bu durumda, virgülle sınırlandırılmış tek bir karakter dizgisi dizisi) ve oldukça esnek çıktı kurallarından faydalanır.

C, 124 bayt

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

İle ara:

program.exe string1 string2

Dize uzunluğu 98 karakterle sınırlıdır.

Octave , 64 61 bayt

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

Her karakterli bir satırda 2B karakter dizisi giren ve çıktıyı aynı biçimde üreten adsız işlev.

Ideone'da dene .

Raket 208 bayt

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

Ungolfed:

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

Test yapmak:

(f "abcdef" "123456")

Çıktı:

'("a2c4e6" "1b3d5f")

Yukarıda özyinelemeli versiyonu.

Yinelemeli sürüm:

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

Ungolfed:

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

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

Hala golf ... Hayır. Diğer cevaplar gibi bir regex kullanmadan bu herhangi bir golf gibi görünmüyor (kopyalama algoritmaları boo).

Aldığımız Yani $ave $bdizeleri, ayarlanan endeksi olarak $ikarşı 0, döküm $abir şekilde char-array ve bir döngü yoluyla göndermek |%{...}. Her yinelemede, bir dizi seçiminde dizine ekleyerek $cve onu birleştirerek diziliyoruz $d(yani, ileri geri değişiyor). Ardından, boru hattından ayrılırız $cve $dörtülü bir şekilde çıktı Write-Output, program tamamlandığında olur.

Lithp , 120 karakter ( -v1 bayrağı için +3)

Satır okunabilirlik için ikiye bölünmüş:

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

-v1Bayrağını gerektirirrun.jsBazı işlevlerin henüz standart kütüphanenin bir parçası olmadığı .

Örnek kullanım:

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

Bu tür standart kütüphanede yeterince zaman harcamamıştım. js-bridge/1İki kere ve uzun regex formunu kullanmak ve ayrıca haritayı kullanarakinvoke/* hepsini olması gerekenden daha uzun olmasına katkıda bulunur.

Sanırım standart kütüphanemde çalışma zamanı geldi.

PHP, 79 Bayt

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

Önceki Sürüm PHP, 82 Bayt

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

C, 54 52 bayt

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

Çıktı alır c zaten istenen uzunluğa sahip olduğunu .

Kullanımı:

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

}

Çıktıyı oluşturmakta ısrar ediyorsanız, işte 91 baytlık bir çözüm:

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

Kullanımı:

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

C, 150 bayt

Başlık dosyalarının tipik ihmallerini ve main()return type ve return deyimini kullandım. Bir uyarı atar, ancak sorunsuz derler. Ayrıca değişken ifadeli dizi bildirimlerine izin veren GCC'ye özgü bir numara kullandım.

Program, dizgileri komut satırından bekler ve bu nedenle programın çalıştırılması gerekir ./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);}

Ya da daha okunaklı

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

Mathematica, 51 bayt

Girdiyi aynı formatta, iki karakter dizisinden oluşan bir dizi olarak alır. İşlev, yeni bir dizi (mod 2) işlemi kullanarak oluşturur.

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

QBasic 4.5, 172 bayt

Ah, bu bir ol 'QBasic ile acı çekiyor ...

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)

Eğlenceli gerçek: Kullanmak DEFSTR, maliyetinden daha fazla byte kaydetti çünkü artık kullanmak Ayerine kullanabiliyordum a$.

QBIC , 112 bayt

QBIC birçok QBasic kazan plakasını düzene sokabilir, ancak MID$QBIC'in bir alt-fonksiyondan yoksun olması nedeniyle ana motorun hala QBasic'te yapılması gerekiyor. Yine de, bana 60 byte kazandırır.

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

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

Ungolfed ve test

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

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

Explanation: {...} bir işlevi tanımlar, ⍵ doğru argümandır. Alma (↑) iki dizgiden bir matris oluşturur, daha sonra her sütunu (⊖) n kere döndürür, burada n parantez içindeki kısımdır (⍳⍴⊃⍵). İlk argümanın uzunluğunun iotası olarak tanımlanır. (Örn: uzunluk = 5 ==> 1 2 3 4 5). Böylece, ilk sütun bir kez, ikinci kez iki kez (orijinal konumlarına dönerek), üçüncü sütun üç kez vb. Döndürülür.

Tryapl.org adresinde deneyin