Suppression des lignes d'un fichier qui se trouvent dans un autre fichier

Question

J'ai un fichier f1 :

line1
line2
line3
line4
..
..

Je veux supprimer toutes les lignes qui sont dans un autre fichier. f2 :

line2
line8
..
..

J'ai essayé quelque chose avec cat y sed ce qui n'est pas du tout ce que je voulais. Comment puis-je faire cela ?

Answer 1

grep -v -x -f f2 f1 devrait faire l'affaire.

Explication :

• -v pour sélectionner les lignes non correspondantes
• -x pour ne correspondre qu'à des lignes entières
• -f f2 pour obtenir des modèles de f2

On peut à la place utiliser grep -F o fgrep pour correspondre Cordes fixes de f2 plutôt que motifs (au cas où vous voudriez enlever les lignes d'une manière "ce que vous voyez est ce que vous obtenez" plutôt que de traiter les lignes en f2 comme des motifs regex).

Answer 2

Essayez plutôt comm (en supposant que f1 et f2 sont "déjà triés")

comm -2 -3 f1 f2

Answer 3

Si l'ordre des lignes dans la sortie n'a pas d'importance, cela fonctionne :

sort file_a file_b|uniq -u

Cela trie les deux fichiers, puis uniq peut facilement trouver les doublons et les supprimer.

El -u sur le uniq moyens de commandement remove duplicates .

La complexité du triage est de O(n.log(n)) (en supposant que sort utilise quicksort) et O(n) pour la suppression des doublons sur les lignes triées, donc ce sera plus rapide que la version grep (O(n²)) si les fichiers sont volumineux. La version de grep ressemble à ceci :

for each line l1 in f1
    for each line l2 in f2
        if l1 == l2
            break
        end if
    end for
    output l1 if no l2 == l1
endfor

Voici un benchmark rapide avec 15K entrées en f1 et 7.5K en f2 :

# add lines with number from 1 to 15000; randomly sorted; to f1
for i in $(seq 1 15000); do echo "$i"; done|sort -R > f1
# add lines with number from 1 to 15000 (with step 2); randomly sorted; to f2
for i in $(seq 1 2 15000); do echo "$i"; done|sort -R > f2

# sort|uniq -u method:
$ time sort f1 f2|uniq -u > /dev/null
real    0m0.067s
user    0m0.064s
sys     0m0.004s

# comm method (requires to sort both files separately first):
time (sort f1 > f1.sorted; sort f2 > f2.sorted; comm -2 -3 f1.sorted f2.sorted) > /dev/null
real    0m0.070s
user    0m0.068s
sys     0m0.000s

# grep method:
time grep -v -x -f f2 f1 > /dev/null
real    0m16.528s
user    0m16.457s
sys     0m0.048s

Ainsi, le sort|uniq ne prend que 0.07s tandis que le grep version prend plus de 16s et ce temps augmentera de façon exponentielle avec la taille des fichiers.

Answer 4

Pour les fichiers d'exclusion qui ne sont pas trop volumineux, vous pouvez utiliser les tableaux associatifs de AWK.

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

La sortie sera dans le même ordre que le fichier "from-this.txt". Le site tolower() le rend insensible à la casse, si vous en avez besoin.

La complexité algorithmique sera probablement O(n) (taille de exclude-these.txt) + O(n) (taille de from-this.txt)

Answer 5

Si vous avez 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

Ce qui a une complexité O(N^2). Si vous voulez vous soucier des performances, voici une autre version

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

qui utilise un hash pour effectuer la soustraction, donc de complexité O(n) (taille de a) + O(n) (taille de b)

voici un petit benchmark, avec l'aimable autorisation de l'utilisateur576875, mais avec 100K lignes, de ce qui précède :

$ 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 a été utilisé pour montrer qu'il n'y a pas de différences entre les 2 fichiers générés.