Eliminare le linee duplicate in coppia?

Ho riscontrato questo caso d'uso oggi. Sembra semplice a prima vista, ma trafficando con sort, uniq, sede awkha rivelato che si tratta di non banale.

Come posso eliminare tutte le coppie di righe duplicate? In altre parole, se esiste un numero pari di duplicati di una determinata riga, eliminali tutti; se esiste un numero dispari di righe duplicate, eliminare tutte tranne una. (Si può presumere un input ordinato.)

È preferibile una soluzione pulita ed elegante.

Esempio di input:

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

Esempio di output:

a
d
e

Ho elaborato la sedrisposta non molto tempo dopo aver pubblicato questa domanda; nessun altro ha usato sedfinora così eccolo qui:

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

Un po 'a giocare con il problema più generale (che dire di eliminare le righe in gruppi di tre? O quattro, o cinque?) Ha fornito la seguente soluzione estensibile:

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

Esteso per rimuovere le triple di linee:

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

O per rimuovere i quadratini di linee:

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

sed ha un ulteriore vantaggio rispetto alla maggior parte delle altre opzioni, che è la sua capacità di operare veramente in un flusso, senza bisogno di più memoria di memoria rispetto al numero effettivo di linee da controllare per i duplicati.

Come ha sottolineato cuonglm nei commenti , è necessario impostare le impostazioni locali su C per evitare errori nel rimuovere correttamente le righe contenenti caratteri multibyte. Quindi i comandi sopra diventano:

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.

Non è molto elegante, ma è semplice come posso inventare:

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

Il substr () taglia semplicemente l' uniqoutput. Funzionerà fino a quando non avrai più di 9.999.999 duplicati di una riga (nel qual caso l'output di uniq potrebbe estendersi su 9 caratteri).

Prova questo awkscript qui sotto:

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

Si presume che il lines.txtfile sia ordinato.

Il test:

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

Con pcregrepper un dato campione:

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

o in modo più generale:

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

Se l'input è ordinato:

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

Mi piace pythonper questo, ad esempio con python2.7+

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

Come ho capito la domanda che ho optato per awk, usando un hash di ogni record, in questo caso sto assumendo che RS = \ n, ma può essere cambiato per considerare qualsiasi altro tipo di arrangiamento, può essere organizzato per considerare un numero pari di ripetizioni, anziché dispari, con un parametro o una piccola finestra di dialogo. Ogni riga viene utilizzata come hash e il suo conteggio viene aumentato, alla fine del file l'array viene scansionato e stampa ogni conteggio pari del record. Includo il conteggio per verificare ma, rimuovere una [x] è sufficiente per risolvere quel problema.

HTH

codice di countline

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

Dati di esempio:

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

Esempio di esecuzione:

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

Se l'input è ordinato, che ne dici di questo awk:

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

con perl:

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

Utilizzando costrutti di shell,

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

Puzzle divertente!

In 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

Verosimilmente in 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)

Tersely in Haskell:

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

una versione: utilizzo i "delimitatori" per semplificare il ciclo interno (presuppone che la prima riga non lo sia __unlikely_beginning__e presuppone che il testo non termini con la riga __unlikely_ending__:, e aggiungo quella riga speciale delimitatore alla fine delle righe inserite. l'algoritmo può assumere entrambi:)

{ 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; }
'

Così :

• ricordiamo il modello che stiamo attualmente osservando, aumentandolo di uno ogni volta che si ripresenta. [e se si ripresenta, saltiamo le 2 azioni successive, che sono valide per il caso in cui il modello cambia]
• Quando il modello CAMBIA:
  • se non un multiplo di 2, stampiamo una ricorrenza del modello memorizzato
  • e in ogni caso quando il modello è cambiato: il nuovo modello memorizzato è il modello corrente e lo abbiamo visto solo una volta.