EDIT Modifiquei a redação das regras para tornar algumas coisas implícitas mais explícitas. Também acrescentei alguma ênfase para esclarecer alguns pontos de aparente confusão e defini explicitamente a opção de criar um programa independente em vez de uma função.

O objetivo aqui é criar uma função que pega um arquivo de texto (ou string) e o transpõe para que as linhas se tornem colunas e vice-versa.

Exemplo:

Eu sou um texto
Transponha-me.
Consegues fazê-lo?

Resulta em:

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

As regras:

• Você está autorizado a assumir que os únicos caracteres em branco utilizados são " "e "\n"e que não há nenhum espaço em branco à direita em qualquer linha.
• Você pode assumir que o arquivo é ASCII. O marcador da linha final que você deseja usar depende de você (CRLF ou LF). Ele deve funcionar corretamente no exemplo, mas também deve funcionar em qualquer entrada que satisfaça as suposições acima.
• Pode ser necessário inserir espaços (como no exemplo) onde não havia nenhum para manter as colunas alinhadas.
• Seu resultado não deve ter espaços em branco à direita em nenhuma linha .
• O caractere de nova linha final (para a última linha) é opcional.
• Deve ser uma função ou um programa completo. Se sua função aceitar uma string, ela deverá retornar os resultados como uma string. Se ele aceitar um nome de arquivo, você retornará o nome do arquivo em que salvou o resultado. Além disso, você pode escrever um programa completo que aceite a entrada STDIN e produz o resultado correto para STDOUT; se você fizer isso, você deve não saída qualquer coisa para STDERR.
• O procedimento mais curto vence, mas vou votar de qualquer resposta que eu quiser.

Com base nas regras, a saída no exemplo tem 53 ou 52 bytes de comprimento (para novas linhas LF), dependendo se a nova linha final está incluída ou não.

Nota: Não é um requisito específico, mas se sua função, quando executada duas vezes sucessivas, não for idêntica à original (a nova linha final pode ser diferente e todas as linhas vazias no final do arquivo serão excluídas), você será excluído. provavelmente quebrando uma das regras.

Japonês , 6 bytes

y mx1R

Experimente
Executar duas vezes - retorna a string original

Explicação

y

Transponha a entrada

m  R

Mapa sobre cada linha

x1

Aparar à direita

J ( 31 40)

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

Esta é uma função que pega uma string e retorna uma string (ou seja, um vetor de caractere com alimentações de linha inseridas nos lugares certos, e não uma matriz).

Editar: nenhum espaço em branco à direita em nenhuma linha.

Teste:

   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
  ?

Ruby 111

Golfe:

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

Ungolfed:

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

O Ruby possui uma função de transposição de matriz, portanto, isso simplesmente preenche as linhas, as transforma em uma matriz de caracteres, usa a função de transposição # Array do Ruby e transforma a matriz de caracteres novamente em linhas.

Para jogar golfe, bastava usar identificadores de um caractere, remover espaços, usar um temporário para text.lines e colocar o cálculo para max_length inline (não há pontos de eficiência).

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")}

Exemplo de uso:

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
  ?

O espaço em branco à direita é removido.

Python 2.7 ( 97 79 94 90)

EDIT: Perdeu o requisito de função;

Tenho certeza de que isso será melhorado, já que sou um iniciante aqui, mas para começar;

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

O código usa um simples splitpara dividir a string em um vetor de linhas. Em seguida, ele usa mapcom um valor de função como None(a função de unidade) e o operador splat para transpor e preencher o vetor (funcionalidade semelhante à zip_longestdo Python3)

O restante do código apenas mapeia Nonepara o espaço, apara e remonta a matriz em uma única sequência novamente.

>>> 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/ \+$//'

folde pastefaça o trabalho importante. O resto é apenas formatação.

Aceita entrada de stdin e saídas para 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 bytes)

Editar: Isso realmente quebra as regras, pois leva um nome de arquivo como argumento, mas grava no stdout. Vou editá-lo mais tarde para gravar em um arquivo e depois imprimir o nome do arquivo em stdout.

Este é o meu primeiro código de golfe, então tenha piedade. Algum C. simples e antigo Coloque a entrada test.txte deixe-a funcionar!

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

Ao usar nomes curtos de variáveis, remover a formatação gratuita e permitir que os identificadores de arquivo vazem e desativar todos os avisos, isso é reduzido para 278 bytes. (Como isso usa importações implícitas, pode não ser vinculado corretamente em todos os sistemas. Funciona na minha máquina!)

#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");}}

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

Teste

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

Ruby: 88 caracteres

(Publicado porque é mais curto que as outras soluções Ruby. Não foi verificado se meu código introduz algo novo em comparação com os outros. Se você já publicou uma solução Ruby e acha que essa é principalmente uma cópia sua, por favor, comente e retirarei minha resposta. )

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

Exemplo de execução:

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 bytes

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/ *$//'

Ele lê a entrada padrão e grava a saída padrão. Tente:

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

Como funciona:

• splitentrada em linhas únicas (arquivos no diretório temporário $D)
• divida linhas em caracteres únicos usando grep(arquivos * +)
• caracteres de layout lado a lado usando paste(colunas separadas por TAB)
• remova as guias de alinhamento, substitua as guias de preenchimento por BLANKs, apare usando sed

Editar:

• -9: Código de arrumação removido ;rm -r $D(obrigado Tim)
• -2: use em +vez de _como sufixo e reduza ${F}_para$F+
• -3: remove o prefixo Ldos arquivos de resultados divididos

Ruby - 144 caracteres

Aqui está minha primeira tentativa, jogando golfe:

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

Para saída, execute puts f textonde texthouver qualquer sequência de várias linhas aderindo às regras acima. A versão ungolfed está abaixo:

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

Para uma solução semelhante, mas finalmente melhor, em Ruby, confira o código de Wayne Conrad acima.

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

Não-golfe:

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

Esta é a minha primeira tentativa de golfe, por favor, seja gentil! Além disso, dicas / sugestões serão muito apreciadas!

MATHEMATICA 117 chars

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)

lê stdin e escreve para stdout. adicionando 1 à pontuação desay

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

CJam, 32 25 bytes

O CJam é mais recente que esse desafio, portanto, essa resposta não é elegível para ser aceita.

Consideravelmente reduzido pelo user23013.

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

Teste aqui.

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

Menos golfe

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

Teste

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>

Retina , 40 bytes

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

Experimente online!

Baseado neste programa que eu criei para transpor qualquer tamanho de retângulo, que usa a sugestão de Leo para transpor um retângulo de tamanho conhecido.

Editar: Jogou mais golfe e não tem mais espaços nas linhas.

Perl 5 , 25 bytes

Observe que isso usa seqüências de escape ANSI e, como tal, não funciona no TIO, você pode vê-lo em ação aqui .

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

Explicação

Esse código primeiro altera o valor do separador de lista ( $") para uma guia vertical, seguido pela sequência de escape ANSI para 'voltar 1 coluna' ( \x1b[1D), depois definimos a variável impressa implicitamente $_como uma sequência que começa com a sequência de escape ANSI para 'iniciar a impressão na coluna da linha 1 $.(onde $.está a linha de texto atual)' ( \x1b1;$.H) e interpola a lista @F(que é uma lista de todos os caracteres nessa linha, preenchida por divisão automática ( -a) com um padrão de divisão vazio ( -F)) que coloca o conteúdo $"entre cada item, movendo o cursor verticalmente para baixo em vez de continuar a saída após o caractere anterior.

Experimente online!

C ++ (243 caracteres)

Aqui está uma função que pega e retorna uma string.

Eu poderia ter barbeado uma dúzia de caracteres, mas decidi mantê-lo como um código não estúpido (corre rápido, lê bem). Talvez eu só tenha decidido fazer isso porque este é o meu primeiro código de golfe ... Ainda não sou suficientemente hardcore :)

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

Com formatação:

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 caracteres :

oneliner:

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

e em uma impressão mais limpa:

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

em 115 caracteres:

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

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

Esta é uma primeira tentativa; Eu suspeito que pode ser melhorado. A maior parte do código é para atender aos requisitos de remoção de preenchimento e espaço à direita - sem eles, n%zip n*seria suficiente.

Ps. A seguinte versão de 46 caracteres fará o trabalho para a entrada de amostra fornecida, mas falhará se qualquer coluna de entrada consistir inteiramente em espaços:

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

Presumo que isso seja suficiente para desqualificá-lo, mesmo que o desafio não o diga explicitamente.

Esquema / raquete 113

O texto:

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

Sem novas linhas e espaços em branco extras:

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

A versão amigável

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

Haskell

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

Era tão curto, eu precisava adicionar espaço em branco ...

Python 89 103 caracteres

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

Eu me sinto sujo. 90 104 caracteres para a versão de força industrial. : ^)

Mathematica, 95 caracteres

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

K, 56

Isso deve atender às especificações agora.

Aceita uma string, retorna uma string.

{`/:{$[" "=*|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 caracteres

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

conectados

ungolfed:

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

Pitão , 11 bytes

# aYcw1;.tY

Experimente online!

Recebe a entrada como uma string, gera uma lista de listas

Pitão , 25 bytes

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

Pega a entrada como uma sequência, gera uma sequência.

Experimente online!

J, 28 26 bytes

Economizou 2 bytes graças a frownyfrog

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

Pega uma string, retorna uma string. Não tenho certeza se existe uma versão mais curta do verbo da função 'cutopen' que eu poderia usar.

Há também o menor

t=.|:@:>@cutLF

Mas não tenho certeza se ele se enquadra nas diretrizes do OP, pois retorna uma matriz de caracteres.

Como funciona:

                     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

A outra versão funciona da mesma maneira, mas não converte a matriz transposta em uma sequência formatada corretamente.

Exemplos:

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 bytes

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

Experimente online!

Eu vi outra solução Lua aqui, mas não acho que haja um problema ao postar 2 soluções no mesmo idioma. Se houver, me diga :)