Étant donné une liste d'au moins deux mots (composée uniquement de lettres minuscules), construisez et affichez une échelle ASCII des mots en alternant la direction d'écriture d'abord à droite, puis à gauche, par rapport à la direction initiale de gauche à droite. .

Lorsque vous avez terminé d'écrire un mot, changez de direction et commencez ensuite à écrire le mot suivant.

Si votre langue ne prend pas en charge les listes de mots, ou si cela vous convient mieux, vous pouvez prendre l'entrée comme une chaîne de mots, séparés par un seul espace.

Les espaces blancs avant et arrière sont autorisés.

["hello", "world"] ou "hello world"

hello
    w
    o
    r
    l 
    d

Ici, nous commençons par écrire helloet lorsque nous arrivons au mot suivant (ou dans le cas de l'entrée sous forme de chaîne - un espace est trouvé), nous changeons la direction relative vers la droite et continuons à écrireworld

Cas de test:

["another", "test", "string"] or "another test string" ->   

another
      t
      e
      s
      tstring


["programming", "puzzles", "and", "code", "golf"] or "programming puzzles and code golf" ->

programming
          p
          u
          z
          z
          l
          e
          sand
             c
             o
             d
             egolf

["a", "single", "a"] or "a single a" ->

a
s
i
n
g
l
ea

Critères gagnants

Le code le plus court en octets dans chaque langue gagne. Ne vous laissez pas décourager par les langues du golf!

bac à sable

Fusain , 9 octets

Ｆ⮌Ａ«↑⮌ι‖↗

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: Fonctionne en dessinant le texte à l'envers, en transposant la toile après chaque mot. 10 octets pour l'entrée de chaîne:

Ｆ⮌Ｓ≡ι ‖↗←ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication: dessine le texte en arrière, transposant le canevas pour les espaces.

C (gcc) , 94 78 74 octets

-4 de Johan du Toit

o,f;g(int*s){for(o=f=0;*s;s++)*s<33?f=!f:printf("\n%*c"+!f,f*(o+=!f),*s);}

Essayez-le en ligne!

Imprime l'échelle, un caractère (de l'entrée) à la fois. Prend une chaîne de mots séparés par des espaces.

05AB1E , 19 16 octets

€θ¨õšøíJD€gs24SΛ

-3 octets grâce à @Emigna .

Essayez-le en ligne.

Explication générale:

Tout comme @Emigna réponse 05AB1E de (assurez - vous de le upvote btw !!), j'utilise la toile builtinΛ .

Les options que j'utilise sont cependant différentes (c'est pourquoi ma réponse est plus longue ..):

• b(les chaînes à imprimer): je laisse inchangée la première chaîne de la liste et j'ajoute le caractère de fin à chaque chaîne suivante de la liste. Par exemple ["abc","def","ghi","jklmno"]deviendrait ["abc","cdef","fghi","ijklmno"].
• a(la taille des lignes): Ce serait égal à ces chaînes, donc [3,4,4,7]avec l'exemple ci-dessus.
• c(la direction dans laquelle imprimer):, [2,4]qui correspondrait à[→,↓,→,↓,→,↓,...]

Ainsi, l'exemple ci-dessus procéderait pas à pas comme suit:

1. Dessiner abcen direction 2/ →.
2. Dessiner cdefdans la direction 4/ ↓(où le premier caractère chevauche le dernier caractère, c'est pourquoi nous avons dû modifier la liste comme ceci)
3. Dessiner fghidans la direction 2/ à →nouveau (également avec chevauchement des caractères de fin / de début)
4. Dessiner ijklmnodans la direction 4/ à ↓nouveau (également avec chevauchement)
5. Afficher immédiatement le résultat du canevas dessiné dans STDOUT

Explication du code:

€θ                # Only leave the last characters in the (implicit) input-list
  ¨               # Remove the last one
   õš             # And prepend an empty string "" instead
     ø            # Create pairs with the (implicit) input-list
      í           # Reverse each pair
       J          # And then join each pair together to single strings
        D€g       # Get the length of each string (without popping by duplicating first)
           s      # Swap so the lengths are before the strings
            24S   # Push [2,4]
               Λ  # Use the Canvas builtin (which outputs immediately implicitly)

05AB1E , 14 13 octets

1 octet enregistré grâce à Grimy

€ðÀD€g>sŽ9÷SΛ

Essayez-le en ligne!

Explication

                 # example input ["Hello", "World"]
€ðÀ              # push a space after each word
                 # STACK: ["Hello"," ","World"," "]
   D             # duplicate
    €g>          # get the length of each word in the copy and add 1
                 # these are the lengths to draw
                 # STACK: ["Hello"," ","World"," "], [6, 2, 6, 2]
       s         # swap the list of word to the top of the stack
        Ž9÷S     # push [2, 5, 4, 1]
                 # this is the list of directions to draw
                 # 1=northeast, 2=east, 4=south, 5=southwest
            Λ    # paint on canvas

Canevas , 17 12 11 10 octets

ø⁸⇵｛⟳Ｋ└×∔⤢

Essayez-le ici!

Explication:

ø⁸⇵{⟳K└×∔⤢  full program taking array as input (loaded with ⁸)

ø         push an empty canvas               ["test", "str"], ""
 ⁸⇵{      for each input word, in reverse:   "str", "test" (showing 2nd iter)
    ⟳       rotate the word vertically       "str", "t¶e¶s¶t"
     K      pop off the last letter          "str", "t¶e¶s", "t"
      └     swap the two items below top     "t¶e¶s", "str", "t"
       ×    prepend                          "t¶e¶s", "tstr"
        ∔   vertically append                "t¶e¶s¶tstr"
         ⤢  transpose the canvas             "test
                                                 s
                                                 t
                                                 r"

JavaScript (ES8),  91 79  77 octets

Prend l'entrée comme un tableau de mots.

a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=`
`).join``

Essayez-le en ligne!

Commenté

a =>                 // a[] = input array
  a.map((s, i) =>    // for each word s at position i in a[]:
    i & 1 ?          //   if this is a vertical word:
      [...s].join(p) //     split s and join it with p
    :                //   else:
      s +=           //     add to s:
        p +=         //       add to p:
          ''.padEnd( //         as many spaces
            s.length //         as there are letters in s
            - !i     //         minus 1 if this is the 1st word (because it's not connected
          ),         //         with the last letter of the previous vertical word)
    p = `\n`         //   start with p = linefeed
  ).join``           // end of map(); join everything

Python 2 , 82 octets

b=p=0
r=''
for w in input():
 for c in w:r+='\n'.ljust(p)*b+c;p+=1-b
 b^=1
print r

Essayez-le en ligne!

brainfuck , 57 octets

->,[[.<+>,],[<<[-]++++++++++.--[-<++++>]>[-<+<.>>]>.<,],]

Essayez-le en ligne!

Prend l'entrée en tant que chaînes séparées par NUL. Notez que cela utilise EOF comme 0 et cessera de fonctionner lorsque l'échelle dépasse 256 espaces.

Explication:

-           Initialise counter as -1
>,[         Start ladder
   [.<+>,]  Print the first word, adding the length of it to the counter
   ,[       Loop over each letter of the second word
      <<[-]++++++++++.    Print a newline
      --[-<++++>]         Create a space character
      >[-<+<.>>]          Print counter many spaces
      >.<,                Print the letter and move to the next letter
   ] 
   ,        Repeat until there are no more words
]

JavaScript, 62 octets

a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=`
`)

Essayez-le en ligne!

Merci Rick Hitchcock , 2 octets enregistrés.

JavaScript, 65 octets

a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':`
`,c),t=p='')

Essayez-le en ligne!

a => a.replace (/./ g, c => (// pour chaque caractère c dans la chaîne a
    1 - c? // si (c est l'espace)
      (t =! t, // met à jour t: la valeur booléenne décrit l'index des mots
                       // véridique: mots indexés impairs;
                       // falsification: même les mots indexés
        ''): // ne génère rien pour l'espace
    t? // si (est un indice impair) ce qui signifie est vertical
      p + c: // ajouter '\ n', quelques espaces et un caractère sigle
                       // autre
      (p + = p? '': '\ n', // prépare la chaîne de préfixe pour les mots verticaux
         c) // ajoute un seul caractère
),
  t = p = '' // initialiser
)

Aheui (ésotope) , 490 458 455 octets

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투＠밧우
＠두내백뱃빼선대내백뱃섣＠여우샐처샐추
희차＠＠＠뭏누번사＠빼뭏오추뻐＠＠＠배
Ｂｙ＠＠＠새대백＠＠＠우뻐색
Ｌｅｇｅｎ＠＠빼쵸누번＠＠빼
ＤＵＳＴ＠＠＠샌뽀터본섣숃멓
＠＠＠＠＠＠＠오어아＠먛요아＠＠샏매우
＠＠＠＠＠아＠＠＠＠＠＠오＠＠＠＠＠서어
＠＠＠＠＠희차＠＠요

Essayez-le en ligne!

Légèrement joué en utilisant des caractères pleine largeur (2 octets) au lieu du coréen (3 octets).

Explication

Aheui est un esolang de type befunge. Voici le code avec la couleur :? 1 partie vérifie si le caractère actuel est un espace ou non.

? 2 parties vérifient si les mots ont été écrits de droite à gauche ou de haut en bas.

? La partie 3 est la condition de rupture de la boucle qui tape les espaces.

? 4 parties vérifient si le caractère actuel est en fin de ligne (-1).

La partie rouge est l'initialisation de la pile. Aheui utilise des piles (de Nothingà ㅎ: 28 piles) pour stocker la valeur.

La partie orange prend input ( 뱋) et vérifie s'il s'agit d'espace, en soustrayant avec 32(code ascii de l'espace).

La partie verte ajoute 1 à la pile qui stocke la valeur de la longueur de l'espace, si vous écrivez de droite à gauche.

La partie violette est une boucle pour l'impression des espaces, si vous écrivez de haut en bas.

Vérification de la partie grise si le caractère actuel est -1 , en en ajoutant un au caractère actuel.

La partie bleue imprime le caractère actuel et se prépare pour le caractère suivant.

Japt -P , 15 octets

ò mrÈ+R+YÕùT±Xl

Essayez-le

ò mrÈ+R+YÕùT±Xl     :Implicit input of string array
ò                   :Partition into 2s
  m                 :Map each pair
   r                :  Reduce by
    È               :  Passing through the following function as X & Y
     +              :    Append to X
      R             :    Newline
       +            :    Append
        YÕ          :    Transpose Y
          ù         :    Left pad each line with spaces to length
           T±       :      T (initially 0) incremented by
             Xl     :      Length of X
                    :Implicitly join and output

bash, 119 caractères

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for((i=0;i<l;i++));do
c="${w:$i:1}"
[ -z $c ]&&d=$((1-d))||printf ${X[$d]}$c
done

Cela utilise des séquences de contrôle ANSI pour déplacer le curseur - ici, j'utilise uniquement la sauvegarde \e7et la restauration \e8; mais la restauration doit être préfixée avec \npour faire défiler la sortie si elle est déjà en bas du terminal. Pour une raison quelconque, cela ne fonctionne pas si vous n'êtes pas déjà au bas du terminal. * haussement d'épaules *

Le caractère actuel $cest isolé en tant que sous-chaîne à un seul caractère de la chaîne d'entrée $w, en utilisant l' forindex de boucle $icomme index dans la chaîne.

La seule vraie astuce que j'utilise ici est celle [ -z $c ]qui retournera true, c'est-à-dire que la chaîne est vide, quand $cest un espace, car il n'est pas cité. Dans l'utilisation correcte de bash, vous devez citer la chaîne en cours de test -zpour éviter exactement cette situation. Cela nous permet d'inverser l'indicateur de direction $dentre 1et 0, qui est ensuite utilisé comme index dans le tableau de séquence de contrôle ANSI, Xsur la prochaine valeur non spatiale de $c.

Je serais intéressé de voir quelque chose qui utilise printf "%${x}s" $c.

Oh ça alors ajoutons un espace. Je ne vois pas où je suis ...

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for ((i=0;i<l;i++)); do
  c="${w:$i:1}"
  [ -z $c ] && d=$((1-d)) || printf ${X[$d]}$c
done

Perl 6 , 65 octets

{$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s","
").print!!.say*.comb}}

Essayez-le en ligne!

Bloc de code anonyme qui prend une liste de mots et s'imprime directement sur STDOUT.

Explication

{                           }  # Anonymous code block
 $/=0;                         # Initialise $/ to 0
 .map:{                    }   # Map the list of words to
       $/+=                    # Increment $/ by
           $++%2??             # For even indexes
                   .comb       # Each letter of the word
                   .fmt(           ) # Formatted as
                        "%$/s"       # Padded with $/-1 spaces
                              ,"\n"  # Joined by newlines
                   .print            # And printed without a newline
                  !   # Boolean not this to add 0 to $/
                !!            # For odd indexes
                  .say        # Print with a newline
                      *.comb  # And add the length of the word

Fusain , 19 octets

ＦＬθ¿﹪鲫↓§θι↗»«§θι↙

Entrée sous forme de liste de chaînes

Essayez-le en ligne (verbeux) ou essayez-le en ligne (pur)

Explication:

Boucle dans la gamme [0, input-length):

For(Length(q))
ＦＬθ

Si l'indice est impair:

If(Modulo(i,2)){...}
﹪鲫...»

Imprimez la chaîne à l'index ivers le bas:

Print(:Down, AtIndex(q,i));
↓§θι

Et puis déplacez le curseur une fois vers le coin supérieur droit:

Move(:UpRight);
↗

Sinon (l'indice est pair):

Else{...}
«...

Imprimez la chaîne à l'index idans la bonne direction:

Print(AtIndex(q,i));
§θι

Et puis déplacez une fois le curseur vers le bas à gauche:

Move(:DownLeft);
↙

Python 2 , 89 88 octets

s=i=-1
r=''
for w in input():r+=[('\n'+' '*s).join(' '+w),w][i];s-=i*len(w);i=~i
print r

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 122 octets

a=>{int i=0;var t="\n";foreach(var z in a)Write(i++%2<1?z+(t+="".PadRight(z.Length-(i<2?1:0))):string.Join(t,z.Skip(0)));}

Essayez-le en ligne!

J , ^{47 45} 43 octets

;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}]

Essayez-le en ligne!

J'ai trouvé une approche différente et amusante ...

J'ai commencé à jouer avec les pads gauche et les zips avec des gérondes cycliques et ainsi de suite, mais j'ai réalisé qu'il serait plus facile de calculer simplement la position de chaque lettre (cela se résume à une somme de scan du tableau correctement choisi) et d'appliquer la modification }à un blanc toile sur l'entrée rasée.

La solution est gérée presque entièrement par Amend }:

; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ]

• ; ( single verb that does all the work ) ] fourche globale
• ; la partie gauche rase l'entrée, c'est-à-dire met toutes les lettres dans une chaîne contiguë
• ] la partie droite est l'entrée elle-même
• (stuff)}nous utilisons le formulaire gérondif de amende }, qui se compose de trois parties v0`v1`v2.
  • v0nous donne les "nouvelles valeurs", qui est le raze (c'est-à-dire tous les caractères de l'entrée en une seule chaîne), nous utilisons donc [.
  • v2nous donne la valeur de départ, que nous transformons. nous voulons simplement une toile vierge d'espaces aux dimensions nécessaires. ([ ' '"0/ [)nous en donne une de taille (all chars)x(all chars).
  • Le verbe du milieu v1sélectionne les positions dans lesquelles nous mettrons nos caractères de remplacement. C'est le nœud de la logique ...
• En partant de la position 0 0en haut à gauche, nous remarquons que chaque nouveau caractère est soit 1 à droite de la position précédente (c.-à-d. prev + 0 1) Ou un en bas (c.-à prev + 1 0-d.). En effet, nous répétons les anciens «len de mot 1», puis les derniers «len de mot 2», et ainsi de suite. Nous allons donc simplement créer la séquence correcte de ces mouvements, puis les numériser, et nous aurons nos positions, que nous encadrerons ensuite parce que c'est comme ça que Amend fonctionne. Ce qui suit n'est que la mécanique de cette idée ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • #:@1 2Crée d' abord la matrice constante 0 1;1 0.
  • # $puis l'étend pour qu'il ait autant de lignes que l'entrée. par exemple, si l'entrée contient 3 mots, elle produira 0 1;1 0;0 1.
  • #&> #la partie gauche de celui-ci est un tableau des longueurs des mots d'entrée et #est copie, donc elle copie 0 1"len de mot 1" fois, puis 1 0"len de mot 2 fois", etc.
  • [: <@(+/)\ fait la somme et la boîte de numérisation.

T-SQL, 185 octets

DECLARE @ varchar(max)='Thomas Clausen Codegolf Script'
,@b bit=0,@s INT=0SET @+=':'WHILE @ like'%_:%'SELECT
@b+=len(left(@,1))-1,@=stuff(@,1,1,'')+iif(left(@,@b)='','','
'+space(@s))+trim(left(@,1)),@s+=len(left(@,~@b))PRINT
stuff(@,1,1,'')

Essayez-le en ligne

Rétine , 51 octets

1,2,`\w+
;$&
+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;
; |;$

Essayez-le en ligne!

Une approche assez simple qui marque tous les autres mots et applique ensuite la transformation directement.

Explication

1,2,`\w+
;$&

Nous marquons tous les autres mots avec un point-virgule en faisant correspondre chaque mot, mais en appliquant uniquement le remplacement aux correspondances (qui sont indexées zéro) à partir de la correspondance 1, puis 3 et ainsi de suite.

+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;

+(mdéfinit certaines propriétés pour les étapes suivantes. Le plus commence une boucle "pendant que ce groupe d'étapes change quelque chose", et le crochet ouvert indique que le plus doit s'appliquer à toutes les étapes suivantes jusqu'à ce qu'il y ait un crochet étroit devant un backtick (qui est toutes les étapes de ce cas). Le mjuste indique à l'expression régulière de traiter ^comme correspondant également depuis le début des lignes au lieu du début de la chaîne.

Le regex réel est assez simple. Nous faisons simplement correspondre la quantité appropriée de choses avant le premier point-virgule, puis utilisons la *syntaxe de remplacement de Retina pour insérer le nombre correct d'espaces.

; |;$

Cette étape est appliquée après la dernière pour supprimer les points-virgules et les espaces à la fin des mots que nous avons modifiés en vertical.

Retina 0.8.2 , 58 octets

(?<!^(\S* \S* )*\S*)
¶
¶? 

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Essayez-le en ligne! Le lien inclut des cas de test. Solution alternative, également 58 octets:

( \S*) 
$1¶
+` (.)
¶$1 
 ¶

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Essayez-le en ligne! Le lien inclut des cas de test.

Je n'utilise pas délibérément Retina 1 ici, donc je ne reçois pas d'opérations sur des mots alternatifs gratuitement; au lieu de cela, j'ai deux approches. La première approche se divise sur toutes les lettres en mots alternés en comptant les espaces précédents, tandis que la deuxième approche remplace les espaces alternatifs par des retours à la ligne, puis utilise les espaces restants pour l'aider à diviser les mots alternatifs en lettres. Chaque approche doit ensuite joindre la dernière lettre verticale au mot horizontal suivant, bien que le code soit différent car ils divisent les mots de différentes manières. L'étape finale des deux approches remplit ensuite chaque ligne jusqu'à ce que son premier caractère non spatial soit aligné sous le dernier caractère de la ligne précédente.

Notez que je ne suppose pas que les mots ne sont que des lettres parce que je n'ai pas à le faire.

PowerShell , 101 89 83 octets

-12 octets grâce à mazzy .

$args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+='
'+' '*$l+$_}}};$t

Essayez-le en ligne!

PowerShell , 74 65 octets

-join($args|%{$_|% t*y|%{($p+=(' ','
')[!$p]*!$i)*$i;$_};$i=!$i})

Essayez-le en ligne!

R , 126 octets

function(x,`>`=strrep)for(i in seq(x)){H=i%%2;cat(paste0('
'>!H,' '>F*!H,e<-'if'(H,x,strsplit(x,''))[[i]]))
F=F+nchar(e[1])-H}

Essayez-le en ligne!

• -3 octets grâce à @Giuseppe

T-SQL, 289 octets

DECLARE @ VARCHAR(MAX)='a a',@I INT=1,@S INT=0,@B INT=0WHILE @I<=LEN(@)IF SUBSTRING(@,@I,1)=''IF @B=0SELECT @S-=1,@=STUFF(@,@I,1,'
'+SPACE(@S)),@I+=@S+3,@B=1 ELSE SELECT @=STUFF(@,@I,1,''),@S+=1,@B=\ELSE IF @B=0SELECT @I+=1,@S+=1 ELSE SELECT @=STUFF(@,@I,0,'
'+SPACE(@S)),@I+=@S+3PRINT @

Cela s'exécute sur SQL Server 2016 et d'autres versions.

@ contient la liste délimitée par des espaces. @I suit la position d'index dans la chaîne. @S suit le nombre total d'espaces à mettre en retrait à partir de la gauche. @B suit l'axe sur lequel la chaîne est alignée au point @I.

Le nombre d'octets inclut la liste d'exemples minimale. Le script parcourt la liste, caractère par caractère, et modifie la chaîne afin qu'elle s'affiche selon les exigences. Lorsque la fin de la chaîne est atteinte, la chaîne est imprimée.

JavaScript (Node.js) , 75 octets

a=>a.map(x=>i++&1?[,...x].join(`
`.padEnd(n)):(n+=x.length,x),n=i=0).join``

Essayez-le en ligne!

Explication et non golfé

function f(a) {                   // Main function:
 return a.map(                    //  Map through all words:
  function(x) {
   if (i++ & 1)                   //   If i % 2 == 1 (i.e. vertical):
    return [,...x].join(          //    Since the first one needs to have its own linefeed 
                                  //    and indentation, add a dummy item to the start.
     "\n".padEnd(n)               //    Join the array with the padded line feeds.
    );
   else {                         //   If i % 2 == 0 (i.e. horizontal):
    n += x.length;                //    Add the length of this string to the variable that
                                  //    counts how long the padded line feeds should be.
    return x;                     //    Append the string at the end without line feeds.
   }
  },
  n = i = 0                       //   Initialize variables.
                                  //   n: the length of the padded line feeds 
                                  //      (including the line feed)
                                  //   i: keeps track of the direction
 ).join("")                       //  Join all stuffs and return.
}

Stax , 12 octets

ìZΣFτëWº═φ‼R

Exécuter et déboguer

Gelée , 21 octets

Ẉm2Ä’x2Ż⁶xⱮṛ;⁷ɗ;ⱮY¥ƭ"

Essayez-le en ligne!

Un programme complet prenant l'entrée en tant que liste de chaînes et sortant implicitement pour sortir de l'échelle de mots.

C (gcc) , 93 87 octets

Merci à gastropner pour les suggestions.

Cette version prend un tableau de chaînes terminées par un pointeur NULL.

c,d;f(s,t)char**s,*t;{for(c=d=0;t=*s++;d=!d)for(;*t;c+=!d)printf("\n%*c"+!d,d*c,*t++);}

Essayez-le en ligne!

Brain-Flak , 152 octets

<>([()])<>{<>({}<>{()<({}<>)><>}<>)<>{}{<>({}<((()()()()()){})>)({<({}[()]<((((()()()()){}){}){})>)>()}{})<>(({}<>({}))[({}[{}])])<>}{}}<>{}{({}<>)<>}<>

Essayez-le en ligne!

Je soupçonne que cela peut être plus court en combinant les deux boucles pour les mots pairs et impairs.

J, 35 33 octets

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y'

Il s'agit d'un verbe qui prend l'entrée en une seule chaîne avec les mots séparés par des espaces. Par exemple, vous pouvez l'appeler comme ceci:

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf'

La sortie est une matrice de lettres et d'espaces, que l'interprète sort avec des sauts de ligne selon les besoins. Chaque ligne sera remplie d'espaces afin qu'ils aient exactement la même longueur.

Il y a un léger problème avec le code: cela ne fonctionnera pas si l'entrée a plus de 98 mots. Si vous souhaitez autoriser une entrée plus longue, remplacez le _98dans le code par _998pour autoriser jusqu'à 998 mots, etc.

Permettez-moi d'expliquer comment cela fonctionne à travers quelques exemples.

Supposons que nous ayons une matrice de lettres et d'espaces que nous imaginons être une sortie partielle pour certains mots, en commençant par un mot horizontal.

   [m=: 3 3$'vwx  y  z'
vwx
  y
  z

Comment pourrions-nous ajouter un nouveau mot avant cela, verticalement? Ce n'est pas difficile: il suffit de transformer le nouveau mot en une matrice de lettres à une colonne avec le verbe ,., puis d'ajouter la sortie à cette matrice à une seule colonne. (Le verbe ,.est pratique car il se comporte comme une fonction d'identité si vous l'appliquez à une matrice que nous utilisons pour le golf.)

   (,.'cat') , m
c  
a  
t  
vwx
  y
  z

Maintenant, nous ne pouvons pas simplement répéter cette façon de ajouter un mot tel quel, car nous n'obtiendrions que des mots verticaux. Mais si nous transposons la matrice de sortie entre chaque étape, alors chaque autre mot sera horizontal.

   (,.'dog') , |: (,.'cat') , m
d     
o     
g     
catv  
   w  
   xyz

Notre première tentative de solution consiste donc à mettre chaque mot dans une matrice à une colonne, puis à les plier en les ajoutant et en les transposant entre eux.

   > (,|:)&.>/ ,.&.>;: 'car house dog children'
c            
a            
r            
housed       
     o       
     g       
     children

Mais il y a un gros problème avec ça. Cela place la première lettre du mot suivant avant de tourner à angle droit, mais la spécification nécessite de tourner avant de mettre la première lettre, donc la sortie devrait être quelque chose comme ceci à la place:

c             
a             
rhouse        
     d        
     o        
     gchildren

La façon dont nous y parvenons consiste à inverser la chaîne d'entrée entière, comme dans

nerdlihc god esuoh rac

puis utilisez la procédure ci-dessus pour construire le zig-zag mais en ne tournant qu'après la première lettre de chaque mot:

n     
e     
r     
d     
l     
i     
h     
c     
gode  
   s  
   u  
   o  
   h  
   rac

Retournez ensuite la sortie:

   [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children'
car   
  h   
  o   
  u   
  s   
  edog
     c
     h
     i
     l
     d
     r
     e
     n

Mais maintenant, nous avons encore un autre problème. Si l'entrée a un nombre impair de mots, alors la sortie aura le premier mot vertical, alors que la spécification dit que le premier mot doit être horizontal. Pour résoudre ce problème, ma solution remplit la liste de mots à exactement 98 mots, en ajoutant des mots vides, car cela ne change pas la sortie.