Lọc tệp theo số dòng

Cho một tệp L có một số nguyên không âm trên mỗi dòng và tệp văn bản F, cách nhanh nhất để chỉ giữ các dòng đó trong F, có số dòng xuất hiện trong tệp L là gì?

Thí dụ:

$ 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

Tôi đang tìm kiếm một lệnh có thể xử lý tệp L có 500 triệu mục trở lên; tập tin L được sắp xếp theo số lượng.

Lưu ý: Tôi mới thực hiện được một nửa command-in-questionnhưng tôi chỉ tự hỏi, liệu người ta có thể sử dụng một số công cụ Unix ở đây không.

Cập nhật: Cảm ơn tất cả các câu trả lời, tôi đã học được rất nhiều ngày hôm nay! Tôi muốn chấp nhận nhiều hơn một câu trả lời, nhưng điều đó là không thể.

Với việc Cbỏ qua các thông báo lỗi có ý nghĩa:

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

Tôi sẽ sử dụng awk, nhưng không lưu trữ toàn bộ nội dung L.txttrong bộ nhớ và thực hiện tra cứu băm không cần thiết ;-).

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

Điều đó sẽ hoạt động khá nhanh (một số bài kiểm tra thời gian được bao gồm bên dưới) với đầu vào có kích thước bất kỳ. Một số lưu ý về cách:

• export LC_ALL=C
  • Bởi vì mục đích của thao tác sau là lấy toàn bộ tệp ./Fxếp chồng lên nhau với ./Ltệp lineno của nó, các ký tự duy nhất chúng ta thực sự cần phải lo lắng là các [0-9]chữ số ASCII và :dấu hai chấm.
  • Vì lý do đó, việc lo lắng về việc tìm kiếm 11 ký tự đó trong một bộ 128 sở hữu sẽ đơn giản hơn so với nếu UTF-8 có liên quan.
• grep -n ''
  • Điều này chèn chuỗi LINENO:vào đầu của mỗi dòng trong stdin - hoặc <./F.
• sort -t: -nmk1,1 ./L -
  • sortbỏ qua việc sắp xếp các tập tin đầu vào của nó, và thay vào đó (chính xác) cho rằng chúng được sắp đặt trước và sắp xếp -mchúng -numericallytheo thứ tự được sắp xếp, về cơ bản bỏ qua mọi thứ ngoài bất kỳ ký tự đại tràng nào có thể -k1,1xảy ra -t:.
  • Mặc dù điều này có thể yêu cầu một số không gian tạm thời để thực hiện (tùy thuộc vào việc một số trình tự có thể xảy ra cách nhau bao xa) , nhưng nó sẽ không đòi hỏi nhiều so với một loại thích hợp, và nó sẽ rất nhanh vì nó liên quan đến việc quay lui bằng không.
  • sortsẽ tạo ra một luồng đơn trong đó bất kỳ dòng lineno nào ./Lsẽ ngay lập tức đi trước các dòng tương ứng ./F. ./LCác dòng luôn luôn đến đầu tiên vì chúng ngắn hơn.
• sed /:/d\;n
  • Nếu dòng hiện tại khớp với /:/dấu hai chấm dtừ đầu ra. Khác, tự động in dòng hiện tại và next.
  • Và do đó , đầu ra của sedprunes chỉ cho các cặp dòng liên tiếp không khớp với dấu hai chấm và dòng sau - hoặc, chỉ một dòng từ và sau đó đến dòng tiếp theo.sort./L
• cut -sd: -f2-
  • cut -snhấn mạnh từ đầu ra của những dòng đầu vào không chứa ít nhất một trong các -d:chuỗi loại bỏ của nó - và vì vậy ./Lcác dòng của nó được cắt tỉa hoàn toàn.
  • Đối với những dòng này, ield :được phân định bằng dấu hai chấm đầu tiên của chúng -fsẽ cutbiến mất - và tất cả các greplineno được chèn vào.

kiểm tra đầu vào nhỏ

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

... tạo ra 5 dòng đầu vào mẫu. Sau đó...

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

... bản in ...

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

kiểm tra thời gian lớn hơn

Tôi đã tạo ra một vài tệp khá lớn:

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

... trong đó đặt 5 triệu dòng /tmp/Fvà 1,5 triệu dòng được chọn ngẫu nhiên vào đó /tmp/L. Sau đó tôi đã làm:

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

Nó được in:

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

(Tôi đã thêm dấu gạch chéo ngược ở đó)

Trong số các giải pháp hiện đang được cung cấp ở đây, đây là giải pháp nhanh nhất trong số chúng nhưng một giải pháp khi đọ sức với bộ dữ liệu được tạo ở trên trên máy của tôi. Trong số những người khác chỉ có một người đến gần để tranh giành vị trí thứ hai, và đó là meuh perl ở đây .

Đây không phải là giải pháp ban đầu được đưa ra - nó đã giảm một phần ba thời gian thực hiện nhờ lời khuyên / cảm hứng được cung cấp bởi người khác. Xem lịch sử bài viết cho các giải pháp chậm hơn (nhưng tại sao?) .

Ngoài ra, điều đáng chú ý là một số câu trả lời khác rất có thể tranh luận tốt hơn nếu không phải là kiến ​​trúc đa cpu của hệ thống của tôi và việc thực hiện đồng thời từng quy trình trong đường ống đó. Tất cả đều hoạt động cùng một lúc - mỗi lõi trên bộ xử lý riêng - truyền xung quanh dữ liệu và thực hiện phần nhỏ của chúng. Nó thật tuyệt

nhưng giải pháp nhanh nhất là ...

Nhưng nó không phải là giải pháp nhanh nhất. Giải pháp nhanh nhất được cung cấp ở đây, bàn tay xuống, là chương trình C . Tôi gọi nó cselect. Sau khi sao chép nó vào clipboard X của tôi, tôi đã biên dịch nó như sau:

xsel -bo | cc -xc - -o cselect

Sau đó tôi đã làm:

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

... và kết quả là ...

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

Tôi sẽ sử dụng awk:

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

Cập nhật: Tôi đã thực hiện các biện pháp hiệu suất; có vẻ như phiên bản này có quy mô tốt hơn với các tập dữ liệu rất lớn (như trường hợp với các yêu cầu đã nêu), vì việc so sánh rất nhanh và bù đắp cho nỗ lực cần thiết để xây dựng bảng băm.

Chỉ để hoàn chỉnh: chúng ta có thể hợp nhất tập lệnh awk xuất sắc trong câu trả lời của Stéphane Chazelas và tập lệnh perl trong câu trả lời của kos nhưng không giữ toàn bộ danh sách trong bộ nhớ, với hy vọng rằng perl có thể nhanh hơn awk. (Tôi đã thay đổi thứ tự các đối số để phù hợp với câu hỏi ban đầu).

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

Tôi đã viết một kịch bản Perl đơn giản để làm điều đó:

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

• Tải F.txt
• Tải L.txt
• Lưu trữ mỗi dòng L.txtthành một mảng
• Đọc F.txttừng dòng, theo dõi số dòng hiện tại của nó và chỉ số mảng hiện tại; tăng F.txtsố dòng hiện tại; nếu F.txtsố dòng hiện tại khớp với nội dung của mảng ở chỉ mục mảng hiện tại, nó sẽ in dòng hiện tại và tăng chỉ mục

Chi phí và cân nhắc phức tạp :

Xem xét chi phí để thực hiện các bài tập, chi phí để so sánh và chi phí để in các dòng, được N ₁ là số dòng trong F.txtvà N ₂ là số dòng trong L.txt, whilevòng lặp chạy nhiều nhất N ₁ lần, dẫn đến các bài tập 2N ₁ + N ₂ (rõ ràng giả sử N ₁ > N ₂ ), so sánh 2N ₁ và in N ₂ ; được tính bằng chi phí của mỗi thao tác, tổng chi phí để chạy whilevòng lặp là 4N ₁ + 2N ₂ , dẫn đến sự phức tạp của tập lệnh O (N).

Kiểm tra tệp đầu vào 10 triệu dòng :

Sử dụng F.txttệp 10 triệu dòng chứa các dòng dài 50 ký tự ngẫu nhiên và tệp 10 triệu dòng L.txtchứa các số từ 1 đến 10000000 (trường hợp xấu nhất):

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

Giải pháp perl này nhanh hơn các giải pháp awk hoặc perl khác khoảng 20% ​​hoặc hơn, nhưng không nhanh như giải pháp trong 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

Vì L.txt được sắp xếp, bạn có thể sử dụng tham gia. Chỉ cần đánh số từng dòng trong F.txt, tham gia hai tệp, sau đó xóa số dòng. Không có tập tin trung gian lớn là cần thiết.

Trên thực tế, ở trên sẽ xử lý các dòng dữ liệu của bạn bằng cách thay thế tất cả khoảng trắng bằng một khoảng trắng. Để giữ nguyên dòng, bạn cần chọn làm dấu phân cách một số ký tự không xuất hiện trong dữ liệu của bạn, ví dụ: "|". Các cmd là sau đó

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

Sed đầu tiên loại bỏ khoảng trắng hàng đầu khỏi đầu ra "cat -n" và thay thế tab. Sed thứ hai loại bỏ số dòng và "|".

Để hoàn thiện, một nỗ lực khác tại joingiải pháp:

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

Điều này hoạt động bằng cách định dạng cột số dòng tham gia hoạt động với độ dài cố định với các số 0 đứng đầu, sao cho các số luôn dài 15 chữ số. Điều này giải quyết vấn đề tham gia không thích thứ tự sắp xếp số thông thường, vì cột hiện đã bị buộc phải sắp xếp từ điển. nlđược sử dụng để thêm số dòng ở định dạng này vào F.txt. Thật không may sedcần phải được sử dụng để định dạng lại việc đánh số trong L.txt.

Cách tiếp cận này có vẻ hoạt động tốt trên dữ liệu thử nghiệm được tạo bằng phương pháp @ mikeerv. Nhưng nó vẫn rất chậm - giải pháp c nhanh hơn 60 lần trên máy của tôi. khoảng 2/3 thời gian được dành cho sedvà 1/3 trong join. Có lẽ có một biểu hiện sed tốt hơn ...

Vì câu trả lời được chấp nhận là bằng C, tôi cho rằng không nên ném giải pháp trăn lên đây:

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

Nếu sử dụng một thư viện bên ngoài như numpy, một giải pháp sẽ trông thậm chí thanh lịch hơn:

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)