Une manière efficace de transposer un fichier en Bash

une autre option est d'utiliser rs :

rs -c' ' -C' ' -T

-c modifie le séparateur de colonne d'entrée, -C modifie le séparateur de colonne de sortie, et -T transpose les lignes et les colonnes. N'utilisez pas -t au lieu de -T , car il utilise un nombre calculé automatiquement de lignes et de colonnes qui n'est généralement pas correct. rs , qui est nommé d'après la fonction reshape dans APL, vient avec BSDs et OS X, mais il devrait être disponible auprès des gestionnaires de paquets sur d'autres plateformes.

une deuxième option est D'utiliser Ruby:

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

une troisième option est d'utiliser jq :

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

jq -R . imprime chaque ligne d'entrée comme une chaîne JSON littérale, -s ( --slurp ) crée un tableau pour les lignes d'ENTRÉE après avoir analysé chaque ligne comme JSON, et -r ( --raw-output ) sort le contenu des chaînes au lieu de JSON string literals. L'opérateur / est surchargé pour séparer les chaînes.

une solution 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

ci-dessus est basé sur les éléments suivants:

import sys

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

Ce code suppose que chaque ligne a le même nombre de colonnes (sans rembourrage).

le transposer projet sur sourceforge est un programme C coreutil-like Pour exactement cela.

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

pur BASH, pas de procédé supplémentaire. Un bel exercice:

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

read -a line < ""                       # 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 < ""

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

voici un script Perl modérément solide pour faire le travail. Il existe de nombreuses analogies structurelles avec la solution awk 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";
}

avec la taille de l'échantillon, la différence de performance entre perl et awk était négligeable (1 milliseconde sur 7 au total). Avec un ensemble de données plus grand (matrice 100x100, entrées 6-8 caractères chacun), perl a légèrement dépassé awk - 0.026 s vs 0.042 s. Aucun des deux n'est susceptible d'être un problème.

timings représentatifs pour Perl 5.10.1 (32-bit) vs awk (version 20040207 when given '- V') vs gawk 3.1.7 (32-bit) sur MacOS X 10.5.8 sur un fichier contenant 10.000 lignes avec 5 colonnes par ligne:

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: 

notez que gawk est beaucoup plus rapide que awk sur cette machine, mais toujours plus lent que perl. Clairement, votre kilométrage peut varier.

regardez GNU datamash qui peut être utilisé comme datamash transpose . Une version future prendra également en charge la tabulation croisée (pivot tables)

si vous avez sc installé, vous pouvez faire:

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

en supposant que toutes vos lignes ont le même nombre de champs, ce programme awk résout le problème:

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

en mots, pendant que vous bouclez la boucle sur les lignes, pour chaque champ f cultivez un ':'-chaîne séparée col[f] contenant les éléments de ce champ. Une fois que vous avez terminé avec toutes les lignes, Imprimez chacune de ces chaînes dans une ligne séparée. Vous pouvez alors substituer': 'pour le séparateur que vous voulez (par exemple, un espace) en pipant la sortie par tr ':' ' ' .

exemple:

$ 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

Il y a un utilitaire pour cela,

GNU datamash utility

apt install datamash  

datamash transpose < yourfile

tiré de ce site, https://www.gnu.org/software/datamash / et http://www.thelinuxrain.com/articles/transposing-rows-and-columns-3-methods

la seule amélioration que je peux voir à votre propre exemple est d'utiliser awk qui réduira le nombre de processus qui sont exécutés et la quantité de données qui est acheminée entre eux:

/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

une solution hackish perl peut être comme ceci. Il est agréable parce qu'il ne charge pas tous les fichiers en mémoire, imprime des fichiers intermédiaires temp, puis utilise le tout-wonderful paste

#!/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;

j'ai utilisé la solution de fgm (merci fgm!), mais nécessaire pour éliminer les caractères de l'onglet à la fin de chaque ligne, donc modifié le script ainsi:

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

read -a line < ""                       # 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 < ""

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

j'étais juste à la recherche de bash tranpose similaire, mais avec un support pour le rembourrage. Voici le script que j'ai écrit basé sur la solution de la MGF, qui semble fonctionner. Si cela peut vous aider...

#!/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 < ""

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

je cherchais une solution pour transposer n'importe quel type de matrice (nxn ou mxn) avec n'importe quel type de données (nombres ou données) et j'ai obtenu la solution suivante:

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

j'utilise normalement ce petit awk pour cette exigence:

  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

il suffit de charger toutes les données dans un tableau bidimensionnel a[line,column] et ensuite l'imprime en arrière comme a[column,line] , de sorte qu'il transpose l'entrée donnée.

cela doit garder la trace du max imum quantité de colonnes que le fichier initial a, de sorte qu'il est utilisé comme le nombre de lignes à imprimer en arrière.

si vous voulez seulement saisir une ligne simple (délimitée par une virgule) $N hors d'un fichier et la transformer en une colonne:

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

pas très élégant, mais cette commande "single-line" résout le problème rapidement:

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

Ici cols est le nombre de colonnes, où vous pouvez remplacer 4 par head -n 1 input | wc -w .

#!/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

une autre version avec set eval

une autre awk solution et entrée limitée avec la taille de la mémoire que vous avez.

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

il s'agit de la combinaison de chaque numéro positon déposé et de l'impression du résultat dans END qui serait la première ligne dans la première colonne, la deuxième ligne dans la deuxième colonne, etc. Sortie Will:

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

Voici une solution de Haskell. Lorsqu'il est compilé avec-O2, il court un peu plus vite que le awk de ghostdog et un peu plus lentement que les lignes d'entrée "Hello world" répétées de Stephan thinly wrapped c python sur ma machine. Malheureusement, le support de GHC pour passer du code de ligne de commande est inexistant autant que je puisse le dire, donc vous devrez l'écrire vous-même dans un fichier. Il tronquera les rangées à la longueur de la rangée la plus courte.

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

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

Un awk solution que de stocker l'ensemble du tableau dans la mémoire

    awk '"151900920"!~/^$/{    i++;
                  split("151900920",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

mais nous pouvons "marcher" le fichier autant de fois que les lignes de sortie sont nécessaires:

#!/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

Qui (pour un faible nombre de lignes de sortie est plus rapide que le code précédent).

Certains *nix standard util one-liners, pas de fichiers temporaires nécessaires. NB: L'OP voulait un efficace fix, (i.e. plus rapide), et les réponses les plus rapides sont généralement. Ces Uni-liners sont pour ceux qui aiment les "outils logiciels" *nix, pour n'importe quelles raisons. Dans les cas rares (par exemple IO et mémoire rares), ces bribes peuvent en fait être plus rapides.

Appeler le fichier d'entrée foo .

1. Si nous savons foo comporte quatre colonnes:

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

2. si nous ne savons pas combien de colonnes foo a:

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

   xargs a une limite de taille et ferait donc un travail incomplet avec un long fichier. Quelle est la limite de taille qui dépend du système, par exemple:

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

   durée maximale de la commande nous pourrions en fait utiliser: 2088944

3. tr & echo :

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

   ...ou si le nombre de colonnes est inconnu:

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

4. utilisant set , qui comme xargs , a des limitations similaires basées sur la taille de la ligne de commande:

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

voici un bash one-liner qui est basé sur la conversion simple de chaque ligne en une colonne et paste - les ensemble:

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. crée tmp1 fichier donc il n'est pas vide.

2. lit chaque ligne et la transforme en une colonne en utilisant tr

3. inscrit la nouvelle colonne le tmp1 fichier

4. copies résultat dans tmp1 .

PS: je voulais vraiment utiliser les io-descripteurs mais je n'ai pas pu les faire fonctionner.

GNU datamash ( https://www.gnu.org/software/datamash ) est parfaitement adapté pour ce problème avec une seule ligne de code et potentiellement arbitrairement gros filesize! datamash-W transposer input_file.txt > input_file_transposed.txt