Una forma eficiente de transponer un archivo en Bash

Tengo un archivo enorme separado por tabulaciones formateado como este

X column1 column2 column3
row1 0 1 2
row2 3 4 5
row3 6 7 8
row4 9 10 11

Me gustaría transponerlo de una manera eficiente usando solo comandos bash (podría escribir una secuencia de comandos Perl de diez líneas aproximadamente para hacer eso, pero debería ser más lento de ejecutar que las funciones nativas de bash). Entonces la salida debería verse como

X row1 row2 row3 row4
column1 0 3 6 9
column2 1 4 7 10
column3 2 5 8 11

Pensé en una solución como esta

cols=`head -n 1 input | wc -w`
for (( i=1; i <= $cols; i++))
do cut -f $i input | tr $'\n' $'\t' | sed -e "s/\t$/\n/g" >> output
done

Pero es lento y no parece la solución más eficiente. He visto una solución para vi en esta publicación , pero sigue siendo demasiado lenta. ¿Alguna idea / sugerencia / idea brillante? :-)

awk '
{ 
    for (i=1; i<=NF; i++)  {
        a[NR,i] = $i
    }
}
NF>p { p = NF }
END {    
    for(j=1; j<=p; j++) {
        str=a[1,j]
        for(i=2; i<=NR; i++){
            str=str" "a[i,j];
        }
        print str
    }
}' file

salida

$ more file
0 1 2
3 4 5
6 7 8
9 10 11

$ ./shell.sh
0 3 6 9
1 4 7 10
2 5 8 11

Rendimiento frente a la solución Perl de Jonathan en un archivo de 10000 líneas

$ head -5 file
1 0 1 2
2 3 4 5
3 6 7 8
4 9 10 11
1 0 1 2

$  wc -l < file
10000

$ time perl test.pl file >/dev/null

real    0m0.480s
user    0m0.442s
sys     0m0.026s

$ time awk -f test.awk file >/dev/null

real    0m0.382s
user    0m0.367s
sys     0m0.011s

$ time perl test.pl file >/dev/null

real    0m0.481s
user    0m0.431s
sys     0m0.022s

$ time awk -f test.awk file >/dev/null

real    0m0.390s
user    0m0.370s
sys     0m0.010s

EDITAR por Ed Morton (@ ghostdog74 no dude en eliminarlo si no lo aprueba).

Quizás esta versión con algunos nombres de variables más explícitos ayude a responder algunas de las preguntas a continuación y, en general, aclare lo que está haciendo el script. También usa pestañas como separador que el OP había solicitado originalmente para manejar campos vacíos y, casualmente, embellece un poco la salida para este caso particular.

$ cat tst.awk
BEGIN { FS=OFS="\t" }
{
    for (rowNr=1;rowNr<=NF;rowNr++) {
        cell[rowNr,NR] = $rowNr
    }
    maxRows = (NF > maxRows ? NF : maxRows)
    maxCols = NR
}
END {
    for (rowNr=1;rowNr<=maxRows;rowNr++) {
        for (colNr=1;colNr<=maxCols;colNr++) {
            printf "%s%s", cell[rowNr,colNr], (colNr < maxCols ? OFS : ORS)
        }
    }
}

$ awk -f tst.awk file
X       row1    row2    row3    row4
column1 0       3       6       9
column2 1       4       7       10
column3 2       5       8       11

Las soluciones anteriores funcionarán en cualquier awk (excepto el awk antiguo y roto, por supuesto, hay YMMV).

Sin embargo, las soluciones anteriores leen todo el archivo en la memoria; si los archivos de entrada son demasiado grandes para eso, puede hacer esto:

$ cat tst.awk
BEGIN { FS=OFS="\t" }
{ printf "%s%s", (FNR>1 ? OFS : ""), $ARGIND }
ENDFILE {
    print ""
    if (ARGIND < NF) {
        ARGV[ARGC] = FILENAME
        ARGC++
    }
}
$ awk -f tst.awk file
X       row1    row2    row3    row4
column1 0       3       6       9
column2 1       4       7       10
column3 2       5       8       11

que casi no usa memoria pero lee el archivo de entrada una vez por número de campos en una línea, por lo que será mucho más lento que la versión que lee el archivo completo en la memoria. También asume que el número de campos es el mismo en cada línea y usa GNU awk para ENDFILEy, ARGINDpero cualquier awk puede hacer lo mismo con pruebas en FNR==1y END.

Otra opción es utilizar rs:

rs -c' ' -C' ' -T

-ccambia el separador de la columna de entrada, -Ccambia el separador de la columna de salida y -Ttranspone filas y columnas. No lo utilice en -tlugar de -T, porque utiliza un número de filas y columnas calculado automáticamente que no suele ser correcto. rs, que lleva el nombre de la función de remodelación en APL, viene con BSD y OS X, pero debería estar disponible en administradores de paquetes en otras plataformas.

Una segunda opción es usar Ruby:

ruby -e'puts readlines.map(&:split).transpose.map{|x|x*" "}'

Una tercera opción es utilizar jq:

jq -R .|jq -sr 'map(./" ")|transpose|map(join(" "))[]'

jq -R .imprime cada línea de entrada como un literal de cadena JSON, -s( --slurp) crea una matriz para las líneas de entrada después de analizar cada línea como JSON y -r( --raw-output) genera el contenido de cadenas en lugar de literales de cadena JSON. El /operador está sobrecargado para dividir cadenas.

Una solución de Python:

python -c "import sys; print('\n'.join(' '.join(c) for c in zip(*(l.split() for l in sys.stdin.readlines() if l.strip()))))" < input > output

Lo anterior se basa en lo siguiente:

import sys

for c in zip(*(l.split() for l in sys.stdin.readlines() if l.strip())):
    print(' '.join(c))

Este código asume que cada línea tiene el mismo número de columnas (no se realiza ningún relleno).

el proyecto de transposición en sourceforge es un programa en C similar a coreutil para exactamente eso.

gcc transpose.c -o transpose
./transpose -t input > output #works with stdin, too.

Pure BASH, sin proceso adicional. Un buen ejercicio:

declare -a array=( )                      # we build a 1-D-array

read -a line < "$1"                       # read the headline

COLS=${#line[@]}                          # save number of columns

index=0
while read -a line ; do
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))
    done
done < "$1"

for (( ROW = 0; ROW < COLS; ROW++ )); do
  for (( COUNTER = ROW; COUNTER < ${#array[@]}; COUNTER += COLS )); do
    printf "%s\t" ${array[$COUNTER]}
  done
  printf "\n" 
done

Eche un vistazo a GNU datamash que se puede usar como datamash transpose. Una versión futura también admitirá la tabulación cruzada (tablas dinámicas)

Aquí hay un script de Perl moderadamente sólido para hacer el trabajo. Hay muchas analogías estructurales con la awksolución de @ ghostdog74 .

#!/bin/perl -w
#
# SO 1729824

use strict;

my(%data);          # main storage
my($maxcol) = 0;
my($rownum) = 0;
while (<>)
{
    my(@row) = split /\s+/;
    my($colnum) = 0;
    foreach my $val (@row)
    {
        $data{$rownum}{$colnum++} = $val;
    }
    $rownum++;
    $maxcol = $colnum if $colnum > $maxcol;
}

my $maxrow = $rownum;
for (my $col = 0; $col < $maxcol; $col++)
{
    for (my $row = 0; $row < $maxrow; $row++)
    {
        printf "%s%s", ($row == 0) ? "" : "\t",
                defined $data{$row}{$col} ? $data{$row}{$col} : "";
    }
    print "\n";
}

Con el tamaño de los datos de la muestra, la diferencia de rendimiento entre perl y awk fue insignificante (1 milisegundo de un total de 7). Con un conjunto de datos más grande (matriz de 100x100, entradas de 6 a 8 caracteres cada una), perl superó ligeramente a awk: 0,026 s frente a 0,042 s. Es probable que ninguno de los dos sea un problema.

Tiempos representativos para Perl 5.10.1 (32 bits) vs awk (versión 20040207 cuando se le da '-V') vs gawk 3.1.7 (32 bits) en MacOS X 10.5.8 en un archivo que contiene 10,000 líneas con 5 columnas por línea:

Osiris JL: time gawk -f tr.awk xxx  > /dev/null

real    0m0.367s
user    0m0.279s
sys 0m0.085s
Osiris JL: time perl -f transpose.pl xxx > /dev/null

real    0m0.138s
user    0m0.128s
sys 0m0.008s
Osiris JL: time awk -f tr.awk xxx  > /dev/null

real    0m1.891s
user    0m0.924s
sys 0m0.961s
Osiris-2 JL: 

Tenga en cuenta que gawk es mucho más rápido que awk en esta máquina, pero aún más lento que perl. Claramente, su millaje variará.

Si lo ha scinstalado, puede hacer:

psc -r < inputfile | sc -W% - > outputfile

Hay una utilidad especialmente diseñada para esto,

Utilidad GNU datamash

apt install datamash  

datamash transpose < yourfile

Tomado de este sitio, https://www.gnu.org/software/datamash/ y http://www.thelinuxrain.com/articles/transposing-rows-and-columns-3-methods

Suponiendo que todas sus filas tienen el mismo número de campos, este programa awk resuelve el problema:

{for (f=1;f<=NF;f++) col[f] = col[f]":"$f} END {for (f=1;f<=NF;f++) print col[f]}

En palabras, a medida que recorre las filas, para cada campo fcrece un ':' - cadena separada que col[f]contiene los elementos de ese campo. Una vez que haya terminado con todas las filas, imprima cada una de esas cadenas en una línea separada. Luego puede sustituir ':' por el separador que desea (digamos, un espacio) canalizando la salida tr ':' ' '.

Ejemplo:

$ echo "1 2 3\n4 5 6"
1 2 3
4 5 6

$ echo "1 2 3\n4 5 6" | awk '{for (f=1;f<=NF;f++) col[f] = col[f]":"$f} END {for (f=1;f<=NF;f++) print col[f]}' | tr ':' ' '
 1 4
 2 5
 3 6

GNU datamash se adapta perfectamente a este problema con solo una línea de código y potencialmente arbitrariamente grande.

datamash -W transpose infile > outfile

Una solución hackish perl puede ser así. Es bueno porque no carga todo el archivo en la memoria, imprime archivos temporales intermedios y luego usa la maravillosa pasta

#!/usr/bin/perl
use warnings;
use strict;

my $counter;
open INPUT, "<$ARGV[0]" or die ("Unable to open input file!");
while (my $line = <INPUT>) {
    chomp $line;
    my @array = split ("\t",$line);
    open OUTPUT, ">temp$." or die ("unable to open output file!");
    print OUTPUT join ("\n",@array);
    close OUTPUT;
    $counter=$.;
}
close INPUT;

# paste files together
my $execute = "paste ";
foreach (1..$counter) {
    $execute.="temp$counter ";
}
$execute.="> $ARGV[1]";
system $execute;

La única mejora que puedo ver en su propio ejemplo es el uso de awk que reducirá la cantidad de procesos que se ejecutan y la cantidad de datos que se canalizan entre ellos:

/bin/rm output 2> /dev/null

cols=`head -n 1 input | wc -w` 
for (( i=1; i <= $cols; i++))
do
  awk '{printf ("%s%s", tab, $'$i'); tab="\t"} END {print ""}' input
done >> output

Normalmente uso este pequeño awkfragmento para este requisito:

  awk '{for (i=1; i<=NF; i++) a[i,NR]=$i
        max=(max<NF?NF:max)}
        END {for (i=1; i<=max; i++)
              {for (j=1; j<=NR; j++) 
                  printf "%s%s", a[i,j], (j==NR?RS:FS)
              }
        }' file

Esto simplemente carga todos los datos en una matriz bidimensional a[line,column]y luego los vuelve a imprimir como a[column,line], de modo que transpone la entrada dada.

Esto necesita realizar un seguimiento de la maxcantidad inmensa de columnas que tiene el archivo inicial, de modo que se use como el número de filas para imprimir.

Usé la solución de fgm (¡gracias fgm!), Pero necesitaba eliminar los caracteres de tabulación al final de cada fila, así que modifiqué el script así:

#!/bin/bash 
declare -a array=( )                      # we build a 1-D-array

read -a line < "$1"                       # read the headline

COLS=${#line[@]}                          # save number of columns

index=0
while read -a line; do
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))
    done
done < "$1"

for (( ROW = 0; ROW < COLS; ROW++ )); do
  for (( COUNTER = ROW; COUNTER < ${#array[@]}; COUNTER += COLS )); do
    printf "%s" ${array[$COUNTER]}
    if [ $COUNTER -lt $(( ${#array[@]} - $COLS )) ]
    then
        printf "\t"
    fi
  done
  printf "\n" 
done

Solo estaba buscando una transposición de bash similar pero con soporte para relleno. Aquí está el script que escribí basado en la solución de fgm, que parece funcionar. Si puede ser de ayuda ...

#!/bin/bash 
declare -a array=( )                      # we build a 1-D-array
declare -a ncols=( )                      # we build a 1-D-array containing number of elements of each row

SEPARATOR="\t";
PADDING="";
MAXROWS=0;
index=0
indexCol=0
while read -a line; do
    ncols[$indexCol]=${#line[@]};
((indexCol++))
if [ ${#line[@]} -gt ${MAXROWS} ]
    then
         MAXROWS=${#line[@]}
    fi    
    for (( COUNTER=0; COUNTER<${#line[@]}; COUNTER++ )); do
        array[$index]=${line[$COUNTER]}
        ((index++))

    done
done < "$1"

for (( ROW = 0; ROW < MAXROWS; ROW++ )); do
  COUNTER=$ROW;
  for (( indexCol=0; indexCol < ${#ncols[@]}; indexCol++ )); do
if [ $ROW -ge ${ncols[indexCol]} ]
    then
      printf $PADDING
    else
  printf "%s" ${array[$COUNTER]}
fi
if [ $((indexCol+1)) -lt ${#ncols[@]} ]
then
  printf $SEPARATOR
    fi
    COUNTER=$(( COUNTER + ncols[indexCol] ))
  done
  printf "\n" 
done

Estaba buscando una solución para transponer cualquier tipo de matriz (nxn o mxn) con cualquier tipo de datos (números o datos) y obtuve la siguiente solución:

Row2Trans=number1
Col2Trans=number2

for ((i=1; $i <= Line2Trans; i++));do
    for ((j=1; $j <=Col2Trans ; j++));do
        awk -v var1="$i" -v var2="$j" 'BEGIN { FS = "," }  ; NR==var1 {print $((var2)) }' $ARCHIVO >> Column_$i
    done
done

paste -d',' `ls -mv Column_* | sed 's/,//g'` >> $ARCHIVO

Si solo desea tomar una sola línea (delimitada por comas) $ N de un archivo y convertirla en una columna:

head -$N file | tail -1 | tr ',' '\n'

No es muy elegante, pero este comando de "línea única" resuelve el problema rápidamente:

cols=4; for((i=1;i<=$cols;i++)); do \
            awk '{print $'$i'}' input | tr '\n' ' '; echo; \
        done

Aquí cols es el número de columnas, donde puede reemplazar 4 por head -n 1 input | wc -w.

Otra awksolución y entrada limitada con el tamaño de memoria que tienes.

awk '{ for (i=1; i<=NF; i++) RtoC[i]= (RtoC[i]? RtoC[i] FS $i: $i) }
    END{ for (i in RtoC) print RtoC[i] }' infile

Esto une cada posición del mismo número archivado en juntos e ENDimprime el resultado que sería la primera fila en la primera columna, la segunda fila en la segunda columna, etc.

X row1 row2 row3 row4
column1 0 3 6 9
column2 1 4 7 10
column3 2 5 8 11

Algunos ejemplos de utilidades estándar * nix , no se necesitan archivos temporales. NB: el OP quería una solución eficiente (es decir, más rápida), y las respuestas principales suelen ser más rápidas que esta respuesta. Estas frases breves son para quienes gustan de las herramientas de software * nix , por cualquier motivo. En casos raros ( por ejemplo, IO y memoria escasos), estos fragmentos pueden ser más rápidos que algunas de las respuestas principales.

Llame al archivo de entrada foo .

1. Si sabemos que foo tiene cuatro columnas:

   for f in 1 2 3 4 ; do cut -d ' ' -f $f foo | xargs echo ; done

2. Si no sabemos cuántas columnas tiene foo :

   n=$(head -n 1 foo | wc -w)
   for f in $(seq 1 $n) ; do cut -d ' ' -f $f foo | xargs echo ; done

   xargstiene un límite de tamaño y, por lo tanto, haría un trabajo incompleto con un archivo largo. ¿Qué límite de tamaño depende del sistema, por ejemplo:

   { timeout '.01' xargs --show-limits ; } 2>&1 | grep Max

   Longitud máxima de comando que podríamos usar: 2088944

3. tr& echo:

   for f in 1 2 3 4; do cut -d ' ' -f $f foo | tr '\n\ ' ' ; echo; done

   ... o si se desconoce el número de columnas:

   n=$(head -n 1 foo | wc -w)
   for f in $(seq 1 $n); do 
       cut -d ' ' -f $f foo | tr '\n' ' ' ; echo
   done

4. El uso set, que como xargs, tiene limitaciones similares basadas en el tamaño de la línea de comandos:

   for f in 1 2 3 4 ; do set - $(cut -d ' ' -f $f foo) ; echo $@ ; done

#!/bin/bash

aline="$(head -n 1 file.txt)"
set -- $aline
colNum=$#

#set -x
while read line; do
  set -- $line
  for i in $(seq $colNum); do
    eval col$i="\"\$col$i \$$i\""
  done
done < file.txt

for i in $(seq $colNum); do
  eval echo \${col$i}
done

otra versión con set eval

Otra variante de bash

$ cat file 
XXXX    col1    col2    col3
row1    0       1       2
row2    3       4       5
row3    6       7       8
row4    9       10      11

Guión

#!/bin/bash

I=0
while read line; do
    i=0
    for item in $line; { printf -v A$I[$i] $item; ((i++)); }
    ((I++))
done < file
indexes=$(seq 0 $i)

for i in $indexes; {
    J=0
    while ((J<I)); do
        arr="A$J[$i]"
        printf "${!arr}\t"
        ((J++))
    done
    echo
}

Salida

$ ./test 
XXXX    row1    row2    row3    row4    
col1    0       3       6       9   
col2    1       4       7       10  
col3    2       5       8       11

Aquí tienes una solución de Haskell. Cuando se compila con -O2, se ejecuta un poco más rápido que el awk de ghostdog y un poco más lento que el c python de Stephan en mi máquina para las líneas de entrada repetidas de "Hola mundo". Lamentablemente, el soporte de GHC para pasar código de línea de comando no existe hasta donde yo sé, por lo que tendrá que escribirlo en un archivo usted mismo. Truncará las filas a la longitud de la fila más corta.

transpose :: [[a]] -> [[a]]
transpose = foldr (zipWith (:)) (repeat [])

main :: IO ()
main = interact $ unlines . map unwords . transpose . map words . lines

Una solución awk que almacena toda la matriz en la memoria.

    awk '$0!~/^$/{    i++;
                  split($0,arr,FS);
                  for (j in arr) {
                      out[i,j]=arr[j];
                      if (maxr<j){ maxr=j}     # max number of output rows.
                  }
            }
    END {
        maxc=i                 # max number of output columns.
        for     (j=1; j<=maxr; j++) {
            for (i=1; i<=maxc; i++) {
                printf( "%s:", out[i,j])
            }
            printf( "%s\n","" )
        }
    }' infile

Pero podemos "recorrer" el archivo tantas veces como las filas de salida sean necesarias:

#!/bin/bash
maxf="$(awk '{if (mf<NF); mf=NF}; END{print mf}' infile)"
rowcount=maxf
for (( i=1; i<=rowcount; i++ )); do
    awk -v i="$i" -F " " '{printf("%s\t ", $i)}' infile
    echo
done

Cuál (para un recuento bajo de filas de salida es más rápido que el código anterior).

Aquí hay un resumen de Bash que se basa simplemente en convertir cada línea en una columna y pastejuntarlas:

echo '' > tmp1;  \
cat m.txt | while read l ; \
            do    paste tmp1 <(echo $l | tr -s ' ' \\n) > tmp2; \
                  cp tmp2 tmp1; \
            done; \
cat tmp1

m.txt:

0 1 2
4 5 6
7 8 9
10 11 12

1. crea el tmp1archivo para que no esté vacío.

2. lee cada línea y la transforma en una columna usando tr

3. pega la nueva columna al tmp1archivo

4. las copias resultan de nuevo en tmp1.

PD: Tenía muchas ganas de usar descriptores io pero no pude hacer que funcionaran.

Un delineador con R ...

  cat file | Rscript -e "d <- read.table(file('stdin'), sep=' ', row.names=1, header=T); write.table(t(d), file=stdout(), quote=F, col.names=NA) "

He usado a continuación dos scripts para realizar operaciones similares antes. El primero está en awk, que es mucho más rápido que el segundo, que está en bash "puro". Es posible que pueda adaptarlo a su propia aplicación.

awk '
{
    for (i = 1; i <= NF; i++) {
        s[i] = s[i]?s[i] FS $i:$i
    }
}
END {
    for (i in s) {
        print s[i]
    }
}' file.txt

declare -a arr

while IFS= read -r line
do
    i=0
    for word in $line
    do
        [[ ${arr[$i]} ]] && arr[$i]="${arr[$i]} $word" || arr[$i]=$word
        ((i++))
    done
done < file.txt

for ((i=0; i < ${#arr[@]}; i++))
do
    echo ${arr[i]}
done