Учитывая список, состоящий как минимум из двух слов (состоящий только из строчных букв), создайте и отобразите 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 .

Попробуйте онлайн.

Общее объяснение:

Так же , как @Emigna 05AB1E ответ «s (убедитесь , что upvote его кстати !!), я использую встроенный 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. Вывести результат нарисованного Canvas немедленно в 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

Python 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: логическое значение описывает индекс слова
                       // truey: нечетные проиндексированные слова;
                       // ложь: даже проиндексированные слова
        ''): // ничего не генерировать для пространства
    т? // if (нечетный индекс), что означает вертикальный
      p + c: // добавить '\ n', несколько пробелов и символ
                       // еще
      (p + = p? '': '\ n', // подготовить строку предваряющего для вертикальных слов
         c) // добавить один символ
),
  t = p = '' // инициализировать
)

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

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

Попробуйте онлайн!

Слегка играется с использованием символов полной ширины (2 байта) вместо корейских (3 байта).

объяснение

Aheui похож на esolang. Вот код с цветом :? 1 часть проверяет, является ли текущий символ пробелом или нет.

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

? 3 часть является условием разрыва цикла, который печатает пробелы.

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

Красная часть - инициализация стека. Aheui использует стеки (от Nothingдо ㅎ: 28 стеков) для хранения значения.

Оранжевая часть принимает input ( 뱋) и проверяет, является ли она пробелом, вычитая с помощью 32(ascii code of space).

Зеленая часть добавляет 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 #) , 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«длина слова 1», затем 1 0«длина слова 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устанавливает некоторые свойства для следующих этапов. Плюс начинается петлей «в то время как эта группа этапов что-то меняет», а открытая скобка означает, что плюс должен применяться ко всем следующим этапам, пока не будет закрывающая скобка перед обратным тылом (который является всеми этапами в этот случай). 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.

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

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

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

Попробуйте онлайн!

Объяснение и ungolfed

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

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

Запустите и отладьте его

Желе , 21 байт

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

Попробуйте онлайн!

Полная программа, принимающая входные данные в виде списка строк и неявно выводящие на стандартный вывод слова ladder.

C (gcc) , 93 87 байтов

Спасибо гастропнеру за предложения.

Эта версия принимает массив строк, оканчивающихся указателем 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++);}

Попробуйте онлайн!

Brain-Flak , 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 словами, добавляя пустые слова, поскольку это не меняет вывод.