Início / unix / Perguntas / 780942
Accepted
Simon Ante
Asked: 2024-07-28 07:47:27 +0800 CST

Remova sequências de texto duplicadas, mas incompletas

  • 772

Tenho dificuldade em descobrir como remover sequências de texto duplicadas, mas incompletas. Nenhum sucesso usando perl, awkou sed.

Eu preciso transformar:

a b
a b c
a b c d
a b c d e
a b c d x
a b c d z

em

a b
a b c d e
a b c d x
a b c d z

Todo padrão incompleto deve ser excluído, mas (1) nem cada string final completa e única e (2) nem strings com duas palavras de comprimento.

Todas as respostas que encontrei foram remoção de endereços de duplicatas idênticas.

awk

3 respostas

  1. Best Answer

    Supondo que todas as seguintes condições sejam atendidas:

    • As strings neste arquivo são classificadas (ou seja, as "duplicatas incompletas" que você deseja remover são seguidas pela linha que as contém)

    • Você deseja corresponder apenas ao INÍCIO da linha, então por exemplo, na sequência seguinte, a primeira linha não será removida (a segunda linha contém a primeira linha, mas não começa com a mesma sequência

      a b c d
e a b c d

    Do que isso é muito semelhante a: Usando sed ou awk, como posso excluir uma linha sempre que a próxima linha começar com o mesmo conteúdo seguido por uma barra? .

    Aqui está uma solução possível:

    awk 'NR==1 {prev=$0; next} index($0 ,prev" ") != 1 || split(prev, _) == 2 {print prev} {prev=$0} END {if (NR>0) print prev}' FILENAME

    Multilinha para legibilidade:

    awk '
  NR==1 {prev=$0; next}
  index($0, prev" ") != 1 || split(prev, _) == 2 {print prev}
  {prev=$0}
  END {if (NR>0) print prev}
  ' FILENAME
    1. Copie a primeira linha do arquivo para uma variável chamada preve pule para a próxima linha.
    2. A partir da segunda linha, verifique se prev" "( prevcom um espaço extra no final) corresponde ao início (índice 1) da linha atual ( $0). Caso contrário, imprima a linha anterior.
    3. Se a linha anterior consistir exatamente em 2 palavras ( split(prev, _) == 2), imprima-a mesmo assim
      • Estou usando o sublinhado _apenas split(prev, _)como uma dica de que não usarei o array resultante de split.
    4. Copie a linha atual ( $0) para prev.
    5. Ao awkterminar de ler o arquivo, imprima a última linha ( prev), a menos que o arquivo esteja vazio.

    Exemplo:

    $ cat testfile
a b
a b c
a b c d
a b c d e
a b c d x
a b c d z

$ awk '
  NR==1 {prev=$0; next}
  index($0, prev" ") != 1 || split(prev, _) == 2 {print prev}
  {prev=$0}
  END {if (NR>0) print prev}
  ' testfile
a b
a b c d e
a b c d x
a b c d z
    • 2 
  2. #! /usr/bin/awk -f

{
    arr_stock[NR] = $0
    arr_nf[NR] = NF
    if (DEBUG) printf("STO:%d:%s:\n", NR, arr_stock[NR])
}

END {
    for (i_stock = 1; i_stock <= NR; i_stock++) {
        flag_found = 0
        motif = arr_stock[i_stock]
        if (DEBUG) printf("- MOT:%d:%d:%s:\n", i_stock, arr_nf[i_stock], motif)
        if (arr_nf[i_stock] > 2) {
            for (i_stock_2 = 1; i_stock_2 <= NR; i_stock_2++) {
                if (DEBUG) printf("  - TST:%d:%s:\n", i_stock_2, arr_stock[i_stock_2])
                if (i_stock != i_stock_2 && arr_stock[i_stock_2] ~ ("^" motif) && arr_stock[i_stock_2] != motif) {
                    if (DEBUG) printf("    - FOUND\n")
                    flag_found = 1
                    break
                }
            }
        }
        if (flag_found == 0) {
            printf("%s\n", motif)
        }
    }
}
    • 0

  3. Usando qualquer awke sort:

    $ cat tst.sh
#!/usr/bin/env bash

sort -r "${@:--}" |
awk '
    (NF == 2) || (index(prev" ",$0" ") != 1)
    { prev = $0 }
' |
sort


    $ ./tst.sh file
a b
a b c d e
a b c d x
a b c d z

    O " "no final de cada string in index()é necessário para que a b dnão corresponda falsamente como uma substring de a b dog, assumindo que queremos apenas comparações de palavras inteiras, e a b ecorresponda a si mesmo, assumindo que queremos excluir linhas duplicadas exatas, bem como linhas de substring, por exemplo dada esta entrada de amostra mais abrangente:

    $ cat file2
a b
a b c
a b c d
a b c d e
a b c d x
a b c d z
a b d
a b dog
a b e
a b e

    obtemos a saída esperada:

    $ ./tst.sh file2
a b
a b c d e
a b c d x
a b c d z
a b d
a b dog
a b e

    Com o script acima, classificamos a entrada primeiro para que strings mais longas apareçam antes de strings mais curtas que começam com os mesmos caracteres, tornando mais fácil para o awk testar se a string atual é uma substring da anterior, então classificamos novamente para o resultado final.

    Essa abordagem de classificação primeiro significa que funcionará independentemente da ordem em que a entrada estiver, por exemplo:

    $ shuf file2 > file3

$ cat file3
a b
a b c d
a b c d z
a b dog
a b c d e
a b c d x
a b c
a b e
a b d
a b e

$ ./tst.sh file3
a b
a b c d e
a b c d x
a b c d z
a b d
a b dog
a b e

    Se também quiséssemos que a ordem de saída fosse igual à ordem de entrada dada a entrada não classificada como acima, poderíamos aplicar um idioma Decorate-Sort-Undecorate para adicionar números de linha originais primeiro, depois classificar e remover aqueles no final:

    $ cat tst2.sh
#!/usr/bin/env bash

awk -v OFS='\t' '{print NR, $0}' "${@:--}" |
sort -r -k2 |
awk -v OFS='\t' '
    { nr=$1; sub(/[^\t]+\t/,"") }
    (NF == 2) || (index(prev" ",$0" ") != 1) {
        print nr, $0
    }
    { prev = $0 }
' |
sort -nk1 |
cut -f2-


    $ ./tst2.sh file3
a b
a b c d z
a b dog
a b c d e
a b c d x
a b e
a b d
    • 0

relate perguntas