Xóa các dòng trùng lặp theo cặp?

Tôi gặp trường hợp sử dụng ngày hôm nay. Có vẻ như đơn giản ở cái nhìn đầu tiên, nhưng quan trọng xung quanh với sort, uniq, sedvà awktiết lộ rằng đó là không tầm thường.

Làm thế nào tôi có thể xóa tất cả các cặp dòng trùng lặp? Nói cách khác, nếu có số lượng trùng lặp chẵn của một dòng nhất định, hãy xóa tất cả chúng; nếu có một số lẻ các dòng trùng lặp, hãy xóa tất cả trừ một dòng. (Đầu vào được sắp xếp có thể được giả định.)

Một giải pháp thanh lịch sạch sẽ là thích hợp hơn.

Ví dụ đầu vào:

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

Ví dụ đầu ra:

a
d
e

Tôi đã tìm ra sedcâu trả lời không lâu sau khi tôi đăng câu hỏi này; không ai khác đã sử dụng sedcho đến nay nó là:

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

Một chút chơi xung quanh với vấn đề chung hơn (về việc xóa các dòng trong bộ ba? Hoặc bốn hoặc năm?) Đã cung cấp giải pháp mở rộng sau:

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

Mở rộng để loại bỏ ba lần dòng:

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

Hoặc để loại bỏ bốn dòng:

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

sed có một lợi thế bổ sung so với hầu hết các tùy chọn khác, đó là khả năng thực sự hoạt động trong luồng, không cần nhiều bộ nhớ hơn so với số lượng dòng thực tế cần kiểm tra trùng lặp.

Như cuonglm đã chỉ ra trong các bình luận , việc đặt ngôn ngữ thành C là cần thiết để tránh thất bại trong việc loại bỏ đúng các dòng chứa các ký tự nhiều byte. Vì vậy, các lệnh trên trở thành:

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ó không thanh lịch lắm, nhưng nó đơn giản như tôi có thể nghĩ ra:

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

Các chất nền () chỉ cắt bỏ uniqđầu ra. Điều đó sẽ hoạt động cho đến khi bạn có hơn 9,999.999 bản sao của một dòng (trong trường hợp đó, đầu ra của uniq có thể vượt quá 9 ký tự).

Hãy thử awkkịch bản này dưới đây:

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

Nó được giả định rằng các lines.txttập tin được sắp xếp.

Các bài kiểm tra:

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

Với pcregrepmột mẫu nhất định:

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

hoặc một cách tổng quát hơn:

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

Nếu đầu vào được sắp xếp:

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

Tôi thích pythonđiều này, ví dụ với python2.7+

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

Khi tôi hiểu câu hỏi tôi đã chọn awk, sử dụng hàm băm của mỗi bản ghi, trong trường hợp này tôi giả sử rằng RS = \ n, nhưng nó có thể được thay đổi để xem xét bất kỳ cách sắp xếp nào khác, nó có thể được sắp xếp để xem xét số lượng chẵn, thay vì số lẻ, với một tham số hoặc hộp thoại nhỏ. Mỗi dòng được sử dụng như hàm băm và số lượng của nó được tăng lên, ở cuối tệp, mảng được quét và in mọi số chẵn của bản ghi. Tôi đang tính cả số đếm để kiểm tra nhưng, xóa [x] là đủ để giải quyết vấn đề đó.

HTH

mã đếm

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

Dữ liệu mẫu:

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

Chạy mẫu:

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

Nếu đầu vào được sắp xếp những gì về điều này awk:

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

với perl:

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

Sử dụng cấu trúc shell,

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

Câu đố vui!

Trong 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

Có thể nói rõ bằng 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)

Khó khăn trong Haskell:

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

một phiên bản: Tôi sử dụng "dấu phân cách" để đơn giản hóa vòng lặp bên trong (nó giả sử dòng đầu tiên không phải __unlikely_beginning__và nó giả sử văn bản không kết thúc bằng dòng: __unlikely_ending__và thêm dòng phân cách đặc biệt đó vào cuối các dòng được nhập. thuật toán có thể giả sử cả hai :)

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

Vì thế :

• chúng tôi nhớ mô hình mà chúng tôi hiện đang xem xét, tăng nó lên một lần mỗi khi nó xuất hiện trở lại. [và nếu nó đã lặp lại, chúng tôi bỏ qua 2 hành động tiếp theo, dành cho trường hợp khi mẫu thay đổi]
• Khi mẫu THAY ĐỔI:
  • nếu không phải là bội số của 2, chúng ta sẽ in một mẫu của mẫu ghi nhớ
  • và trong mọi trường hợp khi mẫu đã thay đổi: mẫu ghi nhớ mới là mẫu hiện tại và chúng tôi chỉ nhìn thấy nó một lần.