Filtrar arquivo por número de linha

Dado um arquivo L com um número inteiro não negativo por linha e o arquivo de texto F, qual seria a maneira mais rápida de manter apenas essas linhas em F, cujo número de linha aparece no arquivo L?

Exemplo:

$ 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

Estou procurando um comando que possa manipular um arquivo L com 500 milhões ou mais de entradas; o arquivo L é classificado numericamente.

Nota: Estou no meio de uma implementação para um, command-in-questionmas eu apenas me perguntei se seria possível usar algumas ferramentas Unix aqui também.

Atualização: Obrigado por todas as respostas, eu aprendi muito hoje! Gostaria de aceitar mais uma resposta, mas isso não é possível.

Com a Comissão de mensagens de erro significativas:

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

Eu usaria awk, mas não armazenaria todo o conteúdo da L.txtmemória e faria pesquisas desnecessárias de hash ;-).

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

Isso deve funcionar muito rapidamente (alguns testes cronometrados estão incluídos abaixo) com entradas de qualquer tamanho. Algumas notas sobre como:

• export LC_ALL=C
  • Como o objetivo da operação a seguir é colocar o arquivo inteiro ./Fempilhado em linha com ./Lo arquivo lineno, os únicos caracteres com os quais realmente precisamos nos preocupar são os [0-9]dígitos ASCII e os :dois pontos.
  • Por esse motivo, é mais simples se preocupar em encontrar esses 11 caracteres em um conjunto de 128 possíveis do que se o UTF-8 estiver envolvido.
• grep -n ''
  • Isso insere a string LINENO:na cabeça de cada linha em stdin - ou <./F.
• sort -t: -nmk1,1 ./L -
  • sortnegligências para classificar seus arquivos de entrada em tudo, e em vez disso (corretamente) presume que eles são pré-classificados e -mErges-los em -numericallyordem de classificação, ignorando basicamente qualquer coisa além de qualquer possível -k1,1ocorrendo st -t:carácter dois pontos de qualquer maneira.
  • Embora isso possa exigir algum espaço temporário (dependendo da distância que algumas sequências possam ocorrer) , não exigirá muito em comparação com uma classificação adequada e será muito rápido porque envolve zero retorno.
  • sortproduzirá um único fluxo no qual qualquer linha de entrada ./Lprecederá imediatamente as linhas correspondentes ./F. ./LAs linhas de sempre vêm primeiro porque são mais curtas.
• sed /:/d\;n
  • Se a linha atual corresponder a /:/dois pontos, delimine-a da saída. Senão, imprima automaticamente a nlinha atual e ext.
  • E assim sedpoda sorta saída apenas para pares de linhas sequenciais que não correspondem a dois pontos e à seguinte linha - ou, apenas a uma linha de ./Le depois a seguinte.
• cut -sd: -f2-
  • cut -ssuprime da saída as linhas de entrada que não contêm pelo menos uma de suas -d:seqüências de elimitadores - e, portanto ./L, as linhas são completamente removidas.
  • Para essas linhas, o primeiro campo :delimitado por dois pontos -festá cutausente - e o mesmo ocorre com todos grepos lineno inseridos.

teste de entrada pequena

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

... gera 5 linhas de entrada de amostra. Então...

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

... imprime ...

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

testes cronometrados maiores

Criei alguns arquivos bastante grandes:

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

... que coloca linhas de 5mil e linhas de /tmp/F1,5mil selecionadas aleatoriamente /tmp/L. Eu então fiz:

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

Imprimiu:

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

(Eu adicionei as barras invertidas lá)

Entre as soluções atualmente oferecidas aqui, essa é a mais rápida de todas, exceto uma quando comparada com o conjunto de dados gerado acima na minha máquina. Dos outros, apenas um chegou perto de disputar o segundo lugar, e esse é o meuh perl aqui .

Esta não é de forma alguma a solução original oferecida - ela perdeu um terço do seu tempo de execução graças a conselhos / inspiração oferecidos por outros. Veja o histórico de publicações para soluções mais lentas (mas por quê?) .

Além disso, vale a pena notar que algumas outras respostas podem muito bem apresentar-se melhor se não fossem a arquitetura de várias CPUs do meu sistema e a execução simultânea de cada um dos processos nesse pipeline. Todos eles trabalham ao mesmo tempo - cada um no seu próprio núcleo de processador - passando os dados e fazendo sua pequena parte do todo. É muito legal.

mas a solução mais rápida é ...

Mas não é a solução mais rápida. A solução mais rápida oferecido aqui, mãos para baixo, é o programa C . Eu chamei cselect. Depois de copiá-lo para minha área de transferência do X, compilei-o como:

xsel -bo | cc -xc - -o cselect

Eu então fiz:

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

... e os resultados foram ...

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

Eu usaria awk:

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

Atualização: eu fiz medidas de desempenho; parece que esta versão é ainda melhor com conjuntos de dados muito grandes (como é o caso dos requisitos declarados), pois a comparação é muito rápida e compensa demais o esforço necessário para criar a tabela de hash.

Apenas para completar: podemos mesclar o excelente script awk na resposta de Stéphane Chazelas, e o script perl na resposta de kos, mas sem manter a lista inteira na memória, na esperança de que o perl possa ser mais rápido que o awk. (Alterei a ordem dos argumentos para corresponder à pergunta original).

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

Eu escrevi um script Perl simples para fazer isso:

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

• Cargas F.txt
• Cargas L.txt
• Armazena cada linha L.txtem uma matriz
• Lê F.txtlinha por linha, rastreando seu número de linha atual e o índice atual da matriz; aumenta o F.txtnúmero da linha atual; se o F.txtnúmero da linha atual corresponder ao conteúdo da matriz no índice atual da matriz, ele imprimirá a linha atual e aumentará o índice

Considerações de custo e complexidade :

Considerando o custo para fazer as atribuições, o custo para fazer as comparações e o custo para imprimir as linhas, dado N ₁ como o número de linhas F.txte N ₂ como o número de linhas L.txt, o whileloop é executado no máximo N ₁ vezes, levando a atribuições 2N ₁ + N ₂ (obviamente assumindo N ₁ > N ₂ ), comparações 2N ₁ e impressões de N ₂ ; dado como igual ao custo de cada operação, o custo total para executar o whileloop é 4N ₁ + 2N ₂ , o que leva a uma complexidade do script de O (N).

Teste em um arquivo de entrada de 10 milhões de linhas :

Usando um F.txtarquivo de 10 milhões de linhas contendo linhas aleatórias de 50 caracteres e um L.txtarquivo de 10 milhões de linhas contendo números de 1 a 10000000 (pior cenário):

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

Essa solução perl é mais rápida do que as outras soluções awk ou perl em 20% ou mais, mas não é tão rápida quanto a solução em 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

Como L.txt está classificado, você pode usar join. Apenas numere cada linha em F.txt, junte os dois arquivos e remova o número da linha. Nenhum arquivo intermediário grande é necessário.

Na verdade, o acima irá alterar suas linhas de dados, substituindo todo o espaço em branco por um único espaço. Para manter a linha intacta, você precisa escolher como delimitador algum caractere que não apareça nos seus dados, por exemplo, "|". O cmd é então

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

O primeiro sed remove espaços à esquerda da saída "cat -n" e substitui a guia. O segundo sed remove o número da linha e "|".

Para completar, outra tentativa de joinsolução:

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

Isso funciona formatando a coluna de número de linha que une funciona como comprimento fixo com zeros à esquerda, para que os números tenham sempre 15 dígitos. Isso contorna o problema de associação, não gostando da ordem de classificação numérica normal, pois a coluna agora foi efetivamente forçada a ser uma classificação de dicionário. nlé usado para adicionar números de linha nesse formato ao F.txt. Infelizmente, sedprecisa ser usado para reformatar a numeração em L.txt.

Essa abordagem parece funcionar bem nos dados de teste gerados usando o método @ mikeserv. Mas ainda é muito lento - a solução c é 60x mais rápida na minha máquina. cerca de 2/3 do tempo é gasto sede 1/3 pol join. Talvez exista uma melhor expressão de sed ...

Como a resposta aceita está em C, concluí que não há problema em lançar uma solução python aqui:

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

Se usar uma biblioteca externa como numpy, uma solução pareceria ainda mais elegante:

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)