Inspiración. * No puedo creer que no hayamos tenido este desafío antes:

Tarea

Dadas una o más cadenas ASCII imprimibles, intercalarlas tomando un carácter de cada cadena, cíclicamente hasta que se agoten los caracteres. Si una cadena se queda sin caracteres antes que los demás, simplemente omita esa de ahora en adelante.

Ejemplos

SIMPLE da SIMPLE

POLLSy EPEESdaPEOPLELESS

LYESy APRONSdaLAYPERSONS

ABCDEy a cy 123 567daAa1B 2Cc3D E567

"\n$?*y ​(cadena vacía) y ,(.)" (espacio final) da ",\(n.$)?"* (espacio final)

^{* Hay soluciones APL más cortas.}

Gelatina , 1 byte

Z

Pruébalo en línea!

El "incorporado" incorporado hará exactamente esto a una lista de cadenas.

Python 2, 101 89 86 69 bytes

Espero poder incluir esto en una lambda de alguna manera, acortándolo al hacerlo recursivo. No es ideal porque esperarías que la transposición sea más corta, desafortunadamente no lo es (por lo que he logrado hasta ahora).

f=lambda s:' '*any(s)and''.join(x[:1]for x in s)+f([x[1:]for x in s])

Viejas soluciones:

w=input();o=''
while any(w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

lambda s:''.join(''.join([c,''][c<' ']for c in x)for x in map(None,*[list(y)for y in s]))

w=input();o=''
while any(x>=' 'for x in w):
 for i in range(len(w)):o+=w[i][:1];w[i]=w[i][1:]
print o

^{gracias a mathmandan por hacerme sentir tonto;) me ahorró un montón de bytes! (en una solución antigua)}

Perl 6 , 34 32 bytes

{[~] flat roundrobin |$_».comb}

{roundrobin(|$_».comb).flat.join}

Una lambda que toma una matriz de cadenas como argumento y devuelve una cadena.

( Pruébelo en línea )

CJam , 4 bytes

qN/z

Pruébalo en línea!

También podemos escribir una función sin nombre para 4 bytes, que espera una lista de cadenas en la parte superior de la pila:

{zs}

Pruébalo en línea!

Pyth - 3 bytes

Muy simple, agregará expansión más tarde, en dispositivos móviles.

s.T

Banco de pruebas

s                         Join all the strings together
 .T                       Transpose, without chopping off overhang
  (Q implicit)

JavaScript (ES6), 52 46 bytes

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

Toma la entrada como una matriz de cadenas y las salidas como una sola cadena.

Fragmento de prueba

f=([[c,...s],...a])=>s+a?c+f(s+s?[...a,s]:a):c

g=a=>console.log("Input:",JSON.stringify(a),"Output:",JSON.stringify(f(a)))

g(["SIMPLE"])
g(["POLLS","EPEES"])
g(["LYES","APRONS"])
g(["ABCDE","a c","123 567"])
g(["\"\\n$?*",",(.)\" "]) // Backslash and quote are escaped, but in/output are correct

Haskell, 33 bytes

import Data.List
concat.transpose

Pruébalo en Ideone. Uso:

Prelude Data.List> concat.transpose$["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

Sin usar un incorporado: ( 38 34 bytes)

f[]=[]
f x=[h|h:_<-x]++f[t|_:t<-x]

Pruébalo en Ideone. ¡4 bytes de descuento gracias a Zgarb! Uso:

Prelude> f["ABCDE","a c","123 567"]
"Aa1B 2Cc3D E567"

C, 114 84 bytes

-20 bytes para no calcular la longitud.

i,b;f(char**s){b=1;while(b){i=-1;b=0;while(s[++i]>0)if(*s[i])putchar(*s[i]++),++b;}}

Acepta una matriz de punteros de caracteres y requiere que el último elemento sea un puntero nulo (ver uso).

Sin golf y uso:

i,b;f(char**s){
 b=1;
 while(b){
  i=-1;
  b=0;
  while(s[++i]>0)
   if(*s[i])
    putchar(*s[i]++),++b;
 }
}


int main(){
 char*a[]={ 
//  "POLLS","EPEES"
//  "LYES","APRONS"
 "ABCDE","a c","123 567"
 ,0};
 f(a);
 puts("");
}

PHP, 68 67 bytes

for(;$f=!$k=$f;$i++)for(;y|$v=$argv[++$k];$f&=""==$c)echo$c=$v[$i];

Recorre los argumentos de la línea de comandos. Corre con -r.

Después del bucle interno, $fes 1cuando todas las cadenas están terminadas, de lo 0contrario (bits se &convierte ""==$cen int).
Próxima iteración del bucle externo: copiar $fen $k(guarda un byte de $k=0) y alternar $f:
cuando todas las cadenas están listas, $fahora está falsey el bucle se rompe.

Retina , 13 bytes

El recuento de bytes asume la codificación ISO 8859-1.

O$#`.
$.%`
¶

Pruébalo en línea!

Explicación

O$#`.
$.%`

Esto se basa en la técnica de transposición estándar en retina. Ordenamos ( O) todos los caracteres sin salto de línea ( .), por ($# ) el número de caracteres que se encuentran delante de ellos en la misma línea ( $.%`), es decir, su posición horizontal.

La segunda etapa simplemente elimina los avances de línea de la entrada.

Java, 19 + 155 = 174 160

String f(java.util.Queue<String> q){String s,r="";while(!q.isEmpty()){s=q.poll();r+=s.isEmpty()?"":s.charAt(0);if(s.length()>1)q.add(s.substring(1));}return r;}

Sin golf:

  String f(java.util.Queue<String> q) {
    String s, r = "";
    while (!q.isEmpty()) {
      s = q.poll();
      r += s.isEmpty() ? "" : s.charAt(0);
      if (s.length() > 1) {
        q.add(s.substring(1));
      }
    }
    return r;
  }

Salida:

SIMPLE

SIN PERSONAS

CAPAS

Aa1B 2Cc3D E567

", (n. $)?" *

Primera modificación: declaración de cadena combinada para guardar algunos bytes. Eliminado import, fue utilizado por el main()método (no mostrado aquí) que también necesitaba LinkedList. Hay menos bytes para hacer referencia Queuedirectamente.

PHP, 77 bytes

Golfed

function($a){for($d=1;$d!=$s;$i++){$d=$s;foreach($a as$v)$s.=$v[$i];}echo$s;}

Función anónima que toma una serie de cadenas.

Estoy seguro de que esto se podría jugar más, pero es temprano. En cada iteración, tomamos la letra i-ésima de cada cadena dada y la agregamos a nuestra cadena final, una a la vez. PHP solo lanza advertencias si accedemos a fragmentos de cadenas que no existen, así que está bien. Solo nos detenemos cuando no se han realizado cambios después de recorrer todas las cadenas una vez.

Siento que el uso de $dse puede jugar más al golf, pero es temprano. :PAGS

En realidad , 7 6 bytes

Sugerencias de golf bienvenidas! Pruébalo en línea!

Editar: -1 byte gracias a Teal pelican.

a Z♂ΣΣ

Ungolfing

          Implicit input each string.
a         Invert the stack so that the strings are in the correct order.
<space>   Get the number of items on the stack, len(stack).
Z         Zip all len(stack) strings into one, transposing them.
♂Σ        sum() every transposed list of chars into strings.
Σ         sum() again to join the strings together.

JavaScript (ES6), 46 bytes

f=([[c,...s],...a])=>c?c+f([...a,s]):a+a&&f(a)

<textarea oninput=o.textContent=f(this.value.split`\n`)></textarea><div id=o>

Python 2 , 58 bytes

lambda*m:''.join(map(lambda*r:''.join(filter(None,r)),*m))

Pruébalo en línea!

J , 13 bytes

({~/:)&;#\&.>

Pruébalo en línea!

Basado en la inspiración para esta pregunta.

Otra forma de hacerlo toma 27 bytes pero funciona usando transposición. La mayoría de los bytes son para manejar los ceros agregados automáticamente del relleno.

[:u:0<:@-.~[:,@|:(1+3&u:)&>

Explicación

({~/:)&;#\&.>  Input: list of boxed strings S
          &.>  For each boxed string x in S
        #\       Get the length of each prefix from shortest to longest
                 This forms the range [1, 2, ..., len(x)]
                 Rebox it
(    )         Operate on S and the prefix lengths
      &;         Raze both
   /:            Grade up the raze of the prefix lengths
 {~              Index into the raze of S using the grades
               Return

Bash + utilidades GNU, 55

 eval paste `sed "s/.*/<(fold -1<<<'&')/g"`|tr -d \\n\\t

E / S a través de STDIN (línea separada) y STDOUT.

Los sedformatos de cada línea a una sustitución de proceso bash . Estos se evaleditan pastepara hacer el entrelazado real. trluego elimina las nuevas líneas y pestañas innecesarias.

Ideona

PHP, 63 bytes

Nota: utiliza la codificación IBM-850

for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];

Corre así:

php -r 'for(;$s^=1;$i++)for(;n|$w=$argv[++$$i];$s&=$x<~■)echo$x=$w[$i];' "\"\n\$?*" "" ",(.)\" " 2>/dev/null;echo
> ",\(n.$)?"* 

Explicación

for(                       # Iterate over string index.
  ;
  $s ^= 1;                 # Continue until $s (stop iterating) is 1.
                           # Flip $s so each iteration starts with $s
                           # being 1.
  $i++                     # Increment string index.
)
  for(
    ;
    "n" | $w=$argv[++$$i]; # Iterate over all input strings. OR with "n"
                           # to allow for empty strings.
    $s &= $x<~■            # If last character printed was greater than
                           # \x0 (all printable chars), set $s to 0,
                           # causing the loop to continue.
  )
    echo $x = $w[$i];      # Print char $i of current string.

Python 3, 75 bytes

Sé que el otro Python es más corto, pero esta es la primera vez que lo uso mapen mi vida, así que estoy muy orgulloso de ello.

lambda n:''.join(i[k]for k in range(max(map(len,n)))for i in n if len(i)>k)

C, 75 71 bytes

La única limitación es la longitud de salida. Actualmente es 99, pero se puede extender fácilmente a 999 (+1 byte).

i;main(a,b)char**b;{a--;for(;i<99;i++)*b[i%a+1]&&putchar(*b[i%a+1]++);}

Sin golf:

i;
main( a, b )
char **b;
{
    a--;
    for( ; i < 99; i++ )
        *b[i % a + 1] && putchar( *b[i % a + 1]++ );
}

Oracle SQL, 195 bytes

    select listagg(b,'') within group(order by l,o) from(select substr(a,level,1) b,level l,o from i start with length(a)>0 connect by prior a=a and level<=length(a) and prior sys_guid() is not null)

Toma su entrada de una tabla nombrada icon columnasa (que contiene la cadena) y o(orden de la cadena):

    create table i (a varchar2(4000), a integer)

Explicación:
Estamos explotando CONNECT BYpara dividir las cuerdas en cada uno de los personajes que las componen. PRIOR SYS_GUID()siendoNOT NULL asegura que no terminemos atrapados en un bucle.
Luego concatenamos los caracteres individuales con LISTAGGpero los barajamos con unORDER BY cláusula, ordenándolos primero por su posición en la cadena original y solo luego por la cadena de la que provienen.

No es tan breve como las otras respuestas, pero SQL no se entiende realmente como un lenguaje de manipulación de cadenas :)

Python 2, 128 96

Esperaba no tener que usar itertools

a=lambda a:"".join([i for i in reduce(lambda: b,c:b+c, map(None,*map(lambda m:list(m),a)) if i])

Sin golf

 a=lambda a:                              #Start a lambda taking in a
    "".join(                              #Join the result together with empty string
        [i for i in reduce(               #For every item, apply the function and 'keep'
           lambda: b,c:b+c,               #Add lists from...
                map(None,*map(            #None = Identity function, over a map of...
                    lambda m:list(m), a)  #list made for mthe strings m
                   ) if i                 #truthy values only (otherwise the outer map will padd with None.
       ])

Perl 5 , 28 bytes

26 bytes código + 2 para -0n.

s/^./!print$&/gem while/./

Pruébalo en línea!

R , 73 bytes

for(i in 1:max(nchar(s<-scan(,""))))for(j in seq(s))cat(substr(s[j],i,i))

Pruébalo en línea!

Explicación: muy simple (pero detallada), simplemente repita la impresión del icarácter de la jcadena. Afortunadamente, substrdevuelve una cadena vacía si se le da una entrada fuera de rango.

Python, 112 bytes

i=len(x)if len(x)>len(y) else len(y) h=0 a="" while h<i: if h<len(x) a+=x[h] if h<len(y): a += y[h] h+=1 print a

Perl 5 , 53 bytes

$i=0,map{push@{$a[$i++]},$_}/./g for<>;print@$_ for@a

Pruébalo en línea!

Método

Crea una matriz bidimensional donde el número de filas es igual a la longitud de la cadena más larga y el número máximo de columnas es igual al número de cadenas. Luego, envíe cada fila de la matriz sin espaciado.

TXR Lisp , 20 bytes

(opip weave cat-str)

Correr:

1> (opip weave cat-str)
#<intrinsic fun: 0 param + variadic>
2> [*1 "LYES" "APRONS"]
"LAYPERSONS"
3> [*1 "ABCDE" "a c" "" "123 567"]
"Aa1B 2Cc3D E567"
4> [*1 "\"\\n$?*" "" ",(.) "]
"\",\\(n.$)? *"

La weavefunción es perezosa, por lo que devuelve una lista, por lo que debemos forzar el resultado a una cadena. Al ser perezoso, puede tejer secuencias infinitas. Por ejemplo, podemos tejer los números naturales pares e impares, que son en sí mismos listas perezosas infinitas:

5> (take 20 (weave (range 2 : 2) (range 1 : 2)))
(2 1 4 3 6 5 8 7 10 9 12 11 14 13 16 15 18 17 20 19)

K (oK) , 35 29 bytes

Solución:

{`c$r@&~^r:,/+(`i$x)[;!#,/x]}

Pruébalo en línea!

Ejemplo:

> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("ABCDE";"a c";"123 567")
"Aa1B 2Cc3D E567"
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("\n$?*";"";",(.)\" ")
"\n,$(?.*)\" "
> {`c$r@&~^r:,/+(`i$x)[;!#,/x]}("POLLS";"EPEES")
"PEOPLELESS"

Explicación:

Use la indexación de segundo nivel para extraer índices de 0 a máximo (longitud de la lista aplanada) en todas las listas de entrada. Cualquier indexación más allá del límite de la sublista devolverá un valor nulo. Voltear (gira 90), aplanar y luego extraer los resultados no nulos.

Notas:

• Lanzo a entero ( i$) para que obtengamos nulos útiles, como espacio ( ) se considera nulo para una lista de caracteres, lo que significa que no puede distinguir nulos de espacios válidos.
• Además, no pude hacer que el TIO funcionara con la entrada (funcionó bien en la respuesta oK), por lo que el enlace TIO incluye el ejemplo "ABCDE" ...

Jq 1.5 , 49 bytes

map(explode)|transpose|map(map(values)[])|implode

Explicación

                      # example input:          ["LYES","APRONS"]
  map(explode)        # make list of ordinals   [[76,89,69,83],[65,80,82,79,78,83]]
| transpose           # zip lists               [[76,65],[89,80],[69,82],[83,79],[null,78],[null,83]]
| map(map(values)[])  # rm nulls and flatten    [76,65,89,80,69,82,83,79,78,83]
| implode             # convert back to string  "LAYPERSONS"

Ejecución de muestra

$ paste input <(jq -Mrc 'map(explode)|transpose|map(map(values)[])|implode' input)
["SIMPLE"]                  SIMPLE
["POLLS","EPEES"]           PEOPLELESS
["LYES","APRONS"]           LAYPERSONS
["ABCDE", "a c", "123 567"] Aa1B 2Cc3D E567
["\"\\n$?*", "", ",(.)\" "] ",\(n.$)?"* 

$ echo -n 'map(explode)|transpose|map(map(values)[])|implode' | wc -c
  49    

Pruébalo en línea