Фільтруйте файл за номером рядка

З огляду на файл 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«вставляють 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 тут .

Це аж ніяк не оригінальне пропоноване рішення - воно втратило третину часу його виконання завдяки порадам / натхненню, запропонованим іншими. Дивіться історію публікацій для повільніших рішень (але чому?) .

Крім того, варто відзначити, що деякі інші відповіді можуть бути набагато кращими, якби не архітектура з декількома процесорами моєї системи та одночасне виконання кожного з процесів у цьому конвеєрі. Всі вони працюють одночасно - кожен у своєму ядрі процесора - передаючи дані та виконуючи свою невелику частину цілого. Це досить круто.

але найшвидше рішення -

Але це не найшвидше рішення. Найшвидше рішення пропонується тут, руки вниз, це програма 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 у відповідь Стефана Шазеласа та сценарій perl у відповіді kos, але не зберігаючи весь список у пам’яті, сподіваючись, що perl може бути швидшим, ніж awk. (Я змінив порядок аргументів, щоб відповідати початковому питанню).

#!/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 до 10000000 (найгірший сценарій):

~/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" і замінює вкладку. Другий sed видаляє номер рядка та "|".

Для повноти ще одна спроба 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. Можливо, є кращий вираз sed ...

Оскільки прийнята відповідь є на С, я подумав, що це добре, щоб кинути тут рішення пітона:

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