Troca de um número ilimitado de colunas

12

Eu tenho um arquivo com colunas. Veja abaixo um exemplo:

a b c ... z  
1 2 3 ... 26

Eu gostaria de trocar todas as colunas onde o primeiro se torna o último, o segundo se torna o último antes ... etc.

z y x ... a  
26 25 24 ... 1

Existe um forro ( awk ou sed ) que faz isso?
Eu sei que se pode usar awk quando há apenas algumas colunas, mas gostaria de poder fazer isso em arquivos com milhares de colunas.

tac faz isso perfeitamente para linhas.
Eu acho que estou procurando o equivalente para colunas.

rev não funcionou para mim, pois também troca conteúdo na coluna.

    
por user22519 24.08.2012 / 20:41

8 respostas

15

awk '{for(i=NF;i>0;i--)printf "%s ",$i;print ""}' file
    
por 24.08.2012 / 22:35
10

Você pode fazer isso com um pequeno script python:

#!/usr/bin/env python

# Swaps order of columns in file, writes result to a file.
# usage: program.py input_file output_file

import sys, os

out = []

for line in open(sys.argv[1], 'r'):
    fields = line.split()
    rev = ' '.join(list(reversed(fields)))
    out.append(rev)

f = open(sys.argv[2], 'w')
f.write(os.linesep.join(out))
    
por 24.08.2012 / 21:24
7

Se você não se importar com python, então este one-liner irá reverter a ordem das colunas separadas por espaço em cada linha:

paddy$ cat infile.txt 
a b c d e f g h i j k l
1 2 3 4 5 6 7 8 9 10 11 12
a e i o u
paddy$ python3 -c 'with open("infile.txt") as f: print("\n".join(" ".join(line.rstrip().split()[::-1]) for line in f))'
l k j i h g f e d c b a
12 11 10 9 8 7 6 5 4 3 2 1
u o i e a
paddy$ 

O acima também funciona com o python2.7:

paddy$ python2.7 -c 'with open("infile.txt") as f: print("\n".join(" ".join(line.rstrip().split()[::-1]) for line in f))'
l k j i h g f e d c b a
12 11 10 9 8 7 6 5 4 3 2 1
u o i e a
paddy$ 
    
por 25.08.2012 / 10:39
4

Uma maneira de usar awk .

Conteúdo de infile :

a b c d e f g h i j k l
1 2 3 4 5 6 7 8 9 10 11 12
a e i o u

Execute o comando awk a seguir:

awk '{
    ## Variable 'i' will be incremented from first field, variable 'j'
    ## will be decremented from last field. And their values will be exchanged.
    ## The loop will end when both values cross themselves.
    j = NF; 
    for ( i = 1; i <= NF; i++ ) { 
        if ( j - i < 1 ) { 
            break;
        } 
        temp = $j; 
        $j = $i; 
        $i = temp; 
        j--; 
    }
    print;
}' infile

Com o seguinte resultado:

l k j i h g f e d c b a
12 11 10 9 8 7 6 5 4 3 2 1
u o i e a
    
por 24.08.2012 / 21:17
3

Isso é lento, mas tem um recurso redentor. Ele mantém a largura dos separadores de campo, quando eles são mais largos que um único caractere. FWIW: Se você executar este script duas vezes, o resultado será idêntico ao original.

Aqui está o script.

awk '{ eix = length($0) 
       for( fn=NF; fn>0; fn--) { dix=eix
            while( substr($0,dix,1) ~ /[ \t]/ ) dix--
            printf "%s%s", substr($0,dix+1,eix-dix), $fn
            dix-=length($fn); eix=dix }
       print substr($0,1,dix)
    }' "$file"

Aqui estão algumas comparações de tempo. O arquivo de teste continha 1 linha.

                      fields           fields     
                      10,0000          10,000,000

user11136 {python} | real  0.029s     real  3.235s
reversible? no     | user  0.032s     user  2.008s
                   | sys   0.000s     sys   1.228s

jmp {python}       | real  0.078s     real  5.045s
reversible? no     | user  0.068s     user  4.268s
                   | sys   0.012s     sys   0.560s

rush {awk}         | real  0.120s     real  10.889s
reversible? no     | user  0.116s     user   8.641s
                   | sys   0.008s     sys    2.252s

petero {awk}       | real  0.319s     real  35.750s
reversible? yes    | user  0.304s     user  33.090s
                   | sys   0.016s     sys    2.660s
    
por 25.08.2012 / 15:50
3

Você pode usar tac você só precisa transpor a entrada antes e depois. Isso pode ser feito com a calculadora de planilha eletrônica sc e seu coeficiente social psc :

< infile psc -S -r | sc -W% - | tac | psc -S -r | sc -W% - > outfile

Como visto aqui .

Isso funciona melhor quando todas as colunas estão preenchidas.

infile

 a b c d e f g h i  j  k  l
 1 2 3 4 5 6 7 8 9 10 11 12
 A B C D E F G H I  J  K  L

outfile

  l  k  j i h g f e d c b a
 12 11 10 9 8 7 6 5 4 3 2 1
  L  K  J I H G F E D C B A

Editar

Como observado por PeterO sc tem um limite rígido de 702 colunas, então esse é o tamanho máximo suportado por este método.

    
por 25.08.2012 / 11:57
3

Esse pipeline é mais rápido que a outra resposta mais rápida por um fator significativo (ver resultados). Usa tr e tac . Ele precisa utilizar 2 bytes ASCII (\ x00- \ x7F) que não existem em seus dados.

\x00 é normalmente uma boa opção, assim como \x01 , mas você pode usar qualquer byte ASCII que não esteja nos dados.

Neste exemplo, SPACE e TAB como os caracteres delimitadores. Delimitadores podem ser multi-byte ou single. O delimitador de saída é um espaço único.

Aqui está o comando. O nome do arquivo mostra o numberof fields _x number of lines

 <"$file" tr ' \t\n' '
o=($(<"$file" char-ascii-not-in-stream)); x="${o[0]}"; y="${o[1]}"
<"$file" tr ' \t\n' "$x$x$y" |tr -s "$x" '\n' |tac |tr '\n' ' ' | tr '$y' '\n' >"$file".$user
#!/usr/bin/awk -f
{c[$0]} END{for(i=0;i<=127;i++) {if(sprintf("%c", i) in c);else {printf "\%03o ",i}}}
' |tr -s '
Peter.O {tr,tac,tr} ==== file_10_x10000
real    0m0.013s    0m0.015s
user    0m0.020s    0m0.020s
sys     0m0.008s    0m0.012s   

user11136 {python} ===== file_10_x10000
real    0m0.057s
user    0m0.048s
sys     0m0.008s

jmp {python} =========== file_10_x10000
real    0m0.160s
user    0m0.160s
sys     0m0.000s

rush {awk} ============= file_10_x10000
real    0m0.121s
user    0m0.120s
sys     0m0.000s

##############################################

Peter.O {tr,tac,tr} ==== file_1000_x1000
real    0m0.048s    0m0.059s
user    0m0.040s    0m0.040s
sys     0m0.040s    0m0.048s

user11136 {python} ===== file_1000_x1000
real    0m0.158s
user    0m0.136s
sys     0m0.028s

jmp {python} =========== file_1000_x1000
real    0m0.327s
user    0m0.320s
sys     0m0.008s

rush {awk} ============= file_1000_x1000
real    0m0.832s
user    0m0.820s
sys     0m0s012s

##############################################

Peter.O {tr,tac,tr} ==== file_1000000_x50
real    0m5.221s    0m6.458s
user    0m4.208s    0m5.248s
sys     0m2.624s    0m2.396s

user11136 {python} ===== file_1000000_x50
real    0m16.286s
user    0m10.041s
sys     0m5.148s

jmp {python} =========== file_1000000_x50
real    0m22.845s
user    0m20.705s
sys     0m1.140s

rush {awk} ============= file_1000000_x50
real    0m44.793s
user    0m43.583s
sys     0m0.848s

##############################################
' '\n' |tac |tr '\n' ' ' |tr '' '\n'

Se você quiser / precisar verificar os bytes não usados, verifique antecipadamente esse script opcional awk . O tempo total, mesmo ao executar este script opcional, ainda é significativamente mais rápido do que outros métodos (até agora :). Aqui está o script de pré-processamento.

 <"$file" tr ' \t\n' '
o=($(<"$file" char-ascii-not-in-stream)); x="${o[0]}"; y="${o[1]}"
<"$file" tr ' \t\n' "$x$x$y" |tr -s "$x" '\n' |tac |tr '\n' ' ' | tr '$y' '\n' >"$file".$user
#!/usr/bin/awk -f
{c[$0]} END{for(i=0;i<=127;i++) {if(sprintf("%c", i) in c);else {printf "\%03o ",i}}}
' |tr -s '
Peter.O {tr,tac,tr} ==== file_10_x10000
real    0m0.013s    0m0.015s
user    0m0.020s    0m0.020s
sys     0m0.008s    0m0.012s   

user11136 {python} ===== file_10_x10000
real    0m0.057s
user    0m0.048s
sys     0m0.008s

jmp {python} =========== file_10_x10000
real    0m0.160s
user    0m0.160s
sys     0m0.000s

rush {awk} ============= file_10_x10000
real    0m0.121s
user    0m0.120s
sys     0m0.000s

##############################################

Peter.O {tr,tac,tr} ==== file_1000_x1000
real    0m0.048s    0m0.059s
user    0m0.040s    0m0.040s
sys     0m0.040s    0m0.048s

user11136 {python} ===== file_1000_x1000
real    0m0.158s
user    0m0.136s
sys     0m0.028s

jmp {python} =========== file_1000_x1000
real    0m0.327s
user    0m0.320s
sys     0m0.008s

rush {awk} ============= file_1000_x1000
real    0m0.832s
user    0m0.820s
sys     0m0s012s

##############################################

Peter.O {tr,tac,tr} ==== file_1000000_x50
real    0m5.221s    0m6.458s
user    0m4.208s    0m5.248s
sys     0m2.624s    0m2.396s

user11136 {python} ===== file_1000000_x50
real    0m16.286s
user    0m10.041s
sys     0m5.148s

jmp {python} =========== file_1000000_x50
real    0m22.845s
user    0m20.705s
sys     0m1.140s

rush {awk} ============= file_1000000_x50
real    0m44.793s
user    0m43.583s
sys     0m0.848s

##############################################
' '\n' |tac |tr '\n' ' ' |tr '' '\n'

Este é o script awk: char-ascii-not-in-stream

%pre%

O segundo conjunto de vezes, para este script, inclui o tempo de char-ascii-not-in-stream .

%pre%     
por 27.08.2012 / 14:20
0

Você também pode fazer isso sem imprimir f :

awk 'BEGIN{ORS=""} {for(k=NF;k>0;--k) {print $k; if (k==1) print "\n"; else print " "}} ' file
    
por 02.04.2017 / 23:40