단어 목록을 입력하면 단어를 대각선으로 배열하여 단어를 출력하십시오.

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f

(위의 입력에 대한 출력이어야합니다 programming puzzles and code golf.)

정확하게 말하면, 각 단어는 첫 번째 열에서 시작하고 이전 단어 아래의 세 행에서 시작하며, 연속 된 각 문자는 한 열을 오른쪽으로 한 줄 아래로 이동합니다.

입력은 정확히 하나의 공백으로 구분 된 단일 단어 문자열 또는 단어 목록 / 배열로 제공 될 수 있습니다. 단어는 소문자로만 구성 a-z되며 항상 1 자 이상이어야합니다.

출력은 단일 문자열, 행 배열 또는 문자 배열 일 수 있습니다. 단일 후행 줄 바꿈을 제외하고 선행 또는 후행 공백은 허용되지 않습니다.

추가 테스트 사례 :

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j

x

x

verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이길 것입니다!

Vim, 85, 76, 66 , 52 키 스트로크 / 바이트

이 도전을 처음 보았을 때 "이것은 vim에 완벽합니다"라고 생각했습니다. 그리고 내가 그것을 시도했을 때 모든 것이 잘못되었습니다. 여기에 모든 것이 지저분한 해키 영광입니다.

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

(대부분) 이전 버전과 호환되는 V 인터프리터 덕분에 온라인으로 사용해보십시오 .

설명:

처음에 나는이 아름답고 간단한 37 바이트 버전을 할 수 있다고 생각했습니다.

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

불행히도 그렇게 간단하지 않습니다. 한 줄씩 살펴 봅시다 :

:se ve=all

이를 통해 '가상 편집'이라는 기능이 활성화됩니다. 커서가 아직 존재하지 않는 열로 이동할 수 있습니다. 이 대답은 기본적으로 불가능합니다.

이제 단어를 다른 줄로 분리해야합니다. 따라서 각 공간을 3 개의 줄 바꿈으로 바꿉니다. 이것은 ex 명령이므로 :se ve=all둘을 막대로 분리하여 마지막 ex 명령과 동시에 실행할 수 있습니다 .

|s/ /\r\r\r/g

이제 버퍼는 다음과 같습니다 :

Programming


Puzzles


and


code-golf

여기서 재미가 시작됩니다. 우리는 전통적인 재귀 매크로를 다음과 같이 설정하고 qq이것을 다음과 같이 호출합니다.

G               " Move to the last line
 o<esc>         " Append an extra newline

?               " Search backwards for
 \<.            " Any character at the beginning of a word
    \S          " Followed by a non-space character
l               " Move one character to the right
 D              " Delete eveything until the end of this line
  j             " Move down one line
   P            " Paste what we just deleted

그런 다음 재귀 매크로를로 마무리합니다 @qq@q. 이 시점에서 우리는 모든 대각선을 가지고 있으며 약간의 정리 만하면됩니다.

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

Turtlèd , 28 26 바이트

오, 저는 골프를 위해 특별히 고안된 언어를 치고있는 것 같습니다. 오늘은 좋은 하루입니다.

!_4[*.[ rd+.]ul[ ul]r;_+]_

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

설명

(쓰기는 그리드의 셀에 쓰는 것을 의미하고, 뾰족한 문자는 문자열 포인터가 가리키는 문자를 의미합니다)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

후행 공백에 유의하십시오.

입력에는 후행 공간이 필요합니다. 파이썬이 목록을 가져올 수 있다는 것을 알았을 때, 이것은 Turtlèd에서 목록을 얻는 것과 비슷합니다.

MATL , 28 바이트

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

입력은 문자열의 셀형 배열이며 쉼표는 선택적 구분 기호로 사용됩니다.

{'programming' 'puzzles' 'and' 'code' 'golf'}

또는

{'programming', 'puzzles', 'and', 'code', 'golf'}

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 : 1 , 2 , 3 , 4 .

설명

예를 들어 다음 입력을 고려하십시오.

{'aaaa' 'bb' 'ccc'}

%코드의 어느 지점에서나 주석 기호 를 삽입하는 부분 결과 (스택 내용)를 볼 수 있습니다 . 예를 들어 네 번째 함수 ( ) 다음에 스택 내용 을 봅니다&n .

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

자바 스크립트 (ES6), 118 (109) 84 바이트

단어 배열로 입력을받습니다. 문자 배열을 반환합니다.

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

대체 버전, 109 바이트

문자열을 반환합니다.

let f =

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill` `)[x]=c),a=[])&&a.map(s=>s.join``).join`
`

console.log(f(["programming", "puzzles", "and", "code", "golf"]))

커먼 리스프, 673 668 597 바이트

끔찍한 해결책입니다. 잠을 자고 난 후에 이것을 더 많이 편집 할 것입니다.

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

용법:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

제공된 목록의 모든 단어를 반복하고 현재 행에 적절한 문자를 추가합니다. 하위 패딩을 사용하여 적절한 패딩을 제공합니다 format.

참고 : 저는 Common Lisp를 처음 사용하지만 많은 개선이 필요하다는 사실을 충분히 알고 있습니다.

C #, 336 바이트 :

골프 :

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

언 골프 드 :

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

테스트 :

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


a
b
 c
  d
e
 f
  g
i  h
j


v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

파이썬 2, 146 바이트

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

참고 : 마지막 두 줄의 들여 쓰기는 <space>and <tab>입니다.

입력은 다음과 같은 문자열 배열로 입력됩니다 : ["hello", "world"]또는 ['hello', 'world']. 출력은 문자 배열입니다.

아마도 이것을하는 더 좋은 방법이있을 것입니다 ...

편집 빠진 대괄호를 지적한 Doorknob에게 감사드립니다. 나는 *k...세 번째 줄에서 앞에 배치했습니다 .

Mathematica, 146 바이트

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

나는이 바이트 수에 실망하지만 오.

단어 목록 (예 :)을 가져와 {"this","that","these"}2 차원 문자 배열을 반환 하는 익명 함수를 정의합니다 . 그리드 형태로 보려면 //Grid끝에를 추가하십시오 .

문자열을 배열로 변환하고, 추가 행을 추가하고, 배열을 바꾸고, 필요한 시프트를 추가 한 다음 다시 바꿉니다.

결과 예 (격자 형식) :

젤리 , 24 바이트

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

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

어떻게?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

파이썬 2, 182 바이트

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

조금 길지만 양 수면에서는 각 줄에 후행 공백이없고 끝에 공백이 없거나 끝에 반환되는 문자열을 반환합니다. 일부 다른 항목은 준수하지 않습니다.

단어 목록이 함수에 전달됩니다. 일부 '공백'이이 목록에 추가 된 다음 알고리즘은 행, 열 쌍을 확장 된 목록의 wordNumber, characterNumber에 맵핑합니다. (이것은 다른 솔루션에서 볼 수있는 일반적인 전략의 역수입니다).

마지막 줄을 제외한 모든 줄에 공백을 허용하면 조금 더 잘 수행 할 수 있습니다 (163 바이트).

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

Q / KDB +, 130 (109) 94 90 86 84 바이트

해결책:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

예 :

q)f "programming puzzles and code golf"
p          
 r         
  o        
p  g       
 u  r      
  z  a     
a  z  m    
 n  l  m   
  d  e  i  
c     s  n 
 o        g
  d        
g  e       
 o         
  l        
   f 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

설명 (ungolfed) :

기본 요점은 입력 문자열에서 동일한 길이의 문자열을 만들어 뒤집고 (회전) 다음 적절한 공백을 추가하여 다음과 같은 것을 얻는 것입니다.

"p  p  a  c  g   "
" r  u  n  o  o  "
"  o  z  d  d  l "
"   g  z     e  f"
"    r  l        "
"     a  e       "
"      m  s      "
"       m        "
"        i       "
"         n      "
"          g     "

다시 뒤집어 stdout으로 인쇄합니다.

다음은 개념을 한 줄씩 세분화 한 것입니다.

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

노트:

우리가 정말로 원한다면 몇 가지 쉬운 바이트를 제거하는 몇 가지 방법 :

• 를 삭제하고 f:익명 함수로 남겨두면 2 바이트를 절약 할 수 있습니다.
• 를 놓는 방법으로 3 바이트를 저장할 수 -1와 ;문자열의 목록을 반환하는 대신 표준 출력에 인쇄
• 공백으로 구분 된 문자열이 아닌 문자열 목록을 전달하면 6 바이트를 절약 할 수 있습니다.

편집 :

• -11 바이트, rtrim패드에 최대 길이 찾기, C변수 저장 필요성 제거
• -15 바이트, 한 번 생성되고 두 번 사용되는 max count each람다 함수 전환a
• -4 바이트, raze람다 함수로 이동하여raze each
• -4 바이트, 공백을 추가하는 핵심 람다 함수를 단순화
• -2 바이트, (+)속기flip

숯 , 16 9 바이트

ＷＳ«Ｐ↘ιＭ³↓

나의 첫 번째 숯불 답변. 덕분에 @DLosc 제안을 Ｐ하고 Ｍ대신에 사용 Ｓ하고 Ｊ하여 라인의 시작 (세 아래)으로 돌아갑니다 (점프).

온라인으로 사용해보십시오 (자세한 내용) 또는 온라인으로 시도해보십시오 (순수) .

설명:

다음 입력 문자열이 여전히있는 동안 루프 :

While(InputString()){ ... }
ＷＳ« ...

커서를 오른쪽 아래 방향으로 움직이지 않고이 문자열을 인쇄하십시오.

Multiprint(:DownRight, i);
Ｐ↘ι

그리고 다음 반복을 위해 세 위치를 아래로 이동하십시오.

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 바이트

단어 배열로 입력을받습니다. 각 줄의 후행 공백이 허용되면 마지막 4자를 제거하여 숯 솔루션과 연결할 수 있습니다.

yÈmú3)iYçÃmx1

사용해 보거나 모든 테스트 사례를 실행하십시오.

설명

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

K4 , 58 바이트

해결책:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

예 :

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"p          "
" r         "
"  o        "
"p  g       "
" u  r      "
"  z  a     "
"a  z  m    "
" n  l  m   "
"  d  e  i  "
"c     s  n "
" o        g"
"  d        "
"g  e       "
" o         "
"  l        "
"   f       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

설명:

오른쪽 패드 문자열은 길이가 같고, 조바꿈하고 " ", 왼쪽 패드를 사용하여 대각선을 생성 한 다음 오른쪽 패드를 사용하여 길이를 수정하고 다시 바꿉니다. 문자열 목록을 가져 와서 문자열 목록을 반환합니다. 아마도 골프를 칠 수는 있지만 여전히 q / kdb + 솔루션보다 짧습니다.

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose

펄 6 , 73 바이트

{my@t;for .kv ->\i,\w{for w.comb.kv {@t[3*i+$^a][$^a]=$^b}};@t »||»" "}

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

입력 인수는 단어 목록입니다. 출력은 문자 배열입니다.

PHP , 100 바이트

<?foreach($_GET as$k=>$v)for($x=0;$y=$v[$x];$t[$x++]=$y)($t=&$s[$k*3+$x])?:$t=" ";echo join("
",$s);

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