Ihre Herausforderung besteht darin, ein Programm oder eine Funktion zu schreiben, die bei zwei gleich langen Zeichenfolgen jedes andere Zeichen vertauscht und die resultierenden Zeichenfolgen in beliebiger Reihenfolge ausgibt bzw. zurückgibt.

Beispiele

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

Regeln

• Die Zeichenfolgen enthalten nur ASCII-Zeichen (32-126).
• Die Zeichenfolgen haben immer die gleiche Länge und sind niemals leer.
• Sie können Eingaben in jedem geeigneten Format akzeptieren: separate Parameter, Elemente in einem Array, getrennt durch eine oder mehrere Zeilenumbrüche, sogar verkettet. Die einzige Einschränkung ist, dass ein String vollständig vor dem anderen stehen muss (z. B. a1\nb2\nc3für "abc", "123"ist ungültig).
• Die Ausgabe kann in beliebiger Reihenfolge erfolgen (dh Sie können mit dem Auswechseln des ersten oder des zweiten Zeichens beginnen) und in einem beliebigen oben genannten gültigen Format erfolgen. (Array mit 2 Elementen, durch Zeilenumbrüche getrennt, verkettet usw.)

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes für jede Sprache.

Haskell, 37 Bytes

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

Komprimiert die beiden Zeichenfolgen, tauscht die Zeichen abwechselnd aus und dekomprimiert sie dann.

Eine 37-Byte-rekursive Alternative:

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

Python, 42 Bytes mit I / O-Golf

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

Vertauscht jedes andere Zeichen der beiden Listen. Nimmt als Eingabe zwei Listen von Zeichen und gibt sie durch Ändern aus .

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

gibt

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

Vim, 18 , 17 Bytes

qqyljvPkvPll@qq@q

Probieren Sie es online!

Dies verwendet den V-Interpreter aus Gründen der Abwärtskompatibilität. Die Eingabe erfolgt in folgendem Format:

string1
string2

Erläuterung:

 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 Bytes

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

Gibt ein Paar mit den Strings zurück. Anwendungsbeispiel: ( (unzip.).(#) ) "Hello," "world!"-> ("Hollo!","werld,").

Einfacher rekursiver Ansatz: Nehmen Sie das erste Zeichen jeder Zeichenfolge als Paar und fügen Sie einen rekursiven Aufruf hinzu, wobei die (übrigen) Zeichenfolgen vertauscht werden. unzipmacht aus der Liste der Paare ein Paar von Listen.

05AB1E , 11 10 Bytes

øvyNFÀ}})ø

Probieren Sie es online!

Erläuterung

Eingabe = ["code", "golf"]wird als Beispiel verwendet.

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

Bytecount enthält 47 Byte Code und -pFlag.

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

Laufen Sie mit -pund -Ekennzeichnen Sie. Erwarten Sie jede Zeichenfolge in einer anderen Zeile:

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

Erklärungen :

-p: Eingabe erfassen $_und am Ende ausdrucken. (um die erste Zeichenfolge abzurufen und auszudrucken)
<>: Eine Eingabezeile abrufen. (um die zweite Zeichenfolge zu erhalten).
=~: wende einen regulären Ausdruck an <>: an s%%%geer, wo dank rder geänderten Zeichenfolge zurückgegeben wird (und dann dank ausgedruckt wird say).
Der reguläre Ausdruck:
.\K(.)findet zwei Zeichen und ersetzt das zweite mit dem Ergebnis der Auswertung dieses Codes "s/.{$-[0]}\\K(.)/$1/;\$1":
Der erste Teil s/.{$-[0]}\\K(.)/$1/wendet einen regulären Ausdruck an auf $_: .{$-[0]}überspringt die ersten Zeichen, um zum gleichen Punkt wie der äußere reguläre Ausdruck zu gelangen (da $-[0]enthält den Index der ersten Erfassungsgruppe, also in diesem Fall der Index der zu ersetzenden Zeichen), und dann erfassen wir ein Zeichen mit(.) und ersetzt ihn durch das Zeichen des äußeren regulären Ausdrucks ( $1). Und dann fügen wir hinzu, $1dass das Ergebnis "s/.{$-[0]}\\K(.)/$1/;\$1"der Charakter ist, den wir in der inneren Regex erfasst haben.
Sie haben das vielleicht bemerkt$1Beziehen Sie sich auf das Zeichen, das in beiden Zeichenfolgen ersetzt werden soll (also auf zwei verschiedene Zeichen), und spielen Sie mit dem /eeModifikator des regulären Ausdrucks, der die rechte Seite des regulären Ausdrucks zweimal auswertet. Der erste ersetzt nur das Zeichen, dem $1nicht das vorangestellt ist \.

Python, 55 Bytes

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

Schneiden!

58 Bytes:

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

64 Bytes:

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

Akkumuliert rekursiv die Zeichen der beiden Zeichenfolgen in sund tund gibt das Paar am Ende aus. Der Wechsel erfolgt durch Umschalten der Eingabezeichenfolgen bei jedem rekursiven Aufruf. Die Ausgabe einer durch Leerzeichen getrennten Zeichenfolge hatte dieselbe Länge:

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

Dies schlägt eine andere rekursive Strategie der abwechselnden Entnahme von Zeichen aus jeder Zeichenfolge mit jeder der beiden möglichen Zeichenfolgen als der ersten knapp aus. (65 Bytes)

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 Bytes

Danke an ETHproductions für 1 Byte!

"@X@YS&h

Die Eingabe ist ein 2D-Array, das die beiden Zeichenfolgen enthält, z ['Halloween'; 'Challenge']. Die Ausgabezeichenfolgen sind in umgekehrter Reihenfolge.

Probieren Sie es online!

Erläuterung

        % 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

Alte Version: 9 Bytes

tZyP:1&YS

Erläuterung

        % 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

Gelee , 5 Bytes

żṚż¥/

Die Eingabe erfolgt als separate Argumente, die Ausgabe wird verkettet.

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Jelly , 9 8 6 Bytes

Danke an Dennis für das Speichern von 2 Bytes!

Zṙ"J$Z

Verwendet die Jelly- Codierung .

Probieren Sie es online!

V , 12 Bytes

lòyljvPkvPll

Probieren Sie es online!

Nichts zu interessantes, nur ein direkter Port meiner vim Antwort, damit ich mit 05AB1E mithalten kann (aber nicht schlagen kann).

Pyke, 9 Bytes

,Fo2%I_(,

Probieren Sie es hier aus!

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

JavaScript (ES6), 51 54

Bearbeite 3 Bytes, die dank @Neil gespeichert wurden

Funktion mit Array-Ein- / Ausgang

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

Ich mag dieses noch, aber es ist 55 (2 Strings in der Eingabe, Array in der Ausgabe)

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

Prüfung

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 Bytes

C.e_FbkC

Probieren Sie es online aus: Demonstration

Transponiert die Wörter, kehrt jedes Buchstabenpaar um, transponiert erneut.

JavaScript (ES6), 55 Byte

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

Ich wollte klug , etwas zu tun mit regexp mit alternativen Zeichen zu ersetzen , sondern dass am Ende unter 67 57 Bytes:

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

Perl, 40 Bytes

Beinhaltet +1 für -n

Geben Sie Strings als Zeilen in STDIN ein

interlace.pl
hello
world
^D

interlace.pl

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

Java, 132 103 100 Bytes

Vielen Dank an Kevin Cruijssen, der unter anderem vorgeschlagen hat, das Array zurückzugeben und 29 Byte zu sparen! Auch Olivier Grégoire für 3 Bytes!

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

So genannt:

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

Ausgabe:

Hollo,werld!

Nutzt die Tatsache, dass Eingaben grundsätzlich auf jede Art und Weise formatiert werden können (in diesem Fall ein einzelnes Zeichen-Array von Zeichenfolgen, die durch ein Komma getrennt sind) und auch ziemlich milde Ausgaberegeln.

C 124 Bytes

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

Rufen Sie an mit:

program.exe string1 string2

Die Länge der Zeichenfolge ist auf 98 Zeichen begrenzt.

Oktave , 64 61 Bytes

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

Anonyme Funktion, die mit jeder Zeichenfolge in einer Zeile ein 2D-Zeichen-Array eingibt und die Ausgabe im gleichen Format erstellt.

Probieren Sie es bei Ideone .

Schläger 208 Bytes

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

Testen:

(f "abcdef" "123456")

Ausgabe:

'("a2c4e6" "1b3d5f")

Oben ist die rekursive Version.

Iterative Version:

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

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

Immer noch Golf spielen ... Nein. Kann nicht scheinen, dieses herunter zu spielen, ohne einen regulären Ausdruck wie andere Antworten zu verwenden (Boo auf Kopieralgorithmen).

Also nehmen wir $aund $bals Strings, setzen den Index $iauf 0, wandeln ihn $aals char-array um und senden ihn durch eine Schleife |%{...}. Bei jeder Iteration verketten wir Zeichenfolgen $cund $dindizieren sie in eine Array-Auswahl (dh, sie wechselt abwechselnd hin und her). Dann verlassen wir $cund befinden uns $din der Pipeline, und die Ausgabe erfolgt implizit Write-Outputnach Abschluss des Programms.

Lithp , 120 Zeichen (+3 für -v1 Flag)

Zeile zweigeteilt zur besseren Lesbarkeit:

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

Benötigt die -v1Flagge umrun.js da einige Funktionen noch nicht Teil der Standardbibliothek sind.

Beispielnutzung:

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

Diese Art von Highlights, die ich nicht genug Zeit für die Standardbibliothek aufgewendet habe. Das js-bridge/1zweimalige Verwenden des langen regulären Ausdrucks sowie das Aufrufen von map using invoke/*all tragen dazu bei, dass dieser Vorgang viel länger dauert als erforderlich.

Zeit, an meiner Standardbibliothek mehr zu arbeiten, denke ich.

PHP, 79 Bytes

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

Vorherige Version PHP, 82 Bytes

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

C 54 52 Bytes

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

Angenommen, die Ausgabe chat bereits die gewünschte Länge.

Verwendung:

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

}

Wenn Sie darauf bestehen, die Ausgabe zu erstellen, finden Sie hier eine 91-Byte- Lösung:

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

Verwendung:

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

C 150 Bytes

Ich habe die typischen Auslassungen von Header-Dateien sowie main()den Rückgabetyp und die Rückgabeanweisung verwendet. Es gibt eine Warnung aus, wird jedoch ohne Probleme kompiliert. Ich habe auch einen GCC-spezifischen Trick verwendet, der Array-Deklarationen mit variablen Ausdrücken ermöglicht.

Das Programm erwartet die Zeichenfolgen von der Befehlszeile und als solche sollte das Programm mit ausgeführt werden ./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);}

Oder besser leserlich,

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 Bytes

Nimmt die Eingabe als Array von zwei Zeichen-Arrays entgegen, wobei die Ausgabe im gleichen Format erfolgt. Die Funktion erstellt einfach das neue Array mit einer (mod 2) -Operation.

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

QBasic 4.5, 172 Bytes

Autsch, dieser wird mit dem alten QBasic schmerzhaft ...

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)

Witzige Tatsache: Mit DEFSTRmehr Bytes gespart, als es kostet, weil ich jetzt Aanstelle von verwenden könnte a$.

QBIC , 112 Bytes

QBIC kann einen Großteil der QBasic-Boilerplate rationalisieren, aber die Hauptmaschine MID$muss noch in QBasic erstellt werden, da QBIC keine Teilzeichenfolgenfunktion besitzt. Trotzdem spart mir 60 Bytes.

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

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

Ungolfed und Prüfung

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

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

Erklärung: {...} definiert eine Funktion, ⍵ ist das richtige Argument. Der Take (↑) erstellt eine Matrix aus den beiden Strings und dreht dann jede Spalte (⊖) n-mal, wobei n der Teil in Klammern (⍳⍴⊃⍵) ist. Das ist definiert als das Jota der Länge des ersten Arguments. (Beispiel: Länge = 5 ==> 1 2 3 4 5). Die erste Spalte wird also einmal gedreht, die zweite wird zweimal gedreht (um zu den ursprünglichen Positionen zurückzukehren), die dritte Spalte wird dreimal gedreht usw.

Probieren Sie es bei tryapl.org