EDIT Ho modificato la formulazione delle regole per rendere più esplicite alcune cose implicite. Ho anche aggiunto un po 'di enfasi per chiarire alcuni punti di apparente confusione e ho definito esplicitamente l'opzione di creare un programma autonomo anziché una funzione.

L'obiettivo qui è creare una funzione che prende un file di testo (o stringa) e lo traspone in modo che le linee diventino colonne e viceversa.

Esempio:

Sono un sms
Trasponimi.
Puoi farlo?

Risultati in:

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

Le regole:

• Siete autorizzati a supporre che i solo spazi utilizzati sono " "e "\n"e che non ci sia spazio bianco in coda su qualsiasi linea.
• Si può presumere che il file sia ASCII. Quale marker di fine linea vuoi usare (CRLF o LF). Deve funzionare correttamente sull'esempio, ma dovrebbe anche funzionare su qualsiasi input che soddisfi i presupposti di cui sopra.
• Potrebbe essere necessario inserire spazi (come nell'esempio) dove non ce n'erano per mantenere le colonne in linea.
• Il risultato non deve avere spazi vuoti finali su nessuna riga .
• Il carattere finale di nuova riga (per l'ultima riga) è facoltativo.
• Dovrebbe essere una funzione o un programma completo. Se la tua funzione accetta una stringa, dovrebbe restituire i risultati come stringa. Se accetta un nome file, restituisci il nome del file in cui hai salvato il risultato. È inoltre possibile scrivere un programma completo che accetta input da STDIN e trasmette il risultato corretto a STDOUT; se si esegue questa operazione, è necessario non uscita nulla a STDERR.
• La procedura più breve vince, ma voterò ogni risposta che mi piace.

In base alle regole, l'output nell'esempio è lungo 53 o 52 byte (per le newline LF) a seconda che la newline finale sia inclusa o meno.

Nota: non è un requisito specifico, ma se la tua funzione, se eseguita due volte in successione, non è identica all'originale (la nuova riga finale potrebbe essere diversa e tutte le righe vuote alla fine del file verranno eliminate), allora sei probabilmente infrangere una delle regole.

Japt , 6 byte

y mx1R

Provalo
Eseguilo due volte : restituisce una stringa originale

Spiegazione

y

Trasporre l'ingresso

m  R

Mappa su ogni linea

x1

Taglia a destra

J ( 31 40)

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

Questa è una funzione che accetta una stringa e restituisce una stringa (ovvero un vettore di caratteri con avanzamenti di riga inseriti nei punti giusti e non una matrice).

Modifica: nessun spazio bianco finale su nessuna riga.

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

golfed:

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 ha una funzione di trasposizione di array, quindi questo semplicemente riempie le linee, le trasforma in una matrice di caratteri, usa la funzione di trasposizione di # di Array di Ruby, quindi trasforma nuovamente la matrice di caratteri in linee.

Giocare a golf consisteva semplicemente nell'utilizzare identificatori a carattere singolo, rimuovere gli spazi, usare un temporaneo per text.lines e mettere in linea il calcolo per max_length (non ci sono punti per l'efficienza).

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

Esempio di utilizzo:

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
  ?

Lo spazio bianco finale viene rimosso.

Python 2.7 ( 97 79 94 90)

EDIT: mancato il requisito di funzione;

Sono abbastanza sicuro che questo sarà migliorato dal momento che sono una specie di principiante qui, ma per cominciare;

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

Il codice utilizza un semplice splitper dividere la stringa in un vettore di righe. Quindi utilizza mapcon un valore di funzione come None(la funzione unity) e l'operatore splat per trasporre e zip_longestpadare il vettore (funzionalità simile a quella in Python3)

Il resto del codice si limita a mappare Nonenello spazio, ritaglia e riassembla nuovamente la matrice in una singola stringa.

>>> 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 pastefare il lavoro importante. Il resto è solo formattazione.

Accetta input da stdin e output in 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 byte)

Modifica: questo in realtà infrange le regole, poiché prende un nome file come argomento ma scrive su stdout. Lo modificherò più tardi per scrivere su un file e quindi stampare il nome file su stdout.

Questo è il mio primo codice golf di sempre, quindi abbi pietà. Alcuni semplici vecchi C. Inserire l'ingresso test.txte lasciarlo funzionare!

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

Utilizzando nomi di variabili brevi, rimuovendo la formattazione gratuita e consentendo la perdita di handle di file e disabilitando tutti gli avvisi, questo viene ridotto a 278 byte. (Dal momento che utilizza importazioni implicite, potrebbe non essere collegato correttamente su tutti i sistemi. Funziona sulla mia macchina!)

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

Tasto di scelta automatica 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)

Rubino: 88 caratteri

(Inserito perché è più corto delle altre soluzioni Ruby. Non ho verificato se il mio codice introduce qualcosa di nuovo rispetto a quelle. Se hai già pubblicato una soluzione Ruby e ritieni che questa sia principalmente una tua copia, per favore commenta e ritirerò la mia risposta. )

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

Esecuzione di esempio:

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 byte

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

Legge l'input standard e scrive l'output standard. Provalo:

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

Come funziona:

• split input in singole righe (file nella directory temporanea $D )
• dividere le linee in singoli caratteri usando grep (file * +)
• caratteri di layout affiancati utilizzando paste(colonne separate da TAB)
• rimuovere le schede di allineamento, sostituire le schede di riempimento con BLANK, tagliare usando sed

Modificare:

• -9: codice di riordino rimosso ;rm -r $D(grazie Tim)
• -2: utilizzare +invece di _come suffisso e abbreviare ${F}_a$F+
• -3: rimuove il prefisso Ldai file dei risultati divisi

Rubino - 144 caratteri

Ecco il mio primo tentativo, golfato:

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

Per l'output, eseguire puts f textdove textè presente una stringa su più righe che aderisce alle regole precedenti. La versione non golfata è di seguito:

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

Per una soluzione simile, ma in definitiva migliore in Ruby, controlla il codice di Wayne Conrad sopra.

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

Non-giocato a golf:

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

Questo è il mio primo tentativo di golf, quindi per favore sii gentile! Inoltre, suggerimenti / suggerimenti sarebbero molto apprezzati!

MATHEMATICA 117 caratteri

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)

legge stdin e scrive su stdout. aggiungendo 1 al punteggio persay

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

CJam, 32 25 byte

CJam è più recente di questa sfida, quindi questa risposta non può essere accettata.

Abbreviato considerevolmente dall'utente23013.

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

Provalo qui.

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

Meno golf

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>

Retina , 40 byte

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

Provalo online!

Sulla base di questo programma che ho creato per trasporre qualsiasi dimensione del rettangolo, che utilizza il suggerimento di Leo per trasporre un rettangolo di dimensioni note.

Modifica: golfato di più e non ha più spazi finali sulle linee.

Perl 5 , 25 byte

Si noti che questo utilizza sequenze di escape ANSI e come tali non funziona su TIO, tuttavia è possibile vederlo in azione qui .

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

Spiegazione

Questo codice cambia prima il valore del separatore di elenco ( $") in una scheda verticale, seguita dalla sequenza di escape ANSI per 'vai indietro di 1 colonna' ( \x1b[1D), quindi impostiamo la variabile implicitamente stampata $_come una stringa che inizia con la sequenza di escape ANSI per 'inizia a stampare alla colonna della riga 1 $.(dove si $.trova la riga di testo corrente)' ( \x1b1;$.H) e interpola l'elenco @F(che è un elenco di tutti i caratteri su quella riga, popolato da autosplit ( -a) con uno schema di divisione vuoto ( -F)) che colloca il contenuto di$" tra ogni elemento, spostando il cursore verticalmente verso il basso invece di continuare l'output dopo il carattere precedente.

Provalo online!

C ++ (243 caratteri)

Ecco una funzione che accetta e restituisce una stringa.

Avrei potuto radere un paio di dozzine di caratteri, ma ho deciso di tenerlo come codice non stupido (corre veloce, legge bene). Forse ho deciso di farlo solo perché questo è il mio primo codice golf ... Non sono ancora abbastanza 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;}

Con formattazione:

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

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 in una stampa più pulita:

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

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

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

Questo è un primo tentativo; Sospetto che possa essere migliorato. La maggior parte del codice è conforme ai requisiti di rimozione dello spazio di riempimento e di riempimento - senza di essi, n%zip n*sarebbe sufficiente.

Ps. La seguente versione a 46 caratteri farà il lavoro per l'input di esempio dato, ma andrà in crash se una colonna di input è interamente composta da spazi:

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

Presumo che sia abbastanza per squalificarlo, anche se la sfida non lo dice esplicitamente.

Schema / Racchetta 113

Il testo:

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

Senza nuove linee e spazi bianchi extra:

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

La versione intuitiva

(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 così corto che dovevo aggiungere nello spazio bianco ...

Python 89 103 caratteri

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

Mi sento sporco. 90 104 caratteri per la versione di resistenza industriale. : ^)

Mathematica, 95 caratteri

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

K, 56

Questo dovrebbe soddisfare le specifiche ora.

Accetta una stringa, restituisce una stringa.

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

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

in linea

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 byte

# aYcw1;.tY

Provalo online!

Accetta input come stringa, genera un elenco di elenchi

Pyth , 25 byte

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

Accetta input come stringa, genera una stringa.

Provalo online!

J, 28 26 byte

Salvato 2 byte grazie a frownyfrog

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

Prende una stringa, restituisce una stringa. Non sono sicuro che esista una versione più breve del verbo della funzione "cutopen" .

C'è anche il più corto

t=.|:@:>@cutLF

Ma non sono sicuro che rientri nelle linee guida dell'OP, in quanto restituisce una serie di personaggi.

Come funziona:

                     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

L'altra versione funziona allo stesso modo, ma non converte l'array trasposto in una stringa formattata correttamente.

Esempi:

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 byte

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

Provalo online!

Ho visto un'altra soluzione Lua qui, ma non credo che ci sia un problema con la pubblicazione di 2 soluzioni nella stessa lingua. Se c'è, dimmi :)