Saring file dengan nomor baris

Diberikan file L dengan satu bilangan bulat non-negatif per baris dan file teks F, apa yang akan menjadi cara cepat untuk menjaga hanya baris-baris di F, yang nomor barisnya muncul di file L?

Contoh:

$ 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

Saya mencari perintah yang dapat menangani file L dengan 500 juta atau lebih entri; File L diurutkan secara numerik.

Catatan: Saya setengah jalan dalam implementasi untuk command-in-questiontetapi saya hanya bertanya-tanya, apakah orang mungkin dapat menggunakan beberapa alat Unix di sini juga.

Pembaruan: Terima kasih atas semua jawaban, saya belajar banyak hari ini! Saya ingin menerima lebih banyak satu jawaban, tetapi itu tidak mungkin.

Dengan Cmenghilangkan pesan kesalahan yang bermakna:

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

Saya akan menggunakan awk, tetapi tidak menyimpan seluruh konten L.txtdalam memori dan melakukan hash look up yang tidak perlu ;-).

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

Itu harus bekerja cukup cepat (beberapa tes waktunya termasuk di bawah ini) dengan input ukuran berapa pun. Beberapa catatan tentang caranya:

• export LC_ALL=C
  • Karena tujuan dari operasi berikut adalah untuk mendapatkan seluruh file yang ./Fditumpuk sejajar dengan ./Lfile lineno -nya , satu-satunya karakter yang benar-benar perlu kita khawatirkan adalah [0-9]digit ASCII dan :titik dua.
  • Untuk alasan itu, lebih mudah untuk khawatir menemukan 11 karakter itu dalam 128 possible daripada jika UTF-8 terlibat.
• grep -n ''
  • Ini memasukkan string LINENO:ke kepala setiap baris di stdin - atau <./F.
• sort -t: -nmk1,1 ./L -
  • sortsama sekali tidak menyortir file-file inputnya, dan sebaliknya (dengan benar) mengira file-file itu di - -mpresort dan menyesuaikannya dalam -numericallyurutan yang diurutkan, pada dasarnya mengabaikan apa pun yang melampaui karakter usus besar yang mungkin -k1,1terjadi -t:.
  • Meskipun ini mungkin memerlukan beberapa ruang temp untuk dilakukan (tergantung pada seberapa jauh jarak beberapa urutan mungkin terjadi) , itu tidak akan memerlukan banyak dibandingkan dengan jenis yang tepat, dan itu akan sangat cepat karena melibatkan nol backtracking.
  • sortakan menampilkan aliran tunggal di mana setiap lineno ./Lakan segera mendahului baris yang sesuai di ./F. ./LGaris selalu didahulukan karena lebih pendek.
• sed /:/d\;n
  • Jika baris saat ini cocok dengan /:/titik dua, dhilangkan itu dari output. Lain, cetak otomatis jalur saat ini dan next.
  • Dan demikian, sedpangkas sortoutput hanya untuk pasangan garis berurutan yang tidak cocok dengan titik dua dan baris berikut - atau, hanya untuk satu baris dari ./Ldan kemudian berikutnya.
• cut -sd: -f2-
  • cut -suppresses dari output mereka dari jalur input yang tidak mengandung setidaknya satu dari -d:string elimiter - dan begitu juga ./Lgaris dipangkas sepenuhnya.
  • Untuk baris-baris yang ada, ield yang :dibatasi usus besar pertama mereka -fada cut- dan begitu juga semua greplineno yang dimasukkan.

uji input kecil

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

... menghasilkan 5 baris input sampel. Kemudian...

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

... mencetak ...

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

tes waktunya lebih besar

Saya membuat beberapa file yang cukup besar:

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

... yang memasukkan 5 mil garis /tmp/Fdan 1,5 mil garis yang dipilih secara acak ke dalam /tmp/L. Saya kemudian melakukan:

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

Itu dicetak:

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

(Saya menambahkan garis miring terbalik di sana)

Di antara solusi yang saat ini ditawarkan di sini, ini adalah yang tercepat dari mereka semua tetapi satu ketika diadu dengan dataset yang dihasilkan di atas pada mesin saya. Yang lainnya hanya satu yang hampir bersaing untuk tempat kedua, dan itu meuh di perl sini .

Ini sama sekali bukan solusi asli yang ditawarkan - ia telah menjatuhkan sepertiga dari waktu pelaksanaannya berkat saran / inspirasi yang ditawarkan oleh orang lain. Lihat riwayat kiriman untuk solusi yang lebih lambat (tapi mengapa?) .

Juga, perlu dicatat bahwa beberapa jawaban lain mungkin akan berpendapat lebih baik jika bukan karena arsitektur multi-CPU dari sistem saya dan eksekusi bersamaan dari setiap proses dalam pipa itu. Mereka semua bekerja pada saat yang sama - masing-masing pada inti prosesor sendiri - melewati data dan melakukan bagian kecil mereka secara keseluruhan. Itu sangat keren.

tetapi solusi tercepat adalah ...

Tetapi ini bukan solusi tercepat. Solusi tercepat yang ditawarkan di sini, tangan-down, adalah program C . Saya menyebutnya cselect. Setelah menyalinnya ke clipboard X saya, saya mengompilasinya seperti:

xsel -bo | cc -xc - -o cselect

Saya kemudian melakukannya:

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

... dan hasilnya adalah ...

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

Saya akan menggunakan awk:

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

Pembaruan: Saya telah melakukan pengukuran kinerja; tampaknya versi ini menskala lebih baik dengan set data yang sangat besar (seperti halnya dengan persyaratan yang dinyatakan), karena perbandingannya sangat cepat dan mengkompensasi upaya yang diperlukan untuk membangun tabel hash.

Hanya untuk kelengkapan: kita dapat menggabungkan skrip awk yang sangat baik dalam jawaban oleh Stéphane Chazelas, dan skrip perl dalam jawaban dengan kos tetapi tanpa menyimpan seluruh daftar dalam memori, dengan harapan perl mungkin lebih cepat daripada awk. (Saya telah mengubah urutan argumen agar sesuai dengan pertanyaan awal).

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

Saya menulis skrip Perl sederhana untuk melakukan itu:

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

• Banyak F.txt
• Banyak L.txt
• Menyimpan setiap baris L.txtdalam sebuah array
• Membaca F.txtbaris demi baris, melacak nomor baris saat ini dan indeks array saat ini; meningkatkan F.txtnomor baris saat ini; jika F.txtnomor baris saat ini cocok dengan konten array di indeks array saat ini, itu mencetak baris saat ini dan meningkatkan indeks

Pertimbangan biaya dan kompleksitas :

Mempertimbangkan biaya untuk membuat penugasan, biaya untuk membuat perbandingan dan biaya untuk mencetak garis, diberikan N ₁ sebagai jumlah baris F.txtdan N ₂ sebagai jumlah baris L.txt, whileloop berjalan paling banyak N ₁ kali, mengarah ke penugasan 2N ₁ + N ₂ (jelas dengan asumsi N ₁ > N ₂ ), untuk perbandingan 2N ₁ dan ke cetakan N ₂ ; diberikan sebagai sama dengan biaya setiap operasi, total biaya untuk menjalankan whileloop adalah 4N ₁ + 2N ₂ , yang mengarah pada kompleksitas skrip O (N).

Tes pada file input 10 juta baris :

Menggunakan file 10-juta-baris yang F.txtberisi 50-karakter-panjang baris acak dan 10-juta-baris L.txtfile yang berisi angka 1 hingga 10.000000 (skenario terburuk):

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

Solusi perl ini lebih cepat daripada solusi awk atau perl lainnya sebesar 20% atau lebih, tetapi sebelumnya tidak secepat solusi dalam 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

Karena L.txt diurutkan Anda dapat menggunakan gabung. Cukup beri nomor pada setiap baris di F.txt, gabungkan dua file, lalu hapus nomor baris. Tidak diperlukan file perantara yang besar.

Sebenarnya, di atas akan memotong-motong garis data Anda dengan mengganti semua ruang putih dengan satu ruang. Agar garis tetap utuh, Anda harus memilih sebagai pembatas beberapa karakter yang tidak muncul dalam data Anda, mis. "|". Cmd kemudian

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

Sed pertama menghapus spasi utama dari output "cat -n" dan menggantikan tab. Sed kedua menghapus nomor baris dan "|".

Untuk kelengkapan, upaya lain untuk joinsolusi:

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

Ini berfungsi dengan memformat kolom nomor baris yang bergabung bekerja sebagai panjang tetap dengan nol di depan, sehingga angka-angka selalu panjang 15 digit. Ini menghindari masalah bergabung tidak menyukai urutan urutan numerik yang normal, karena kolom sekarang secara efektif telah dipaksa menjadi semacam kamus. nldigunakan untuk menambahkan nomor baris dalam format ini ke F.txt. Sayangnya sedperlu digunakan untuk memformat ulang penomoran dalam L.txt.

Pendekatan ini tampaknya berfungsi baik pada data uji yang dihasilkan menggunakan metode @ mikeserv. Tetapi masih sangat lambat - solusi c 60x lebih cepat pada mesin saya. sekitar 2/3 dari waktu dihabiskan di seddan 1/3 di join. Mungkin ada ekspresi sed yang lebih baik ...

Karena jawaban yang diterima adalah dalam C, saya pikir tidak masalah untuk melempar solusi python di sini:

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

Jika menggunakan perpustakaan eksternal seperti numpy, solusi akan terlihat lebih elegan:

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)