您的任务是获取一个由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        
, !        

Javascript- 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

万岁，我击败了Perl！：D

红宝石，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

Java脚本 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

Perl-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())))

Python 2.7， 108 103

我敢肯定，这可以打更多，但这是python中的初始解决方案。

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字节，外加2字节的代码-na来工作。来自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''

有人已经做得更好，但我还是建议您这样做。在输入中的每个单词上添加空格，直到其长度与最长的单词相同（以避免下一部分的索引错误），然后打印c每个单词的第一个字母（c从0到每个字符串的长度）。

我想出了一种更好的方法，并减少了25个字节。我直接处理错误，而不是用空格填充字符串来避免索引错误！只要没有要打印的内容，我都会用try:print w[c],，代替它打印一个空格except:print' ',。我还记得，在打印语句和字符串文字之间不需要空格，这样可以节省一个字节。

请注意，Python 2允许您混合使用制表符和空格，并将它们视为单独的缩进级别。SE的Markdown解释器将制表符替换为四个空格，但是该程序的每一行（除第一行外）均具有一个缩进字节。

格式化非常容易，因为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左移一步）VT-100代码已由退格键代替（如此处所示^H，但仅是一个ASCII字符）；也忘记了“空格分隔”指令，现已修复

编辑2：

通过使用for循环而不是while和32来保存7个字符' '：

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，直接使用argvaka v。这是完全可怕的。但是节省了4个字符。也换成==用^，因此切换?:操作数，以节省更多的焦炭。

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个字节？！不能接受 所以我又给了它一个镜头：

Python 3-92个字节

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

自发布第一个答案以来的109天里，我想我已经走了很长一段路。我什至不会发生像在2.7 ^1上使用Python 3这样的事情。将此代码压缩到100字节以下，我的灵魂终于可以安息了，我可以继续来世。

说明

s=input().split()

这将从中获得一行，stdin并通过将其分割为空白字符来创建列表。输入中唯一可能存在的空格是空格，因此此行获取单词列表。

让我们从内而外地走第二行：

                                           max(map(len,s))

map接受一个函数和一个可迭代的参数。它将函数应用于可迭代的每个元素，并返回结果的新可迭代。在这里，我使用每个输入单词的长度创建一个可迭代的对象。max从迭代获得最大值。这使我们得到输入中最长的单词。

                                  [a.ljust(              )for a in s]

列表理解与相似map。它对可迭代的每个元素执行某项操作，并返回结果列表。对于输入中的每个单词，我都会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(*³技巧进行转置，用于join用空格将一行中的每个字符分隔开join来，再次用换行符分隔每行，并打印！对于92字节程序中唯一的非输入处理行来说还不错。

^{1. print()我从raw_input()-> 删除的4个字符超过了花在括号上的多余字符input()。
2.我实际上不能演奏萨克斯管。
3 )。别客气。}

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)

Mathematica 49

显然，Mathematica并不是最好的选择：

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

注意^T（转置）仅是一个字符（我现在找不到正确的字符代码）

Javascript，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

您可能会在此处看到在线演示。

PS：这是我有史以来第一个GolfScript代码，所以请不要严格判断我;）

R，116

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

Bash + coreutils，54岁

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

输出：

$ ./transpose.sh您好，世界！我叫Foo。
硬件
eoyaso
尔莫
勒。
od       
，！       
$ 

APL：18

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

说明：

a←''，在字符串前面放置一个空格并分配给一个

''=查找空格，产生一个布尔值

1↓¨a⊂⍨使子字符串从布尔值具有1的位置开始，并丢弃每个字符串的第一个元素（因此空格）

⍉↑从结果子串中取出矩阵，然后沿对角线将其反转

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]])

拿3-感谢@grc

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])

Python 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);

我认为这是我能得到的。我只是拆分，找到最大的单词并进行相应的转置，如果较短的单词中不存在char，则添加空格。比以前提交的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             
 ,  !