Inspiration. * Ich kann nicht glauben, dass wir diese Herausforderung noch nicht hatten:

Aufgabe

Verschachteln Sie eine oder mehrere druckbare ASCII-Zeichenfolgen, indem Sie ein Zeichen aus jeder Zeichenfolge zyklisch bis zur vollständigen Zeichenfolge übernehmen. Wenn einer Zeichenfolge die Zeichen vor den anderen ausgehen, überspringen Sie diese von da an.

Beispiele

SIMPLE gibt SIMPLE

POLLSund EPEESgibtPEOPLELESS

LYESund APRONSgibtLAYPERSONS

ABCDEund a cund 123 567gibtAa1B 2Cc3D E567

"\n$?*und ​(leere Zeichenkette) und ,(.)" (abschließendes Leerzeichen) ergeben ",\(n.$)?"* (abschließendes Leerzeichen)

^{* Es gibt kürzere APL-Lösungen.}

Gelee , 1 Byte

Z

Probieren Sie es online!

Die eingebaute "Transponierung" macht genau das mit einer Liste von Strings.

Python 2, 101 89 86 69 Bytes

Ich hoffe, ich kann das irgendwie in ein Lambda umwandeln, indem ich es rekursiv mache. Es ist nicht ideal, weil Sie hoffen würden, dass die Transponierung kürzer ist, leider nicht (nach dem, was ich bisher erfunden habe).

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

Alte Lösungen:

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

^{danke an mathmandan für das dumme gefühl;) sparte mir ein paar bytes! (auf einer alten Lösung)}

Perl 6 , 34 32 Bytes

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

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

Ein Lambda, das ein Array von Zeichenfolgen als Argument verwendet und eine Zeichenfolge zurückgibt.

( Online ausprobieren )

CJam , 4 Bytes

qN/z

Probieren Sie es online!

Wir können auch eine unbenannte Funktion für 4 Bytes schreiben, die eine Liste von Strings über dem Stack erwartet:

{zs}

Probieren Sie es online!

Pyth - 3 Bytes

Sehr einfach, wird später auf dem Handy eine Erweiterung hinzufügen.

s.T

Test Suite

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

Nimmt Eingaben als Array von Zeichenfolgen und Ausgaben als einzelne Zeichenfolge.

Testschnipsel

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

Probieren Sie es auf Ideone. Verwendung:

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

Ohne Verwendung eines eingebauten: ( 38 34 Bytes)

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

Probieren Sie es auf Ideone. 4 Bytes weniger dank Zgarb! Verwendung:

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

C 114 84 Bytes

-20 Bytes, um die Länge nicht zu berechnen.

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

Akzeptiert ein Array von Zeichenzeigern und erfordert, dass das letzte Element ein Nullzeiger ist (siehe Verwendung).

Ungolfed und Nutzung:

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

Schleifen über Befehlszeilenargumente. Laufen Sie mit -r.

Nach der inneren Schleife $fist, 1wenn alle Zeichenfolgen fertig sind, 0sonst (bitweise &Umwandlung ""==$cin int).
Nächste Iteration der äußeren Schleife: Kopieren $fnach $k(speichert ein Byte von $k=0) und Umschalten $f:
Wenn alle Zeichenfolgen fertig sind, $fist jetzt falseund die Schleife wird unterbrochen.

Retina , 13 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

O$#`.
$.%`
¶

Probieren Sie es online!

Erläuterung

O$#`.
$.%`

Dies basiert auf der Standardtranspositionstechnik in der Netzhaut. Wir sortieren ( O) alle Nichtzeilenvorschubzeichen ( .) nach ( $#) der Anzahl der Zeichen vor ihnen in derselben Zeile ( $.%`), dh ihrer horizontalen Position.

Die zweite Stufe entfernt dann einfach Zeilenvorschübe von der Eingabe.

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

Ausgabe:

EINFACH

MENSCHENLOS

LAYPERSONS

Aa1B 2Cc3D E567

", (n. $)?" *

Erste Änderung: Zusammengeführte Zeichenfolgendeklaration zum Speichern einiger Bytes. Entfernt import, wurde es von der verwendeten main()Methode (hier nicht dargestellten) , die auch benötigt LinkedList. Es sind weniger Bytes, um Queuedirekt zu referenzieren .

PHP, 77 Bytes

Golf gespielt

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

Anonyme Funktion, die eine Reihe von Zeichenfolgen akzeptiert.

Ich bin sicher, dass dies mehr Golf könnte, aber es ist früh. Bei jeder Iteration greifen wir den i-ten Buchstaben aus jeder gegebenen Zeichenfolge und hängen ihn nacheinander an unsere letzte Zeichenfolge an. PHP gibt nur Warnungen aus, wenn wir auf Teile von Strings zugreifen, die nicht existieren, also ist das in Ordnung. Wir hören erst auf, wenn keine Änderungen vorgenommen wurden, nachdem alle Saiten einmal durchlaufen wurden.

Ich fühle mich wie die Verwendung von $dmehr Golf gespielt werden kann, aber es ist früh. : P

Eigentlich , 7 6 Bytes

Golfvorschläge willkommen! Probieren Sie es online!

Bearbeiten: -1 Byte dank 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 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 Bytes

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

Probieren Sie es online!

J , 13 Bytes

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

Probieren Sie es online!

Basierend auf der Inspiration für diese Frage.

Ein anderer Weg, dies zu tun, benötigt 27 Bytes, arbeitet aber mit Transponierung. Die meisten Bytes behandeln die automatisch hinzugefügten Nullen aus dem Auffüllen.

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

Erläuterung

({~/:)&;#\&.>  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 + GNU-Dienstprogramme, 55

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

E / A über STDIN (zeilengetrennt) und STDOUT.

Die sedFormate jeder Zeile führen zu einer Bash-Prozessersetzung . Diese werden dann evalbearbeitet paste, um das eigentliche Interleaving durchzuführen. trentfernt dann unnötige Zeilenumbrüche und Tabulatoren.

Ideone.

PHP, 63 Bytes

Anmerkung: Verwendet die IBM-850-Codierung

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

Laufen Sie wie folgt:

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

Erläuterung

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

Ich weiß, dass der andere Python kürzer ist, aber dies ist das erste Mal mapin meinem Leben, dass ich darauf stolz bin

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

Einzige Einschränkung ist die Ausgabelänge. Derzeit ist es 99, kann aber leicht auf 999 (+1 Byte) erweitert werden.

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)

Übernimmt seine Eingabe aus einer Tabelle imit den Spalten a(die die Zeichenfolge enthalten) und o(die Reihenfolge der Zeichenfolge):

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

Erläuterung:
Wir nutzen es CONNECT BY, um die Zeichenfolgen in die einzelnen Zeichen aufzuteilen, aus denen sie bestehen. PRIOR SYS_GUID()Dadurch wird NOT NULLsichergestellt, dass wir nicht in einer Schleife stecken bleiben.
Wir verketten dann die einzelnen Zeichen mit LISTAGG, mischen sie jedoch mit einer ORDER BYKlausel um und ordnen sie zuerst nach ihrer Position in der ursprünglichen Zeichenfolge und erst dann nach der Zeichenfolge, aus der sie stammen.

Nicht so kurz wie die anderen Antworten, aber SQL ist nicht wirklich als Manipulationssprache für Strings gedacht :)

Python 2, 128 96

Ich hatte gehofft, keine itertools verwenden zu müssen

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 Bytes

26 Byte Code + 2 für -0n.

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

Probieren Sie es online!

R , 73 Bytes

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

Probieren Sie es online!

Erklärung: sehr einfach (aber wortreich), durchlaufe einfach das iZeichen der jZeichenkette. Gibt glücklicherweise substreine leere Zeichenfolge zurück, wenn eine Eingabe außerhalb des gültigen Bereichs erfolgt.

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

Probieren Sie es online!

Methode

Erstellt ein zweidimensionales Array, bei dem die Anzahl der Zeilen der Länge der längsten Zeichenfolge und die maximale Anzahl der Spalten der Anzahl der Zeichenfolgen entspricht. Geben Sie dann jede Zeile des Arrays ohne Abstand aus.

TXR Lisp , 20 Bytes

(opip weave cat-str)

Lauf:

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.$)? *"

Die weaveFunktion ist faul und gibt eine Liste zurück. Aus diesem Grund müssen wir das Ergebnis in eine Zeichenfolge umwandeln. Da es faul ist, kann es unendliche Sequenzen weben. Zum Beispiel können wir gerade und ungerade natürliche Zahlen weben, die selbst unendlich faul sind:

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 bis 29 Bytes

Lösung:

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

Probieren Sie es online!

Beispiel:

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

Erläuterung:

Verwenden Sie die Indexierung der zweiten Ebene, um Indizes von 0 bis maximal (Länge der abgeflachten Liste) über alle Eingabelisten hinweg abzurufen. Alle Indizierungen, die über den Rand der Unterliste hinausgehen, geben eine Null zurück. Drehen (dreht sich um 90), reduzieren und dann die Nicht-Null-Ergebnisse herausziehen.

Anmerkungen:

• Ich habe in integer ( i$) umgewandelt, damit wir nützliche Nullen erhalten, da space ( ) als Null für eine Zeichenliste betrachtet wird, was bedeutet, dass Sie Nullen nicht von gültigen Leerzeichen unterscheiden können.
• Außerdem konnte ich den TIO nicht dazu bringen, mit Eingaben zu arbeiten (funktionierte im oK-Repl einwandfrei), sodass der TIO-Link das Beispiel "ABCDE" enthält.

Jq 1,5 , 49 Bytes

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

Erläuterung

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

Probelauf

$ 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    

Probieren Sie es online aus