Codegolf - Построить Словесную Лестницу

Учитывая список как минимум из двух слов (составленный только из строчных букв), постройте и отобразите лестницу слов в формате ASCII, чередуя направление записи сначала вправо, затем влево, относительно исходного направления слева направо. .

Закончив писать слово, измените направление и только потом приступайте к написанию следующего слова.

Если ваш язык не поддерживает списки слов или вам так удобнее, вы можете принять входные данные в виде строки слов, разделенных одним пробелом.

Допускаются начальные и конечные пробелы.

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

Здесь мы начнем с написания hello w o r l d and when we come to the next word (or in the case of the input as a string - a space is found), we change the relative direction to the right and continue to write "hello world"

Тестовые случаи:

Критерии победы

Побеждает самый короткий код в байтах на каждом языке. Не позволяйте языкам игры в гольф разочаровывать вас!

Песочница

#код-гольф #ascii-art

Древесный уголь, 9 байт

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a=>a.replace(/./g,c=>( // for each character c in string a

1 - c ?            //   if (c is space)

(t = !t,         //     update t: boolean value describe word index

//       truthy: odd indexed words;

//       falsy: even indexed words

'') :          //     generate nothing for space

t?                 //   if (is odd index) which means is vertical

p+c :            //     add '\n', some spaces, and a sigle charater

//   else

(p+=p?' ':'\n',  //     prepare the prepend string for vertical words

c)            //     add a single character
),

t=p=''               //   initialize
)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Попробуйте онлайн! Ссылка на подробную версию кода. Пояснение: Работает путем рисования текста задом наперед, транспонируя холст после каждого слова. 10 байт для ввода строки:

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение: Отрисовывает текст задом наперед, перемещая холст на пробелы.

С (ГКК), 94 78 74 байт

-4 от Йохан дю Туа

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

Печатает лестницу по одному символу (входных данных) за раз. Принимает строку слов, разделенную пробелами.

05AB1E, 19 16 байты

-3 байта благодаря @Эминья.

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

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

Точно так же, как @Эминьяответ 05AB1E (кстати, не забудьте проголосовать за него!!), я использую встроенный холст ìZΣFτëWº═φ‼R .

Однако варианты, которые я использую, разные (поэтому мой ответ длиннее...):

• 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. } (the strings to print): I leave the first string in the list unchanged, and add the trailing character to each next string in the list. For example a=>a.map(x=>i++&1?[,...x].join(` `.padEnd(n)):(n+=x.length,x),n=i=0).join`` стал бы 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 @ .
• 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} (the sizes of the lines): This would be equal to these strings, so -join($args|%{$_|% t*y|%{($p+=(' ',' ')[!$p]*!$i)*$i;$_};$i=!$i}) с примером выше.
• $args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+=' '+' '*$l+$_}}};$t (the direction to print in): [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children' car h o u s edog c h i l d r e n , который будет отображаться в n e r d l i h c gode s u o h rac

Итак, приведенный выше пример шаг за шагом сделает следующее:

1. Рисовать nerdlihc god esuoh rac in direction c a rhouse d o gchildren / > (,|:)&.>/ ,.&.>;: 'car house dog children' c a r housed o g children .
2. Рисовать (,.'dog') , |: (,.'cat') , m d o g catv w xyz in direction (,.'cat') , m c a t vwx y z / ,. (where the first character overlaps with the last character, which is why we had to modify the list like this)
3. Рисовать ,. in direction [m=: 3 3$'vwx y z' vwx y z / _998 again (also with overlap of trailing/leading characters)
4. Рисовать _98 in direction 3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf' / 3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' again (also with overlap)
5. Немедленно выведите результат нарисованного Canvas в STDOUT.

Объяснение кода:

Холст, 17 12 11 10 байты

Попробуйте здесь!

Объяснение:

JavaScript (ES8), 91 79 77 байт

Принимает входные данные как массив слов.

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

Прокомментировал

05AB1E, 14 13 байт

Сэкономлено 1 байт благодаря Грязный

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

Объяснение

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

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

мозготрах, 57 байт

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

Принимает входные данные в виде строк, разделенных NUL. Обратите внимание, что здесь используется EOF равный 0, и он перестанет работать, когда лестница превысит 256 ячеек.

Объяснение:

JavaScript, 62 байта

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

Спасибо Рик Хичкок, сохранено 2 байта.

JavaScript, 65 байт

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

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

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

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

Объяснение

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

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

Часть ?3 — это условие прерывания цикла, который печатает пробелы.

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

Красная часть — инициализация стека. Ахеуи использует стеки (из # to #&> # : 28 стопок) для сохранения ценности.

Оранжевая часть принимает входные данные( 0 1;1 0;0 1 ) and check if it is space, by subtracting with # $ (ascii-код пространства).

Зеленая часть добавляет 1 в стек, в котором хранится значение длины пробела при написании справа налево.

Фиолетовая часть — это цикл для печати пробелов при записи сверху вниз.

Серая часть проверяет, является ли текущий символ 0 1;1 0 , by adding one to current character.

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

Япт #:@1 2 , 15 байт

Попробуйте это

Баш, 119 символов

Для перемещения курсора используются управляющие последовательности ANSI — здесь я использую только сохранение. 0 0 and restore v1 ; но восстановление должно иметь префикс (all chars)x(all chars) to scroll the output if it's already at the bottom of the terminal. For some reason it doesn't work if you're not уже в нижней части терминала. *пожимаю плечами*

Текущий персонаж ([ ' '"0/ [) is isolated as a single-character substring from the input string v2 , используя [ loop index v0 как индекс в строке.

Единственный реальный трюк, который я здесь использую, это v0`v1`v2 which will return } , т.е. строка пуста, когда (stuff)} is a space, because it's unquoted. In correct usage of bash, you would quote the string being tested with ] чтобы избежать именно такой ситуации. Это позволяет нам перевернуть флаг направления ; between ; ( single verb that does all the work ) ] и ; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ] , which is then used as an index into the ANSI control sequence array, } на следующем непространственном значении } .

Мне было бы интересно увидеть что-то, что использует ;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}] .

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

Перл 6, 65 байт

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

Анонимный блок кода, который принимает список слов и выводит его прямо в STDOUT.

Объяснение

Древесный уголь, 19 байты

Ввод в виде списка строк

Попробуйте онлайн (подробно) или попробуй онлайн (чистый)

Объяснение:

Цикл в диапазоне i :

Если индекс нечетный:

Распечатать строку по индексу Print(:Down, AtIndex(q,i)); ↓§θι in a downward direction:

А затем переместите курсор один раз в правый верхний угол:

Иначе (индекс четный):

Распечатать строку по индексу [0, input-length) in a regular right direction:

А затем переместите курсор один раз в нижний левый угол:

Питон 2, 89 88 байт

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

C# (интерактивный компилятор Visual C#), 122 байта

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

Дж, ^{47 45} 43 байта

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

Я нашел интересный, другой подход...

Я начал возиться с левыми клавишами и застежками с циклическими герундиями и так далее, но потом понял, что проще просто вычислить положение каждой буквы (это сводится к сканированной сумме правильно выбранного массива) и применить поправку $c to a blank canvas on the razed input.

Решением почти полностью занимается компания Amend. X :

• 1 overall fork
• $d left part razes the input, ie, puts all the letters into a contiguous string
• -z right part is the input itself
• $c we use the gerund form of amend true , состоящий из трех частей [ -z $c ] .
  • $i gives us the "new values", which is the raze (ie, all the characters of the input as one string), so we use for .
  • $w gives us the starting value, which we are transforming. we simply want a blank canvas of spaces of the needed dimensions. $c дает нам один размер \n .
  • Средний глагол \e8 selects which positions we will put our replacement characters in. This is the crux of the logic...
• Начиная с позиции \e7 in the upper left, we notice that each new character is either 1 to the right of the previous position (ie, 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 ) или один вниз (т. е. ò 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 ). Indeed we do the former "len of word 1" times, then the latter "len of word 2" times, and so on, alternating. So we'll just create the correct sequence of these movements, then scan sum them, and we'll have our positions, which we then box because that's how Amend works. What follows is just the mechanics of this idea...
• ò mrÈ+R+YÕùT±Xl
  • Первый -P creates the constant matrix -1 .
  • 32 then extends it so it has as many rows as the input. eg, if the input contains 3 words it will produce 뱋 .
  • ㅎ the left part of that is an array of the lengths of the input words and Nothing это копия, поэтому она копирует ?뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투＠밧우 ＠두내백뱃빼선대내백뱃섣＠여우샐처샐추 희차＠＠＠?누번사＠빼э오추뻐＠＠＠배 Ｂｙ＠＠＠새대백＠＠＠우뻐색 Ｌｅｇｅｎ＠＠빼쵸누번＠＠빼 ＤＵＳＴ＠＠＠샌뽀터본섣숃멓 ＠＠＠＠＠＠＠오어아＠먛요아＠＠샏매우 ＠＠＠＠＠아＠＠＠＠＠＠오＠＠＠＠＠서어 ＠＠＠＠＠희차＠＠요 "len of word 1" times, then a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':` `,c),t=p='') «лен слова 2 раза» и т. д.
  • a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=` `) does the scan sum and box.

T-SQL, 185 байт

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

сетчатка, 51 байт

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

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

Объяснение

Мы отмечаем каждое второе слово точкой с запятой, сопоставляя каждое слово, но применяя замену только к совпадениям (которые имеют нулевой индекс), начиная с совпадения 1, затем 3 и так далее.

€ðÀD€g>sŽ9÷SΛ sets some properties for the following stages. The plus begins a "while this group of stages changes something" loop, and the open bracket denotes that the plus should apply to all of the following stages until there is a close bracket in front of a backtick (which is all of the stages in this case). The 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 просто сообщает регулярному выражению, что нужно лечить a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=` `).join`` as also matching from the beginning of lines instead of just the beginning of the string.

Фактическое регулярное выражение довольно простое. Мы просто сопоставляем необходимое количество данных перед первой точкой с запятой, а затем используем метод Retina. ø⁸⇵{⟳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" replacement syntax to put in the correct number of spaces.

Этот этап применяется после предыдущего, чтобы удалить точки с запятой и пробелы в конце слов, которые мы изменили на вертикальные.

Ретина 0.8.2, 58 байт

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

Попробуйте онлайн! Ссылка включает тестовые примеры.

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

Обратите внимание: я не предполагаю, что слова — это просто буквы, потому что в этом нет необходимости.

Дж, 35 33 байта

Это глагол, который принимает входные данные как одну строку со словами, разделенными пробелами. Например, вы можете назвать это так:

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

С кодом есть одна небольшая проблема: он не будет работать, если входные данные содержат более 98 слов. Если вы хотите разрешить более длинный ввод, замените → in the code by 2 разрешить до 998 слов и т. д.

Позвольте мне объяснить, как это работает, на некоторых примерах.

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

Как мы можем добавить перед этим новое слово по вертикали? Это несложно: просто превратите новое слово в одностолбцовую матрицу букв с глаголом. ↓ , then append the output to that single-column matrix. (The verb 4 удобно, поскольку ведет себя как тождественная функция, если применить ее к матрице, которую мы используем для игры в гольф.)

Теперь мы не можем просто повторять этот способ добавления слова как есть, потому что тогда мы получим только вертикальные слова. Но если мы транспонируем выходную матрицу между каждым шагом, то каждое второе слово будет горизонтальным.

Итак, наша первая попытка найти решение — поместить каждое слово в матрицу из одного столбца, а затем сложить их путем добавления и транспонирования между ними.

Но с этим есть большая проблема. При этом первая буква следующего слова помещается перед поворотом под прямым углом, но спецификация требует поворота перед размещением первой буквы, поэтому вместо этого вывод должен быть примерно таким:

Способ достижения этой цели — перевернуть всю входную строку, как в

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

Затем переверните вывод:

Но теперь у нас есть еще одна проблема. Если на входе нечетное количество слов, то на выходе первое слово будет вертикальным, тогда как в спецификации указано, что первое слово должно быть горизонтальным. Чтобы исправить это, мое решение дополняет список слов ровно до 98 слов, добавляя пустые слова, поскольку это не меняет вывод.

PowerShell, 101 89 83 байт

-12 байт благодаря сумасшедший.

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

PowerShell, 74 65 байт

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

Р, 126 байт

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

• -3 байта благодаря @Giuseppe

T-SQL, 289 байт

Это работает на SQL Server 2016 и других версиях.

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

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

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

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

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

Стакс, 12 байты

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

Желе, 21 байт

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

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

С (ГКК), 93 87 байт

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

Эта версия принимает массив строк, заканчивающийся NULL-указателем.

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

Брейн-зенитная артиллерия, 152 байта

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

Я подозреваю, что это можно сделать короче, объединив два цикла для нечетных и четных слов.