กรองไฟล์ตามหมายเลขบรรทัด

เมื่อกำหนดไฟล์ L ที่มีจำนวนเต็มไม่เป็นลบหนึ่งตัวต่อบรรทัดและไฟล์ข้อความ F จะเป็นวิธีที่รวดเร็วในการเก็บเฉพาะบรรทัดเหล่านั้นใน F ซึ่งมีหมายเลขบรรทัดใดปรากฏในไฟล์ L

ตัวอย่าง:

$ 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

ฉันกำลังมองหาคำสั่งที่สามารถจัดการไฟล์ L ที่มี 500 ล้านรายการขึ้นไป ไฟล์ L เรียงลำดับตัวเลข

หมายเหตุ: ฉันผ่านการใช้งานไปครึ่งทางแล้วcommand-in-questionแต่ฉันเพิ่งสงสัยว่าอาจใช้เครื่องมือ Unix ได้ที่นี่เช่นกัน

ปรับปรุง: ขอบคุณสำหรับคำตอบทั้งหมดฉันเรียนรู้มากวันนี้! ฉันต้องการยอมรับคำตอบมากกว่าหนึ่งคำตอบ แต่นั่นเป็นไปไม่ได้

ด้วยการCละเว้นข้อความผิดพลาดที่มีความหมาย:

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

ฉันจะใช้awkแต่ไม่เก็บเนื้อหาทั้งหมดของL.txtในหน่วยความจำและทำการแฮชค้นหาโดยไม่จำเป็น ;-)

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

ที่ควรจะทำงานได้อย่างรวดเร็ว(การทดสอบตามกำหนดเวลาบางส่วนจะรวมอยู่ด้านล่าง)พร้อมอินพุตทุกขนาด หมายเหตุบางประการเกี่ยวกับวิธีการ:

• export LC_ALL=C
  • เนื่องจากจุดของการดำเนินการต่อไปนี้คือการทำให้ไฟล์ทั้งหมดของ./Fกองซ้อนในแนวเดียวกันกับ./Lไฟล์ lineno ของมันตัวละครเดียวที่เราต้องกังวลคือ[0-9]ตัวเลขASCII และ:โคลอน
  • ด้วยเหตุนี้จึงง่ายกว่าที่คุณจะกังวลเกี่ยวกับการค้นหาตัวละครทั้ง 11 ตัวในกลุ่มของ 128 สิ่งของมากกว่าที่เป็นถ้ามีส่วนเกี่ยวข้องกับ UTF-8
• grep -n ''
  • แทรกนี้สตริงLINENO:เข้ามาในหัวของสายในทุก stdin - <./Fหรือ
• sort -t: -nmk1,1 ./L -
  • sortละเลยที่จะเรียงลำดับไฟล์อินพุตเลยและแทน(อย่างถูกต้อง)ทึกทักเอาว่าพวกมันถูกจัดเรียง-mไว้แล้วและ-numericallyเรียงตามลำดับโดยไม่สนใจสิ่งใด ๆ นอกเหนือจากตัวอักษรโคลอนที่-k1,1เกิดขึ้น-t:
  • ในขณะนี้อาจต้องใช้พื้นที่ชั่วคราวในการทำ(ขึ้นอยู่กับว่าบางลำดับอาจเกิดขึ้นห่างกัน)มันจะไม่ต้องการมากเมื่อเทียบกับการเรียงลำดับที่เหมาะสมและมันจะเร็วมากเพราะมันเกี่ยวข้องกับการย้อนรอยเป็นศูนย์
  • sortจะส่งกระแสข้อมูลเดียวที่มีผ้าปูที่นอนในใด ๆ./Lจะนำหน้าบรรทัดที่เกี่ยวข้อง./Fทันที ./Lเส้นของต้องมาก่อนเสมอเพราะเส้นสั้นกว่า
• sed /:/d\;n
  • หากบรรทัดปัจจุบันตรงกับ/:/โคลอนdจะลบออกจากเอาต์พุต อื่นพิมพ์อัตโนมัติในปัจจุบันและnต่อสาย
  • ดังนั้นการส่งออกของsedลูกพรุนsortไปยังคู่สายตามลำดับเท่านั้นซึ่งไม่ตรงกับเครื่องหมายโคลอนและบรรทัดต่อไปนี้ - หรือเฉพาะบรรทัดจาก./Lและถัดไปเท่านั้น
• cut -sd: -f2-
  • cut -sตัวพิมพ์ใหญ่จากเอาต์พุตของบรรทัดอินพุตที่ไม่มี-d:สตริงตัวกำจัดอย่างน้อยหนึ่งตัว- และ./Lบรรทัดของนั้นจะถูกตัดออกอย่างสมบูรณ์
  • สำหรับสายเหล่านั้นที่ทำครั้งแรกของพวกเขา:ลำไส้ใหญ่คั่น-field เป็นcutไป - และอื่น ๆ ไปทั้งหมดของgrep's แทรก LineNo ของ

ทดสอบอินพุตขนาดเล็ก

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

... สร้างอินพุตตัวอย่าง 5 บรรทัด จากนั้น ...

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

... พิมพ์ ...

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

การทดสอบหมดเวลาที่ใหญ่กว่า

ฉันสร้างไฟล์ขนาดใหญ่สองสามไฟล์:

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

... ซึ่งวางสาย 5mil ใน/tmp/Fและ 1.5mil /tmp/Lสายการสุ่มเลือกของเข้าที่ จากนั้นฉันก็:

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

มันพิมพ์:

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

(ฉันเพิ่มแบ็กสแลชที่นั่น)

ในบรรดาโซลูชั่นที่มีอยู่ในปัจจุบันนี่คือวิธีที่เร็วที่สุดของทั้งหมด แต่หนึ่งวิธีเมื่อเทียบกับชุดข้อมูลที่สร้างขึ้นบนเครื่องของฉัน ของคนอื่น ๆ เพียงคนเดียวที่เข้ามาใกล้ต่อสู้เพื่อที่สองและที่เป็น meuh เป็นที่นี่perl

นี่ไม่ใช่วิธีการดั้งเดิมที่เสนอ - มันลดลงหนึ่งในสามของเวลาดำเนินการขอบคุณคำแนะนำ / แรงบันดาลใจจากผู้อื่น ดูประวัติการโพสต์สำหรับการแก้ปัญหาช้า( แต่ทำไม?)

นอกจากนี้ยังเป็นที่น่าสังเกตว่าคำตอบอื่น ๆ อาจจะดีกว่าถ้ามันไม่ใช่สถาปัตยกรรม multi-cpu ของระบบของฉันและการทำงานพร้อมกันของแต่ละกระบวนการในไปป์ไลน์นั้น พวกเขาทั้งหมดทำงานในเวลาเดียวกัน - แต่ละตัวประมวลผลหลัก - ส่งผ่านข้อมูลและทำส่วนเล็ก ๆ ของทั้งหมด มันเจ๋งมาก

แต่ทางออกที่เร็วที่สุดคือ ...

แต่มันไม่ใช่ทางออกที่เร็วที่สุด วิธีที่เร็วที่สุดที่นำเสนอที่นี่มือลงเป็นโปรแกรม C cselectผมเรียกมันว่า หลังจากคัดลอกไปยังคลิปบอร์ด X ของฉันฉันรวบรวมมันเช่น:

xsel -bo | cc -xc - -o cselect

จากนั้นฉันก็:

time \
    ./cselect /tmp/L /tmp/F |
wc -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

ฉันต้องการใช้awk:

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

อัปเดต: ฉันได้ทำการวัดประสิทธิภาพแล้ว ดูเหมือนว่ารุ่นนี้จะปรับขนาดได้ดียิ่งขึ้นด้วยชุดข้อมูลที่มีขนาดใหญ่มาก (เช่นกรณีที่มีข้อกำหนดที่ระบุไว้) เนื่องจากการเปรียบเทียบนั้นรวดเร็วมากและชดเชยความพยายามที่จำเป็นในการสร้างตารางแฮช

เพื่อความสมบูรณ์: เราสามารถรวมสคริปต์ awk ที่ยอดเยี่ยมในคำตอบโดยStéphane Chazelas และสคริปต์ Perl ในคำตอบโดย kos แต่โดยไม่เก็บรายการทั้งหมดไว้ในหน่วยความจำด้วยความหวังว่า Perl อาจเร็วกว่า awk (ฉันได้เปลี่ยนลำดับของ args เพื่อให้ตรงกับคำถามเดิม)

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

ฉันเขียนสคริปต์ Perl ง่าย ๆ ที่จะทำ:

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

• โหลด F.txt
• โหลด L.txt
• ร้านค้าแต่ละบรรทัด L.txtลงในอาร์เรย์
• อ่านทีF.txtละบรรทัดติดตามหมายเลขบรรทัดปัจจุบันและดัชนีอาร์เรย์ปัจจุบัน เพิ่มF.txtหมายเลขบรรทัดปัจจุบัน หากF.txtหมายเลขบรรทัดปัจจุบันตรงกับเนื้อหาของอาร์เรย์ที่ดัชนีอาร์เรย์ปัจจุบันจะพิมพ์บรรทัดปัจจุบันและเพิ่มดัชนี

ข้อพิจารณาด้านราคาและความซับซ้อน :

เมื่อพิจารณาจากค่าใช้จ่ายที่จะทำให้การกำหนดค่าใช้จ่ายที่จะทำให้รถและค่าใช้จ่ายในการพิมพ์เส้นที่ได้รับ N ₁เป็นจำนวนเส้นในF.txtและ N ₂เป็นจำนวนบรรทัดในL.txtที่whileห่วงวิ่งมากที่สุด N ₁ครั้ง นำไปสู่การมอบหมาย2N ₁ + N ₂ (โดยชัดว่าสมมติว่า N ₁ > N ₂ ) เปรียบเทียบกับ2N ₁และ N ₂ภาพพิมพ์; กำหนดเท่ากับต้นทุนของการดำเนินการแต่ละครั้งค่าใช้จ่ายทั้งหมดในการดำเนินการwhileลูปคือ 4N ₁ + 2N ₂ซึ่งนำไปสู่ความซับซ้อนของสคริปต์ของ O (N)

ทดสอบไฟล์อินพุต 10 ล้านบรรทัด :

การใช้ไฟล์ 10 ล้านเส้นF.txtที่มีบรรทัดยาว 50 อักขระแบบสุ่มและไฟล์ 10 ล้านบรรทัดL.txtที่มีตัวเลขตั้งแต่ 1 ถึง 10,000,000 (สถานการณ์กรณีที่เลวร้ายที่สุด):

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

โซลูชัน perl นี้เร็วกว่าโซลูชัน awk หรือ perl อื่น ๆ ประมาณ 20% หรือมากกว่านั้น แต่ไม่เร็วเท่ากับโซลูชันใน 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

เนื่องจาก L.txt ถูกเรียงลำดับคุณสามารถใช้เข้าร่วม เพียงกำหนดหมายเลขแต่ละบรรทัดใน F.txt เข้าร่วมสองไฟล์จากนั้นลบหมายเลขบรรทัด ไม่จำเป็นต้องใช้ไฟล์ขนาดใหญ่

ที่จริงแล้วข้างต้นจะคล้ำสายข้อมูลของคุณโดยแทนที่พื้นที่สีขาวทั้งหมดด้วยช่องว่างเดียว เพื่อให้บรรทัดยังคงเหมือนเดิมคุณต้องเลือกเป็นตัวคั่นบางตัวที่ไม่ปรากฏในข้อมูลของคุณเช่น "|" cmd นั้น

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

sed แรกจะลบช่องว่างนำออกจากเอาต์พุต "cat -n" และแทนที่แท็บ รุ่นที่สองจะลบหมายเลขบรรทัดและ "|"

เพื่อความสมบูรณ์ลองอีกjoinวิธีในการแก้ปัญหา:

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

สิ่งนี้ทำงานโดยการจัดรูปแบบคอลัมน์หมายเลขบรรทัดที่เข้าร่วมทำงานเป็นความยาวคงที่ด้วยศูนย์นำหน้าเพื่อให้ตัวเลขมีความยาว 15 หลักเสมอ สิ่งนี้จะหลีกเลี่ยงปัญหาของการเข้าร่วมที่ไม่ชอบลำดับการเรียงเชิงตัวเลขปกติเนื่องจากคอลัมน์ได้ถูกบังคับให้เรียงลำดับพจนานุกรมอย่างมีประสิทธิภาพ nlใช้เพื่อเพิ่มหมายเลขบรรทัดในรูปแบบนี้ไปยัง F.txt น่าเสียดายsedที่ต้องใช้การฟอร์แมตตัวเลขใน L.txt

วิธีการนี้ดูเหมือนว่าจะใช้ได้บนข้อมูลทดสอบที่สร้างขึ้นโดยใช้วิธีการของ @ mikeserv แต่มันยังช้ามาก - โซลูชัน c นั้นเร็วกว่า 60 เท่าบนเครื่องของฉัน เกี่ยวกับ 2/3 ของเวลาที่ใช้ในsedและ 1/3 joinใน อาจมีการแสดงออกที่ดีกว่า ...

เนื่องจากคำตอบที่ได้รับการยอมรับอยู่ใน C ฉันคิดว่ามันก็โอเคที่จะทิ้งโซลูชันหลามไว้ที่นี่:

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

หากใช้ไลบรารีภายนอกเช่น numpy โซลูชันจะดูสง่างามยิ่งขึ้น:

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)