Doppelte Zeilen paarweise löschen?

Ich bin heute auf diesen Anwendungsfall gestoßen. Es scheint einfach auf den ersten Blick, aber das Hantieren mit sort, uniq, sedund awkgezeigt , dass es nicht trivial ist.

Wie kann ich alle doppelten Zeilenpaare löschen ? Mit anderen Worten, wenn es eine gerade Anzahl von Duplikaten einer bestimmten Zeile gibt, löschen Sie alle. Wenn es eine ungerade Anzahl doppelter Zeilen gibt, löschen Sie alle bis auf eine. (Eine sortierte Eingabe kann angenommen werden.)

Eine saubere, elegante Lösung ist vorzuziehen.

Beispiel Eingabe:

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

Beispielausgabe:

a
d
e

Ich habe die sedAntwort nicht lange nach dem Posten dieser Frage gefunden. sedBisher hat noch niemand davon Gebrauch gemacht. Hier ist es:

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

Ein bisschen Herumspielen mit dem allgemeineren Problem (wie wäre es mit dem Löschen von Zeilen in Dreier- oder Vier- oder Fünfersätzen?) Ergab die folgende erweiterbare Lösung:

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

Erweitert, um Dreifache von Zeilen zu entfernen:

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

Oder um Quads von Zeilen zu entfernen:

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

sed hat einen zusätzlichen Vorteil gegenüber den meisten anderen Optionen, nämlich die Fähigkeit, wirklich in einem Stream zu arbeiten, wobei nicht mehr Speicher benötigt wird als die tatsächliche Anzahl der auf Duplikate zu überprüfenden Zeilen.

Wie in den Kommentaren erwähnt , ist das Setzen des Gebietsschemas auf C erforderlich, um zu vermeiden, dass Zeilen, die Mehrbytezeichen enthalten, nicht ordnungsgemäß entfernt werden. So werden die obigen Befehle:

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.

Es ist nicht sehr elegant, aber so einfach, wie ich es mir vorstellen kann:

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

Das substr () schneidet nur die uniqAusgabe ab. Das funktioniert, bis Sie mehr als 9.999.999 Duplikate einer Zeile haben (in diesem Fall kann die Ausgabe von uniq über 9 Zeichen hinausgehen).

Probieren Sie dieses awkSkript aus:

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

Es wird davon ausgegangen, dass die lines.txtDatei sortiert ist.

Der Test:

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

Mit pcregrepfür eine gegebene Probe:

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

oder allgemeiner:

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

Wenn die Eingabe sortiert ist:

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

Das gefällt mir pythonzum Beispiel mit python2.7+

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

Da ich die Frage, für die ich mich entschieden habe, unter Verwendung eines Hashs für jeden Datensatz für awk verstanden habe, gehe ich in diesem Fall davon aus, dass RS = \ n ist gerade Anzahl von Wiederholungen anstelle der ungeraden mit einem Parameter oder einem kleinen Dialog. Jede Zeile wird als Hash verwendet und ihre Anzahl erhöht. Am Ende der Datei wird das Array gescannt und jede gerade Anzahl der Datensätze gedruckt. Ich beziehe die Anzahl ein, um zu überprüfen, aber das Entfernen eines [x] reicht aus, um dieses Problem zu lösen.

HTH

countlines code

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

Beispieldaten:

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

Probelauf:

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

Wenn die Eingabe sortiert ist, wie sieht es damit aus awk:

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

mit perl:

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

Shell-Konstrukte verwenden,

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

Fun Puzzle!

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

Ausführlich 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)

Knapp in Haskell:

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

a version: Ich verwende "Begrenzer", um die innere Schleife zu vereinfachen (es wird davon ausgegangen, dass die erste Zeile nicht __unlikely_beginning__mit der Zeile: endet __unlikely_ending__, und füge diese spezielle Begrenzerzeile am Ende der eingegebenen Zeilen hinzu Algorithmus kann beides annehmen:)

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

So :

• Wir erinnern uns an das Muster, das wir gerade betrachten, und erhöhen es jedes Mal um eins, wenn es erneut auftritt. [und wenn es wieder vorkommt, überspringen wir die nächsten 2 Aktionen, die für den Fall sind, wenn sich das Muster ändert]
• Wenn sich das Muster ändert:
  • Wenn dies nicht ein Vielfaches von 2 ist, drucken wir ein Vorkommen des gespeicherten Musters
  • und in jedem Fall, wenn sich das Muster geändert hat: Das neu gespeicherte Muster ist das aktuelle Muster, und wir haben es nur einmal gesehen.