Um script bash para pegar duas linhas em um arquivo de texto e formar colunas ao longo de uma linha

Question

Estou apenas começando no bash para facilitar o trabalho para um estágio. Então, eu não sou muito bom e lamento de antemão se minha tentativa inicial for tão imprecisa que não seja útil. Por favor, não hesite em pedir esclarecimentos.

Minha entrada se parece com:

Set1
1
2
3
4
Set2
5
6
7
8

Gostaria que minha saída fosse:

group1  1   5
group1  2   6
group2  3   7
group2  4   8

Então eu pude fazer

A=$(sed -n '2p' input)
B=$(sed -n '7p' input)

printf "group1\t$A\t$B" >> output

e repita isso mais 3 vezes.

O problema é que em vez de 2 grupos de 4 números cada, eu tenho 7 grupos de 34 números cada, então algo como 200-300 no total. É por isso que gostaria de criar um script que automatize essa tarefa.

Para os primeiros 17 números (group1), eu tive:

#!/bin/bash


##############################################################################
#group1


for (( i=0; i<=16; i++ )) ;
do

A=$(echo "scale=1;x=2+$i; x" |bc -l)

B=$(echo "scale=1;x=128+$i; x" |bc -l)

C=$(sed -n "$Ap" input)

D=$(sed -n "$Bp" input)

printf "group1\t$C\t$D\n" >> output


done   

Claro que não funciona, provavelmente por vários motivos. Por um lado, eu realmente não fui capaz de usar sed para filtrar uma linha específica usando uma variável como a entrada para o número da linha. Esse é o meu erro atual, mas eu suspeito que haverá mais além disso. Estou mais do que aberto a outras abordagens.

• Existe uma maneira automatizada de inserir dois números de linha como entrada e organizá-los em colunas ao longo de uma única linha?
• Existe uma maneira automatizada de fazer essa linha única começar com outra coluna, por exemplo. group1 / group1 / group2 / group2?

Obrigado por qualquer conselho.

    

Answer 1

Se você quiser algo rápido e simples apenas para colocar em coluna os dados, você pode tentar pr

pr -t -2 input
Set1                                Set2
1                                   5
2                                   6
3                                   7
4                                   8

pr -t -7 input17x7
Set1      Set2      Set1      Set2      Set1      Set2      Set1
1         a         1         a         1         a         1
2         b         2         b         2         b         2
3         c         3         c         3         c         3
4         d         4         d         4         d         4
5         e         5         e         5         e         5
6         f         6         f         6         f         6
7         g         7         g         7         g         7
8         h         8         h         8         h         8
9         i         9         i         9         i         9
10        j         10        j         10        j         10
11        k         11        k         11        k         11
12        l         12        l         12        l         12
13        m         13        m         13        m         13
14        n         14        n         14        n         14
15        o         15        o         15        o         15
16        p         16        p         16        p         16
17        q         17        q         17        q         17

Para um melhor controle, há o utilitário rs . Por exemplo, você poderia fazer:

{ printf 'Group\n' ; printf 'group%d\n' {1..17} ; cat input17x7; } | rs -et 18 8
Group    Set1     Set2     Set1     Set2     Set1     Set2     Set1
group1   1        a        1        a        1        a        1
group2   2        b        2        b        2        b        2
group3   3        c        3        c        3        c        3
group4   4        d        4        d        4        d        4
group5   5        e        5        e        5        e        5
group6   6        f        6        f        6        f        6
group7   7        g        7        g        7        g        7
group8   8        h        8        h        8        h        8
group9   9        i        9        i        9        i        9
group10  10       j        10       j        10       j        10
group11  11       k        11       k        11       k        11
group12  12       l        12       l        12       l        12
group13  13       m        13       m        13       m        13
group14  14       n        14       n        14       n        14
group15  15       o        15       o        15       o        15
group16  16       p        16       p        16       p        16
group17  17       q        17       q        17       q        17

Se você não quiser o cabeçalho, canalize o resultado via tail -n +2