Inspiration. * Je ne peux pas croire que nous n'ayons pas eu ce défi auparavant:

Tâche

Étant donné une ou plusieurs chaînes ASCII imprimables, entrelacez-les en prenant un caractère de chaque chaîne, de manière cyclique jusqu'à ce qu'il n'y ait plus de caractères. Si une chaîne manque de caractères avant les autres, sautez simplement celle-là à partir de là.

Exemples

SIMPLE donne SIMPLE

POLLSet EPEESdonnePEOPLELESS

LYESet APRONSdonneLAYPERSONS

ABCDEet a cet 123 567donneAa1B 2Cc3D E567

"\n$?*et ​(chaîne vide) et ,(.)" (espace de fin) donne ",\(n.$)?"* (espace de fin)

^{* Il existe des solutions APL plus courtes.}

Gelée , 1 octet

Z

Essayez-le en ligne!

Le transposé intégré fera exactement cela à une liste de chaînes.

Python 2, 101 89 86 69 octets

J'espère que je pourrai intégrer cela dans un lambda, le raccourcir en le rendant récursif. Ce n'est pas idéal parce que vous espérez que la transposition est plus courte, malheureusement ce n'est pas le cas (d'après ce que j'ai réussi à trouver jusqu'à présent).

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

Anciennes solutions:

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

^{merci à mathmandan de m'avoir rendu stupide;) m'a sauvé un tas d'octets! (sur une ancienne solution)}

Perl 6 , 34 32 octets

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

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

Un lambda qui prend un tableau de chaînes comme argument et renvoie une chaîne.

( Essayez-le en ligne )

CJam , 4 octets

qN/z

Essayez-le en ligne!

Nous pouvons également écrire une fonction sans nom pour 4 octets, qui attend une liste de chaînes en haut de la pile:

{zs}

Essayez-le en ligne!

Pyth - 3 octets

Très simple, ajoutera une extension plus tard, sur mobile.

s.T

Suite de tests

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

JavaScript (ES6), 52 46 octets

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

Prend l'entrée comme un tableau de chaînes et les sorties comme une seule chaîne.

Extrait de test

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 octets

import Data.List
concat.transpose

Essayez-le sur Ideone. Usage:

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

Sans utiliser de build-in: ( 38 34 octets)

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

Essayez-le sur Ideone. 4 octets de réduction grâce à Zgarb! Usage:

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

C, 114 84 octets

-20 octets pour ne pas calculer la longueur.

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

Accepte un tableau de pointeurs de caractères et requiert que le dernier élément soit un pointeur nul (voir utilisation).

Non golfé et utilisation:

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 octets

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

Boucle sur les arguments de ligne de commande. Courir avec-r .

Après la boucle intérieure, $fest 1quand toutes les chaînes sont finies, le 0reste ( au niveau du bit &moulages ""==$cà int).
Prochaine itération de la boucle externe: copier $fvers $k(enregistre un octet $k=0) et basculer $f:
lorsque toutes les chaînes sont terminées, $fc'est maintenant falseet la boucle est rompue.

Rétine , 13 octets

Le nombre d'octets suppose un codage ISO 8859-1.

O$#`.
$.%`
¶

Essayez-le en ligne!

Explication

O$#`.
$.%`

Ceci est basé sur la technique de transposition standard dans la rétine. Nous trions ( O) tous les caractères non sauts de ligne ( .), par ( $#) le nombre de caractères devant eux sur la même ligne ( $.%`), c'est-à-dire leur position horizontale.

Le deuxième étage supprime ensuite simplement les sauts de ligne de l'entrée.

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

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

Sortie:

SIMPLE

PERSONNES

LES LAÏCS

Aa1B 2Cc3D E567

", (n. $)?" *

Première modification: déclaration de chaîne fusionnée pour économiser quelques octets. Supprimé import, il a été utilisé par la main()méthode (non illustrée ici) qui était également nécessaire LinkedList. Il y a moins d'octets à référencer Queuedirectement.

PHP, 77 octets

Golfé

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

Fonction anonyme qui prend un tableau de chaînes.

Je suis sûr que cela pourrait être joué davantage, mais c'est tôt. À chaque itération, nous récupérons la i-ème lettre de chaque chaîne donnée et l'ajoutons à notre chaîne finale, une à la fois. PHP lance simplement des avertissements si nous accédons à des bits de chaînes qui n'existent pas, donc ça va. Nous nous arrêtons uniquement lorsqu'aucune modification n'a été effectuée après avoir parcouru toutes les chaînes une fois.

J'ai l'impression que l'utilisation de $dpeut être jouée davantage, mais c'est tôt. : P

En fait , 7 6 octets

Suggestions de golf bienvenues! Essayez-le en ligne!

Edit: -1 octet grâce au pélican sarcelle.

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 octets

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 octets

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

Essayez-le en ligne!

J , 13 octets

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

Essayez-le en ligne!

Basé sur l' inspiration de cette question.

Une autre façon de le faire prend 27 octets mais fonctionne en utilisant la transposition. La plupart des octets doivent gérer les zéros ajoutés automatiquement à partir du remplissage.

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

Explication

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

Utilitaires Bash + GNU, 55

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

E / S via STDIN (ligne séparée) et STDOUT.

Le sedformate chaque ligne à une substitution de processus bash . Ceux-ci sont ensuite evalédités pastepour effectuer l'entrelacement proprement dit. trsupprime ensuite les nouvelles lignes et les tabulations inutiles.

Ideone.

PHP, 63 octets

Remarque: utilise le codage IBM-850

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

Courez comme ceci:

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

Explication

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 octets

Je sais que l'autre Python est plus court, mais c'est la première fois que je l'utilise mapde ma vie, donc j'en suis assez fier

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

C, 75 71 octets

La seule limitation est la longueur de sortie. Il est actuellement de 99, mais peut facilement être étendu à 999 (+1 octet).

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

Non golfé:

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

Oracle SQL, 195 octets

    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)

Prend son entrée dans une table nommée iavec des colonnes a(contenant la chaîne) et o(ordre de la chaîne):

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

Explication:
Nous exploitons CONNECT BYpour briser les chaînes en chacun des personnages qui les composent. PRIOR SYS_GUID()être NOT NULLassure que nous ne nous retrouvons pas coincés dans une boucle.
Nous concaténons ensuite les caractères simples avec LISTAGGmais nous les mélangons avec une ORDER BYclause, en les classant d'abord par leur position dans la chaîne d'origine et ensuite seulement par la chaîne dont ils sont issus.

Pas aussi court que les autres réponses, mais SQL n'est pas vraiment un langage de manipulation de chaînes :)

Python 2, 128 96

J'espérais ne pas avoir à utiliser 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])

Non 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 octets

Code de 26 octets + 2 pour -0n.

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

Essayez-le en ligne!

R , 73 octets

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

Essayez-le en ligne!

Explication: très simple (mais verbeux), il suffit de parcourir ile caractère de la je chaîne. Heureusement, substrretourne une chaîne vide si on lui donne une entrée hors plage.

Python, 112 octets

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 octets

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

Essayez-le en ligne!

Méthode

Crée un tableau à deux dimensions où le nombre de lignes est égal à la longueur de la chaîne la plus longue et le nombre maximal de colonnes est égal au nombre de chaînes. Puis sortez chaque ligne du tableau sans espacement.

TXR Lisp , 20 octets

(opip weave cat-str)

Courir:

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 weavefonction est paresseuse, elle renvoie donc une liste, c'est pourquoi nous devons forcer le résultat sur une chaîne. Paresseux, il peut tisser des séquences infinies. Par exemple, nous pouvons tisser les nombres naturels pairs et impairs, qui sont eux-mêmes des listes paresseuses infinies:

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 octets

Solution:

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

Essayez-le en ligne!

Exemple:

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

Explication:

Utilisez l'indexation de deuxième niveau pour extraire les index de 0 à max (longueur de la liste aplatie) dans toutes les listes d'entrée. Toute indexation au-delà de la limite de la sous-liste renverra un null. Retourner (rotation de 90), aplatir, puis extraire les résultats non nuls.

Remarques:

• Je transforme en entier (i$ ) afin que nous obtenions des Null utiles, car space ( ) est considéré comme nul pour une liste de caractères, ce qui signifie que vous ne pouvez pas dire Null à partir d'espaces valides.
• De plus, je ne pouvais pas faire fonctionner le TIO avec une entrée (fonctionnait bien dans la réponse oK), donc le lien TIO inclut l'exemple "ABCDE" ...

Jq 1,5 , 49 octets

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

Explication

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

Sample Run

$ 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    

Essayez-le en ligne