EDITAR Modifiqué la redacción de las reglas para hacer que algunas cosas implícitas fueran más explícitas. También agregué énfasis para aclarar algunos puntos de aparente confusión, y definí explícitamente la opción de hacer un programa independiente en lugar de una función.

El objetivo aquí es hacer una función que tome un archivo de texto (o cadena) y lo transponga para que las líneas se conviertan en columnas y viceversa.

Ejemplo:

Soy un texto
Transpórtame
¿Puedes hacerlo?

Resultados en:

ITC
 real academia de bellas artes
aan
Minnesota
 sy
apo
 UNED
ts
eed
xo
tm
.ei
 .t
  ?

Las normas:

• Se le permite asumir que los únicos espacios en blanco son utilizados " "y "\n"y que no hay espacios en blanco finales en cualquier línea.
• Puede suponer que el archivo es ASCII. El marcador de línea final que desea utilizar depende de usted (CRLF o LF). Debe funcionar correctamente en el ejemplo, pero también debe funcionar en cualquier entrada que satisfaga los supuestos anteriores.
• Puede que tenga que insertar espacios (como en el ejemplo) donde no había ninguno para mantener las columnas en línea.
• Su resultado no debe tener espacios en blanco al final de ninguna línea .
• El carácter de nueva línea final (para la última línea) es opcional.
• Debe ser una función o un programa completo. Si su función acepta una cadena, debería devolver los resultados como una cadena. Si acepta un nombre de archivo, devuelve el nombre del archivo donde guardó el resultado. Además, puede escribir un programa completo que acepte la entrada de STDIN y envíe el resultado correcto a STDOUT; si lo hace, debe no producir una salida a stderr.
• El procedimiento más corto gana, pero votaré cualquier respuesta que me guste.

Según las reglas, la salida en el ejemplo tiene 53 o 52 bytes de longitud (para las nuevas líneas LF) dependiendo de si la nueva línea final está incluida o no.

Nota: No es un requisito específico, pero si su función, cuando se ejecuta dos veces sucesivamente, no es idéntica a la original (la nueva línea final puede ser diferente y se eliminarán las líneas vacías al final del archivo) probablemente rompiendo una de las reglas.

Japt , 6 bytes

y mx1R

Pruébelo
Ejecútelo dos veces : devuelve la cadena original

Explicación

y

Transponer la entrada

m  R

Mapa sobre cada línea

x1

Recortar a la derecha

J ( 31 40)

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

Esta es una función que toma una cadena y devuelve una cadena (es decir, un vector de caracteres con saltos de línea insertados en los lugares correctos, y no una matriz).

Editar: sin espacios en blanco finales en ninguna línea.

Prueba:

   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

Golfizado:

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

Sin golf:

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 tiene una función de transposición de matriz, por lo que esto simplemente rellena las líneas, las convierte en una matriz de caracteres, usa la función de transposición Ruby Array #, luego convierte la matriz de caracteres nuevamente en líneas.

Jugar al golf fue simplemente usar identificadores de un solo carácter, eliminar espacios, usar un temporario para text.lines y poner el cálculo para max_length en línea (no hay puntos para la eficiencia).

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

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

Se elimina el espacio en blanco al final.

Python 2.7 ( 97 79 94 90)

EDITAR: se perdió el requisito de función;

Estoy bastante seguro de que esto mejorará ya que soy una especie de principiante aquí, pero para empezar;

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

El código utiliza un simple splitpara dividir la cadena en un vector de filas. Luego se usa mapcon un valor de función comoNone (la función de unidad) y el operador splat para transponer y rellenar el vector (funcionalidad similar a zip_longestPython3)

El resto del código solo se asigna Noneal espacio, recorta y vuelve a ensamblar la matriz en una sola cadena.

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

foldy pastehacer el trabajo importante. El resto es solo formatear.

Acepta entradas de stdin y salidas a 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: esto realmente rompe las reglas, ya que toma un nombre de archivo como argumento pero escribe en stdout. Lo editaré más tarde para escribir en un archivo y luego imprimiré el nombre del archivo en stdout.

Este es mi primer código de golf, así que ten piedad. Algunos viejos y simples C. ¡Coloca la entrada test.txty déjala correr!

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

Mediante el uso de nombres de variables cortos, eliminando el formato gratuito y permitiendo que se filtren los identificadores de archivos, y deshabilitando todas las advertencias, esto se reduce a 278 bytes. (Dado que esto utiliza importaciones implícitas, es posible que no se vincule correctamente en todos los sistemas. ¡Funciona en mi 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
}

Prueba

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

Ruby: 88 caracteres

(Publicado porque es más corto que las otras soluciones de Ruby. No se verificó si mi código introduce algo nuevo en comparación con esos. Si ya publicó una solución de Ruby y siente que es principalmente una copia suya, por favor comente y retiraré mi respuesta. )

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

Ejecución de muestra:

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

Lee la entrada estándar y escribe la salida estándar. Intentalo:

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

Cómo funciona:

• split entrada en líneas individuales (archivos en directorio temporal $D )
• dividir líneas en caracteres individuales usando grep (archivos * +)
• caracteres de diseño lado a lado usando paste (columnas separadas por TAB)
• quite las TAB de alineación, reemplace las TAB de relleno con EN BLANCO, recorte usando sed

Editar:

• -9: Se eliminó el código de ordenación ;rm -r $D (gracias Tim)
• -2: uso + lugar de _como sufijo y acortar${F}_ a$F+
• -3: eliminar el prefijo Lde los archivos de resultados divididos

Ruby - 144 caracteres

Aquí está mi primer intento, golfizado:

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 la salida, ejecute puts f textdonde textestá cualquier cadena de varias líneas que cumpla con las reglas anteriores. La versión sin golf es la siguiente:

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 obtener una solución similar, pero en última instancia mejor en Ruby, consulte el código de Wayne Conrad anterior.

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

No golfizado:

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

Este es mi primer intento de golf, ¡así que por favor sea amable! Además, los consejos / sugerencias serán muy apreciados.

MATHEMATICA 117 caracteres

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)

lee stdin y escribe en stdout. sumando 1 al puntaje porsay

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

CJam, 32 25 bytes

CJam es más nuevo que este desafío, por lo que esta respuesta no es elegible para ser aceptada.

Reducido considerablemente por el usuario 23013.

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

Pruébalo aquí.

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

Prueba

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

Pruébalo en línea!

Basado en este programa que creé para transponer cualquier tamaño de rectángulo, que utiliza la sugerencia de Leo para transponer un rectángulo de un tamaño conocido.

Editar: Golf más y ya no tiene espacios finales en las líneas.

Perl 5 , 25 bytes

Tenga en cuenta que esto usa secuencias de escape ANSI y, como tal, no funciona en TIO, sin embargo, puede verlo en acción aquí .

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

Explicación

Este código primero cambia el valor del separador de lista ( $") para que sea una pestaña vertical, seguido de la secuencia de escape ANSI para 'ir hacia atrás 1 columna' ( \x1b[1D), luego configuramos la variable impresa implícitamente $_como una cadena que comienza con la secuencia de escape ANSI para 'comenzar a imprimir en la columna de la línea 1 $.(donde $.está la línea de texto actual)' ( \x1b1;$.H) e interpola la lista @F(que es una lista de todos los caracteres en esa línea, poblada por autosplit ( -a) con un patrón de división vacío ( -F)) que coloca el contenido de$" entre cada elemento, moviendo el cursor verticalmente hacia abajo en lugar de continuar la salida después del carácter anterior.

Pruébalo en línea!

C ++ (243 caracteres)

Aquí hay una función que toma y devuelve una cadena.

Podría haber afeitado un par de docenas de caracteres, pero decidí mantenerlo como código no estúpido (funciona rápido, se lee bien). Tal vez solo decidí hacer eso porque este es mi primer código de golf ... Todavía no soy lo suficientemente duro :)

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

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 :

un trazador de líneas:

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

y en una impresión más limpia:

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

en 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}%((;\+

Este es un primer intento; Sospecho que se puede mejorar. La mayor parte del código es para cumplir con los requisitos de eliminación de espacio libre y relleno; sin ellos, n%zip n*sería suficiente.

PD. La siguiente versión de 46 caracteres hará el trabajo para la entrada de muestra dada, pero se bloqueará si alguna columna de entrada consta completamente de espacios:

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

Supongo que es suficiente para descalificarlo, incluso si el desafío no lo dice explícitamente.

Esquema / Raqueta 113

El texto:

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

Sin nuevas líneas y espacios en blanco adicionales:

(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 versión fácil de usar.

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

Fue tan corto que necesitaba agregar espacios en blanco ...

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

Me siento sucio 90 104 caracteres para la versión industrial de la fuerza. : ^)

Mathematica, 95 caracteres

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

K, 56

Esto debería cumplir con las especificaciones ahora.

Acepta una cadena, devuelve una cadena.

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

en línea

sin golf:

{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

Pruébalo en línea!

Toma la entrada como una cadena, genera una lista de listas

Pyth , 25 bytes

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

Toma la entrada como una cadena, emite una cadena.

Pruébalo en línea!

J, 28 26 bytes

Guardado 2 bytes gracias a frownyfrog

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

Toma una cadena, devuelve una cadena. No estoy seguro de si podría usar una versión más corta del verbo de función 'cutopen' .

También está el más corto

t=.|:@:>@cutLF

Pero no estoy seguro de que esté dentro de las pautas del OP, ya que devuelve una serie de caracteres.

Cómo 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

La otra versión funciona igual, pero no convierte la matriz transpuesta en una cadena con el formato adecuado.

Ejemplos:

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

Pruébalo en línea!

Vi otra solución Lua aquí, pero no creo que haya un problema al publicar 2 soluciones en el mismo idioma. Si hay, dime :)