编辑我修改了规则的措词，使一些隐含的内容更加明确。我还强调了一些明显的混淆，并明确定义了制作独立程序而不是函数的选项。

这里的目标是创建一个接受文本文件（或字符串）并对其进行转置的函数，以使行成为列，反之亦然。

例：

我是文字。
转置我。
你可以做到吗？

结果是：

国贸中心
 拉
an
mn
 sy
载脂蛋白
 OU
ts
杂草
o
Tm值
.ei
 .t
  ？

规则：

• 您可以假定使用的唯一空格字符是" "并且"\n"在任何行上都没有尾随空格。
• 您可以假定文件是ASCII。您要使用哪个终端标记（CRLF或LF）。它必须在示例中正确运行，但也应在满足上述假设的任何输入下工作。
• 您可能必须在没有空格的地方插入空格（如示例中所示），以使列保持一致。
• 您的结果在任何行上都不能包含尾随空格。
• 最后的换行符（用于最后一行）是可选的。
• 它应该是一个功能或一个完整的程序。如果您的函数接受字符串，则它应该以字符串形式返回结果。如果它接受文件名，则返回保存结果的文件名。另外，您还可以编写一个完整的程序，该程序接受来自STDIN的输入并将正确的结果输出到STDOUT。如果这样做，则不得将任何内容输出到STDERR。
• 最短的程序胜出，但我会赞成我喜欢的任何答案。

根据规则，示例中的输出长度为53或52个字节（对于LF换行符），具体取决于是否包含最终换行符。

注意：这不是特定的要求，但是如果您的函数连续运行两次时与原始函数不同（最终的换行符可能会有所不同，并且文件末尾的任何空行都将被删除），那么您就是可能违反其中一项规则。

Japt，6个字节

y mx1R

尝试
运行两次 -返回原始字符串

说明

y

转置输入

m  R

映射每行

x1

修剪右

J（31 40）

f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

这是一个接受字符串并返回字符串的函数（即在正确位置插入换行符的字符向量，而不是矩阵。）

编辑：在任何行上都没有尾随空格。

测试：

   f=:3 :';(,&LF@dlb&.|.)&.><"1|:>LF cut y'

   string=:stdin''
I am a text.
Transpose me.
Can you do it?
^D

   $string
42
   $f string
53
   f string
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

红宝石111

打高尔夫球：

def f t;s=t.lines;s.map{|l|l.chomp.ljust(s.map(&:size).max).chars}.transpose.map{|l|l.join.rstrip+?\n}.join;end

取消高尔夫：

def transpose_text(text)
  max_length = text.lines.map(&:size).max
  text.lines.map do |line|
    line.chomp.ljust(max_length).chars
  end.transpose.map do |chars|
    chars.join.rstrip + "\n"
  end.join
end

Ruby具有数组转置功能，因此只需填充行，将它们转换为字符数组，使用Ruby的Array＃transpose函数，然后将字符数组转换回行。

打高尔夫球只是使用单字符标识符，删除空格，为text.lines使用临时变量，然后将max_length的计算内容内联（效率没有任何意义）。

R，171

function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")}

用法示例：

text <- "I am a text.
Transpose me.
Can you do it?"


(function(e){p=strsplit
x=t(plyr::rbind.fill.matrix(lapply(p(p(e,"\n")[[1]],""),t)))
x[is.na(x)]=" "
cat(apply(x,1,function(y)sub(" *$","",paste(y,collapse=""))),sep="\n")})(text)

ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?

尾随空白将被删除。

Python 2.7（97 79 94 90）

编辑：缺少功能要求；

我相当确定这会有所改善，因为我是这里的初学者，但首先要说的是；

c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))

该代码使用简单的split方法将字符串拆分为行向量。然后map，它使用一个函数值为as None（单位函数）和splat运算符来转置和填充矢量（类似于zip_longestPython3中的功能）

其余代码只是映射None到空间，修剪并重新将矩阵重新组装为单个字符串。

>>> a = 'I am a text.\nTranspose me.\nCan you do it?'
>>> c(a)                                                                            
'ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?'
>>> len("""c=lambda a:'\n'.join(''.join(y or' 'for y in x).rstrip()for x in map(None,*a.split('\n')))""")
88
# (+2 since `\n` is considered by `len` to be a single char)

Bash + coreutils + sed，83

eval paste `sed 's/.*/<(fold -w1<<<"&")/'`|expand -t2|sed 's/\(.\) /\1/g;s/ \+$//'

fold并paste做重要的工作。其余的只是格式化。

接受来自stdin的输入并输出到stdout：

$ < tr.txt ./transposefile.sh
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
$ < tr.txt ./transposefile.sh | ./transposefile.sh
I am a text.
Transpose me.?
Can you do it
$ 

C（278字节）

编辑：这实际上违反了规则，因为它将文件名作为参数但写入标准输出。稍后我将对其进行编辑以写入文件，然后将文件名打印到stdout。

这是我有史以来的第一次高尔夫，所以请多加注意。一些普通的旧C。将输入放进去test.txt，让它运行！

clang transpose.c -o transpose && ./transpose test.txt

#import <stdio.h>
#import <stdlib.h>
#import <string.h>

#define BUFFER_SIZE 1024

#define MAX(A,B) ((A)>(B)?(A):(B))

int main(int argc, char **argv) {
    char line[BUFFER_SIZE];

    FILE *f; int nLines, maxLen;

    f = fopen(argv[1], "r");
    while(!feof(f) && fgets(line, BUFFER_SIZE, f)) {
        nLines++;
        maxLen = MAX(maxLen, strlen(line));
    }
    fclose(f);

    for (int charPos = 0; charPos < maxLen; charPos++) {
        f = fopen(argv[1], "r");
        for (int linePos = 0; linePos < nLines; linePos++) {
            fgets(line, BUFFER_SIZE, f);
            printf("%c", charPos < strlen(line) && line[charPos] != '\xA' ? line[charPos] : ' ');
        }
        printf("\n");
        fclose(f);
    }

    return 0;
}

通过使用简短的变量名，删除不必要的格式，并允许文件句柄泄漏，并禁用所有警告，可以减少到278个字节。（由于这使用了隐式导入，因此可能无法在所有系统上正确链接。在我的机器上可以使用！）

#import <stdio.h>
int main(int C,char**V){char L[1024];int A,B,D,I,J,*F=fopen(V[1],"r");while(!feof(F)&&fgets(L,1024,F)){A++;D=strlen(L);B=B>D?B:D;}for(I=0;I<B;I++){F=fopen(V[1],"r");for(J=0;J<A;J++)fgets(L,1024,F)&&printf("%c",I<strlen(L)&&L[I]!='\n'?L[I]:' ');printf("\n");}}

自动热键210

f(i){
StringSplit,o,i,`n
m:=0
loop % o0 {
a:=A_index
if (t:=Strlen(p:=o%a%))>m
m:=t
StringSplit,l%a%,o%a%
}
loop % m {
a:=A_index,n:=""
loop % o0
n.=(j:=l%A_index%%a%)=""?" ":j
s.=Rtrim(n," ") "`n"
}
return s
}

测试

text=
(
I am a text.
Transpose me.
Can you do it?
)
msgbox % f(text)

Ruby：88个字符

（发布是因为它比其他Ruby解决方案要短。未检查我的代码是否比其他Ruby解决方案引入了任何新内容。如果您已经发布了Ruby解决方案，并且您觉得这主要是您的副本，请发表评论，我将退回我的答案。 ）

f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}

样品运行：

irb(main):001:0> f=->t{l=t.split$/;r=[""]*m=l.map(&:size).max;l.map{|l|m.times{|i|r[i]+=l[i]||" "}};r*$/}
=> #<Proc:0x99a9e68@(irb):1 (lambda)>

irb(main):002:0> sample='I am a text.
irb(main):003:0' Transpose me.
irb(main):004:0' Can you do it?'
=> "I am a text.\nTranspose me.\nCan you do it?"

irb(main):005:0> puts f[sample]
ITC
 ra
aan
mn
 sy
apo
 ou
ts
eed
x o
tm
.ei
 .t
  ?
=> nil

irb(main):006:0> puts f[f[sample]]
I am a text.
Transpose me.
Can you do it?
=> nil

Bash，124个字节

D=`mktemp -d`;split -l1 - $D/;for F in $D/*;do grep -o . $F>$F+
done;paste $D/*+|sed -e's/\([^\t]\)\t/\1/g;s/\t/ /g;s/ *$//'

它读取标准输入并写入标准输出。试试吧：

echo $'I am a text.\nTranspose me.\nCan you do it?' | script.sh

怎么运行的：

• split输入单行（临时目录中的文件$D）
• 使用grep（文件* +）将行分割成单个字符
• 使用paste（TAB分隔的列）并排布局字符
• 卸下对齐TAB，用空白代替填充TAB，使用 sed

编辑：

• -9：删除了整理代码;rm -r $D（感谢Tim）
• -2：使用+代替_后缀并缩短${F}_为$F+
• -3：L从拆分结果文件中删除前缀

Ruby-144个字符

打高尔夫球，这是我的第一次尝试：

def f t
t.split(?\n).each{|l|l<<' 'until l.size==t.split(?\n).map(&:size).max}.map{|x|x.split('')}.transpose.map{|l|l.join.rstrip}.join(?/n)
end

对于输出，请运行puts f textwhere text遵守以上规则的任何多行字符串。未发布的版本如下：

def text_transpose(text)
  lines = text.split(?\n)
  maxlen = lines.map(&:size).max
  lines.each { |line| line << ' ' until line.size == maxlen }
       .map  { |line| line.split('') }.transpose
       .map  { |char| char.join.rstrip }.join(?\n)
end

对于Ruby中类似但最终更好的解决方案，请查看上面的Wayne Conrad的代码。

PHP 194

function x($a){$a.="\n";$s=strlen($a);$i=0;while($c<$s)if($a{$c}!="\n")$b[$i++].=$a{$c++};else{$c++;for(;$i<$s;$i++)$b[$i].=" ";$i=0;}ksort($b);return rtrim(implode("\n",array_map("trim",$b)));}

非高尔夫：

function x($a) {
    $a.="\n";
    $s=strlen($a);
    $i=0;
    while($c<$s)
        if($a{$c}!="\n")
            $b[$i++].=$a{$c++};
        else{
            $c++;
            for(;$i<$s;$i++)
                $b[$i].=" ";$i=0;
        }
    ksort($b);
    return rtrim(implode("\n",array_map("trim",$b)));
}

这是我第一次打高尔夫球，所以请客气！此外，技巧/建议将不胜感激！

MATHEMATICA 117个字符

t = "I am a text.\nTranspose me.\nCan you do it?";

f=(m=Length/@(f=Flatten[Characters/@StringSplit[#,"\n"],{{2},{1}}])//Max;
StringJoin@@@(PadLeft[#,m," "]&/@f)//Column)&

Perl（92 + 1）

读取标准输入并写入标准输出。将分数加1say

@L=map[grep!/\n/,split//],<>;do{$_=join'',map shift@$_||$",@L;s/ +$//;say}while grep@$_>0,@L

CJam，32 25字节

CJam比这项挑战要新，因此此答案不符合要求。

user23013大大缩短了。

qN/_z,f{Se]}z{S+e`);e~N}%

在这里测试。

qN/                       "Read input, split into lines.";
   _z,                    "Transpose, get length (find maximum line length).";
      f{Se]}              "Pad each line to that length with spaces.";
            z             "Transpose.";
             {         }% "Map this block onto each line in the result.";
              S+          "Add a space to ensure there's at least one.";
                e`        "Run-length encode.";
                  );      "Discard the trailing run of spaces.";
                    e~    "Run-length decode";
                      N   "Push a newline.";

Javascript，103

s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

少打高尔夫球

s=>[...s].map(
     // we need 'i' ranging from 0 to the length of the longest input line
     // so we scan all the input string, that is surely longer
     // but we need to check that after some point the output must be empty
     (_, i) => ( 
       r = '', // the current output row, starts empty
       q = '', // flag to check if we are beyond the longest line
       s.split('\n') // split in rows
       .map( 
         b => ( // for each input row in b
           q = b[i] || q, // if there is a char at position i in b, i goes to q
           r += b[i] || ' ' // add to output the char at position i or a fill space
         )
       ),
       q // if q is still '', we are beyond the longest input line 
       ? r.replace(/ *$/,`\n`) // trim leading space and add newline
       : '' // no output 
     )
   ).join('')

测试

F=
s=>[...s].map((_,i)=>s.split`
`.map(b=>r+=b[q=b[i]||q,i]||' ',r=q='')&&r.replace(/ *$/,q?`
`:q)).join``

function go() {
  var text=I.value
  var output = F(text)
  O.textContent = output
}

go()

#I { width:50%; height:5em }

<textarea id=I>I am a text.
Transpose me.
Can you do it?</textarea><br>
<button onclick='go()'>Transpose</button>
<pre id=O></pre>

视网膜，40字节

P`.+
~L0$`.
L,$.%'vs,$.(x$%=),`.+
m` *$

在线尝试！

基于我创建的该程序可以转置任何大小的矩形，该程序使用Leo的建议来转置已知大小的矩形。

编辑：打更多的高尔夫球，不再在行尾有空格。

Perl 5，25个字节

请注意，这使用ANSI转义序列，因此在TIO上不起作用，但是您可以在此处查看它的运行情况。

$"="[1D";$_="[1;$.H@F"

说明

这段代码首先将列表分隔符（$"）的值更改为垂直制表符，然后是ANSI转义序列“向后1列”（\x1b[1D），然后将隐式打印的变量设置为$_以ANSI转义序列开头的字符串代表“从第1行的列开始打印$.（此处$.是当前文本行）”（\x1b1;$.H）并内插列表@F（这是该行上所有字符的列表，由自动拆分（-a）填充并带有空的拆分模式（-F））它将的内容$"放置在每个项目之间，垂直向下移动光标，而不是在前一个字符之后继续输出。

在线尝试！

C ++（243个字符）

这是一个接受并返回字符串的函数。

我本可以剃掉几个字符，但决定保留它为非愚蠢的代码（运行速度快，没​​问题）。也许我只是决定这么做，因为这是我的第一个代码高尔夫。。。

string f(string s){stringstream ss(s);vector<string> v;for(size_t i=0;getline(ss,s);++i){if(v.size() < s.size())v.resize(s.size());for(size_t j=0;j<s.size();++j){v[j].resize(i,' ');v[j].push_back(s[j]);}}s="";for(auto& i:v)s+=i+'\n';return s;}

使用格式：

string f(string s)
{
    stringstream ss(s);
    vector<string> v;

    for(size_t i = 0; getline(ss, s); ++i)
    {
        if(v.size() < s.size())
            v.resize(s.size());

        for(size_t j = 0; j < s.size(); ++j)
        {
            v[j].resize(i, ' ');
            v[j].push_back(s[j]);
        }
    }

    s = "";
    for(auto& i : v)
        s += i + '\n';

    return s;
}

Python 2.7-115 个字符：

单线：

>>> a
'I am a text.\nTranspose me.\nCan you do it?'

>>> "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
'ITC\n ra\naan\nmn \n sy\napo\n ou\nts \need\nx o\ntm \n.ei\n .t\n  ?\n'

并在更清洁的印刷中：

>>> print "".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])
ITC
 ra
aan
mn 
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

115个字符：

>>> len(""""".join(["".join(i)+'\n' for i in zip(*[x+" "*(len(max(a.splitlines(), key=len))-len(x)) for x in a.splitlines()])])""")
115

GolfScript，51个字符

n%.{,}%$-1=" "*:y;{y+y,<}%zip{n\+0{;).32=}do}%((;\+

这是第一次尝试；我怀疑它可以改善。大部分代码都符合填充和尾部空格删除要求-没有它们，n%zip n*就足够了。

附言 以下46个字符的版本将为给定的示例输入执行此工作，但是如果任何输入列完全由空格组成，则将崩溃：

n%.{,}%$-1=" "*:y;{y+y,<}%zip{0{;).32=}do]}%n*

我认为这足以取消比赛资格，即使挑战并未明确说明。

方案/球拍113

文本：

(define t (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

没有换行和多余的空格：

(define s(λ(v x)(if(= x 0)'()(cons(list->string(car v))(s(cdr v)(- x 1))))))(s(apply map list t)(length(car t)))

人性化版本

(define text (list 
    (string->list "I am a text.") 
    (string->list "Transpose me.")
    (string->list "Can you do it?")
))

(define transpose
    (λ(text length)
        (if (= length 0)
            '()
            (cons (list->string (car text)) (transpose (cdr text) (- length 1)))
)))

(transpose (apply map list text) (length (car text)))

哈斯克尔

import Data.List
main = interact (unlines . transpose . lines)

太短了，我需要添加空格...

Python的89 103个字符

def f(a):return'\n'.join([''.join(i).rstrip()for i in zip(*[j+' '*99 for j in a.split('\n')])]).rstrip()

我很脏 工业强度版本为90 104字符。：^）

Mathematica，95个字符

f=""<>Riffle[Thread@PadRight@Characters@StringSplit[#,"\n"]//.{0->" ",{x___," "..}:>{x}},"\n"]&

K，56

现在应该符合规格。

接受一个字符串，返回一个字符串。

{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}

。

k)f:{`/:{$[" "=*|x;|(+/&\" "=|x)_|x;x]}'x@'/:!max@#:'x:`\:x}
k)f"I am a text.\nTranspose me.\nCan you do it?"
"ITC\n ra\naan\nmn\n sy\napo\n ou\nts\need\nx o\ntm\n.ei\n .t\n  ?\n"
k)f f"I am a text.\nTranspose me.\nCan you do it?"
"I am a text.\nTranspose me.\nCan you do it?\n"

Groovy，98个字符

{i->o=[].withDefault{''};i.readLines().each{it.toList().eachWithIndex{c,d->o[d]+=c}};o.join('\n')}

线上

松散：

{i->
o=[].withDefault{''};//create list with empty string as default value 
i.readLines()
.each{
    it.toList() //split every line to characters
    .eachWithIndex{ 
        c,d->o[d]+=c //append to string from list with right index
    }
};
o.join('\n')}//join list with newlines
}

Pyth，11个字节

# aYcw1;.tY

在线尝试！

将输入作为字符串，输出列表列表

Pyth，25个字节

# aYcw1=+Z1;jbcj"".n.tY)Z

将输入作为字符串，输出字符串。

在线尝试！

J，28 26字节

由于frownyfrog，节省了2个字节

t=.,@:(,&LF"1)@|:@:>@cutLF

接受一个字符串，返回一个字符串。我不确定是否可以使用较短版本的'cutopen' 函数 动词。

还有更短的

t=.|:@:>@cutLF

但是我不确定它是否属于OP的指导原则，因为它会返回一个字符数组。

怎么运行的：

                     cutLF   | Splits the input on new lines and boxes them
                    @        | Composes verbs (as does @:, but they're not equal)
                   >         | Unboxes this, forming an array of the lines
                 @:          |
               |:            | Transposes the array
      (      )@              |
       ,&LF                  | Appends a new line...
           "1                | To each row of the array
    @:                       |
   ,                         | Flatten the result
t=.                          | Assign this verb to t

另一个版本的工作原理相同，但是不会将转置的数组转换为格式正确的字符串。

例子：

NB. Define a multi-line string

    text =: 0 : 0
I am a text.
Transpose me.
Can you do it?
)

    t text
ITC
 ra
aan
mn    NB. There's whitespace after the 'n' here, but I assume it doesn't count as trailing since it's part of the original string
 sy
apo
 ou
ts 
eed
x o
tm 
.ei
 .t
  ?

    t t text
I am a text.     NB. Again, whitespace here, but it's part of the argument of the second 't' (added by the first 't' to keep columns straight)
Transpose me. 
Can you do it?

Lua中，203 189字节

t={{}}i=1m=0(...):gsub(".",function(c)n=#t[i]if c=="\n"then i=i+1t[i]={}else t[i][n+1]=c end m=m<=n and n+1or m end)
for x=1,m do for p=1,i do io.write(t[p][x]or" ")end _=m<=x or print()end

在线尝试！

我在这里看到了另一个Lua解决方案，但是我认为用相同的语言发布2个解决方案没有问题。如果有，告诉我:)