Давши список щонайменше двох слів (складених лише з малих літер), побудуйте та покажіть сходи ASCII слів, чергуючи напрям написання спочатку праворуч, потім ліворуч, відносно початкового напрямку зліва направо .

Коли ви закінчите писати слово, змініть напрямок і лише після цього починайте писати наступне слово.

Якщо ваша мова не підтримує списки слів, або це зручніше для вас, ви можете взяти введення як рядок слів, розділених єдиним пробілом.

Дозволені провідні та кінцеві пробіли.

["hello", "world"] або "hello world"

hello
    w
    o
    r
    l 
    d

Тут ми починаємо з написання helloі коли ми переходимо до наступного слова (або у випадку введення як рядок - пробіл знайдений), ми змінюємо відносний напрямок праворуч і продовжуємо писатиworld

Тестові приклади:

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

Критерії вин

Виграє найкоротший код у байтах на кожній мові. Не дозволяйте зневажати мов для гольфу!

Пісочниця

Вугілля деревне , 9 байт

Ｆ⮌Ａ«↑⮌ι‖↗

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення: Працює, малюючи текст назад, переносячи полотно після кожного слова. 10 байт для рядкового введення:

Ｆ⮌Ｓ≡ι ‖↗←ι

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення: малює текст назад, переносячи полотно на пробіли.

C (gcc) , 94 78 74 байт

-4 від Йохан дю Тойт

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

Спробуйте в Інтернеті!

Друкує сходи, по одному символу (одночасно). Займає розділений пробілом рядок слів.

05AB1E , 19 16 байт

€θ¨õšøíJD€gs24SΛ

-3 байти завдяки @Emigna .

Спробуйте в Інтернеті.

Загальне пояснення:

Як і відповідь 05AB1E @Emigna (не забудьте підтримати його до цього часу !!), я використовую Canvas вбудованийΛ .

Однак, я використовую різні варіанти (тому моя відповідь довша ..):

• b(рядки для друку): Я залишаю першу рядок у списку незмінною, і додаю проміжний символ до кожного наступного рядка у списку. Наприклад ["abc","def","ghi","jklmno"]стане ["abc","cdef","fghi","ijklmno"].
• a(розміри рядків): це було б дорівнює цим рядкам, тому [3,4,4,7]з прикладом вище.
• c(напрямок для друку):, [2,4]яке буде відображатись[→,↓,→,↓,→,↓,...]

Отже, наведений вище приклад покроково виконує наступне:

1. Малюємо abcв напрямку 2/ →.
2. Малюємо cdefв напрямку 4/ ↓(де перший символ перекривається з останнім символом, саме тому нам довелося змінювати список, як цей)
3. Малюйте fghiу напрямку 2/ →знову (також із накладанням проміжних / провідних символів)
4. Малюємо ijklmnoв напрямку 4/ ↓знову (також з накладанням)
5. Виведіть результат намальованого полотна негайно в STDOUT

Пояснення коду:

€θ                # 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 байт

Збережено 1 байт завдяки Grimy

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

Спробуйте в Інтернеті!

Пояснення

                 # 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

Полотно , 17 12 11 10 байт

ø⁸⇵｛⟳Ｋ└×∔⤢

Спробуйте тут!

Пояснення:

ø⁸⇵{⟳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 байт

Вводить введення як масив слів.

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

Спробуйте в Інтернеті!

Прокоментував

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

Пітон 2 , 82 байти

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

Спробуйте в Інтернеті!

мозковий ебать , 57 байт

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

Спробуйте в Інтернеті!

Приймає дані як рядки, розділені NUL. Зауважте, що для цього використовується коефіцієнт EOF як 0, і він перестане працювати, коли трап перевищить 256 пробілів.

Пояснення:

-           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 байти

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

Спробуйте в Інтернеті!

Дякую Ріку Хічкоку , 2 байти збережено.

JavaScript, 65 байт

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

Спробуйте в Інтернеті!

a => a.replace (/./ g, c => (// для кожного символу c у рядку a)
    1 - с? // if (c - простір)
      (t =! t, // update t: булеве значення описує індекс слів
                       // truthy: непарні індексовані слова;
                       // хибність: навіть індексовані слова
        ''): // генерувати нічого для простору
    т? // if (є непарний індекс), що означає вертикальний
      p + c: // додати '\ n', деякі пробіли та символьну симуляцію
                       // інше
      (p + = p? '': '\ n', // підготувати рядок для подання вертикальних слів
         в) // додайте один символ
),
  t = p = '' // ініціалізувати
)

Ахей (езотоп) , 490 458 455 байт

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

Спробуйте в Інтернеті!

Трохи гольфуйте, використовуючи символи повної ширини (2 байти), а не корейські (3 байти).

Пояснення

Ахей - це схожий на езоланг. Ось код з кольором :? 1 частина перевіряє, чи поточний символ пробіл чи ні.

2 частини перевіряють, чи слова написані справа наліво чи зверху вниз.

3 частина - умова розриву циклу, який набирає пробіли.

? 4 частини перевіряють, чи є поточний символ кінцем рядка (-1).

Червона частина - це ініціалізація стека. Aheui використовує стеки (від Nothingдо ㅎ: 28 стеків) для зберігання значення.

Помаранчева частина бере введення ( 뱋) і перевіряє, чи це пробіл, віднімаючи 32(код коду простору).

Зелена частина додає 1 до стеку, який зберігає значення довжини простору, якщо писати справа наліво.

Фіолетова частина - це петля для друку пробілів, якщо писати вгору-вниз.

Сіра частина перевірити, чи є поточний символ -1, додавши його до поточного символу.

Синя частина друкує поточний символ та готується до наступного символу.

Japt -P , 15 байт

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

Спробуй це

ò 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

баш, 119 ч

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

При цьому для керування курсором використовуються керуючі послідовності ANSI - тут я використовую лише збереження \e7та відновлення \e8; але відновлення має бути встановлено префіксом, \nщоб прокрутити вихід, якщо він вже знаходиться в нижній частині терміналу. Чомусь це не працює, якщо ви вже не внизу терміналу. * знизати плечима *

Поточний символ $cвиділяється як односимвольна підрядка з вхідного рядка $w, використовуючи forіндекс циклу $iяк індекс у рядку.

Єдиний справжній трюк, який я тут використовую, - [ -z $c ]це повернення true, тобто рядок порожній, коли $cце пробіл, оскільки він не цитується. При правильному використанні bash, ви б цитували тестування рядка, -zщоб уникнути саме такої ситуації. Це дозволяє нам перевернути прапор напряму $dміж 1і 0, який потім використовується як індекс в масив послідовностей керування ANSI, Xна наступне непробільне значення $c.

Мені було б цікаво побачити щось, що використовує printf "%${x}s" $c.

О боже, давайте додамо трохи пробілів. Я не бачу, де я ...

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 байт

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

Спробуйте в Інтернеті!

Блок анонімного коду, який приймає список слів і друкує прямо до STDOUT.

Пояснення

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

Вугілля деревне , 19 байт

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

Введіть як список рядків

Спробуйте в Інтернеті (багатослівний) або спробуйте онлайн (чисто)

Пояснення:

Петля в діапазоні [0, input-length):

For(Length(q))
ＦＬθ

Якщо індекс непарний:

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

Друкуйте рядок в індексі iв напрямку донизу:

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

А потім перемістіть курсор один раз у верхній правий кут:

Move(:UpRight);
↗

Інше (індекс рівний):

Else{...}
«...

Друкуйте рядок в індексі iу правильному правильному напрямку:

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

А потім перемістіть курсор один раз уліво вліво:

Move(:DownLeft);
↙

Python 2 , 89 88 байт

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

Спробуйте в Інтернеті!

C # (Visual C # Interactive Compiler) , 122 байти

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

Спробуйте в Інтернеті!

J , ^{47 45} 43 байт

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

Спробуйте в Інтернеті!

Я знайшов цікавий, інший підхід ...

Я почав возитися з лівими колодками та блискавками з циклічними заголовками тощо, але потім зрозумів, що буде простіше просто обчислити позицію кожної літери (це зводиться до суми сканування правильно вибраного масиву) і застосувати поправки }до порожнього полотно на зведеному вході.

Рішення майже повністю обробляється Amend }:

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

• ; ( single verb that does all the work ) ] загальна виделка
• ; ліва частина відрізає вхід, тобто ставить усі літери в суміжний рядок
• ] права частина - це сам вхід
• (stuff)}ми використовуємо форму герунду правки }, яка складається з трьох частин v0`v1`v2.
  • v0дає нам "нові значення", що є рівнем (тобто всі символи введення як один рядок), тому ми використовуємо [.
  • v2дає нам вихідну цінність, яку ми трансформуємо. ми просто хочемо порожнє полотно з пробілами потрібних розмірів. ([ ' '"0/ [)дає нам один розмір (all chars)x(all chars).
  • Середнє дієслово v1вибирає, в які позиції ми будемо ставити наші замінні символи. Це суть логіки ...
• Починаючи з положення 0 0у верхньому лівому куті, ми помічаємо, що кожен новий символ знаходиться або 1 справа від попередньої позиції (тобто prev + 0 1), або один вниз (тобто prev + 1 0). Насправді ми робимо колишній "час слова 1", потім останній "тривалість слова 2", і так далі, чергуючи. Тож ми просто створимо правильну послідовність цих рухів, потім скануємо їх підсумки, і ми отримаємо свої позиції, які ми поставимо у вікні, тому що так працює Amend. Далі йде лише механіка цієї ідеї ...
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • Спочатку #:@1 2створює постійну матрицю 0 1;1 0.
  • # $потім продовжує його, щоб у нього було стільки ж рядків, скільки вхідних. наприклад, якщо вхід містить 3 слова, він створить 0 1;1 0;0 1.
  • #&> #ліва частина - це масив довжин введених слів і #є копією, тому вона копіює 0 1"len слова 1" раз, потім 1 0"len слова 2 рази" тощо.
  • [: <@(+/)\ робить суму сканування та поле.

T-SQL, 185 байт

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

Спробуйте в Інтернеті

Сітківка , 51 байт

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

Спробуйте в Інтернеті!

Досить прямолінійний підхід, який позначає кожне інше слово, а потім безпосередньо застосовує перетворення.

Пояснення

1,2,`\w+
;$&

Ми позначаємо кожне інше слово крапкою з комою, порівнюючи кожне слово, але лише застосовуючи заміну до збігів (які нульово індексуються), починаючи з матчу 1, а потім 3 тощо.

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

+(mвстановлює деякі властивості для наступних етапів. Плюс починається циклом ", поки ця група етапів щось змінює", і відкрита дужка позначає, що плюс повинен застосовуватися на всіх наступних етапах, поки не з'явиться близька дужка перед backtick (що є всіма етапами в цей випадок). mПросто каже регулярний вираз для лікування ^так само як і відповідність з початку рядка , а не тільки в початку рядка.

Фактичний регулярний вираз досить простий. Ми просто співставляємо відповідну кількість матеріалів до першого крапки з комою, а потім використовуємо *синтаксис заміни Retina для введення правильної кількості пробілів.

; |;$

Цей етап застосовується після останнього, щоб видалити крапки з комою та пробілами в кінці слів, які ми змінили на вертикальні.

Сітківка 0,8,2 , 58 байт

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

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

Спробуйте в Інтернеті! Посилання включає тестові випадки. Альтернативне рішення, також 58 байт:

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

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

Спробуйте в Інтернеті! Посилання включає тестові випадки.

Я навмисно не використовую тут Retina 1, тому я не отримую операцій з альтернативними словами безкоштовно; натомість у мене є два підходи. Перший підхід розбиває всі літери на альтернативні слова шляхом підрахунку попередніх пробілів, тоді як другий підхід замінює проміжні пробіли новими рядками, а потім використовує решта пробілів, щоб допомогти йому розділити альтернативні слова на літери. Кожен підхід повинен потім з'єднати останню вертикальну букву з наступним горизонтальним словом, хоча код відрізняється, оскільки вони розділяють слова по-різному. Заключний етап обох підходів потім прокладає кожен рядок, поки його перший непробільний символ не вирівняється під останнім символом попереднього рядка.

Зауважте, що я не вважаю, що слова - це лише букви, оскільки мені цього не потрібно.

PowerShell , 101 89 83 байт

-12 байт завдяки мазі .

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

Спробуйте в Інтернеті!

PowerShell , 74 65 байт

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

Спробуйте в Інтернеті!

R , 126 байт

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}

Спробуйте в Інтернеті!

• -3 байти завдяки @Giuseppe

T-SQL, 289 байт

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 @

Це працює на SQL Server 2016 та інших версіях.

@ містить список, обмежений пробілом. @ Я відстежує позицію індексу в рядку. @S відстежує загальну кількість пробілів для відступу зліва. @B відстежує, вісь якої рядка вирівняна з точкою @I.

Кількість байтів включає список мінімальних прикладів. Сценарій проходить список, символ за символом і змінює рядок так, щоб він відображався відповідно до вимог. Коли кінець рядка буде досягнуто, рядок PRINTED.

JavaScript (Node.js) , 75 байт

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

Спробуйте в Інтернеті!

Пояснення і невольф

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

Стакс , 12 байт

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

Запустіть і налагоджуйте його

Желе , 21 байт

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

Спробуйте в Інтернеті!

Повна програма, що приймає введення як список рядків і неявно виводить для складання слова драбинка.

C (gcc) , 93 87 байт

Дякуємо gastropner за пропозиції.

Ця версія містить масив рядків, що закінчується покажчиком 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++);}

Спробуйте в Інтернеті!

Мозок-Флак , 152 байти

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

Спробуйте в Інтернеті!

Я підозрюю, що це може бути коротшим, поєднуючи дві петлі для непарних і парних слів.

J, 35 33 байт

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

Це дієслово, яке сприймає вхід як єдиний рядок зі словами, розділеними пробілами. Наприклад, ви можете назвати це так:

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

Вихід - це матриця букв і пробілів, які інтерпретатор виводить новими рядками за потребою. Кожен рядок буде прокладений пробілами, щоб вони мали однакову довжину.

Є одна незначна проблема з кодом: він не працюватиме, якщо вхід має більше 98 слів. Якщо ви хочете дозволити більш тривале введення, замініть _98код на, _998щоб дозволити до 998 слів тощо.

Дозвольте пояснити, як це працює на деяких прикладах.

Припустимо, у нас є матриця букв і пробілів, які, на нашу думку, є частковим результатом для деяких слів, починаючи з горизонтального слова.

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

Як ми могли перед цим скласти нове слово по вертикалі? Це не важко: просто перетворіть нове слово на матрицю з одним стовпцем з дієсловом ,., а потім додайте вихід до цієї матриці з одним стовпцем. (Дієслово ,.зручно тим, що воно поводиться як функція ідентичності, якщо застосувати його до матриці, яку ми використовуємо для гольфу.)

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

Тепер ми не можемо просто повторити такий спосіб попереднього слова, як тоді, оскільки тоді ми отримаємо лише вертикальні слова. Але якщо ми перенесемо вихідну матрицю між кожним кроком, то кожне інше слово буде горизонтальним.

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

Отже, наша перша спроба рішення полягає в тому, щоб скласти кожне слово в матрицю з одним стовпцем, а потім скласти їх, додавши і перемістивши між ними.

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

Але в цьому є велика проблема. Це ставить першу букву наступного слова перед поворотом під прямим кутом, але специфікація вимагає повороту перед тим, як ставити першу букву, тому вихід має бути приблизно таким:

c             
a             
rhouse        
     d        
     o        
     gchildren

Досягнення цього способу полягає в тому, щоб повернути весь рядок введення, як в

nerdlihc god esuoh rac

потім скористайтеся описаною вище процедурою для побудови зигзагу, але повернувшись лише після першої літери кожного слова:

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

Потім переверніть вихід:

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

Але зараз у нас є ще одна проблема. Якщо вхід має непарну кількість слів, то вихід має мати перше слово вертикальне, тоді як специфікація говорить, що перше слово має бути горизонтальним. Щоб виправити це, моє рішення вкладає список слів до рівно 98 слів, додаючи порожні слова, оскільки це не змінює вихід.