La tua sfida è scrivere un programma o una funzione che, quando vengono date due stringhe di uguale lunghezza, scambia ogni altro carattere e genera / restituisce le stringhe risultanti in entrambi gli ordini.

Esempi

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

Regole

• Le stringhe conterranno solo caratteri ASCII (32-126).
• Le stringhe avranno sempre la stessa lunghezza e non saranno mai vuote.
• È possibile accettare input in qualsiasi formato adatto: parametri separati, elementi in un array, separati da una o più nuove righe, anche concatenati. L'unica limitazione è che una stringa deve venire completamente prima dell'altra (ad es. a1\nb2\nc3Per "abc", "123"non è valida).
• L'output può essere in entrambi gli ordini (ovvero è possibile iniziare a scambiare dal primo o dal secondo carattere) e in qualsiasi formato valido sopra menzionato. (Array di 2 elementi, separato da newline (s), concatenato, ecc.)

punteggio

Questo è code-golf , quindi vince il codice più breve in byte per ogni lingua.

Haskell, 37 byte

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

Comprime le due stringhe, scambiando alternativamente i caratteri, quindi decomprimendoli.

Un'alternativa ricorsiva a 37 byte:

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

Python, 42 byte con golf I / O

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

Scambia ogni altro carattere delle due liste. Accetta come input due elenchi di caratteri e li emette modificandoli .

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

dà

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

Vim, 18 , 17 byte

qqyljvPkvPll@qq@q

Provalo online!

Questo utilizza l'interprete V a causa della compatibilità con le versioni precedenti. L'input è disponibile in questo formato:

string1
string2

Spiegazione:

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

Restituisce una coppia con le stringhe. Esempio di utilizzo:( (unzip.).(#) ) "Hello," "world!" -> ("Hollo!","werld,").

Approccio ricorsivo semplice: prendere il primo carattere di ogni stringa come coppia e aggiungere una chiamata ricorsiva con le (restanti) stringhe scambiate. unzipcrea una coppia di liste dall'elenco delle coppie.

05AB1E , 11 10 byte

øvyNFÀ}})ø

Provalo online!

Spiegazione

input = ["code", "golf"]usato come esempio.

ø             # 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 include 47 byte di codice e -pflag.

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

Corri con -pe -Ebandiera. Aspettati ogni stringa su una riga diversa:

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

spiegazioni :

-p: cattura l'ingresso $_e lo stampa alla fine. (per ottenere e stampare la prima stringa)
<>: ottenere una riga di input. (per ottenere la seconda stringa).
=~: Applicare una regex per <>: s%%%geer, dove grazie al rsi restituisce la stringa modificata (e quindi grazie a stampato say).
La regex:
.\K(.)trova due caratteri e sostituirà la seconda con il risultato della valutazione di questo codice "s/.{$-[0]}\\K(.)/$1/;\$1":
La prima parte, s/.{$-[0]}\\K(.)/$1/applica una regex a $_:.{$-[0]} salta i primi caratteri per arrivare allo stesso punto della regex esterna (poiché $-[0]contiene il indice del primo gruppo di acquisizione, quindi in questo caso l'indice dei caratteri da sostituire), quindi catturiamo un carattere con(.)e sostituirlo con il carattere del regex esterno ( $1). E poi aggiungiamo $1così il risultato di "s/.{$-[0]}\\K(.)/$1/;\$1"è il personaggio che abbiamo catturato nella regex interiore.
Potresti aver notato che si $1riferiscono al personaggio che vogliamo sostituire in entrambe le stringhe (quindi due caratteri diversi), quindi giochiamo con il /eemodificatore della regex che valuta due volte il lato destro della regex: il primo sostituirà solo quello $1che non è preceduto dal \.

Python, 55 byte

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

Affettare!

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]

Accumula in modo ricorsivo i caratteri delle due stringhe in se te ne genera la coppia alla fine. L'alternanza viene eseguita cambiando le stringhe di input per ciascuna chiamata ricorsiva. L'output di una stringa separata da spazio era della stessa lunghezza:

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

Questo ha stroncato una diversa strategia ricorsiva di prendere alternativamente caratteri da ogni stringa, con ognuna delle due possibili stringhe come la prima. (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

Grazie a ETHproductions per 1 byte di sconto!

"@X@YS&h

Input è una matrice 2D contenente le due stringhe, quali: ['Halloween'; 'Challenge']. Le stringhe di output sono in ordine inverso.

Provalo online!

Spiegazione

        % 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

Vecchia versione: 9 byte

tZyP:1&YS

Spiegazione

        % 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

Gelatina , 5 byte

żṚż¥/

L'input è come argomenti separati, l'output è concatenato.

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Grazie a Dennis per aver salvato 2 byte!

Zṙ"J$Z

Utilizza la codifica Jelly .

Provalo online!

V , 12 byte

lòyljvPkvPll

Provalo online!

Niente di troppo interessante, solo una porta diretta della mia risposta VIM in modo da poter competere con (ma non battere) 05AB1E.

Pyke, 9 byte

,Fo2%I_(,

Provalo qui!

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

JavaScript (ES6), 51 54

Modifica 3 byte salvati grazie a @Neil

Funzione con input / output array

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

Mi piace di più, ma è 55 (2 stringhe in input, array in output)

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

Test

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 byte

C.e_FbkC

Provalo online: dimostrazione

Traspone le parole, inverte ogni coppia di "indici attuali" volte, traspone di nuovo.

JavaScript (ES6), 55 byte

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

Volevo fare qualcosa di intelligente usando regexp per sostituire i caratteri alternativi, ma alla fine ho preso 67 57 byte:

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

Perl, 40 byte

Include +1 per -n

Dare stringhe come linee su 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

Grazie a Kevin Cruijssen per aver suggerito di restituire l'array (tra gli altri miglioramenti) e di risparmiare 29 byte! Anche Olivier Grégoire per 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;}

Chiamato così:

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

Produzione:

Hollo,werld!

Sfrutta il fatto che l'input può essere sostanzialmente formattato in qualsiasi modo (in questo caso, un singolo array di caratteri di stringhe delimitato da una virgola) e anche regole di output piuttosto indulgenti.

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

Chiama con:

program.exe string1 string2

La lunghezza della stringa è limitata a 98 caratteri.

Ottava , 64 61 byte

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

Funzione anonima che immette un array di caratteri 2D con ciascuna stringa in una riga e produce l'output nello stesso formato.

Provalo su Ideone .

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

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:

(f "abcdef" "123456")

Produzione:

'("a2c4e6" "1b3d5f")

Sopra è la versione ricorsiva.

Versione iterativa:

(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

Ancora golf ... No. Non riesco a giocarci sopra senza usare una regex come le altre risposte (boo su algoritmi di copia).

Quindi prendiamo $ae $bcome stringhe, impostiamo index $isu 0, lanciamo $acome un chararray e lo inviamo attraverso un loop |%{...}. Ad ogni iterazione, stiamo concatenando stringhe su $ce $dindicizzando in una selezione di array (cioè, quindi si alterna avanti e indietro). Quindi, lasciamo $ce siamo $din cantiere e l'output tramite implicito Write-Outputavviene al completamento del programma.

Lithp , 120 caratteri (+3 per -v1 flag)

Linea divisa in 2 per leggibilità:

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

Richiede la -v1bandiera perrun.js quanto alcune funzioni non fanno ancora parte della libreria standard.

Esempio di utilizzo:

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

Questo tipo di punti salienti che non ho trascorso abbastanza tempo nella libreria standard. Dover usarejs-bridge/1 due volte e il lungo modulo regex, oltre a invocare la mappa usando invoke/*tutto, contribuisce a rendere questo molto più lungo di quanto deve essere.

Tempo per lavorare sulla mia biblioteca standard più penso.

PHP, 79 byte

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

Versione precedente 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++);}

Presuppone che l'output cabbia già la lunghezza desiderata.

Uso:

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

}

Se insisti nel creare l'output, ecco una soluzione di 91 byte :

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

Uso:

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

C, 150 byte

Ho usato le tipiche omissioni dei file header e main()il tipo di ritorno e la dichiarazione di ritorno. Emette un avvertimento, ma viene compilato senza problemi. Ho anche usato un trucco specifico per GCC che consente dichiarazioni di array con espressioni variabili.

Il programma prevede le stringhe dalla riga di comando e come tale, il programma dovrebbe essere eseguito con ./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);}

O più leggibilmente,

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 byte

Accetta input come una matrice di due array di caratteri, con output nello stesso formato. La funzione costruisce semplicemente il nuovo array usando un'operazione (mod 2).

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

QBasic 4.5, 172 byte

Ahi, questo diventa doloroso con il vecchio 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)

Curiosità: usare DEFSTRpiù byte risparmiati di quanto sia costato perché ora potrei usare Ainvece di a$.

QBIC , 112 byte

QBIC può semplificare gran parte della piastra della caldaia QBasic, ma il MID$motore principale deve ancora essere eseguito in QBasic perché QBIC non ha una funzione di sottostringa. Tuttavia, mi fa risparmiare 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;}}

Ungolfed e 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

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

Spiegazione: {...} definisce una funzione, ⍵ è l'argomento giusto. Il Take (↑) crea una matrice dalle due stringhe, quindi ruota ogni colonna (⊖) n volte, dove n è la parte tra parentesi (⍳⍴⊃⍵). Questo è definito come iota della lunghezza del primo argomento. (Es .: lunghezza = 5 ==> 1 2 3 4 5). Quindi la prima colonna viene ruotata una volta, la seconda due volte (tornando alle posizioni originali), la terza colonna tre volte, ecc ...

Provalo su tryapl.org