Excluir linhas duplicadas em pares?

Encontrei esse caso de uso hoje. Parece simples à primeira vista, mas brincar com sort, uniq, sede awkrevelou que é trivial.

Como posso excluir todos os pares de linhas duplicadas? Em outras palavras, se houver um número par de duplicatas de uma determinada linha, exclua todas elas; se houver um número ímpar de linhas duplicadas, exclua todas, exceto uma. (A entrada classificada pode ser assumida.)

Uma solução limpa e elegante é preferível.

Exemplo de entrada:

a
a
a
b
b
c
c
c
c
d
d
d
d
d
e

Exemplo de saída:

a
d
e

Eu resolvi a sedresposta pouco tempo depois de postar esta pergunta; ninguém mais usou sedaté agora, aqui está:

sed '$!N;/^\(.*\)\n\1$/d;P;D'

Um pouco de brincadeira com o problema mais geral (e a exclusão de linhas em conjuntos de três? Ou quatro ou cinco?) Forneceu a seguinte solução extensível:

sed -e ':top' -e '$!{/\n/!{N;b top' -e '};};/^\(.*\)\n\1$/d;P;D' temp

Estendido para remover triplos de linhas:

sed -e ':top' -e '$!{/\n.*\n/!{N;b top' -e '};};/^\(.*\)\n\1\n\1$/d;P;D' temp

Ou para remover quads de linhas:

sed -e ':top' -e '$!{/\n.*\n.*\n/!{N;b top' -e '};};/^\(.*\)\n\1\n\1\n\1$/d;P;D' temp

sed possui uma vantagem adicional sobre a maioria das outras opções, que é a capacidade de operar verdadeiramente em um fluxo, sem mais memória necessária do que o número real de linhas a serem verificadas quanto a duplicatas.

Como o cuonglm apontou nos comentários , é necessário definir o código de idioma para C para evitar falhas na remoção adequada das linhas que contêm caracteres de vários bytes. Portanto, os comandos acima se tornam:

LC_ALL=C sed '$!N;/^\(.*\)\n\1$/d;P;D' temp
LC_ALL=C sed -e ':top' -e '$!{/\n/!{N;b top' -e '};};/^\(.*\)\n\1$/d;P;D' temp
LC_ALL=C sed -e ':top' -e '$!{/\n.*\n/!{N;b top' -e '};};/^\(.*\)\n\1\n\1$/d;P;D' temp
# Etc.

Não é muito elegante, mas é o mais simples que consigo:

uniq -c input | awk '{if ($1 % 2 == 1) { print substr($0, 9) }}'

O substr () apenas apara a uniqsaída. Isso funcionará até que você tenha mais de 9.999.999 duplicatas de uma linha (nesse caso, a saída da uniq pode ultrapassar 9 caracteres).

Experimente este awkscript abaixo:

#!/usr/bin/awk -f
{
  if ((NR!=1) && (previous!=$0) && (count%2==1)) {
    print previous;
    count=0;
  }
  previous=$0;
  count++;
}
END {
  if (count%2==1) {
    print previous;
  }
}

Supõe-se que o lines.txtarquivo esteja classificado.

O teste:

$ chmod +x script.awk
$ ./script.awk lines.txt
a
d
e

Com pcregreppara uma determinada amostra:

pcregrep -Mv '(.)\n\1$' file

ou de uma maneira mais geral:

pcregrep -Mv '(^.*)\n\1$' file

Se a entrada for classificada:

perl -0pe  'while(s/^(.*)\n\1\n//m){}'

Eu gosto pythondisso, por exemplo, com python2.7+

from itertools import groupby
with open('input') as f:
    for k, g in groupby(f):
            if len(list(g)) % 2:
                    print(k),

Como entendi a pergunta que optei pelo awk, usando um hash de cada registro, neste caso, estou assumindo que RS = \ n, mas pode ser alterado para considerar qualquer outro tipo de arranjo, pode ser arranjado para considerar um número par de repetições, em vez de ímpares, com um parâmetro ou uma pequena caixa de diálogo. Cada linha é usada como o hash e sua contagem é aumentada. No final do arquivo, a matriz é digitalizada e imprime todas as contagens iguais do registro. Estou incluindo a contagem para verificar, mas remover um [x] é suficiente para resolver esse problema.

HTH

código de linhas de contagem

#!/usr/bin/nawk -f
{a[$0]++}
END{for (x in a) if (a[x]%2!=0) print x,a[x] }

Dados de amostra:

a
One Sunny Day
a
a
b
my best friend
my best friend
b
c
c
c
One Sunny Day
c
d
my best friend
my best friend
d
d
d
One Sunny Day
d
e
x
k
j
my best friend
my best friend

Exemplo de execução:

countlines feed.txt
j 1
k 1
x 1
a 3
One Sunny Day 3
d 5
e 1

Se a entrada for classificada, e quanto a isso awk:

awk '{ x[$0]++; if (prev != $0 && x[prev] % 2 == 1) { print prev; } prev = $0; } END { if (x[prev] % 2 == 1) print prev; }' sorted

com perl:

uniq -c file | perl -lne 'if (m(^\s*(\d+) (.*)$)) {print $2 if $1 % 2 == 1}'

Usando construções de shell,

uniq -c file | while read a b; do if (( $a & 1 == 1 )); then echo $b; fi done

Quebra-cabeça divertido!

Em Perl:

#! /usr/bin/env perl

use strict;
use warnings;

my $prev;
while (<>) {
  $prev = $_, next unless defined $prev;  # prime the pump

  if ($prev ne $_) {
    print $prev;
    $prev = $_;                           # first half of a new pair
  }
  else {
    undef $prev;                          # discard and unprime the pump
  }
}

print $prev if defined $prev;             # possible trailing odd line

Verbosamente em Haskell:

main :: IO ()
main = interact removePairs
  where removePairs = unlines . go . lines
        go [] = []
        go [a] = [a]
        go (a:b:rest)
          | a == b = go rest
          | otherwise = a : go (b:rest)

Concertamente em Haskell:

import Data.List (group)
main = interact $ unlines . map head . filter (odd . length) . group . lines

uma versão: eu uso "delimitadores" para simplificar o loop interno (assume que a primeira linha não está __unlikely_beginning__e assume que o texto não está terminando com a linha: __unlikely_ending__e adicione essa linha delimitadora especial no final das linhas inseridas. algoritmo pode assumir ambos:)

{ cat INPUTFILE_or_just_-  ; echo "__unlikely_ending__" ; } | awk '
  BEGIN {mem="__unlikely_beginning__"; occured=0; }  

    ($0 == mem)            { occured++ ; next } 

    ( occured%2 )           { print mem ;} 
                            { mem=$0; occured=1; }
'

Então :

• lembramos o padrão que estamos vendo atualmente, aumentando-o em um toda vez que ocorre novamente. [e se ocorrer novamente, pularemos as próximas 2 ações, que são o caso quando o padrão muda]
• Quando o padrão MUDAR:
  • se não for múltiplo de 2, imprimimos uma ocorrência do padrão memorizado
  • e em todos os casos em que o padrão mudou: o novo padrão memorizado é o padrão atual e só o vimos uma vez.