Eliminazione di righe da un file che si trovano in un altro file

Ho un file f1:

line1
line2
line3
line4
..
..

Voglio eliminare tutte le righe che si trovano in un altro file f2:

line2
line8
..
..

Ho provato qualcosa con cate sed, che non era nemmeno vicino a quello che volevo. Come posso fare questo?

grep -v -x -f f2 f1 dovrebbe fare il trucco.

Spiegazione:

• -v per selezionare le righe non corrispondenti
• -x per abbinare solo intere righe
• -f f2 per ottenere modelli da f2

Si può invece utilizzare grep -Fo fgrepper abbinare stringhe fisse da f2piuttosto che i modelli (nel caso in cui si desidera rimuovere le linee in maniera "ciò che vedi, se quello che si ottiene", piuttosto che trattare le linee f2come i modelli regex).

Prova invece la comunicazione (supponendo che f1 e f2 siano "già ordinati")

comm -2 -3 f1 f2

Per escludere file che non sono troppo grandi, puoi utilizzare gli array associativi di AWK.

awk 'NR == FNR { list[tolower($0)]=1; next } { if (! list[tolower($0)]) print }' exclude-these.txt from-this.txt 

L'output sarà nello stesso ordine del file "from-this.txt". La tolower()funzione fa distinzione tra maiuscole e minuscole, se necessario.

La complessità algoritmica sarà probabilmente O (n) (exclude-these.txt size) + O (n) (from-this.txt size)

Simile alla risposta di Dennis Williamson (per lo più modifiche sintattiche, ad esempio l'impostazione del numero di file esplicitamente invece del NR == FNRtrucco):

awk '{if (f==1) { r[$0] } else if (! ($0 in r)) { print $0 } } ' f=1 exclude-these.txt f=2 from-this.txt

L'accesso r[$0]crea la voce per quella riga, non è necessario impostare un valore.

Supponendo che awk utilizzi una tabella hash con ricerca costante e (in media) tempo di aggiornamento costante, la complessità temporale di questa sarà O (n + m), dove n e m sono le lunghezze dei file. Nel mio caso, n era ~ 25 milioni em ~ 14000. La soluzione awk è stata molto più veloce dell'ordinamento e ho anche preferito mantenere l'ordine originale.

se hai Ruby (1.9+)

#!/usr/bin/env ruby 
b=File.read("file2").split
open("file1").each do |x|
  x.chomp!
  puts x if !b.include?(x)
end

Che ha complessità O (N ^ 2). Se vuoi preoccuparti delle prestazioni, ecco un'altra versione

b=File.read("file2").split
a=File.read("file1").split
(a-b).each {|x| puts x}

che utilizza un hash per effettuare la sottrazione, così è la complessità O (n) (dimensione di a) + O (n) (dimensione di b)

ecco un piccolo benchmark, per gentile concessione di user576875, ma con 100K linee, di cui sopra:

$ for i in $(seq 1 100000); do echo "$i"; done|sort --random-sort > file1
$ for i in $(seq 1 2 100000); do echo "$i"; done|sort --random-sort > file2
$ time ruby test.rb > ruby.test

real    0m0.639s
user    0m0.554s
sys     0m0.021s

$time sort file1 file2|uniq -u  > sort.test

real    0m2.311s
user    0m1.959s
sys     0m0.040s

$ diff <(sort -n ruby.test) <(sort -n sort.test)
$

diff è stato utilizzato per mostrare che non ci sono differenze tra i 2 file generati.

Alcuni confronti temporali tra varie altre risposte:

$ for n in {1..10000}; do echo $RANDOM; done > f1
$ for n in {1..10000}; do echo $RANDOM; done > f2
$ time comm -23 <(sort f1) <(sort f2) > /dev/null

real    0m0.019s
user    0m0.023s
sys     0m0.012s
$ time ruby -e 'puts File.readlines("f1") - File.readlines("f2")' > /dev/null

real    0m0.026s
user    0m0.018s
sys     0m0.007s
$ time grep -xvf f2 f1 > /dev/null

real    0m43.197s
user    0m43.155s
sys     0m0.040s

sort f1 f2 | uniq -u non è nemmeno una differenza simmetrica, perché rimuove le linee che appaiono più volte in entrambi i file.

comm può essere utilizzato anche con le stringhe stdin e here:

echo $'a\nb' | comm -23 <(sort) <(sort <<< $'c\nb') # a

Sembra essere un lavoro adatto per la shell SQLite:

create table file1(line text);
create index if1 on file1(line ASC);
create table file2(line text);
create index if2 on file2(line ASC);
-- comment: if you have | in your files then specify “ .separator ××any_improbable_string×× ”
.import 'file1.txt' file1
.import 'file2.txt' file2
.output result.txt
select * from file2 where line not in (select line from file1);
.q

Hai provato questo con sed?

sed 's#^#sed -i '"'"'s%#g' f2 > f2.sh

sed -i 's#$#%%g'"'"' f1#g' f2.sh

sed -i '1i#!/bin/bash' f2.sh

sh f2.sh

Non una risposta di "programmazione", ma ecco una soluzione rapida e sporca: basta andare su http://www.listdiff.com/compare-2-lists-difference-tool .

Ovviamente non funzionerà per file di grandi dimensioni, ma ha funzionato per me. Alcune note:

• Non sono affiliato in alcun modo al sito web (se ancora non mi credi, puoi semplicemente cercare uno strumento diverso online; ho usato il termine di ricerca "imposta elenco differenze online")
• Il sito Web collegato sembra effettuare chiamate di rete su ogni confronto di elenchi, quindi non fornire dati sensibili