최소 두 단어 (소문자만으로 구성됨)의 목록이 주어지면, 처음부터 오른쪽으로, 왼쪽에서 오른쪽으로, 왼쪽에서 오른쪽으로의 초기 방향을 교대하여 단어의 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 바이트

Johan du Toit 에서 -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Λ

@Emigna 덕분에 -3 바이트 .

온라인으로 사용해보십시오.

일반적인 설명 :

@Emigna 의 05AB1E 답변 과 마찬가지로 (btw !!) 그를 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 바이트

Grimy 덕분에 1 바이트 절약

€ðÀ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"

자바 스크립트 (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

온라인으로 사용해보십시오!

brainfuck , 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
]

자바 스크립트, 62 바이트

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

온라인으로 사용해보십시오!

감사합니다 Rick Hitchcock , 2 바이트가 저장되었습니다.

자바 스크립트, 65 바이트

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

온라인으로 사용해보십시오!

a => a.replace (/./ g, c => (// 문자열 a의 각 문자 c에 대해
    1-c? // if (c는 공백)
      (t =! t, // 업데이트 t : 부울 값 설명 단어 색인
                       // 진실성 : 홀수 색인 단어;
                       // 허위 : 색인 된 단어
        '') : // 공간을 위해 아무것도 생성하지 않습니다
    티? // 수직을 의미하는 경우 (홀수 인덱스 인 경우)
      p + c : // '\ n', 공백, sigle charater 추가
                       // 그렇지 않으면
      (p + = p? '': '\ n', // 수직 어 앞에 붙일 문자열 준비
         c) // 단일 문자 추가
),
  t = p = ''// 초기화
)

Aheui (esotope) , 490 458 455 바이트

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

온라인으로 사용해보십시오!

한국어 (3 바이트) 대신 전각 문자 (2 바이트)를 사용하여 약간의 골프를칩니다.

설명

Aheui는 펀지와 같은 esolang입니다. 다음은 색상이있는 코드입니다. ? 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

bash, 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이 상황을 정확하게 피하기 위해 테스트중인 문자열을 인용 할 것 입니다. 이를 통해 and $d사이 의 방향 플래그를 뒤집을 수 1있으며 0, X다음에 공백이 아닌 값에서 다음에 ANSI 제어 시퀀스 배열의 인덱스로 사용됩니다 $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

펄 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);
↙

파이썬 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/[)}]

온라인으로 사용해보십시오!

나는 재미 있고 다른 접근법을 발견했습니다 ...

순환 패드가있는 왼쪽 패드와 지퍼로 엉망이되기 시작했지만 각 문자의 위치를 ​​계산하는 것이 더 쉽다는 것을 깨달았습니다 (이것은 올바르게 선택된 배열의 스캔 합계로 귀결됩니다). } 빈에 razed 입력에 캔버스.

솔루션은 거의 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 등에서 시작하여 일치하는 항목 (0 인덱싱)에만 대체를 적용합니다.

+(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 감사는 바이트 mazzy을 .

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

온라인으로 사용해보십시오!

• @Giuseppe 덕분에 -3 바이트

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 및 기타 버전에서 실행됩니다.

@는 공백으로 구분 된 목록을 보유합니다. @I는 문자열에서 인덱스 위치를 추적합니다. @S는 왼쪽에서 들여 쓰기 할 총 공간 수를 추적합니다. @B는 @I 지점에서 문자열이 정렬되는 축을 추적합니다.

바이트 수에는 최소 예제 목록이 포함됩니다. 스크립트는 문자를 기준으로 목록을 살펴보고 요구 사항에 따라 표시되도록 문자열을 변경합니다. 문자열의 끝에 도달하면 문자열이 인쇄됩니다.

자바 스크립트 (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¥ƭ"

온라인으로 사용해보십시오!

입력을 문자열 목록으로 가져와 암시 적으로 단어 사다리를 표준 출력합니다.

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

온라인으로 사용해보십시오!

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

이 앞에 수직으로 새로운 단어를 붙일 수있는 방법은 무엇입니까? 어렵지 않습니다 : verb를 사용하여 새 단어를 단일 열 문자 행렬로 바꾸고 ,.출력을 해당 단일 열 행렬에 추가하십시오. (이 동사 ,.는 골프에 사용하는 행렬에 적용하면 항등 함수로 작동하기 때문에 편리합니다.)

   (,.'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 단어로 채우고 출력을 변경하지 않으므로 빈 단어를 추가합니다.