Datei nach Zeilennummer filtern

Was wäre bei einer Datei L mit einer nicht-negativen Ganzzahl pro Zeile und Textdatei F ein schneller Weg, um nur die Zeilen in F zu belassen, deren Zeilennummer in Datei L erscheint?

Beispiel:

$ 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

Ich suche nach einem Befehl, der eine Datei L mit 500 Millionen oder mehr Einträgen verarbeiten kann. Datei L ist numerisch sortiert.

Hinweis: Ich bin auf halbem Weg durch eine Implementierung für eine, command-in-questionaber ich habe mich nur gefragt, ob man möglicherweise auch hier einige Unix-Tools verwenden kann.

Update: Vielen Dank für die Antworten, ich habe heute viel gelernt! Ich würde gerne noch eine Antwort annehmen, aber das ist nicht möglich.

Mit CWeglassen aussagekräftige Fehlermeldungen:

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

Ich würde verwenden awk, aber nicht den gesamten Inhalt L.txtim Speicher speichern und unnötige Hash-Lookups durchführen ;-).

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

Das sollte ziemlich schnell gehen (einige zeitgesteuerte Tests sind unten aufgeführt) mit Eingaben jeder Größe. Einige Hinweise, wie:

• export LC_ALL=C
  • Da der Sinn der folgenden Operation darin besteht, die gesamte ./Fgestapelte Datei mit der ./LLineno-Datei in Einklang zu bringen, müssen wir uns nur um ASCII- [0-9]Ziffern und den :Doppelpunkt kümmern .
  • Aus diesem Grund ist es einfacher, diese 11 Zeichen in einem Satz von 128 Möglichkeiten zu finden, als wenn UTF-8 anderweitig betroffen ist.
• grep -n ''
  • Dies fügt den String LINENO:in den Kopf jeder Zeile in stdin - or ein <./F.
• sort -t: -nmk1,1 ./L -
  • sortVernachlässigt das Sortieren seiner Eingabedateien überhaupt und geht stattdessen (korrekt) davon aus, dass sie vorsortiert sind, und -mfügt sie in -numericallysortierter Reihenfolge zusammen, wobei grundsätzlich alles ignoriert wird, was über ein eventuell -k1,1vorkommendes -t:Doppelpunkt-Zeichen hinausgeht .
  • Dies kann zwar einige temporäre Speicherplätze erfordern (abhängig davon, wie weit einige Sequenzen voneinander entfernt sind) , erfordert jedoch im Vergleich zu einer geeigneten Sortierung nicht viel und ist sehr schnell, da kein Backtracking erforderlich ist.
  • sortGibt einen einzelnen Stream aus, in dem alle Linenos ./Ldirekt vor den entsprechenden Zeilen stehen ./F. ./LDie Zeilen stehen immer an erster Stelle, weil sie kürzer sind.
• sed /:/d\;n
  • Wenn die aktuelle Zeile mit einem /:/Doppelpunkt dübereinstimmt, wird sie aus der Ausgabe entfernt. Andernfalls werden die aktuelle und die next-Zeile automatisch gedruckt .
  • Und so sedPflaumen sort‚s Ausgabe nur sequenzielle Leitungspaar , die nicht einen Doppelpunkt und die folgende Zeile passen - oder, um nur eine Zeile aus ./Lund dann die nächsten.
• cut -sd: -f2-
  • cut -sUppresses von Output die seiner Eingabezeilen, die nicht mindestens einen seiner -d:Elimiter-Strings enthalten - und so werden ./Ldie Zeilen komplett beschnitten.
  • Für die Zeilen, die dies tun, ist ihr erstes durch :Doppelpunkte getrenntes -fFeld cutweg - und so geht es mit allen von ihnen grepeingefügten Linenos.

kleiner Eingangstest

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

... generiert 5 Zeilen Sample-Input. Dann...

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

... druckt ...

==> 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

größere zeitgesteuerte Tests

Ich habe ein paar ziemlich große Dateien erstellt:

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

... die 5mil Zeilen in /tmp/Fund 1,5mil zufällig ausgewählte Zeilen davon in setzen /tmp/L. Ich habe dann gemacht:

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

Es druckte:

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

(Ich habe die Backslashes dort hinzugefügt)

Unter den derzeit hier angebotenen Lösungen ist dies die schnellste von allen, außer einer, wenn sie mit dem oben auf meinem Computer generierten Datensatz verglichen wird. Von den anderen wäre nur einer beinahe um den zweiten Platz gekämpft, und das ist meuhs perl hier .

Dies ist keineswegs die ursprüngliche Lösung, die angeboten wird. Dank der Ratschläge und Anregungen anderer konnte die Ausführungszeit um ein Drittel verkürzt werden. Informationen zu langsameren Lösungen finden Sie im Post-Verlauf (aber warum?) .

Es ist auch erwähnenswert, dass einige andere Antworten möglicherweise besser miteinander konkurrieren, wenn nicht die Multi-CPU-Architektur meines Systems und die gleichzeitige Ausführung der einzelnen Prozesse in dieser Pipeline berücksichtigt würden. Sie arbeiten alle zur gleichen Zeit - jeder auf seinem eigenen Prozessorkern - und geben die Daten weiter und erledigen ihren kleinen Teil des Ganzen. Es ist ziemlich cool.

aber die schnellste lösung ist ...

Aber es ist nicht die schnellste Lösung. Die schnellste Lösung, die hier zweifellos angeboten wird, ist das C-Programm . Ich habe es genannt cselect. Nachdem ich es in meine X-Zwischenablage kopiert habe, habe ich es wie folgt kompiliert:

xsel -bo | cc -xc - -o cselect

Ich habe dann gemacht:

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

... und die Ergebnisse waren ...

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

Ich würde verwenden awk:

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

Update: Ich habe Leistungsmessungen durchgeführt. Es scheint, dass diese Version bei sehr großen Datenmengen noch besser skaliert (wie es bei den angegebenen Anforderungen der Fall ist), da der Vergleich sehr schnell ist und den zum Aufbau der Hash-Tabelle erforderlichen Aufwand überkompensiert.

Der Vollständigkeit halber: Wir können das ausgezeichnete awk-Skript in der Antwort von Stéphane Chazelas und das Perl-Skript in der Antwort von kos zusammenführen, ohne jedoch die gesamte Liste im Gedächtnis zu behalten, in der Hoffnung, dass Perl möglicherweise schneller ist als awk. (Ich habe die Reihenfolge der Argumente geändert, um sie mit der ursprünglichen Frage abzugleichen.)

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

Ich habe dazu ein einfaches Perl-Skript geschrieben:

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 ++;
    }
}

• Ladungen F.txt
• Ladungen L.txt
• Speichert jede Zeile von L.txtin einem Array
• Liest F.txtzeilenweise und verfolgt dabei die aktuelle Zeilennummer und den aktuellen Array-Index. erhöht die F.txtaktuelle Zeilennummer; Wenn die F.txtaktuelle Zeilennummer mit dem Inhalt des Arrays am aktuellen Arrayindex übereinstimmt, wird die aktuelle Zeile gedruckt und der Index erhöht

Kosten- und Komplexitätsaspekte :

In Anbetracht der Kosten für die Ausführung der Aufgaben, der Kosten für die Durchführung der Vergleiche und der Kosten für das Drucken der Zeilen, wobei N ₁ als Anzahl der Zeilen F.txtund N ₂ als Anzahl der Zeilen angegeben wird, läuft L.txtdie whileSchleife höchstens N _1- mal. führt zu 2N ₁ + N ₂ -Zuweisungen (offensichtlich unter der Annahme, dass N ₁ > N _{2 ist} ), zu 2N ₁ -Vergleichen und zu N ₂ -Drucken; Wenn die Kosten für jede Operation gleich sind, betragen die Gesamtkosten für die Ausführung der whileSchleife 4N ₁ + 2N ₂ , was zu einer Komplexität des Skripts von O (N) führt.

Test mit einer Eingabedatei mit 10 Millionen Zeilen :

Verwenden einer 10-Millionen-Zeilen- F.txtDatei mit zufälligen Zeilen von 50 Zeichen Länge und einer 10-Millionen-Zeilen- L.txtDatei mit Zahlen von 1 bis 10000000 (Worst-Case-Szenario):

~/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

Diese Perl-Lösung ist um etwa 20% schneller als die anderen awk- oder perl-Lösungen, jedoch offensichtlich nicht so schnell wie die Lösung in 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

Da L.txt sortiert ist, können Sie join verwenden. Nummerieren Sie einfach jede Zeile in F.txt, verbinden Sie die beiden Dateien und entfernen Sie die Zeilennummer. Es werden keine großen Zwischendateien benötigt.

Tatsächlich werden Ihre Datenleitungen durch das oben beschriebene Verfahren entstellt, indem der gesamte Leerraum durch ein einzelnes Leerzeichen ersetzt wird. Um die Zeile intakt zu halten, müssen Sie als Trennzeichen ein Zeichen wählen, das in Ihren Daten nicht vorkommt, z. B. "|". Der cmd ist dann

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

Das erste sed entfernt führende Leerzeichen aus der Ausgabe von "cat -n" und ersetzt den Tabulator. Der zweite Satz entfernt die Zeilennummer und "|".

Der Vollständigkeit halber noch ein joinLösungsversuch:

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

Dies funktioniert, indem die Spalte mit der Zeilennummer, die verbunden wird, als feste Länge mit führenden Nullen formatiert wird, sodass die Zahlen immer 15 Stellen lang sind. Dies umgeht das Problem, dass Verknüpfungen die normale numerische Sortierreihenfolge nicht mögen, da die Spalte nun effektiv als Wörterbuchsortierung verwendet werden muss. nlwird verwendet, um Zeilennummern in diesem Format zu F.txt hinzuzufügen. sedMuss leider zur Neuformatierung der Nummerierung in L.txt verwendet werden.

Dieser Ansatz scheint bei den mit der @ mikeserv-Methode generierten Testdaten in Ordnung zu sein. Aber es ist immer noch sehr langsam - die c-Lösung ist auf meinem Computer 60x schneller. etwa 2/3 der Zeit wird in sedund 1/3 in verbracht join. Vielleicht gibt es einen besseren sed Ausdruck ...

Da die akzeptierte Antwort in C ist, dachte ich, es ist in Ordnung, hier eine Python-Lösung zu werfen:

# 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)

Wenn Sie eine externe Bibliothek wie numpy verwenden, sieht eine Lösung noch eleganter aus:

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)