EDYCJA Zmodyfikowałem sformułowanie zasad, aby niektóre rzeczy, które były ukryte, były bardziej wyraźne. Położyłem też nacisk na wyjaśnienie niektórych punktów pozornego zamieszania i wyraźnie zdefiniowałem opcję tworzenia samodzielnego programu zamiast funkcji.

Celem jest tutaj utworzenie funkcji, która pobierze plik tekstowy (lub ciąg znaków) i przetransponuje go, tak aby linie stały się kolumnami i odwrotnie.

Przykład:

Jestem SMS-em
Transponuj mnie.
Możesz to zrobić?

Prowadzi do:

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

Zasady:

• Masz prawo przypuszczać, że tylko białych znaków stosowane są " "i "\n"i że nie ma końcowe białe znaki na każdej linii.
• Możesz założyć, że plik to ASCII. Który znacznik linii końcowej, którego chcesz użyć, zależy od Ciebie (CRLF lub LF). Musi działać poprawnie na przykładzie, ale powinien również działać na każdym wejściu, który spełnia powyższe założenia.
• Być może będziesz musiał wstawić spacje (jak w przykładzie) tam, gdzie ich nie było, aby utrzymać kolumny w linii.
• Twój wynik nie może zawierać końcowych białych znaków w żadnej linii .
• Ostatni znak nowej linii (dla ostatniego wiersza) jest opcjonalny.
• Powinna to być funkcja lub pełny program. Jeśli twoja funkcja akceptuje ciąg, powinien zwrócić wyniki jako ciąg. Jeśli akceptuje nazwę pliku, zwracana jest nazwa pliku, w którym zapisano wynik. Dodatkowo możesz napisać pełny program, który akceptuje dane wejściowe ze STDIN i wypisuje poprawny wynik do STDOUT; jeśli to zrobisz, musisz nie wyjście coś na stderr.
• Najkrótsza procedura wygrywa, ale będę głosować za każdą odpowiedzią, którą lubię.

W oparciu o reguły dane wyjściowe w tym przykładzie mają długość 53 lub 52 bajty (dla nowych linii LF) w zależności od tego, czy dołączony jest końcowy nowy wiersz, czy nie.

Uwaga: Nie jest to szczególne wymaganie, ale jeśli twoja funkcja, gdy uruchomisz ją dwa razy z rzędu, nie jest identyczna z oryginalną (końcowa nowa linia może być inna, a puste linie na końcu pliku zostaną usunięte), oznacza to, że prawdopodobnie złamanie jednej z zasad.

Japt , 6 bajtów

y mx1R

Spróbuj
Uruchom go dwa razy - zwraca oryginalny ciąg

Wyjaśnienie

y

Transponuj dane wejściowe

m  R

Mapa nad każdą linią

x1

Przytnij w prawo

J ( 31 40)

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

Jest to funkcja, która pobiera ciąg znaków i zwraca ciąg znaków (tj. Wektor znakowy z liniami wstawionymi w odpowiednich miejscach, a nie macierz).

Edycja: brak spacji końcowych w żadnej linii.

Test:

   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

Gra w golfa:

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

Nie golfowany:

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 ma funkcję transpozycji tablicy, więc po prostu uzupełnia linie, zamienia je w tablicę znaków, używa funkcji transpozycji tablicy Ruby, a następnie zamienia tablicę znaków z powrotem w linie.

Gra w golfa polegała po prostu na użyciu jednoznakowych identyfikatorów, usuwaniu spacji, używaniu tymczasowego dla text.lines i wstawianiu obliczeń dla max_length inline (nie ma punktów za wydajność).

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

Przykład użycia:

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
  ?

Końcowe białe znaki są usuwane.

Python 2.7 ( 97 79 94 90)

EDYCJA: pominięto wymaganie funkcji;

Jestem całkiem pewien, że to się poprawi, ponieważ jestem tu trochę początkującym, ale na początek;

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

Kod wykorzystuje prosty splitdo podzielenia łańcucha na wektor wierszy. Następnie używa mapz wartością funkcji as None(funkcja jedności) i operatorem splat do transponowania i zip_longestwypełnienia wektora (podobna funkcjonalność jak w Python3)

Reszta kodu po prostu odwzorowuje Noneprzestrzeń, przycina i ponownie składa matrycę w pojedynczy ciąg znaków.

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

foldi pastewykonuj ważną pracę. Reszta to tylko formatowanie.

Akceptuje dane wejściowe ze standardowego wejścia i wyjścia na standardowe wyjście:

$ < 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 bajtów)

Edycja: To faktycznie łamie reguły, ponieważ bierze nazwę pliku jako argument, ale zapisuje na standardowe wyjście. Przeredaguję go później, aby zapisać do pliku, a następnie wydrukuję nazwę pliku na standardowe wyjście.

To jest mój pierwszy golf w historii, więc zmiłuj się. Niektóre zwykłe stare C. Umieść dane wejściowe test.txti pozwól, aby się uruchomiły!

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

Używając krótkich nazw zmiennych, usuwając nieuzasadnione formatowanie i pozwalając na wyciekanie uchwytów plików oraz wyłączając wszystkie ostrzeżenia, zmniejsza się to do 278 bajtów. (Ponieważ używa to niejawnego importu, może nie działać poprawnie na wszystkich systemach. Działa na moim komputerze!)

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

Test

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

Ruby: 88 znaków

(Wysłano, ponieważ jest krótsze niż inne rozwiązania Ruby. Nie sprawdziłem, czy mój kod wprowadza coś nowego w porównaniu do tych. Jeśli już opublikowałeś rozwiązanie Ruby i uważasz, że jest to w większości Twoja kopia, proszę o komentarz, a ja wycofam swoją odpowiedź. )

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

Przykładowy przebieg:

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 bajty

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

Odczytuje standardowe wejście i zapisuje standardowe wyjście. Spróbuj:

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

Jak to działa:

• splitwejście do pojedynczych wierszy (pliki w katalogu tymczasowym $D)
• dziel linie na pojedyncze znaki za pomocą grep(pliki * +)
• układ znaków obok siebie za pomocą paste(kolumny rozdzielone tabulatorami)
• usunąć tabulatory wyrównania, zastąpić tabulatory wypełniacza PUSTYMI, przyciąć za pomocą sed

Edytować:

• -9: Usunięto kod porządkowy ;rm -r $D(dzięki Tim)
• -2: użyj +zamiast _sufiksu i skróć ${F}_do$F+
• -3: usuń prefiks Lz podzielonych plików wyników

Rubin - 144 znaków

Oto moja pierwsza próba gry w golfa:

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

Aby uzyskać wynik, uruchom puts f textgdzie textjest dowolny ciąg wielu wierszy zgodny z powyższymi regułami. Wersja bez golfa znajduje się poniżej:

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

Aby znaleźć podobne, ale ostatecznie lepsze rozwiązanie w Ruby, sprawdź powyższy kod Wayne'a Conrada.

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

Nie golfa:

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

To moja pierwsza gra w golfa, więc proszę bądź miły! Również wskazówki / sugestie będą mile widziane!

MATHEMATICA 117 znaków

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)

czyta standardowe wejście i pisze na standardowe wyjście. dodanie 1 do wyniku dlasay

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

CJam, 32 25 bajtów

CJam jest nowszy niż to wyzwanie, więc ta odpowiedź nie kwalifikuje się do zaakceptowania.

Znacząco skrócony przez user23013.

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

Sprawdź to tutaj.

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

Mniej golfa

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

Test

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>

Siatkówka , 40 bajtów

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

Wypróbuj online!

Na podstawie tego programu, który stworzyłem do transponowania dowolnego rozmiaru prostokąta, który wykorzystuje sugestię Leo do transponowania prostokąta o znanym rozmiarze.

Edycja: więcej gra w golfa i nie ma już spacji na liniach.

Perl 5 , 25 bajtów

Zauważ, że wykorzystuje to sekwencje specjalne ANSI i jako takie nie działa na TIO, możesz jednak zobaczyć to tutaj .

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

Wyjaśnienie

Ten kod najpierw zmienia wartość separatora listy ( $") na tabulator pionowy, a następnie sekwencję zmiany znaczenia ANSI dla „cofnij się o 1 kolumnę” ( \x1b[1D), a następnie ustawiamy domyślnie drukowaną zmienną $_na ciąg znaków rozpoczynający się sekwencją zmiany znaczenia ANSI dla „rozpocznij drukowanie w kolumnie 1 wiersza $.(gdzie $.jest bieżący wiersz tekstu)” ( \x1b1;$.H) i interpoluje listę @F(która jest listą wszystkich znaków w tym wierszu, wypełnioną przez autosplit ( -a) z pustym wzorem podziału ( -F)) który umieszcza zawartość $"pomiędzy poszczególnymi elementami, przesuwając kursor pionowo w dół zamiast kontynuować wyświetlanie po poprzednim znaku.

Wypróbuj online!

C ++ (243 znaki)

Oto funkcja, która pobiera i zwraca ciąg znaków.

Mógłbym ogolić kilkadziesiąt znaków, ale postanowiłem zachować go jako niezbyt głupi kod (działa szybko, czyta się dobrze). Może postanowiłem to zrobić, ponieważ to mój pierwszy golf w golfa ... Nie jestem jeszcze wystarczająco hardkorowy :)

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

Z formatowaniem:

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 znaków :

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'

i w czystszym druku:

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

w 115 znakach:

>>> 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 znaków

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

To jest pierwsza próba; Podejrzewam, że można to poprawić. Większość kodu ma być zgodna z wymogami wypełniania i usuwania spacji końcowych - bez nich n%zip n*wystarczyłoby.

Ps. Następująca 46- znakowa wersja wykona zadanie dla danych wejściowych próbki, ale zawiesi się, jeśli dowolna kolumna wejściowa składa się całkowicie ze spacji:

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

Zakładam, że to wystarczy, aby go zdyskwalifikować, nawet jeśli wyzwanie nie mówi wprost.

Schemat / Rakieta 113

Tekst:

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

Bez nowych linii i dodatkowych białych znaków:

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

Wersja przyjazna dla użytkownika

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

Było tak krótko, że musiałem dodać białe znaki ...

Python 89 103 znaków

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

Czuję się brudny 90 104 znaków dla wersji o wytrzymałości przemysłowej. : ^)

Mathematica, 95 znaków

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

K, 56

To powinno teraz spełniać specyfikację.

Akceptuje ciąg, zwraca ciąg.

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

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

online

bez golfa:

{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 bajtów

# aYcw1;.tY

Wypróbuj online!

Pobiera dane wejściowe jako ciąg znaków, wyświetla listę list

Pyth , 25 bajtów

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

Pobiera dane wejściowe jako ciąg, generuje ciąg.

Wypróbuj online!

J, 28 26 bajtów

Oszczędność 2 bajtów dzięki frownyfrog

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

Bierze ciąg, zwraca ciąg. Nie jestem pewien, czy istnieje krótsza wersja czasownika funkcyjnego „cutopen” , której mogłabym użyć.

Jest też krótszy

t=.|:@:>@cutLF

Ale nie jestem pewien, czy spełnia on wytyczne PO, ponieważ zwraca tablicę znaków.

Jak to działa:

                     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

Druga wersja działa tak samo, ale nie konwertuje transponowanej tablicy na poprawnie sformatowany ciąg.

Przykłady:

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 bajtów

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

Wypróbuj online!

Widziałem tutaj inne rozwiązanie Lua, ale nie sądzę, że jest problem z opublikowaniem 2 rozwiązań w tym samym języku. Jeśli tak, powiedz mi :)