BEARBEITEN Ich habe den Wortlaut der Regeln geändert, um einige Dinge, die implizit waren, deutlicher zu machen. Ich habe auch einige Akzente gesetzt, um einige offensichtliche Unklarheiten zu beseitigen, und die Option, ein eigenständiges Programm anstelle einer Funktion zu erstellen, explizit definiert.

Das Ziel hier ist es, eine Funktion zu erstellen, die eine Textdatei (oder einen String) aufnimmt und so transponiert, dass Zeilen zu Spalten werden und umgekehrt.

Beispiel:

Ich bin ein text
Transponiere mich.
Kannst du es machen?

Ergebnisse in:

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

Die Regeln:

• Sie dürfen davon ausgehen, dass nur Leerzeichen verwendet werden " "und "\n"in keiner Zeile ein Leerzeichen nachgestellt ist.
• Sie können davon ausgehen, dass die Datei ASCII ist. Welchen Endzeilenmarker Sie verwenden möchten, liegt bei Ihnen (CRLF oder LF). Es muss im Beispiel korrekt funktionieren, aber es sollte auch bei jeder Eingabe funktionieren , die die obigen Annahmen erfüllt.
• Möglicherweise müssen Sie Leerzeichen (wie im Beispiel) einfügen, wenn keine vorhanden sind, damit die Spalten in einer Linie bleiben.
• Ihr Ergebnis darf in keiner Zeile ein nachgestelltes Leerzeichen enthalten .
• Das letzte Zeilenumbruchzeichen (für die letzte Zeile) ist optional.
• Es sollte entweder eine Funktion oder ein vollständiges Programm sein. Wenn Ihre Funktion eine Zeichenfolge akzeptiert, sollte sie die Ergebnisse als Zeichenfolge zurückgeben. Wenn ein Dateiname akzeptiert wird, geben Sie den Namen der Datei zurück, in der Sie das Ergebnis gespeichert haben. Sie dürfen außerdem ein vollständiges Programm schreiben , das Eingaben von STDIN akzeptiert und das richtige Ergebnis an STDOUT ausgibt. wenn Sie dies tun, müssen Sie nicht ausgegeben , etwas zu STDERR.
• Das kürzeste Verfahren gewinnt, aber ich stimme jeder Antwort zu, die ich mag.

Basierend auf den Regeln ist die Ausgabe im Beispiel entweder 53 oder 52 Byte lang (für LF-Zeilenumbrüche), je nachdem, ob der letzte Zeilenumbruch enthalten ist oder nicht.

Hinweis: Dies ist keine spezielle Anforderung, aber wenn Ihre Funktion beim zweimaligen Ausführen nacheinander nicht mit der ursprünglichen Funktion identisch ist (die letzte Zeile kann abweichen und alle leeren Zeilen am Ende der Datei werden gelöscht), sind Sie es wahrscheinlich gegen eine der Regeln verstoßen.

Japt , 6 Bytes

y mx1R

Probieren Sie
es zweimal aus - gibt die ursprüngliche Zeichenfolge zurück

Erläuterung

y

Transponieren Sie die Eingabe

m  R

Karte über jede Linie

x1

Nach rechts schneiden

J ( 31 40)

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

Dies ist eine Funktion , die einen String annimmt, und gibt eine Zeichenfolge (dh ein Zeichenvektor mit Zeilenvorschübe an den richtigen Stellen eingesetzt ist , und nicht eine Matrix.)

Bearbeiten: Kein abschließendes Leerzeichen in einer Zeile.

Prüfung:

   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
  ?

Rubin 111

Golf gespielt:

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

Ruby verfügt über eine Array-Transponierungsfunktion. Auf diese Weise werden die Zeilen einfach aufgefüllt, in ein Array von Zeichen umgewandelt, die Array-Transponierungsfunktion von Ruby verwendet und das Array von Zeichen wieder in Zeilen umgewandelt.

Beim Golfen wurden lediglich Einzelzeichen-IDs verwendet, Leerzeichen entfernt, eine temporäre Zeile für text.lines verwendet und die Berechnung für max_length inline gestellt (es gibt keine Punkte für die Effizienz).

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

Anwendungsbeispiel:

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
  ?

Das nachfolgende Leerzeichen wird entfernt.

Python 2.7 ( 97 79 94 90)

BEARBEITEN: Verpasste die Funktionsanforderung;

Ich bin mir ziemlich sicher, dass dies verbessert wird, da ich hier ein Anfänger bin, aber zunächst einmal;

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

Der Code verwendet eine einfache split, um die Zeichenfolge in einen Vektor von Zeilen aufzuteilen. Anschließend wird mapmit einem Funktionswert wie None(der Einheitsfunktion) und dem Splat-Operator der Vektor transponiert und aufgefüllt (ähnliche Funktionalität wie zip_longestin Python3).

Der Rest des Codes ist nur Nonedem Leerzeichen zugeordnet, schneidet die Matrix ab und setzt sie wieder zu einer einzelnen Zeichenfolge zusammen.

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

foldund pasteerledige die wichtige Arbeit. Der Rest ist nur die Formatierung.

Akzeptiert Eingaben von stdin und Ausgaben von 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)

Bearbeiten: Dies verstößt gegen die Regeln, da ein Dateiname als Argument verwendet wird, aber in stdout geschrieben wird. Ich bearbeite es später, um in eine Datei zu schreiben und dann den Dateinamen auf stdout zu drucken.

Dies ist mein erster Code Golf überhaupt, also erbarme dich. Irgendein schlichtes altes C. Gib die Eingabe ein test.txtund lass sie laufen!

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

Durch die Verwendung kurzer Variablennamen, das Entfernen unbegründeter Formatierungen, das Zulassen von Leckstellen bei Dateihandles und das Deaktivieren aller Warnungen wird dies auf 278 Byte reduziert. (Da implizite Importe verwendet werden, ist die Verknüpfung möglicherweise nicht auf allen Systemen ordnungsgemäß. Funktioniert auf meinem Computer!)

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

Prüfung

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

Ruby: 88 Zeichen

(Wird veröffentlicht, weil es kürzer ist als die anderen Ruby-Lösungen. Wird nicht überprüft, ob mein Code im Vergleich zu diesen neue Funktionen bietet. Wenn Sie bereits eine Ruby-Lösung veröffentlicht haben und der Meinung sind, dass dies hauptsächlich eine Kopie von Ihnen ist, kommentieren Sie dies bitte und ich werde meine Antwort zurückziehen. )

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

Probelauf:

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

Es liest die Standardeingabe und schreibt die Standardausgabe. Versuch es:

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

Wie es funktioniert:

• split Eingabe in einzelne Zeilen (Dateien im temporären Verzeichnis $D )
• Zeilen in einzelne Zeichen aufteilen mit grep (Dateien * +)
• Layout-Zeichen nebeneinander mit paste (durch Tabulatoren getrennten Spalten)
• Ausrichtungs-TABs entfernen, Füll-TABs durch BLANKs ersetzen und mit zuschneiden sed

Bearbeiten:

• -9: Aufräumcode entfernt ;rm -r $D (danke Tim)
• -2: +statt _als Suffix verwenden und kürzen${F}_ zu$F+
• -3: Präfix Laus geteilten Ergebnisdateien entfernen

Ruby - 144 Zeichen

Hier ist mein erster Versuch, Golf zu spielen:

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

Führen Sie für die Ausgabe aus, puts f textwo textsich eine mehrzeilige Zeichenfolge befindet, die den obigen Regeln entspricht. Die ungolfed Version ist unten:

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

Eine ähnliche, aber letztendlich bessere Lösung in Ruby finden Sie im obigen Code von 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)));}

Nicht golfen:

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

Dies ist mein erster Golfversuch, seien Sie also bitte nett! Auch Tipps / Vorschläge wären sehr dankbar!

MATHEMATICA 117 Zeichen

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)

liest stdin und schreibt an stdout. Hinzufügen von 1 zur Punktzahl fürsay

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

CJam, 32 25 Bytes

CJam ist neuer als diese Herausforderung, daher kann diese Antwort nicht akzeptiert werden.

Deutlich verkürzt durch user23013.

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

Teste es hier.

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

Weniger golfen

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

Prüfung

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

Probieren Sie es online!

Basierend auf diesem Programm , das ich erstellt habe, um jede Größe von Rechtecken zu transponieren, die verwendet werden der Vorschlag von Leo verwendet wird zum Transponieren eines Rechtecks ​​bekannter Größe verwendet.

Bearbeiten: Mehr Golf gespielt und keine Leerzeichen mehr in den Zeilen.

Perl 5 , 25 Bytes

Beachten Sie, dass dies ANSI-Escape-Sequenzen verwendet und daher auf TIO nicht funktioniert. Sie können es jedoch hier in Aktion sehen .

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

Erläuterung

Dieser Code ändert zuerst den Wert von list separator ( $") in einen vertikalen Tabulator, gefolgt von der ANSI-Escape-Sequenz für '1 Spalte zurückgehen' ( \x1b[1D). Anschließend setzen wir die implizit gedruckte Variable $_auf eine Zeichenfolge, die mit der ANSI-Escape-Sequenz beginnt für 'Drucken in Zeile 1 Spalte beginnen $.(wo $.ist die aktuelle Textzeile)' ( \x1b1;$.H) und interpoliert die Liste @F(die eine Liste aller Zeichen in dieser Zeile ist, die mit Autosplit ( -a) mit einem leeren Aufteilungsmuster ( -F) gefüllt ist ) was setzt den Inhalt von$" zwischen die einzelnen Elemente eingefügt, wobei der Cursor vertikal nach unten bewegt wird, anstatt die Ausgabe nach dem vorherigen Zeichen fortzusetzen.

Probieren Sie es online!

C ++ (243 Zeichen)

Hier ist eine Funktion, die eine Zeichenfolge akzeptiert und zurückgibt.

Ich hätte ein paar Dutzend Zeichen rasieren können, aber ich habe beschlossen, es als nicht-dummen Code zu behalten (läuft schnell, liest sich in Ordnung). Vielleicht habe ich mich nur dafür entschieden, weil dies mein erster Code Golf ist ... ich bin noch nicht hardcore genug :)

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

Mit Formatierung:

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

Einzeiler:

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

und in einem saubereren Druck:

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

in 115 Zeichen:

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

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

Dies ist ein erster Versuch; Ich vermute, es kann verbessert werden. Der größte Teil des Codes besteht darin, die Anforderungen für die Entfernung von Auffüll- und Leerzeichen zu erfüllen - ohne sie n%zip n*würde es nur ausreichen.

Ps. Folgende 46- stellige Version erledigt die Aufgabe für die angegebene Beispieleingabe, stürzt jedoch ab, wenn eine Eingabespalte vollständig aus Leerzeichen besteht:

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

Ich gehe davon aus, dass dies ausreicht, um das Spiel zu disqualifizieren, auch wenn die Herausforderung dies nicht ausdrücklich angibt.

Schema / Schläger 113

Der Text:

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

Ohne neue Zeilen und zusätzliche Leerzeichen:

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

Die benutzerfreundliche Version

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

Es war so kurz, ich musste in Leerzeichen hinzufügen ...

Python 89 103 Zeichen

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

Ich fühle mich dreckig. 90 104 Zeichen für Industriestärkenversion. : ^)

Mathematica, 95 Zeichen

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

K, 56

Dies sollte die Spezifikation jetzt erfüllen.

Akzeptiert eine Zeichenfolge und gibt eine Zeichenfolge zurück.

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

Groovig, 98 Zeichen

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

online

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
}

Pyth , 11 Bytes

# aYcw1;.tY

Probieren Sie es online!

Nimmt Eingaben als Zeichenfolge und gibt eine Liste von Listen aus

Pyth , 25 Bytes

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

Nimmt Eingaben als Zeichenfolge und gibt eine Zeichenfolge aus.

Probieren Sie es online!

J 28 26 Bytes

2 Bytes dank frownyfrog gespeichert

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

Nimmt einen String, gibt einen String zurück. Ich bin nicht sicher , ob es eine kürzere Version der ‚cutopen‘ Funktion Verb , dass ich verwenden könnte.

Es gibt auch die kürzeren

t=.|:@:>@cutLF

Ich bin mir jedoch nicht sicher, ob es unter die Richtlinien des OP fällt, da es eine Reihe von Zeichen zurückgibt.

Wie es funktioniert:

                     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

Die andere Version funktioniert genauso, konvertiert das transponierte Array jedoch nicht in eine korrekt formatierte Zeichenfolge.

Beispiele:

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

Probieren Sie es online!

Ich habe hier eine andere Lua-Lösung gesehen, aber ich glaube nicht, dass es ein Problem gibt, zwei Lösungen in derselben Sprache zu veröffentlichen. Wenn ja, sag es mir :)