líneas Borrado de un archivo que se encuentran en otro archivo

Question

que tienen un archivo f1:

line1 
line2 
line3 
line4 
.. 
.. 

quiero borrar todas las líneas que están en otro archivo f2:

line2 
line8 
.. 
.. 

Probé algo con cat y sed, que ni siquiera estaba cerca de lo que pretendía. ¿Cómo puedo hacer esto?

Answer 1

grep -v -x -f f2 f1 debería hacer el truco.

Explicación:

• -v para seleccionar líneas no coincidentes
• -x para que coincida con las líneas enteras solamente
• -f f2 para obtener patrones de f2

Una vez puede utilizar -F f2 para que coincida cadenas fijas de f2 en lugar de patrones (en caso de que desee eliminar las líneas de una manera "lo que ve si obtiene lo que obtiene" en lugar de tratar las líneas en f2 como patrones regex).

Answer 2

Try comm lugar (suponiendo F1 y F2 están "ya ordenados")

comm -2 -3 f1 f2 

Answer 3

si tiene Rubí (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 

que tiene O (n^2) la complejidad. Si quieres que se preocupan por el rendimiento, aquí es otra versión

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

que utiliza un hash para efectuar la sustracción, por lo que es la complejidad O (n) (tamaño de a) + O (n) (tamaño de b)

aquí hay un pequeño punto de referencia, cortesía de user576875, pero con líneas de 100K, de lo anterior:

$ 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 se utilizó para mostrar que no hay diferencias entre los 2 archivos generados.

Answer 4

parece ser un trabajo adecuado para la cáscara de 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 

Answer 5

Para excluir archivos que no son demasiado grandes, puede utilizar matrices asociativas de AWK.

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

La salida estará en el mismo orden que el archivo "from-this.txt". La función tolower() lo hace insensible a las mayúsculas y minúsculas, si lo necesita.

La complejidad algorítmica probablemente será O (n) (exclude-these.txt size) + O (n) (from-this.tamaño txt)

Answer 6

Algunas comparaciones temporales entre varias otras respuestas:

$ 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 no es ni siquiera una diferencia simétrica, ya que elimina las líneas que aparecen varias veces en cualquiera de los archivos.

comunicación también se puede usar con stdin y aquí cuerdas:

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

Answer 7

similares a la respuesta de Dennis Williamson (en su mayoría los cambios sintácticos, por ejemplo, el ajuste del número de archivos de forma explícita en lugar de la NR == FNR truco):

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

Al acceder a r[$0] se crea la entrada para esa línea, no es necesario establecer un valor.

Suponiendo que awk usa una tabla hash con búsqueda constante y (en promedio) tiempo de actualización constante, la complejidad temporal de esto será O (n + m), donde n y m son las longitudes de los archivos. En mi caso, n fue ~ 25 millones y m ~ 14000. La solución awk fue mucho más rápida que la ordenada, y también preferí mantener el orden original.

Answer 8

¿Has probado este 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