Biorąc pod uwagę listę co najmniej dwóch słów (składających się tylko z małych liter), utwórz i wyświetl drabinkę ASCII słów, zmieniając kierunek pisania najpierw w prawo, a następnie w lewo, w stosunku do początkowego kierunku od lewej do prawej .

Po zakończeniu pisania słowa zmień kierunek i dopiero wtedy zacznij pisać następne słowo.

Jeśli Twój język nie obsługuje list słów lub jest to dla Ciebie wygodniejsze, możesz wziąć dane wejściowe jako ciąg słów oddzielonych pojedynczym odstępem.

Wiodące i końcowe białe znaki są dozwolone.

["hello", "world"] lub "hello world"

hello
    w
    o
    r
    l 
    d

Tutaj zaczynamy od pisania, helloa kiedy dochodzimy do następnego słowa (lub w przypadku wprowadzenia jako ciągu - spacja jest znaleziona), zmieniamy względny kierunek w prawo i kontynuujemy pisanieworld

Przypadki testowe:

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

Kryteria wygranej

Wygrywa najkrótszy kod w bajtach w każdym języku. Nie daj się zniechęcić językiem golfa!

Piaskownica

Węgiel , 9 bajtów

Ｆ⮌Ａ«↑⮌ι‖↗

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Działa poprzez rysowanie tekstu do tyłu, transponowanie płótna po każdym słowie. 10 bajtów na ciąg znaków:

Ｆ⮌Ｓ≡ι ‖↗←ι

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Rysuje tekst do tyłu, przenosząc płótno na spacje.

C (gcc) , 94 78 74 bajtów

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

Wypróbuj online!

Drukuje drabinę, jeden znak (wejścia) na raz. Pobiera rozdzielony spacjami ciąg słów.

05AB1E , 19 16 bajtów

€θ¨õšøíJD€gs24SΛ

-3 bajty dzięki @Emigna .

Wypróbuj online.

Ogólne wyjaśnienie:

Podobnie jak @Emigna „s 05AB1E odpowiedzi (upewnij upvote go btw !!), używam polecenie wbudowane płótnieΛ .

Opcje, których używam, są jednak różne (dlatego moja odpowiedź jest dłuższa ...):

• b(ciągi do wydrukowania): pozostawiam pierwszy ciąg na liście bez zmian i dodam znak końcowy do każdego następnego ciągu na liście. Na przykład ["abc","def","ghi","jklmno"]stałby się ["abc","cdef","fghi","ijklmno"].
• a(rozmiary linii): Byłoby to równe tym ciągom, tak [3,4,4,7]jak w powyższym przykładzie.
• c(kierunek drukowania w):, [2,4]który odwzorowałby na[→,↓,→,↓,→,↓,...]

W powyższym przykładzie krok po kroku wykonaj następujące czynności:

1. Rysuj abcw kierunku2 / →.
2. Rysuj cdefw kierunku4 / ↓(gdzie pierwszy znak nakłada się na ostatni znak, dlatego musieliśmy zmodyfikować listę w ten sposób)
3. Rysuj fghiw kierunku2 / →ponownie (także z nakładaniem się znaków wiodących / wiodących)
4. Rysuj ijklmnow kierunku4 / ↓ponownie (także z zakładką)
5. Natychmiast wyślij wynik narysowanego płótna do STDOUT

Objaśnienie kodu:

€θ                # 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 bajtów

Oszczędność 1 bajtu dzięki Grimy

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

Wypróbuj online!

Wyjaśnienie

                 # 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

Płótno , 17 12 11 10 bajtów

ø⁸⇵｛⟳Ｋ└×∔⤢

Wypróbuj tutaj!

Wyjaśnienie:

ø⁸⇵{⟳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 bajtów

Pobiera dane wejściowe jako tablicę słów.

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

Wypróbuj online!

Skomentował

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 bajty

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

Wypróbuj online!

pieprzenie mózgu , 57 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako ciągi rozdzielone NUL. Zauważ, że używa EOF jako 0 i przestanie działać, gdy drabina przekroczy 256 spacji.

Wyjaśnienie:

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

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

Wypróbuj online!

Dzięki Rick Hitchcock , zapisane 2 bajty.

JavaScript, 65 bajtów

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

Wypróbuj online!

a => a.replace (/./ g, c => (// dla każdego znaku c w ciągu a
    1 - c? // if (c to spacja)
      (t =! t, // aktualizacja t: wartość logiczna opisuje indeks słów
                       // truey: słowa indeksowane nieparzyste;
                       // falsy: nawet indeksowane słowa
        ''): // nic nie generuje dla przestrzeni
    t? // if (jest nieparzystym indeksem), co oznacza, że ​​jest pionowy
      p + c: // dodaj „\ n”, niektóre spacje i znak sigle
                       // else
      (p + = p? '': '\ n', // przygotuj ciąg poprzedzający dla słów pionowych
         c) // dodaj pojedynczy znak
),
  t = p = '' // inicjalizacja
)

Aheui (esotop) , 490 458 455 bajtów

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

Wypróbuj online!

Lekko golfowy za pomocą znaków o pełnej szerokości (2 bajty) zamiast koreańskich (3 bajty).

Wyjaśnienie

Aheui to esolang podobny do befunge. Oto kod z kolorem :? 1 część sprawdza, czy bieżącym znakiem jest spacja, czy nie.

? 2 części sprawdzają, czy słowa pisane były od prawej do lewej lub od góry do dołu.

Część 3 to warunek przerwania pętli, który wpisuje spacje.

? 4 części sprawdzają, czy bieżący znak to koniec linii (-1).

Część czerwona to inicjalizacja stosu. Aheui używa stosów (od Nothingdo ㅎ: 28 stosów) do przechowywania wartości.

Część pomarańczowa pobiera input ( 뱋) i sprawdza, czy jest to spacja, odejmując 32(ascii kod spacji).

Zielona część dodaje 1 do stosu, który przechowuje wartość długości przestrzeni, jeśli piszesz od prawej do lewej.

Część fioletowa to pętla do drukowania spacji, w przypadku pisania od góry do dołu.

Część szara sprawdź, czy jest obecny znak -1, dodając jeden do bieżącego znaku.

Niebieska część drukuje obecną postać i przygotowuje się do następnej postaci.

Japt -P , 15 bajtów

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

Spróbuj

ò 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 znaków

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

Używa sekwencji kontrolnych ANSI do poruszania kursorem - tutaj używam tylko opcji zapisz \e7i przywróć \e8; ale przywracanie musi być poprzedzone znakiem, \naby przewinąć dane wyjściowe, jeśli są już na dole terminala. Z jakiegoś powodu nie działa, jeśli nie jesteś jeszcze na dole terminala. * wzrusza ramionami *

Bieżący znak $cjest izolowany jako ciąg znaków jednego znaku z ciągu wejściowego $w, przy użyciu forindeksu pętli $ijako indeksu w ciągu.

Jedyną sztuczką, której tu używam, jest [ -z $c ]zwrócenie true, tzn. Łańcuch jest pusty, gdy $cjest spacją, ponieważ nie jest cytowany. Przy prawidłowym użyciu bash, cytujesz testowany ciąg, -zaby uniknąć dokładnie takiej sytuacji. To pozwala nam odwrócić flagę kierunku $dpomiędzy 1i 0, która jest następnie używana jako indeks w tablicy sekwencji sterujących ANSI, Xna następnej wartości spacji $c.

Byłbym zainteresowany, aby zobaczyć coś, co wykorzystuje printf "%${x}s" $c.

O rany, dodajmy trochę białych znaków. Nie widzę gdzie jestem ...

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 bajtów

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

Wypróbuj online!

Anonimowy blok kodu, który pobiera listę słów i drukuje bezpośrednio do STDOUT.

Wyjaśnienie

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

Węgiel drzewny , 19 bajtów

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

Wprowadź jako listę ciągów

Wypróbuj online (pełne) lub wypróbuj online (czysty)

Wyjaśnienie:

Pętla w zakresie [0, input-length):

For(Length(q))
ＦＬθ

Jeśli indeks jest nieparzysty:

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

Wydrukuj ciąg o indeksie iw dół:

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

Następnie przesuń kursor raz w prawo w prawym górnym rogu:

Move(:UpRight);
↗

W przeciwnym razie (indeks jest parzysty):

Else{...}
«...

Wydrukuj ciąg o indeksie iw regularnym prawidłowym kierunku:

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

A następnie przesuń kursor raz w lewy dolny róg:

Move(:DownLeft);
↙

Python 2 , 89 88 bajtów

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

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 122 bajty

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

Wypróbuj online!

J , ^{47 45} 43 bajtów

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

Wypróbuj online!

Znalazłem zabawne, inne podejście ...

Zacząłem bawić się w lewe pady i zamki z cyklicznymi gerundami i tak dalej, ale potem zdałem sobie sprawę, że łatwiej byłoby po prostu obliczyć pozycję każdej litery (sprowadza się to do sumy skanowania prawidłowo wybranej tablicy) i zastosować poprawkę } do pustego płótno na zniszczonym wejściu.

Rozwiązanie obsługiwane jest prawie całkowicie przez Amend }:

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

• ; ( single verb that does all the work ) ] ogólny widelec
• ; lewa część niszczy wejście, tzn. umieszcza wszystkie litery w ciągłym ciągu
• ] właściwa część to sam wkład
• (stuff)}używamy formy poprawek gerund }, która składa się z trzech częściv0`v1`v2 .
  • v0 daje nam „nowe wartości”, czyli „raze” (tzn. wszystkie znaki wejściowe jako jeden ciąg), więc używamy [ .
  • v2daje nam wartość początkową, którą przekształcamy. chcemy po prostu puste płótno przestrzeni o wymaganych wymiarach. ([ ' '"0/ [)daje nam jeden rozmiar (all chars)x(all chars).
  • Środkowy czasownik v1wybiera pozycje, w których umieścimy nasze zastępcze postacie. To jest sedno logiki ...
• Zaczynając od pozycji 0 0w lewym górnym rogu, zauważamy, że każda nowa postać znajduje się albo 1 na prawo od poprzedniej pozycji (tj. prev + 0 1), Albo jedną w dół (tj prev + 1 0.). Rzeczywiście robimy pierwsze czasy „długość słowa 1”, a następnie drugie czasy „długość słowa 2” i tak dalej, naprzemiennie. Więc po prostu utworzymy prawidłową sekwencję tych ruchów, a następnie zeskanujemy je i zsumujemy, i będziemy mieli nasze pozycje, które następnie zestawimy, ponieważ tak działa Amend. Poniżej znajduje się tylko mechanika tego pomysłu ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Najpierw #:@1 2tworzy stałą macierz 0 1;1 0.
  • # $następnie rozszerza go, aby miał tyle wierszy, co dane wejściowe. np. jeśli dane wejściowe zawierają 3 słowa, które utworzy 0 1;1 0;0 1.
  • #&> #lewa część tego jest tablicą długości słów wejściowych i #jest kopiowana, więc kopiuje razy 0 1„długość słowa 1”, a następnie1 0 „długość słowa 2 razy” itd.
  • [: <@(+/)\ robi sumę skanowania i pole.

T-SQL, 185 bajtów

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

Wypróbuj online

Siatkówka , 51 bajtów

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

Wypróbuj online!

Raczej proste podejście, które oznacza każde inne słowo, a następnie stosuje transformację bezpośrednio.

Wyjaśnienie

1,2,`\w+
;$&

Oznaczamy każde inne słowo średnikiem, dopasowując każde słowo, ale stosując tylko zamianę na dopasowania (które są indeksowane zerowo), zaczynając od dopasowania 1, a następnie 3 itd.

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

+(mustawia niektóre właściwości dla następujących etapów. Znak plus rozpoczyna pętlę „podczas gdy ta grupa etapów zmienia coś”, a otwarty nawias oznacza, że ​​znak plus powinien obowiązywać na wszystkich kolejnych etapach, dopóki nie pojawi się nawias zamykający przed odwrotnym ruchem (który jest wszystkimi etapami w ta sprawa). Po mprostu każe wyrażeniu regularnemu leczyć^ jako dopasowanie również od początku linii zamiast od samego początku łańcucha.

Rzeczywiste wyrażenie regularne jest dość proste. Po prostu dopasowujemy odpowiednią liczbę elementów przed pierwszym średnikiem, a następnie używamy *składni zastępczej Retiny, aby wstawić odpowiednią liczbę spacji.

; |;$

Ten etap jest stosowany po ostatnim, aby usunąć średniki i spacje na końcu słów, które zmieniliśmy na pionowe.

Retina 0.8.2 , 58 bajtów

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

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

Wypróbuj online! Link zawiera przypadki testowe. Alternatywne rozwiązanie, również 58 bajtów:

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

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

Wypróbuj online! Link zawiera przypadki testowe.

Celowo nie używam tutaj Retina 1, więc nie otrzymuję operacji na alternatywnych słowach za darmo; zamiast tego mam dwa podejścia. Pierwsze podejście dzieli wszystkie litery na alternatywne słowa, licząc poprzedzające spacje, podczas gdy drugie podejście zastępuje alternatywne spacje nowymi liniami, a następnie wykorzystuje pozostałe spacje, aby pomóc mu podzielić alternatywne słowa na litery. Każde podejście musi następnie połączyć ostatnią literę pionową z następnym poziomym słowem, chociaż kod jest inny, ponieważ dzielą słowa na różne sposoby. Ostatni etap obu podejść następnie wypełnia każdą linię, aż jej pierwszy znak spacji nie zostanie wyrównany pod ostatnim znakiem poprzedniej linii.

Zauważ, że nie zakładam, że słowa to tylko litery, ponieważ nie muszę.

PowerShell , 101 89 83 bajtów

-12 bajtów dzięki mazzy .

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

Wypróbuj online!

PowerShell , 74 65 bajtów

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

Wypróbuj online!

R , 126 bajtów

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}

Wypróbuj online!

• -3 bajty dzięki @Giuseppe

T-SQL, 289 bajtów

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 @

Działa to na SQL Server 2016 i innych wersjach.

@ przechowuje listę rozdzielaną spacjami. @I śledzi pozycję indeksu w ciągu. @S śledzi całkowitą liczbę spacji do wcięcia od lewej. @B śledzi, do której osi ciąg jest wyrównany w punkcie @I.

Liczba bajtów obejmuje minimalną listę przykładów. Skrypt przechodzi przez listę, znak po znaku, i zmienia ciąg, aby wyświetlał się zgodnie z wymaganiami. Po osiągnięciu końca ciągu zostanie on WYDRUKOWANY.

JavaScript (Node.js) , 75 bajtów

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

Wypróbuj online!

Wyjaśnienia i niepoznany

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 bajtów

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

Uruchom i debuguj

Galaretka , 21 bajtów

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

Wypróbuj online!

Pełny program, który przyjmuje dane wejściowe jako listę ciągów znaków i niejawnie wypisuje je na standardowe słowo drabinkowe.

C (gcc) , 93 87 bajtów

Dzięki gastropner za sugestie.

Ta wersja pobiera tablicę ciągów zakończonych wskaźnikiem 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++);}

Wypróbuj online!

Brain-Flak , 152 bajty

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

Wypróbuj online!

Podejrzewam, że może to być krótsze, łącząc dwie pętle dla nieparzystych i parzystych słów.

J, 35 33 bajtów

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

Jest to czasownik, który przyjmuje dane wejściowe jako pojedynczy ciąg znaków ze słowami oddzielonymi spacjami. Na przykład możesz to tak nazwać:

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

Dane wyjściowe to macierz liter i spacji, które interpreter wyświetla w razie potrzeby z nowymi wierszami. Każda linia będzie wypełniona spacjami, aby miały dokładnie taką samą długość.

Jest jeden drobny problem z kodem: nie zadziała, jeśli dane wejściowe zawierają więcej niż 98 słów. Jeśli chcesz zezwolić na dłuższe dane wejściowe, wymień_98 kod na, _998aby zezwolić na maksymalnie 998 słów itp.

Pozwól mi wyjaśnić, jak to działa na kilku przykładach.

Załóżmy, że mamy matrycę liter i spacji, które naszym zdaniem są częściowym wynikiem niektórych słów, zaczynając od słowa poziomego.

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

Jak moglibyśmy wstawić nowe słowo przed tym, w pionie? To nie jest trudne: po prostu zmień nowe słowo na macierz jednokolumnową z czasownikiem ,., a następnie dołącz wynik do tej macierzy jednokolumnowej. (Czasownik ,.jest wygodny, ponieważ zachowuje się jak funkcja tożsamości, jeśli zastosujesz go do matrycy, której używamy do gry w golfa.)

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

Teraz nie możemy po prostu powtórzyć tego sposobu wcześniejszego przygotowania słowa, ponieważ wtedy otrzymalibyśmy tylko słowa pionowe. Ale jeśli transponujemy macierz wyjściową między każdym krokiem, wówczas każde inne słowo będzie poziome.

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

Tak więc naszą pierwszą próbą rozwiązania jest umieszczenie każdego słowa w macierzy jednokolumnowej, a następnie złożenie ich poprzez dołączenie i transpozycję między nimi.

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

Ale jest z tym duży problem. Spowoduje to umieszczenie pierwszej litery następnego słowa przed obróceniem kąta prostego, ale specyfikacja wymaga obrócenia przed wstawieniem pierwszej litery, więc wynik powinien być mniej więcej taki:

c             
a             
rhouse        
     d        
     o        
     gchildren

Sposób, w jaki to osiągamy, polega na odwróceniu całego ciągu wejściowego, tak jak w

nerdlihc god esuoh rac

następnie użyj powyższej procedury, aby zbudować zygzak, ale obracając się dopiero po pierwszej literze każdego słowa:

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

Następnie odwróć wyjście:

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

Ale teraz mamy kolejny problem. Jeśli dane wejściowe zawierają nieparzystą liczbę słów, wówczas pierwsze słowo będzie miało pionowe, a specyfikacja mówi, że pierwsze słowo musi być poziome. Aby to naprawić, moje rozwiązanie uzupełnia listę słów dokładnie 98 słowami, dodając puste słowa, ponieważ to nie zmienia wyniku.