Su desafío es escribir un programa o función que, cuando se le dan dos cadenas de igual longitud, intercambia cada otro carácter y genera / devuelve las cadenas resultantes en cualquier orden.

Ejemplos

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

Reglas

• Las cadenas solo contendrán caracteres ASCII (32-126).
• Las cadenas siempre tendrán la misma longitud y nunca estarán vacías.
• Puede aceptar entradas en cualquier formato adecuado: parámetros separados, elementos en una matriz, separados por una o más líneas nuevas, incluso concatenados. La única restricción es que una cadena debe aparecer completamente antes que la otra (por ejemplo, a1\nb2\nc3for "abc", "123"no es válida).
• La salida puede estar en cualquier orden (es decir, puede comenzar a intercambiar desde el primer o el segundo carácter), y en cualquier formato válido mencionado anteriormente. (Matriz de 2 elementos, separados por línea (s) nueva, concatenados, etc.)

Tanteo

Este es el código de golf , por lo que gana el código más corto en bytes para cada idioma.

Haskell, 37 bytes

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

Comprime las dos cadenas, alternando alternativamente los caracteres, luego descomprime.

Una alternativa recursiva de 37 bytes:

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

Python, 42 bytes con golf de E / S

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

Intercambia cualquier otro personaje de las dos listas. Toma como entrada dos listas de caracteres y sale modificándolos .

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

da

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

Vim, 18 , 17 bytes

qqyljvPkvPll@qq@q

Pruébalo en línea!

Esto utiliza el intérprete de V debido a la compatibilidad con versiones anteriores. La entrada viene en este formato:

string1
string2

Explicación:

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

Devuelve un par con las cadenas. Ejemplo de uso: ( (unzip.).(#) ) "Hello," "world!"->("Hollo!","werld,") .

Enfoque recursivo simple: tome el primer carácter de cada cadena como un par y agregue una llamada recursiva con el (resto de) cadenas intercambiadas. unziphace un par de listas de la lista de pares.

05AB1E , 11 10 bytes

øvyNFÀ}})ø

Pruébalo en línea!

Explicación

input = ["code", "golf"]usado como ejemplo.

ø             # 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 incluye 47 bytes de código y -pbandera.

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

Corre con -py -Ebandera. Espere cada cadena en una línea diferente:

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

Explicaciones :

-p: captura la entrada $_y la imprime al final. (para obtener e imprimir la primera cadena)
<>: obtenga una línea de entrada. (para obtener la segunda cadena).
=~: aplica una expresión regular a <>:, s%%%geerdonde rse devuelve gracias a la cadena modificada (y luego se imprime gracias a say).
La expresión regular:
.\K(.)encuentra dos caracteres y reemplazará el segundo con el resultado de la evaluación de este código "s/.{$-[0]}\\K(.)/$1/;\$1":
la primera parte, s/.{$-[0]}\\K(.)/$1/aplica una expresión regular a $_: y la reemplaza con el carácter de la expresión regular externa ( ). Y luego agregamos, por lo que el resultado es el personaje que capturamos en la expresión regular interna. Puede que hayas notado que.{$-[0]} omite los primeros caracteres para llegar al mismo punto que la expresión regular externa (ya que $-[0]contiene índice del primer grupo de captura, entonces en ese caso el índice de los caracteres a sustituir), y luego capturamos un carácter con(.)$1$1"s/.{$-[0]}\\K(.)/$1/;\$1"
$1nos referimos al carácter que queremos reemplazar en ambas cadenas (por lo tanto, dos caracteres diferentes), así que jugamos con el /eemodificador de la expresión regular que evalúa el lado derecho de la expresión regular dos veces: el primero sustituirá solo el $1que no está precedido por el \.

Python, 55 bytes

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

Rebanar!

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]

Acumula recursivamente los caracteres de las dos cadenas en sy t, y genera el par de ellas al final. La alternancia se realiza cambiando las cadenas de entrada de cada llamada recursiva. La salida de una cadena separada por espacios tenía la misma longitud:

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

Esto superó por poco una estrategia recursiva diferente de tomar alternativamente caracteres de cada cadena, con cada una de las dos cadenas posibles como la primera. (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

¡Gracias a ETHproductions por 1 byte de descuento!

"@X@YS&h

La entrada es una matriz 2D que contiene las dos cadenas, como: ['Halloween'; 'Challenge'] . Las cadenas de salida están en orden inverso.

Pruébalo en línea!

Explicación

        % 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

Versión anterior: 9 bytes

tZyP:1&YS

Explicación

        % 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

Jalea , 5 bytes

żṚż¥/

La entrada es como argumentos separados, la salida se concatena.

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Gelatina , 9 8 6 bytes

¡Gracias a Dennis por guardar 2 bytes!

Zṙ"J$Z

Utiliza la codificación Jelly .

Pruébalo en línea!

V , 12 bytes

lòyljvPkvPll

Pruébalo en línea!

Nada demasiado interesante, solo un puerto directo de mi respuesta vim para que pueda competir con (pero no vencer) 05AB1E.

Pyke, 9 bytes

,Fo2%I_(,

Pruébalo aquí!

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

JavaScript (ES6), 51 54

Editar 3 bytes guardados gracias a @Neil

Función con entrada / salida de matriz

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

Me gusta más, pero es 55 (2 cadenas en entrada, matriz en salida)

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

Prueba

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

Pruébelo en línea: demostración

Transpone las palabras, invierte cada par de letras 'índice actual'-veces, transpone nuevamente.

JavaScript (ES6), 55 bytes

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

Quería hacer algo inteligente con el uso de regexp para reemplazar caracteres alternativos, pero eso terminó tomando 67 57 bytes:

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

Perl, 40 bytes

Incluye +1 para -n

Dar cadenas como líneas en STDIN

interlace.pl
hello
world
^D

interlace.pl

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

Java, 132 103 100 bytes

¡Gracias a Kevin Cruijssen por sugerir devolver la matriz (entre otras mejoras) y guardar 29 bytes! ¡También Olivier Grégoire por 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;}

Llamado así:

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

Salida:

Hollo,werld!

Aprovecha el hecho de que la entrada básicamente puede formatearse de cualquier manera (en este caso, una única matriz de caracteres de cadenas que están delimitadas por una coma) y reglas de salida bastante indulgentes.

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

Llamar con:

program.exe string1 string2

La longitud de la cadena está limitada a 98 caracteres.

Octava , 64 61 bytes

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

Función anónima que ingresa una matriz de caracteres 2D con cada cadena en una fila y produce la salida en el mismo formato.

Pruébalo en Ideone .

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

Sin golf:

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

Pruebas:

(f "abcdef" "123456")

Salida:

'("a2c4e6" "1b3d5f")

Arriba está la versión recursiva.

Versión 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))))

Sin golf:

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

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

Todavía jugando al golf ... No. Parece que no se puede reducir esto sin usar una expresión regular como otras respuestas (abucheo en los algoritmos de copia).

Así que tomamos $ay $bcomo cadenas, establecemos el índice $ien 0, lo convertimos $aen una charmatriz y lo enviamos a través de un bucle |%{...}. Cada iteración, estamos concatenando cadenas $ce $dindexando en una selección de matriz (es decir, alternando de un lado a otro). Luego, nos vamos $cy estamos $den la tubería, y la salida a través de lo implícito Write-Outputsucede al finalizar el programa.

Lithp , 120 caracteres (+3 para la bandera -v1)

Línea dividida en 2 para facilitar la lectura:

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

Requiere la -v1bandera pararun.js ya que algunas funciones aún no forman parte de la biblioteca estándar.

Uso de la muestra:

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

Este tipo de aspectos destacados que no he pasado suficiente tiempo en la biblioteca estándar. Tener que usar js-bridge/1dos veces y la forma de expresión regular larga, así como invocar el uso del mapa, invoke/*contribuyen a que esto sea mucho más largo de lo necesario.

Tiempo para trabajar en mi biblioteca estándar más creo.

PHP, 79 bytes

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

Versión anterior 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++);}

Asume salida c ya tiene la longitud deseada.

Uso:

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

}

Si insiste en crear la salida, aquí hay una solución de 91 bytes :

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 bytes

Usé las omisiones típicas de los archivos de encabezado y main()el tipo de retorno y la declaración de retorno. Lanza una advertencia, pero se compila sin problemas. También utilicé un truco específico de GCC que permite declaraciones de matriz con expresiones variables.

El programa espera las cadenas de la línea de comando y, como tal, el programa debe ejecutarse 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 más legible,

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

Toma la entrada como una matriz de dos matrices de caracteres, con salida en el mismo formato. La función simplemente construye la nueva matriz usando una operación (mod 2).

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

QBasic 4.5, 172 bytes

Ay, este se vuelve doloroso con el viejo 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)

Dato curioso: el uso de DEFSTRmás bytes guardados de lo que cuesta porque ahora podría usar en Alugar de a$.

QBIC , 112 bytes

QBIC puede simplificar muchas de las repeticiones de QBasic, pero el MID$motor principal aún debe hacerse en QBasic porque QBIC carece de una función de subcadena. Aún así, me ahorra 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;}}

Sin golf y probando

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

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

Explicación: {...} define una función, ⍵ es el argumento correcto. La toma (↑) crea una matriz a partir de las dos cadenas, luego gira cada columna (⊖) n veces, donde n es la parte entre paréntesis (⍳⍴⊃⍵). Eso se define como el ápice de la longitud del primer argumento. (Ej: longitud = 5 ==> 1 2 3 4 5). Entonces, la primera columna se gira una vez, la segunda dos veces (volviendo a las posiciones originales), la tercera columna tres veces, etc.

Pruébalo en tryapl.org