Ispirazione. * Non posso credere che non abbiamo mai avuto questa sfida prima:

Compito

Dato uno o più stringhe ASCII stampabili, interlacciali prendendo un carattere da ogni stringa, ciclicamente fino a quando non sono più caratteri. Se una stringa esaurisce i caratteri prima degli altri, salta quella da quel momento in poi.

Esempi

SIMPLE dà SIMPLE

POLLSe EPEESdàPEOPLELESS

LYESe APRONSdàLAYPERSONS

ABCDEe a ce 123 567dàAa1B 2Cc3D E567

"\n$?*e ​(stringa vuota) e ,(.)" (spazio finale) dà ",\(n.$)?"* (spazio finale)

^{* Esistono soluzioni APL più brevi.}

Gelatina , 1 byte

Z

Provalo online!

Il "trasposizione" incorporato farà esattamente questo in un elenco di stringhe.

Python 2, 101 89 86 69 byte

Spero di riuscire a metterlo in una lambda in qualche modo, accorciandolo rendendolo ricorsivo. Non è l'ideale perché speri che il recepimento sia più breve, sfortunatamente non lo è (da quello che sono riuscito a inventare finora).

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

Vecchie soluzioni:

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

^{grazie a Mathmandan per avermi fatto sentire stupido;) mi ha salvato un sacco di byte! (su una vecchia soluzione)}

Perl 6 , 34 32 byte

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

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

Un lambda che accetta una matrice di stringhe come argomento e restituisce una stringa.

( Provalo online )

CJam , 4 byte

qN/z

Provalo online!

Possiamo anche scrivere una funzione senza nome per 4 byte, che prevede un elenco di stringhe in cima allo stack:

{zs}

Provalo online!

Pyth - 3 byte

Molto semplice, aggiungerà l'espansione in seguito, su dispositivo mobile.

s.T

Test Suite

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

JavaScript (ES6), 52 46 byte

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

Accetta input come una matrice di stringhe e output come una singola stringa.

Snippet di prova

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 byte

import Data.List
concat.transpose

Provalo su Ideone. Uso:

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

Senza utilizzare un build-in: ( 38 34 byte)

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

Provalo su Ideone. 4 byte di sconto grazie a Zgarb! Uso:

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

C, 114 84 byte

-20 byte per non calcolare la lunghezza.

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

Accetta la matrice di puntatori char e richiede che l'ultimo elemento sia un puntatore null (vedi utilizzo).

Ungolfed e utilizzo:

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 byte

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

Passa attraverso gli argomenti della riga di comando. Corri con -r.

Dopo il ciclo interno, $fè 1quando tutte le stringhe sono finiti, 0altro (bit per bit &calchi ""==$ca int).
Prossima iterazione del ciclo esterno: copia $fin $k(salva un byte da $k=0) e attiva $f/ disattiva :
quando tutte le stringhe sono terminate, $fè ora falsee il ciclo si interrompe.

Retina , 13 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

O$#`.
$.%`
¶

Provalo online!

Spiegazione

O$#`.
$.%`

Questo si basa sulla tecnica di trasposizione standard in Retina. Ordiniamo ( O) tutti i caratteri non di avanzamento riga ( .), per ( $#) il numero di caratteri davanti a loro sulla stessa riga ( $.%`), ovvero la loro posizione orizzontale.

Il secondo stadio quindi rimuove semplicemente gli avanzamenti di linea dall'input.

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

Ungolfed:

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

Produzione:

SEMPLICE

PEOPLELESS

laici

Aa1B 2Cc3D E567

", (n. $)?" *

Prima modifica: dichiarazione di stringa unita per salvare alcuni byte. Rimosso import, è stato utilizzato dal main()metodo (non mostrato qui) che era necessario LinkedList. Sono necessari meno byte per fare riferimento Queuedirettamente.

PHP, 77 byte

golfed

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

Funzione anonima che accetta una matrice di stringhe.

Sono sicuro che questo potrebbe essere giocato di più, ma è presto. Ad ogni iterazione, prendiamo l'i-esima lettera da ciascuna stringa data e la aggiungiamo alla nostra stringa finale, una alla volta. PHP emette solo avvisi se accediamo a bit di stringhe che non esistono, quindi va bene. Ci fermiamo solo quando non sono state apportate modifiche dopo aver ripetuto ciclicamente tutte le stringhe una volta.

Sento che l'uso di $dpuò essere golfato di più, ma è presto. : P

In realtà , 7 6 byte

Suggerimenti di golf benvenuti! Provalo online!

Modifica: -1 byte grazie al pellicano Teal.

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 byte

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 byte

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

Provalo online!

J , 13 byte

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

Provalo online!

Basato sull'ispirazione per questa domanda.

Un altro modo per farlo richiede 27 byte ma funziona usando transpose. La maggior parte dei byte deve gestire gli zero aggiunti automaticamente dal riempimento.

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

Spiegazione

({~/:)&;#\&.>  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

Utilità Bash + GNU, 55

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

I / O via STDIN (separato da linea) e STDOUT.

La sedformatta ogni riga per una sostituzione di processo bash . Questi vengono quindi evalinseriti pasteper eseguire l'interleaving reale. trquindi rimuove le righe e le righe non necessarie.

Ideone.

PHP, 63 byte

Nota: utilizza la codifica IBM-850

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

Esegui in questo modo:

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

Spiegazione

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 byte

So che l'altro Python è più corto, ma questa è la prima volta che lo uso mapnella mia vita, quindi ne sono abbastanza orgoglioso

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

C, 75 71 byte

L'unica limitazione è la lunghezza dell'uscita. Attualmente è 99, ma può essere facilmente allungato a 999 (+1 byte).

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

Ungolfed:

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

Oracle SQL, 195 byte

    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)

Prende l'input da una tabella denominata icon colonne a(contenente la stringa) e o(ordine della stringa):

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

Spiegazione:
Stiamo sfruttando CONNECT BYper spezzare le stringhe in ciascuno dei personaggi che le compongono. PRIOR SYS_GUID()essere NOT NULLassicura che non finiamo bloccati in un ciclo.
Quindi concateniamo i singoli caratteri con LISTAGGma li mescoliamo con una ORDER BYclausola, ordinandoli prima in base alla loro posizione nella stringa originale e solo successivamente dalla stringa da cui provengono.

Non così breve come le altre risposte, ma SQL non è realmente inteso come un linguaggio di manipolazione delle stringhe :)

Python 2, 128 96

Speravo di non dover usare 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])

Ungolfed

 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 byte

26 byte codice + 2 per -0n.

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

Provalo online!

R , 73 byte

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

Provalo online!

Spiegazione: molto semplice (ma dettagliato), basta passare in irassegna la stampa del carattere della jth stringa. Fortunatamente, substrrestituisce una stringa vuota se viene fornito un input fuori range.

Python, 112 byte

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 byte

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

Provalo online!

Metodo

Crea una matrice bidimensionale in cui il numero di righe è uguale alla lunghezza della stringa più lunga e il numero massimo di colonne è uguale al numero di stringhe. Quindi emettere ogni riga dell'array senza spaziatura.

TXR Lisp , 20 byte

(opip weave cat-str)

Correre:

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 weavefunzione è pigra, quindi restituisce un elenco, motivo per cui dobbiamo forzare il risultato in una stringa. Essendo pigro, può tessere infinite sequenze. Ad esempio, possiamo tessere i numeri naturali pari e dispari, che sono essi stessi infiniti elenchi pigri:

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 byte

Soluzione:

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

Provalo online!

Esempio:

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

Spiegazione:

Utilizzare l'indicizzazione di 2 ° livello per estrarre gli indici da 0 a max (lunghezza dell'elenco appiattito) in tutti gli elenchi di input. Qualsiasi indicizzazione oltre il limite dell'elenco secondario restituirà un valore nullo. Capovolgi (ruota di 90), appiattisci e quindi estrai i risultati non nulli.

Gli appunti:

• Lancio a integer ( i$) in modo da ottenere null utili, poiché space ( ) è considerato null per un elenco di caratteri, il che significa che non è possibile distinguere nulli da spazi validi.
• Inoltre non sono riuscito a far funzionare il TIO con l'input (funzionava bene nella sostituzione oK), quindi il collegamento TIO include l'esempio "ABCDE" ...

Jq 1,5 , 49 byte

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

Spiegazione

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

Esecuzione del campione

$ 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    

Provalo online