당신의 임무는 ASCII 문자의 입력 문자열을 가져 와서 공백으로 구분 된 일련의 수직 단어로 문자열을 출력하는 것입니다. 예는 다음과 같습니다.

주어진 문자열 :

Hello, World! My name is Foo.

출력은 다음과 같아야합니다.

H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d
, !

프로그램이 터미널을 감쌀 필요가있는 문자열을 올바르게 처리하면 10 보너스 포인트가 주어지며, 80 문자로 설정됩니다.

프로그램이 반대로 할 수 있다면 50 포인트!

J, 15

|:>'\S+| 'rxall

용법:

   |:>'\S+| 'rxall 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d        
, !        

자바 스크립트- 228 172 145 126

A=prompt().split(" "),B="",N=A;for(y=0;y<N.length;y++){for(i=0;i<N.length;i++){if(A[i][y]){B+=A[i][y];}else{B+=" ";}}B+="\n";}

내 첫 번째 코드 골프 :)

APL, 22

{⍉⊃⍵⊂⍨1+0,+\2≠/⍵=' '}

설명

{              ⍵=' '}   A. check which chars are spaces           
            2≠/         B. of that vector, which consecutive pairs are different  
          +\            C. compute the partial sums                           
      1+0,              D. insert 0 at the front and add 1 to every item
   ⍵⊂⍨                     use this vector to split the original string
 ⍉⊃                        disclose into a matrix and transpose

    'W o w   S u c h   D o g e'
A.   0 0 0 1 0 0 0 0 1 0 0 0 0
B.    0 0 1 1 0 0 0 1 1 0 0 0
C.    0 0 1 2 2 2 2 3 4 4 4 4
D.  1 1 1 2 3 3 3 3 4 5 5 5 5

예

      {⍉⊃⍵⊂⍨1+0,+\2≠/⍵=' '} 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d        
, !        

루비, 91 87

s=gets.split
puts s.map{|x|x.ljust(s.map(&:size).max,' ').split''}.transpose.map &:join

Hooray, 나는 Perl을 이겼다! :디

루비, 150-50 보너스 = 100

s=$<.read
n=s.index"
"
s=s.split n ?'
':' '
o=s.map{|x|x.ljust(s.map(&:size).max,' ').split''}.transpose.map &:join
puts n ?o.map(&:strip).join(' '):o

개행을 감지하고 감지되면 특수 처리를 적용합니다.

다음과 같이 실행

ruby transposegolf.rb < transposegolfinput.txt

자바 스크립트 184 149 123

var a=s.split(" "),b="",c;for(c in a)b+="<div style='float:left'>"+a[c].split("").join("<br>")+"</div>";document.write(b);

예제 문자열이 정의 된 상태에서 :

var s = "Hello, World! My name is Foo.";
var a=s.split(" "),b="",c;for(c in a)b+="<div style='float:left'>"+a[c].split("").join("<br>")+"</div>";document.write(b);

두 번째 명령문을 브라우저 콘솔에 복사 할 수 있습니다.

미완성 :

var res = "Hello, World! My name is Foo.";
var t=res.split(" ");
var s ="";
for (var word in t){
    s+="<div style='float:left'>" + t[word].split("").join("<br />") + "</div>";
}
document.write(s);

JSFiddle 링크 : http://jsfiddle.net/FzMvK/

내 첫 번째 코드 골프 포스트 : P

펄-92 97

$_=<>;chop;@x=split$";do{print((substr$_,$q,1or$").$")for@x;$q++,print$/}while/@{['\S'x$q]}/

작업이 매우 간단합니다.

K, 33

{" "/:',:''x@'/:!max@#:'x:" "\:x}

입력 및 출력 예 :

k){" "/:',:''x@'/:!max@#:'x:" "\:x}"Hello, World! My name is Foo."
"H W M n i F"
"e o y a s o"
"l r   m   o"
"l l   e   ."
"o d        "
", !        "

파이썬 :

찌르기를 ​​처리하는 한 줄의 코드 :

import sys
m = "Hello, World! My name is Foo."

map(lambda y: sys.stdout.write(' '.join(y)+'\n'), zip(*map(lambda x: x.ljust(max(map(len,m.split()))), m.split())))

파이썬 2.7, 108 103

이것이 더 골프를 칠 수 있다고 확신하지만 파이썬의 초기 솔루션이 있습니다.

w=raw_input().split();m=max(map(len,w));i=0
while i<m:print" ".join(map(lambda x:x.ljust(m)[i],w));i+=1

개량:

• split ( "") => split ()
• 여분의 공백을 제거했습니다.

F #, 187

let o=Console.ReadLine()
let s=o.Split(' ')
let m=s|>Seq.map String.length|>Seq.max
for l=0 to m-1 do
 for w in s|>Seq.map(fun x->x.PadRight(m,' ').[l])do printf"%c "w
 printfn"%s"""

루비, 63

$F.map(&:size).max.times{|i|puts$F.map{|s|s[i]||' '}.join' '}

알고리즘은 매우 간단합니다. 골프 만 했어요 코드 길이는 61 바이트이며 -na작동해야하는 옵션의 경우 2 바이트입니다 . 보낸 사람 ruby -h:

-n   assume 'while gets(); ... end' loop around your script
-a   autosplit mode with -n or -p (splits $_ into $F)

샘플 실행 :

$ echo 'This sentence is false' | ruby -na cols.rb
T s i f
h e s a
i n   l
s t   s
  e   e
  n    
  c    
  e

파이썬 2.7-137 112 바이트

s=raw_input().split()
for c in range(max(map(len,s))):
 for w in s:
    try:print w[c],
    except:print' ',
 print''

다른 누군가가 이미 더 잘 해냈지만 이것을 버릴 수도 있습니다. 가장 긴 단어와 길이가 같아 질 때까지 (다음 부분의 색인 오류를 피하기 위해) 입력의 각 단어에 공백을 추가 한 다음 0에서 각 문자열의 길이까지 c모든 단어 의 th 문자 를 인쇄 c합니다.

나는 이것을하는 훨씬 더 좋은 방법을 생각해 내고 25 바이트를 잘라 냈습니다. 인덱스 오류를 피하기 위해 공백으로 문자열을 채우는 대신 오류를 직접 처리합니다! 인쇄에 아무것도 할 때마다, 내가 가진 그 자리에 하나의 공간을 인쇄 try:print w[c],, except:print' ',. 또한 print 문과 문자열 리터럴 사이에 공백이 필요하지 않으므로 1 바이트를 절약했습니다.

Python 2를 사용하면 탭과 공백을 혼합하고 별도의 들여 쓰기 수준으로 간주합니다. SE의 Markdown 인터프리터는 탭 문자를 4 개의 공백으로 바꾸지 만 첫 번째를 제외한이 프로그램의 모든 줄에는 정확히 1 바이트의 들여 쓰기가 있습니다.

print 'something',인쇄 'something '하기보다는 형식이 매우 쉬웠 습니다 'something\n'. 나는 각 캐릭터에 대해 그것을했고, 빈 print줄을 사용하여 필요한 곳에서 줄 바꿈을 얻었습니다.

C, 111 (110) 95 90 바이트

이 솔루션은 VT-100 제어 코드를 사용하여 터미널에서 커서를 움직입니다.

main(int _,char**v){char*s=*++v;printf("^[7");while(*s)' '==*s?(s++,printf("^[8^[[2C^[7")):printf("%c^[[B^H",*s++);}

^[순서는 여기에 표시 할 수없는 하나의 ASCII의 ESC 문자에 대한 자리 표시 자입니다.

• ^[7 현재 포인터 위치를 저장합니다
• ^[8 커서 위치를 저장된 위치로 복원
• ^[[2C 2 단계 오른쪽으로 이동
• ^[[B 1 단계 아래로 이동

편집 1^[[D (1 단계 왼쪽) VT-100 코드가 백 스페이스로 대체 (로 표시되어 ^H여기서, 오직 하나 개의 아스키 문자이다); 또한 "공백으로 분리"명령을 잊어 버렸습니다.

편집 2 :

7 개 문자는 사용하여 저장 for하는 대신 루프를 while하고, 32대신 ' ':

main(int _,char**v){printf("^[7");for(char*s=*++v;*s;s++)32==*s?printf("^[8^[[2C^[7"):printf("%c^[[B^H",*s);}

8 개 개의 문자는 덜 하나를 호출하여 저장 printf삼항 : ?:연산자는 현재에 사용되는 printf매개 변수를

main(int _,char**v){printf("^[7");for(char*s=*++v;*s;s++)printf(32==*s?"^[8^[[2C^[7":"%c^[[B^H",*s);}

편집 3 :

일명 일명 s직접 작업 로컬 변수를 제거했습니다 . 이것은 완전히 끔찍하다. 그러나 4자를 절약했습니다. 또한 교환 에 따라서 스위치 1 개 이상의 문자를 저장하는 오퍼랜드.argvv==^?:

main(int c,char**v){printf("^[7");for(v++;**v;)printf(32^*(*v)++?"%c^[[B^H":"^[8^[[2C^[7",**v);}

용법

$ gcc transpose.c -o transpose --std=c99
$ ./transpose 'Hello, World! My name is Foo.'
H W M n i F
e o y a s o
l r   m   o
l l   e   .
o d
, !

골프 용 버전 (첫 번째 버전)

main (int _,char**v) {
    char*s=*++v; // init s with the address of the first letter
    printf("^[7"); // save the current cursor position
    while(*s) 
        ' '==*s ? ( /* if current char is a space */
            s++,printf("^[8^[[2C^[7") /* return to the saved location, move right, save position */
        ) : /* kind of else */
            printf("%c^[[B^H",*s++); /* print the current char, move down, move left */
}

골프화되지 않은 버전 (마지막 버전)

main(int c,char**v) {
    printf("^[7");
    for(v++;**v;) /* v++: make v point to argv[1] */
        printf(     
            32^*(*v)++? /* test if **v is different from ' ', and make *v point to
                           the next char */
                "%c^[[B^H":         
                "^[8^[[2C^[7",      
            **v); /* this undefined behaviour (using *v and (*v)++ in the same expression)
                     works as "expected" with gcc 4.7.2 */
} 

나는 이 질문 에 오랫동안 대답 했다. 실제로이 사이트에 처음 기여한 것 중 하나였습니다. 나는 최근에 그것을 다시 발견하고 부끄러웠다. 112 바이트?! 용납 할 수 없습니다. 그래서 나는 또 다른 기회를주었습니다.

파이썬 3-92 바이트

s=input().split()
print('\n'.join(map(' '.join,zip(*[a.ljust(max(map(len,s)))for a in s]))))

첫 번째 답변을 게시 한 후 109 일 동안 나는 먼 길을 왔다고 생각합니다. 2.7 ¹ 이상의 Python 3을 사용하는 것과 같은 것조차도 나에게 일어나지 않았을 것입니다. 이 코드가 100 바이트 미만으로 줄어듦에 따라 제 영혼은 마침내 휴식을 취할 수 있고 내세로 갈 수 있습니다.

설명

s=input().split()

이것은에서 선을 얻을 수 stdin및 공백 문자로 분할을하여 목록을 만듭니다. 입력에있을 가능성이있는 유일한 공백은 공백 이므로이 줄은 단어 목록을 가져옵니다.

안쪽에서 바깥쪽으로 두 번째 줄을 보자.

                                           max(map(len,s))

map함수와 iterable을 인수로 사용합니다. iterable의 각 요소에 함수를 적용하고 결과의 새로운 iterable을 리턴합니다. 여기에서는 각 입력 단어의 길이로 iterable을 만듭니다. maxiterable에서 최대 값을 가져옵니다. 이것은 우리에게 입력에서 가장 긴 단어를 가져옵니다.

                                  [a.ljust(              )for a in s]

목록 이해는와 비슷합니다 map. iterable의 모든 요소에 대해 무언가를 수행하고 결과 목록을 리턴합니다. 입력의 모든 단어에 대해 that_word.ljust(코드를 작성 )합니다. ljust"왼쪽 정렬"의 줄임말입니다. 정수를 인수로 사용하여 길이가 될 때까지 문자열에 공백을 추가합니다.

                             zip(*                                    )

이것은 깔끔한 트릭입니다. 이와 관련하여 *"이 반복 가능한 여러 인수로 압축 해제"를 의미합니다. 이런 식 으로 행렬zip 을 전치하는 데 사용할 수 있습니다 (예 : zip(*[(1,2),(3,4)])-> [(1,3),(2,4)]). 유일한 제한 사항은 행렬의 모든 행이 길이가 같아야하거나 모든 행의 요소는 가장 짧지 만 일치하도록 잘립니다.

                map(' '.join,                                          )

우리는 이미 무엇을 알고 map있습니다. 여기에서 유일한 새로운 것은입니다 join. 이것은 반복 가능한 문자열을 가져 와서 연결된 구분 기호를 사용하여 단일 문자열로 만듭니다. 예를 들어, 'a'.join(['I', 'can', 'play', 'the', 'saxophone'])² 는 Iacanaplayatheasaxophone입니다.

print('\n'.join(                                                        ))

이것은 join많은 문자열을 가져 와서 줄 바꿈으로 구분합니다. 남은 모든 것은이다 print에 stdout우리는 완료!

이제 모두 함께 :

print('\n'.join(map(' '.join,zip(*[a.ljust(max(map(len,s)))for a in s]))))

입력에서 가장 긴 단어의 길이를 찾고, 같은 길이가 될 때까지 모든 단어에 공백을 추가하고, zip(*^{3 개의} 트릭으로 바꾸고, join공백으로 한 행의 각 문자 join를 분리하고, 개행으로 각 행을 분리하는 데 사용합니다. 그리고 인쇄하십시오! 92 바이트 프로그램에서 비 입력 처리 라인에만 나쁘지 않습니다.

<sup>1. print()괄호 에 쓰인 여분의 문자는 내가 raw_input()-> 에서 떨어 뜨린 4 개의 문자보다 큽니다 input().
2. 실제로는 색소폰을 연주 할 수 없습니다.
3 ). 천만에요.</sup>

05AB1E , 득점 8 -20 -21 ( 30 29 바이트 - 50 개 보너스) :

|Dgi#ζεSðý}»}ë¹ε2ô€¬}ζJεðÜ}ðý

온라인으로 사용해보십시오 (일반적인 단일 라인 입력).
온라인으로 사용해보십시오 (여러 줄 반전 입력).

설명:

|                     # Take the input split on newlines:
                      #  i.e. 'This is a test' → ['This is a test']
                      #  i.e. 'T i a t\nh s   e\ni     s\ns     t'
                      #    → ['T i a t','h s   e','i     s','s     t']
 Dg                   #  Duplicate this list, and take the length
                      #   i.e. ['This is a test'] → 1
                      #   i.e. ['T i a t','h s   e','i     s','s     t'] → 4
   i         }        # If the length is exactly 1:
    ¹                 #  Take the input again 
     #                #  Split the input-string by spaces
                      #   i.e. 'This is a test' → ['This','is','a','test']
      ζ               #  Zip with space-filler: Swap all rows and columns
                      #   i.e. ['This','is','a','test'] → ['Tiat','hs e','i  s','s  t']
       ε   }          #  For each item:
        S             #   Convert the item to a list of characters
                      #    i.e. 'Tiat' → ['T','i','a','t']
         ðý           #   Join them by a single space
                      #    i.e. ['T','i','a','t'] → 'T i a t'
            »         #  Join the result by newlines (and output implicitly)
    ë                 # Else:
     ε    }           #  For each item:
      2ô              #   Split it into chunks of two characters
                      #    i.e. 'h s   e' → ['h ','s ','  ','e']
        €¬            #   Take the head (first character) of each:
                      #    i.e. ['h ','s ','  ','e'] → ['h','s',' ','e']
           ζ          #  Zip with space-filler: Swap all rows and columns
                      #   i.e. [['T','i','a','t'],['h','s',' ','e'],['i',' ',' ','s'],['s',' ',' ','t']]
                      #     → [['T','h','i','s'],['i','s',' ',' '],['a',' ',' ',' '],['t','e','s','t']]
            J         #  Join each inner list to a single string
                      #   i.e. [['T','h','i','s'],['i','s',' ',' '],['a',' ',' ',' '],['t','e','s','t']]
                      #     → ['This','is  ','a   ','test']
             ε  }     #  For each item:
              ðÜ      #   Remove any trailing spaces
                      #    i.e. 'is  ' → 'is'
                 ðý   #  Join the items by a single space (and output implicitly)

원래 8 바이트 답변 :

#ζεSðý}»

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

설명:

#           # Split the input-string by spaces
            #  i.e. 'This is a test' → ['This','is','a','test']
 ζ          # Zip with space-filler: Swap all rows and columns
            #  i.e. ['This','is','a','test'] → ['Tiat','hs e','i  s','s  t']
  ε   }     # For each item:
   S        #  Convert the item to a list of characters
            #   i.e. 'Tiat' → ['T','i','a','t']
    ðý      #  Join them by a single space
            #   i.e. ['T','i','a','t'] → 'T i a t'
       »    # Join the result by newlines (and output implicitly)

매스 매 티카 49

분명히 Mathematica는 이것에 가장 적합하지 않습니다.

Grid[PadRight@Characters@StringSplit@s^T]/. 0->" "

참고 ^T(조옮김)은 하나의 문자입니다 (지금 올바른 문자 코드를 찾을 수 없습니다)

자바 스크립트, 141

a=prompt().split(' '),c=0,d=a.map(function(a){b=a.length;c=c<b?b:c});for(j=0;j<c;j++){b='';for(i in a)b+=a[i][j]?a[i][j]:' ';console.log(b);}

견본

hello, world! this is code golf

hwticg
eohsoo
lri dl
lls ef
od    
,! 

GolfScript [41 바이트]

' '%:x{.,x{,}%$-1=-abs' '*+}%zip{' '*}%n*

작동 방식 :

' '%:x          split text into words and store array in 'x'
{               for each word in the array:
    .,              from word's length
    x{,}%$-1=-      substract the length of the longest word in 'x'
    abs             get absolute value (maybe there is a shorter way?)
    ' '*+           add corresponding number of spaces
}%
zip{' '*}%      transpose array of words and add spaces between letters
n*              join words with a new line character

온라인 데모는 여기에서 볼 수 있습니다 .

추신 : 이것은 내 첫 GolfScript 코드이므로 엄격하게 판단하지 마십시오.)

R, 116

z=t(plyr::rbind.fill.matrix(lapply(strsplit(scan(,""),""),t)));z[is.na(z)]=" ";invisible(apply(cbind(z,"\n"),1,cat))

배쉬 + 코어 유틸리티, 54

eval paste `printf " <(fold -w1<<<%s)" $@`|expand -t2

산출:

$ ./transpose.sh 안녕하세요, 월드! 내 이름은 푸입니다.
HWM ni F
어야 소
lrmo
lle.
od       
,!       
$ 

APL : 18

⍉↑1↓¨a⊂⍨' '=a←' ',

설명:

a ← '', 문자열 앞에 공백을두고

''= 공백을 찾고 부울을 생성합니다.

1 ↓ ¨a⊂⍨ 부울이 1을 갖는 곳에서 시작하여 부분 문자열을 만들고 각 요소의 첫 번째 요소를 삭제합니다 (공백)

sub ↑ 결과 문자열에서 행렬을 만들고 대각선을 따라 뒤집습니다.

R , 81 바이트

같은 줄 바꿈 저장하여 바이트를 저장 e모두에서 사용할 수 있습니다, scan전화의 비교 전화와 cat.

w=scan(,e,t=scan(,e<-"
"));while(any((s=substr(w,F<-F+1,F))>e))cat(pmax(" ",s),e)

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

K (oK) , 26 바이트

해결책:

`0:{" "/'+(|/#:'x)$x}@" "\

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

설명:

`0:{" "/'+(|/#:'x)$x}@" "\ / the solution
                      " "\ / split input on whitespace
   {                }@     / apply (@) lambda
                  $x       / pad ($) input (x)
          (      )         / do this together
             #:'x          / count (#:) each (')
           |/              / max
         +                 / transpose / flip
    " "/'                  / join each with whitespace
`0:                        / print to stdout

파이썬 2.7 - 119 (106)

1-166을 가져 가라. 내가 원하는 순서대로 팝 작업을하기 위해리스트를 뒤집는 것이 필요했지만 이것은 낭비로 보였다. 그리고 재미를 위해 하나의 이해력으로 결합하려고 할 때, 팝은 일을 망쳤습니다.

w=raw_input().split(' ');l=max([len(l) for l in w]);
q=[list(p)[::-1]for p in w]+[['\n']*l]
t=[' '+(v.pop() if v else' ')for i in range(l)for v in q]
print ''.join(t)

2-119를 사용하십시오. 그래서 간단한 목록 인덱싱으로 변경했습니다. 그럼에도 불구하고 여전히 공간과 줄 바꿈이 패딩처럼 들리는 것처럼 보입니다.

w=raw_input().split(' ');l=max([len(l)for l in w]);print''.join([' '+(v+' '*l)[i]for i in range(l)for v in w+['\n'*l]])

@grc 덕분에 3을 가져 가라.

w=raw_input().split();l=max(map(len,w));print''.join(' '+(v+' '*l)[i]for i in range(l)for v in w+['\n'*l])

파이썬 3, 124

a=input().split()
l=max(map(len,a))
print("\n".join(" ".join(c[i] for c in [i+" "*(l-len(i)) for i in a]) for i in range(l)))

하스켈, 112

골프 :

import Data.List
r s=unlines$transpose$p$words s
p w=m(\s->s++replicate(maximum(m l w)-l s)' ')w
m=map
l=length

설명 :

import Data.List

-- Break on spaces, then pad, then transpose, then join with newlines
r s=unlines$transpose$p$words s

-- Pads each String in a list of String to have the same length as the longest String
p w=m(\s->s++replicate(maximum(m l w)-l s)' ')w

-- Aliases to save space
m=map
l=length

예:

*Main Data.List> putStrLn $ r "Hello Doge"
HD
eo
lg
le
o

JavaScript, 139 (console.log 출력의 156)

s=" ",b="",a=prompt().split(s),l=0;for(var i in a){m=a[i].length;l=(l<m)?m:l;}for(i=0;i<l;i++){for(var j in a)b+=((x=a[j][i])?x:s)+s;b+="\n"}console.log(b);

나는 이것이 내가 얻을 수있는만큼 골프라고 생각합니다. 문자가 짧은 단어에 없으면 공백을 추가하여 분할하고 가장 큰 단어를 찾은 다음 적절하게 바꿉니다. 이전에 제출 한 JavaScript 답변보다 많지만 해당 답변이 효과가없는 것 같습니까?

Japt -R , 5 바이트

¸y¬m¸

시도 해봐

설명

¸         :Split on spaces
 y        :Transpose
  ¬       :Split columns
   m      :Map rows
    ¸     :  Join with spaces
          :Implicitly join with newlines and output

Pyth, 8 바이트

jbjL\ Cc

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

꽤 직설적 인. 따옴표로 묶은 입력을받습니다."Hello World"

jbjL\ CcQ
---------
       cQ    Chop the input Q on spaces
      C      Matrix transpose
  jL\        Join each element by spaces,
             i.e. interleave spaces between the characters of each element
jb           Join by newlines

APL (NARS), 79 자, 158 바이트

{m←⌈/↑∘⍴¨z←(' '≠⍵)⊂,⍵⋄v←∊m{⍵\⍨∊(k⍴1)(0⍴⍨⍺-k←↑⍴⍵)}¨z⋄((2×↑⍴z)⍴1 0)\[2]⍉(↑⍴z)m⍴v}

테스트:

  f←{m←⌈/↑∘⍴¨z←(' '≠⍵)⊂,⍵⋄v←∊m{⍵\⍨∊(k⍴1)(0⍴⍨⍺-k←↑⍴⍵)}¨z⋄((2×↑⍴z)⍴1 0)\[2]⍉(↑⍴z)m⍴v}
  f 'Hello, World! My name is Foo.'
H W M n i F 
e o y a s o 
l r   m   o 
l l   e   . 
o d         
, !         

이전 함수는 출력이 완벽하지 않습니다.

  {⍪¨(' '≠⍵)⊂,⍵}'Hello, World! My name is Foo.'
 H  W  M  n  i  F 
 e  o  y  a  s  o 
 l  r     m     o 
 l  l     e     . 
 o  d             
 ,  !