Dato un elenco di almeno due parole (composto solo da lettere minuscole), costruisci e visualizza una scala ASCII delle parole alternando la direzione di scrittura prima a destra, poi a sinistra, relativamente alla direzione iniziale da sinistra a destra .

Quando hai finito di scrivere una parola, cambia la direzione e solo allora inizia a scrivere la parola successiva.

Se la tua lingua non supporta elenchi di parole o è più conveniente per te, puoi prendere l'input come una stringa di parole, separate da un singolo spazio.

Sono ammessi spazi bianchi iniziali e finali.

["hello", "world"] o "hello world"

hello
    w
    o
    r
    l 
    d

Qui iniziamo scrivendo helloe quando arriviamo alla parola successiva (o nel caso dell'input come stringa - viene trovato uno spazio), cambiamo la direzione relativa a destra e continuiamo a scrivereworld

Casi 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

Criteri vincenti

Vince il codice più breve in byte in ogni lingua. Non lasciarti scoraggiare dalle lingue del golf!

sandbox

Carbone , 9 byte

Ｆ⮌Ａ«↑⮌ι‖↗

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Funziona disegnando il testo all'indietro, trasponendo la tela dopo ogni parola. 10 byte per input stringa:

Ｆ⮌Ｓ≡ι ‖↗←ι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: disegna il testo all'indietro, trasponendo la tela per gli spazi.

C (gcc) , 94 78 74 byte

-4 di 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);}

Provalo online!

Stampa la scala, un carattere (dell'input) alla volta. Accetta una stringa di parole separata dallo spazio.

05AB1E , 19 16 byte

€θ¨õšøíJD€gs24SΛ

-3 byte grazie a @Emigna .

Provalo online.

Spiegazione generale:

Proprio come @Emigna risposta 05AB1E s' (assicuratevi di upvote lui btw !!), io uso il comando incorporato CanvasΛ .

Le opzioni che utilizzo sono tuttavia diverse (motivo per cui la mia risposta è più lunga ..):

• b(le stringhe da stampare): lascio invariata la prima stringa nell'elenco e aggiungo il carattere finale a ciascuna stringa successiva nell'elenco. Ad esempio ["abc","def","ghi","jklmno"]sarebbe diventato ["abc","cdef","fghi","ijklmno"].
• a(le dimensioni delle linee): questo sarebbe uguale a queste stringhe, quindi [3,4,4,7]con l'esempio sopra.
• c(la direzione in cui stampare):, [2,4]che dovrebbe mappare[→,↓,→,↓,→,↓,...]

Quindi l'esempio sopra farebbe passo per passo il seguente:

1. Disegna abcin direzione 2/ →.
2. Disegna cdefin direzione 4/ ↓(dove il primo carattere si sovrappone all'ultimo carattere, motivo per cui abbiamo dovuto modificare l'elenco in questo modo)
3. Disegna fghiin direzione 2/ di →nuovo (anche con sovrapposizione di caratteri finali / iniziali)
4. Disegna ijklmnoin direzione 4/ di ↓nuovo (anche con sovrapposizione)
5. Stampa immediatamente il risultato della tela disegnata su STDOUT

Spiegazione del codice:

€θ                # 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 byte

Salvato 1 byte grazie a Grimy

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

Provalo online!

Spiegazione

                 # 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

Tela , 17 12 11 10 byte

ø⁸⇵｛⟳Ｋ└×∔⤢

Provalo qui!

Spiegazione:

ø⁸⇵{⟳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 byte

Accetta input come una matrice di parole.

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

Provalo online!

Commentate

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 byte

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

Provalo online!

Brainfuck , 57 byte

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

Provalo online!

Accetta input come stringhe separate NUL. Si noti che questo utilizza EOF come 0 e smetterà di funzionare quando la scala supera 256 spazi.

Spiegazione:

-           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 byte

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

Provalo online!

Grazie Rick Hitchcock , 2 byte salvati.

JavaScript, 65 byte

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

Provalo online!

a => a.replace (/./ g, c => (// per ogni carattere c nella stringa a
    1 - c? // if (c è spazio)
      (t =! t, // update t: il valore booleano descrive l'indice delle parole
                       // verità: parole indicizzate dispari;
                       // falsy: anche parole indicizzate
        ''): // non genera nulla per lo spazio
    t? // if (è un indice dispari) che significa che è verticale
      p + c: // aggiungi '\ n', alcuni spazi e un carattere sigle
                       // altro
      (p + = p? '': '\ n', // prepara la stringa prepend per le parole verticali
         c) // aggiungi un singolo carattere
),
  t = p = '' // inizializza
)

Aheui (esotopo) , 490 458 455 byte

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

Provalo online!

Leggermente giocato usando caratteri a larghezza intera (2 byte) anziché coreano (3 byte).

Spiegazione

Aheui è un esolang simile a un tuffo. Ecco il codice con il colore :? 1 parte controlla se il carattere corrente è spazio o meno.

? 2 parti verificano se le parole sono state scritte da destra a sinistra o dall'alto verso il basso.

? 3 parte è la condizione di interruzione del loop che digita gli spazi.

? 4 parti controllano se il carattere corrente è la fine della linea (-1).

La parte rossa è l'inizializzazione dello stack. Aheui utilizza pile (da Nothinga ㅎ: 28 pile) per memorizzare il valore.

La parte arancione prende input ( 뱋) e controlla se è spazio, sottraendo con 32(codice ascii di spazio).

La parte verde aggiunge 1 allo stack che memorizza il valore della lunghezza dello spazio, se si scrive da destra a sinistra.

La parte viola è un loop per gli spazi di stampa, se si scrive su-giù.

Parte grigia controlla se il personaggio attuale è -1, aggiungendone uno al personaggio attuale.

La parte blu stampa il personaggio attuale e si prepara per il personaggio successivo.

Japt -P , 15 byte

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

Provalo

ò 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 caratteri

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

Questo utilizza sequenze di controllo ANSI per spostare il cursore - qui sto usando solo il salvataggio \e7e il ripristino \e8; ma per ripristinare \nl'output è necessario aggiungere il prefisso se è già nella parte inferiore del terminale. Per qualche motivo non funziona se non sei già nella parte inferiore del terminale. * scrollata di spalle *

Il carattere corrente $cviene isolato come sottostringa a carattere singolo dalla stringa di input $w, usando l' forindice del ciclo $icome indice nella stringa.

L'unico vero trucco che sto usando qui è [ -z $c ]che tornerà true, cioè la stringa è vuota, quando $cè uno spazio, perché non è quotata. Nell'uso corretto di bash, citeresti la stringa sottoposta a test -zper evitare esattamente questa situazione. Questo ci consente di invertire il flag di direzione $dtra 1e 0, che viene quindi utilizzato come indice nella matrice della sequenza di controllo ANSI, Xsul successivo valore non spaziale di $c.

Sarei interessato a vedere qualcosa che usa printf "%${x}s" $c.

Oh Dio, aggiungiamo un po 'di spazio. Non riesco a vedere dove sono ...

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 byte

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

Provalo online!

Blocco di codice anonimo che accetta un elenco di parole e stampa direttamente su STDOUT.

Spiegazione

{                           }  # 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

Carbone , 19 byte

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

Inserisci come un elenco di stringhe

Provalo online (dettagliato) o provalo online (puro)

Spiegazione:

Loop nella gamma [0, input-length):

For(Length(q))
ＦＬθ

Se l'indice è dispari:

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

Stampa la stringa all'indice iin una direzione verso il basso:

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

Quindi sposta il cursore una volta verso l'alto-destra:

Move(:UpRight);
↗

Altrimenti (l'indice è pari):

Else{...}
«...

Stampa la stringa all'indice inella normale direzione destra:

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

Quindi sposta il cursore una volta verso il basso a sinistra:

Move(:DownLeft);
↙

Python 2 , 89 88 byte

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

Provalo online!

C # (compilatore interattivo Visual C #) , 122 byte

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

Provalo online!

J , ^{47 45} 43 byte

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

Provalo online!

Ho trovato un approccio divertente e diverso ...

Ho iniziato a scherzare con i pad e le zip di sinistra con gerundi ciclici e così via, ma poi ho capito che sarebbe stato più semplice calcolare la posizione di ogni lettera (questo si riduce a una somma di scansione dell'array scelto correttamente) e applicare la modifica }a uno spazio tela sull'ingresso rasato.

La soluzione è gestita quasi interamente da Amend }:

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

• ; ( single verb that does all the work ) ] forcella complessiva
• ; la parte sinistra sfoca l'input, cioè mette tutte le lettere in una stringa contigua
• ] la parte destra è l'input stesso
• (stuff)}usiamo la forma gerund di modifica }, che consiste di tre parti v0`v1`v2.
  • v0ci dà i "nuovi valori", che è la raze (cioè tutti i caratteri dell'input come una stringa), quindi usiamo [.
  • v2ci dà il valore iniziale, che stiamo trasformando. vogliamo semplicemente una tela bianca di spazi delle dimensioni necessarie. ([ ' '"0/ [)ci dà uno di dimensioni (all chars)x(all chars).
  • Il verbo centrale v1seleziona in quali posizioni inseriremo i nostri personaggi sostitutivi. Questo è il punto cruciale della logica ...
• Partendo dalla posizione 0 0in alto a sinistra, notiamo che ogni nuovo personaggio è 1 a destra della posizione precedente (cioè, prev + 0 1) o uno in basso (cioè, prev + 1 0). Effettivamente facciamo la prima "len della parola 1" volte, poi la seconda "len della parola 2" volte, e così via, alternando. Quindi creeremo solo la sequenza corretta di questi movimenti, quindi eseguiremo la scansione per sommarli, e avremo le nostre posizioni, che poi insacchettiamo perché funziona così Amend. Ciò che segue è solo la meccanica di questa idea ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Innanzitutto #:@1 2crea la matrice costante 0 1;1 0.
  • # $quindi lo estende in modo che abbia tutte le righe dell'input. ad esempio, se l'ingresso contiene 3 parole produrrà 0 1;1 0;0 1.
  • #&> # la parte sinistra di ciò è una matrice delle lunghezze delle parole di input e # è copia, quindi copia 0 1"len della parola 1" volte, quindi 1 0"len della parola 2 volte", ecc.
  • [: <@(+/)\ fa la somma e la casella di scansione.

T-SQL, 185 byte

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,'')

Provalo online

Retina , 51 byte

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

Provalo online!

Un approccio piuttosto semplice che segna ogni altra parola e quindi applica direttamente la trasformazione.

Spiegazione

1,2,`\w+
;$&

Contrassegniamo ogni altra parola con un punto e virgola abbinando ciascuna parola, ma applicando solo la sostituzione alle corrispondenze (che sono indicizzate zero) a partire dalla corrispondenza 1 e quindi 3 e così via.

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

+(mimposta alcune proprietà per le seguenti fasi. Il plus inizia un ciclo "mentre questo gruppo di fasi cambia qualcosa" e la parentesi aperta indica che il plus deve essere applicato a tutte le fasi successive fino a quando non c'è una parentesi chiusa di fronte a un backtick (che è tutte le fasi in questo caso). Ilm just dice al regex di trattare ^come una corrispondenza anche dall'inizio delle righe anziché solo all'inizio della stringa.

L'attuale regex è piuttosto semplice. Abbiniamo semplicemente la quantità appropriata di elementi prima del primo punto e virgola e quindi usiamo la *sintassi sostitutiva di Retina per inserire il numero corretto di spazi.

; |;$

Questa fase viene applicata dopo l'ultima per rimuovere punti e virgola e spazi alla fine delle parole che abbiamo cambiato in verticale.

Retina 0.8.2 , 58 byte

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

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

Provalo online! Il link include casi di test. Soluzione alternativa, anche 58 byte:

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

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

Provalo online!Il link include casi di test.

Non sto deliberatamente usando Retina 1 qui, quindi non ottengo operazioni su parole alternative gratuitamente; invece ho due approcci. Il primo approccio si divide su tutte le lettere in parole alternative contando gli spazi precedenti, mentre il secondo approccio sostituisce gli spazi alternati con nuove righe e quindi utilizza gli spazi rimanenti per aiutarlo a dividere le parole alternate in lettere. Ogni approccio deve quindi unire l'ultima lettera verticale con la successiva parola orizzontale, sebbene il codice sia diverso perché dividono le parole in modi diversi. La fase finale di entrambi gli approcci quindi riempie ogni riga fino a quando il suo primo carattere non spaziale viene allineato sotto l'ultimo carattere della riga precedente.

Nota che non presumo che le parole siano solo lettere perché non devo.

PowerShell , 101 89 83 byte

-12 byte grazie a mazzy .

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

Provalo online!

PowerShell , 74 65 byte

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

Provalo online!

R , 126 byte

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}

Provalo online!

• -3 byte grazie a @Giuseppe

T-SQL, 289 byte

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 @

Questo funziona su SQL Server 2016 e altre versioni.

@ contiene l'elenco delimitato da spazi. @I tiene traccia della posizione dell'indice nella stringa. @S tiene traccia del numero totale di spazi da rientrare da sinistra. @B traccia con quale asse è allineata la stringa nel punto @I.

Il conteggio dei byte include un elenco di esempi minimo. Lo script passa attraverso l'elenco, carattere per carattere, e modifica la stringa in modo che venga visualizzata in base ai requisiti. Quando viene raggiunta la fine della stringa, la stringa viene STAMPATA.

JavaScript (Node.js) , 75 byte

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

Provalo online!

Spiegazione e non golfato

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 byte

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

Esegui ed esegui il debug

Gelatina , 21 byte

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

Provalo online!

Un programma completo che prende l'input come un elenco di stringhe e genera implicitamente l'output della parola ladder.

C (gcc) , 93 87 byte

Grazie a gastropner per i suggerimenti.

Questa versione accetta una matrice di stringhe terminata da un puntatore 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++);}

Provalo online!

Brain-Flak , 152 byte

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

Provalo online!

Sospetto che questo possa essere più breve combinando i due loop per parole pari e dispari.

J, 35 33 byte

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

Questo è un verbo che accetta l'input come singola stringa con le parole separate da spazi. Ad esempio, potresti chiamarlo così:

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

L'output è una matrice di lettere e spazi, che l'interprete emette con nuove righe come richiesto. Ogni linea sarà riempita con spazi in modo che abbiano la stessa identica lunghezza.

C'è un piccolo problema con il codice: non funzionerà se l'input ha più di 98 parole. Se si desidera consentire un input più lungo, sostituire il _98nel codice _998per consentire fino a 998 parole, ecc.

Lasciami spiegare come funziona attraverso alcuni esempi.

Supponiamo di avere una matrice di lettere e spazi che immaginiamo sia un output parziale per alcune parole, a cominciare da una parola orizzontale.

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

Come potremmo anteporre una nuova parola prima di questa, in verticale? Non è difficile: basta trasformare la nuova parola in una matrice di lettere a colonna singola con il verbo ,., quindi aggiungere l'output a quella matrice a colonna singola. (Il verbo,. è conveniente perché si comporta come una funzione di identità se lo applichi a una matrice, che usiamo per giocare a golf.)

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

Ora non possiamo semplicemente ripetere questo modo di anteporre una parola così com'è, perché otterremmo solo parole verticali. Ma se trasponiamo la matrice di output tra ogni passaggio, ogni altra parola sarà orizzontale.

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

Quindi il nostro primo tentativo di soluzione è quello di mettere ogni parola in una matrice a colonna singola, quindi piegarle aggiungendole e trasponendole.

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

Ma c'è un grosso problema con questo. Questo mette la prima lettera della parola successiva prima di girare ad angolo retto, ma la specifica richiede di girare prima di inserire la prima lettera, quindi l'output dovrebbe essere qualcosa del genere invece:

c             
a             
rhouse        
     d        
     o        
     gchildren

Il modo in cui raggiungiamo questo obiettivo è di invertire l'intera stringa di input, come in

nerdlihc god esuoh rac

quindi usa la procedura sopra per costruire lo zig-zag ma girando solo dopo la prima lettera di ogni parola:

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

Quindi capovolgi l'output:

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

Ma ora abbiamo ancora un altro problema. Se l'input ha un numero dispari di parole, allora l'output avrà la prima parola verticale, mentre la specifica dice che la prima parola deve essere orizzontale. Per risolvere questo problema, la mia soluzione completa l'elenco di parole esattamente a 98 parole, aggiungendo parole vuote, poiché ciò non modifica l'output.