Filtrar archivo por número de línea

Dado un archivo L con un número entero no negativo por línea y un archivo de texto F, ¿cuál sería una forma rápida de mantener solo esas líneas en F, cuyo número de línea aparece en el archivo L?

Ejemplo:

$ cat L.txt
1
3

$ cat F.txt
Hello World
Hallo Welt
Hola mundo

$ command-in-question -x L.txt F.txt
Hello World
Hola mundo

Estoy buscando un comando que pueda manejar un archivo L con 500 millones o más entradas; el archivo L está ordenado numéricamente.

Nota: Estoy a mitad de camino de una implementación para un, command-in-questionpero me preguntaba si uno también podría usar algunas herramientas de Unix aquí.

Actualización: Gracias por todas las respuestas, ¡aprendí mucho hoy! Me gustaría aceptar más una respuesta, pero eso no es posible.

Al Comitir mensajes de error significativos:

#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[]) {

    FILE *L;
    FILE *F;

    unsigned int to_print;
    unsigned int current = 0;
    char *line = NULL;
    size_t len = 0;

    if ((L = fopen(argv[1], "r")) == NULL) {
        return 1;
    } else if ((F = fopen(argv[2], "r")) == NULL) {
        fclose(L);
        return 1;
    } else {

        while (fscanf(L, "%u", &to_print) > 0) {
            while (getline(&line, &len, F) != -1 && ++current != to_print);
            if (current == to_print) {
                printf("%s", line);
            }
        }

        free(line);
        fclose(L);
        fclose(F);
        return 0;
    }
}

Lo usaría awk, pero no almacenaría todo el contenido L.txten la memoria y haría búsquedas innecesarias de hash ;-).

list=L.txt file=F.txt
LIST="$list" awk '
  function nextline() {
    if ((getline n < list) <=0) exit
  }
  BEGIN{
    list = ENVIRON["LIST"]
    nextline()
  }
  NR == n {
    print
    nextline()
  }' < "$file"

grep -n | sort | sed | cut

(   export LC_ALL=C
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)   <./F

Eso debería funcionar bastante rápido (algunas pruebas cronometradas se incluyen a continuación) con entradas de cualquier tamaño. Algunas notas sobre cómo:

• export LC_ALL=C
  • Debido a que el objetivo de la siguiente operación es obtener todo el archivo ./Fapilado en línea con ./Lel archivo de lineno, los únicos caracteres de los que realmente tendremos que preocuparnos son los [0-9]dígitos ASCII y los :dos puntos.
  • Por esa razón, es más simple preocuparse por encontrar esos 11 caracteres en un conjunto de 128 posibles que si UTF-8 está involucrado de otra manera.
• grep -n ''
  • Esto inserta la cadena LINENO:en el encabezado de cada línea en stdin - o <./F.
• sort -t: -nmk1,1 ./L -
  • sortse niega a ordenar sus archivos de entrada en absoluto, y en su lugar (correctamente) presume que se han clasificado previamente y -mles Erges en -numericallyforma ordenada, ignorando básicamente cualquier cosa más allá de cualquier posible -k1,1que ocurre st -t:carácter de dos puntos de todos modos.
  • Si bien esto puede requerir cierto espacio temporal (dependiendo de qué tan separadas puedan estar algunas secuencias) , no requerirá mucho en comparación con un tipo adecuado, y será muy rápido porque implica un retroceso cero.
  • sortgenerará una sola secuencia donde cualquier entrada de lineno ./Lprecederá inmediatamente a las líneas correspondientes ./F. ./LLas líneas siempre vienen primero porque son más cortas.
• sed /:/d\;n
  • Si la línea actual coincide con /:/dos puntos, delíjala de la salida. De lo contrario, imprima automáticamente la nlínea actual y la ext.
  • Y, por lo tanto, sedelimina sortla salida a solo pares de líneas secuenciales que no coinciden con dos puntos y la siguiente línea, o, solo a una línea desde ./Ly luego a la siguiente.
• cut -sd: -f2-
  • cut -selimina de la salida los de sus líneas de entrada que no contienen al menos una de sus -d:cadenas de eliminación, y así ./Llas líneas se eliminan por completo.
  • Para aquellas líneas que lo hacen, su primer campo :delimitado por dos puntos -festá cutlejos, y así desaparecen todos greplos lineno insertados.

pequeña prueba de entrada

seq 5 | sed -ne'2,3!w /tmp/L
        s/.*/a-z &\& 0-9/p' >/tmp/F

... genera 5 líneas de entrada de muestra. Luego...

(   export LC_ALL=C; </tmp/F \
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)|  head - /tmp[FL]

...huellas dactilares...

==> standard input <==
a-z 1& 0-9
a-z 4& 0-9
a-z 5& 0-9

==> /tmp/F <==
a-z 1& 0-9
a-z 2& 0-9
a-z 3& 0-9
a-z 4& 0-9
a-z 5& 0-9

==> /tmp/L <==
1
4
5

pruebas cronometradas más grandes

Creé un par de archivos bastante grandes:

seq 5000000 | tee /tmp/F |
sort -R | head -n1500000 |
sort -n >/tmp/L

... que ponen 5mil líneas /tmp/Fy 1.5mil líneas seleccionadas al azar de eso /tmp/L. Entonces hice:

time \
(   export LC_ALL=C
    grep -n ''   | sort -t:  -nmk1,1 ./L - |
    sed /:/d\;n  | cut  -sd: -f2-
)   <./F |wc - l

Impreso:

1500000
grep -n '' \
    0.82s user 0.05s system 73% cpu 1.185 total
sort -t: -nmk1,1 /tmp/L - \
    0.92s user 0.11s system 86% cpu 1.185 total
sed /:/d\;n \
    1.02s user 0.14s system 98% cpu 1.185 total
cut -sd: -f2- \
    0.79s user 0.17s system 80% cpu 1.184 total
wc -l \
    0.05s user 0.07s system 10% cpu 1.183 total

(Agregué las barras invertidas allí)

Entre las soluciones que se ofrecen actualmente aquí, esta es la más rápida de todas, pero una cuando se enfrenta al conjunto de datos generado anteriormente en mi máquina. De los otros, solo uno estuvo cerca de competir por el segundo lugar, y ese es meuh perl aquí .

Esta no es de ninguna manera la solución original ofrecida: ha reducido un tercio de su tiempo de ejecución gracias a los consejos / inspiración ofrecidos por otros. Vea el historial de publicaciones para soluciones más lentas (pero ¿por qué?) .

Además, vale la pena señalar que algunas otras respuestas podrían contestar mejor si no fuera por la arquitectura de múltiples CPU de mi sistema y la ejecución concurrente de cada uno de los procesos en esa tubería. Todos trabajan al mismo tiempo, cada uno en su propio núcleo de procesador, pasando los datos y haciendo su pequeña parte del conjunto. Es genial.

pero la solución más rápida es ...

Pero no es la solución más rápida. La solución más rápida que aquí se ofrecen, las manos hacia abajo, es el programa C . Yo lo llamaba cselect. Después de copiarlo en mi portapapeles X, lo compilé como:

xsel -bo | cc -xc - -o cselect

Entonces hice:

time \
    ./cselect /tmp/L /tmp/F |
wc -l

... y los resultados fueron ...

1500000
./cselect /tmp/L /tmp/F  \
    0.50s user 0.05s system 99% cpu 0.551 total
wc -l \
    0.05s user 0.05s system 19% cpu 0.551 total

Yo usaría awk:

awk 'NR==FNR {a[$1]; next}; FNR in a' L.txt F.txt

Actualización: he hecho medidas de rendimiento; parece que esta versión se escala aún mejor con conjuntos de datos muy grandes (como es el caso con los requisitos establecidos), ya que la comparación es muy rápida y compensa en exceso el esfuerzo necesario para construir la tabla hash.

Solo para completar: podemos fusionar el excelente guión awk en la respuesta de Stéphane Chazelas, y el guión perl en la respuesta de kos pero sin mantener toda la lista en la memoria, con la esperanza de que perl sea más rápido que awk. (He cambiado el orden de los argumentos para que coincida con la pregunta original).

#!/usr/bin/env perl
use strict;

die "Usage: $0 l f\n" if $#ARGV+1 != 2;
open(L,$ARGV[0]) or die "$ARGV[0]: $!";
open(F,$ARGV[1]) or die "$ARGV[1]: $!";

while(my $number = <L>){
    #chop $number;
    while (<F>) {
        if($. == $number){
            print;
            last;
        }
    }
}

Escribí un script simple de Perl para hacer eso:

Usage: script.pl inputfile_f inputfile_f

#!/usr/bin/env perl

$number_arguments = $#ARGV + 1;
if ($number_arguments != 2) {
    die "Usage: script.pl inputfile_f inputfile_l\n";
}

open($f, '<', $ARGV[0])
    or die "$ARGV[0]: Not found\n";
open($l, '<', $ARGV[1])
    or die "$ARGV[1]: Not found\n";

@line_numbers = <$l>;

while ($line = <$f>) {
    $count_f ++;
    if ($count_f == @line_numbers[$count_l]) {
        print $line;
        $count_l ++;
    }
}

• Cargas F.txt
• Cargas L.txt
• Almacena cada línea de L.txten una matriz
• Lee F.txtlínea por línea, rastreando su número de línea actual y el índice de matriz actual; aumenta el F.txtnúmero de línea actual; si el F.txtnúmero de línea actual coincide con el contenido de la matriz en el índice de la matriz actual, imprime la línea actual y aumenta el índice

Consideraciones de costo y complejidad :

Teniendo en cuenta el costo de realizar las asignaciones, el costo de hacer las comparaciones y el costo de imprimir las líneas, dado N ₁ como el número de líneas F.txty N ₂ como el número de líneas L.txt, el whileciclo se ejecuta como máximo N ₁ veces, conduce a asignaciones de 2N ₁ + N ₂ (obviamente asumiendo N ₁ > N ₂ ), a comparaciones de 2N ₁ y a impresiones de N ₂ ; dado que es igual al costo de cada operación, el costo total para ejecutar el whileciclo es 4N ₁ + 2N ₂ , lo que conduce a una complejidad del script de O (N).

Prueba en un archivo de entrada de 10 millones de líneas :

Usando un F.txtarchivo de 10 millones de líneas que contiene líneas aleatorias de 50 caracteres y un L.txtarchivo de 10 millones de líneas que contiene números del 1 al 10000000 (peor de los casos):

~/tmp$ for ((i=0; i<3; i++)); do time ./script.pl F.txt L.txt > output; done

real    0m15.628s
user    0m13.396s
sys 0m2.180s

real    0m16.001s
user    0m13.376s
sys 0m2.436s

real    0m16.153s
user    0m13.564s
sys 0m2.304s

Esta solución perl es más rápida que las otras soluciones awk o perl en un 20% más o menos, pero obviamente no es tan rápida como la solución en C.

perl -e '
  open L, shift or die $!;
  open F, shift or die $!;
  exit if ! ($n = <L>);
  while (1) {
    $_ = <F>;
    next if $. != $n;
    print;
    exit if ! ($n = <L>);
  }
' -- L F

cat <<! >L.txt
1
3
!

cat <<! >F.txt
Hello World
Hallo Welt
Hola mundo
!

cmd(){
 L=$1 F=$2
 cat -n $F |
 join $L - |
 sed 's/[^ ]* //'
}

cmd L.txt F.txt
Hello World
Hola mundo

Como L.txt está ordenado, puede usar join. Simplemente numere cada línea en F.txt, una los dos archivos y luego elimine el número de línea. No se necesitan archivos intermedios grandes.

En realidad, lo anterior destruirá sus líneas de datos al reemplazar todos los espacios en blanco por un solo espacio. Para mantener la línea intacta, debe elegir como delimitador algún carácter que no aparezca en sus datos, por ejemplo, "|". El cmd es entonces

cmd(){
 L=$1 F=$2
 cat -n $F |
 sed 's/^ *//;s/\t/|/' |
 join -t'|' $L - |
 sed 's/[^|]*|//'
}

El primer sed elimina los espacios iniciales de la salida "cat -n" y reemplaza la pestaña. El segundo sed elimina el número de línea y "|".

Para completar, otro intento de joinsolución:

sed -r 's/^/00000000000000/;s/[0-9]*([0-9]{15})/\1/' /tmp/L | join <( nl -w15 -nrz /tmp/F ) - | cut -d' ' -f2-

Esto funciona formateando la columna de número de línea que une funciona como una longitud fija con ceros a la izquierda, de modo que los números siempre tengan 15 dígitos. Esto evita el problema de que a la unión no le guste el orden numérico normal, ya que la columna se ha visto obligada a clasificarse en el diccionario. nlse usa para agregar números de línea en este formato a F.txt. Lamentablemente sed, debe usarse para volver a formatear la numeración en L.txt.

Este enfoque parece funcionar bien en los datos de prueba generados utilizando el método de @ mikeserv. Pero todavía es muy lento: la solución c es 60 veces más rápida en mi máquina. aproximadamente 2/3 del tiempo se gasta en sedy 1/3 en join. Quizás haya una mejor expresión sed ...

Como la respuesta aceptada está en C, pensé que está bien lanzar una solución de Python aquí:

# Read mask
with open('L.txt', 'r') as f:
    mask = [int(line_num) for line_num in f.read().splitlines()]

# Filter input file
filtered_lines = []
with open('F.txt', 'r') as f:
    for i, line in enumerate(f.read().splitlines()):
        if (i+1) in mask:
            filtered_lines.append(line)

# Write newly filtered file
with open('F_filtered.txt', 'w') as f:
    for line in filtered_lines:
        f.write('%s\n' % line)

Si usa una biblioteca externa como numpy, una solución se vería aún más elegante:

import numpy as np

with open('L.txt', 'r') as f:
    mask = np.array([int(line_num)-1 for line_num in f.read().splitlines()])

with open('F.txt', 'r') as f:
    lines = np.array(f.read().splitlines())
filtered_lines = lines[mask]

with open('F_filtered.txt', 'w') as f:
    for line in filtered_lines:
        f.write('%s\n' % line)