Qual é o caminho mais rápido para obter a n-ésima linha de um arquivo de texto [duplicado]

Question

Dado um arquivo com m linhas, como obter a linha n-ésima. m pode ser menor que n às vezes. Eu tentei:

method1: sed -ne '10p' file.txt
method2: sed -ne '10p' <file.txt
method3: sed -ne '10{p;q;}' file.txt
method4: awk 'NR==10' file.txt

no link da LeetCode . method1 vence os outros. Eu não sei porque. Eu acho que o method3 deveria ser mais rápido.

Existem maneiras mais rápidas?

Atualizações:

Seguindo a sugestão @skwllsp, executo alguns comandos. Os resultados são: instruções

instructions commands
428,160,537 perf stat sed -ne '10p' file.txt
427,426,310 perf stat sed -ne '10p' <file.txt
1,033,730   perf stat sed -ne '10{p;q;}' file.txt
1,111,502   perf stat awk 'NR == 10 { print ; exit ;} ' file.txt 

method4 mudou de acordo com a resposta do @Archemar

e

777,525 perf -stat tail -n +10 file.txt |head -n 1

que é muito menos que o método1.

    

Answer 1

Vamos medir seus testes para ver quantas instruções são feitas em cada método. Eu criei meu próprio arquivo seq 2000000 > 2000000.txt e quero descobrir qual método é o mais rápido.

$ perf stat sed -ne '10p' 2000000.txt 
10

 Performance counter stats for 'sed -ne 10p 2000000.txt':

        203.877247 task-clock                #    0.991 CPUs utilized          
                 5 context-switches          #    0.025 K/sec                  
                 3 cpu-migrations            #    0.015 K/sec                  
               214 page-faults               #    0.001 M/sec                  
       405,075,423 cycles                    #    1.987 GHz                     [50.20%]
   <not supported> stalled-cycles-frontend 
   <not supported> stalled-cycles-backend  
       838,221,677 instructions              #    2.07  insns per cycle         [75.20%]
       203,113,013 branches                  #  996.251 M/sec                   [74.99%]
           766,918 branch-misses             #    0.38% of all branches         [75.16%]

       0.205683270 seconds time elapsed

Então, primeiro método - 838.221.677 instruções.

$ perf stat sed -ne '10{p;q;}' 2000000.txt 
10

 Performance counter stats for 'sed -ne 10{p;q;} 2000000.txt':

          1.211558 task-clock                #    0.145 CPUs utilized          
                 2 context-switches          #    0.002 M/sec                  
                 0 cpu-migrations            #    0.000 K/sec                  
               213 page-faults               #    0.176 M/sec                  
         1,633,950 cycles                    #    1.349 GHz                     [23.73%]
   <not supported> stalled-cycles-frontend 
   <not supported> stalled-cycles-backend  
           824,789 instructions              #    0.50  insns per cycle        
           164,935 branches                  #  136.135 M/sec                  
            11,751 branch-misses             #    7.12% of all branches         [83.24%]

       0.008374725 seconds time elapsed

Então, terceiro método - 824.789 instruções. É muito melhor que o primeiro método.

O método aprimorado

$ perf stat awk 'NR == 10 { print ; exit ;} ' 2000000.txt 
10

 Performance counter stats for 'awk NR == 10 { print ; exit ;}  2000000.txt':

          1.357354 task-clock                #    0.162 CPUs utilized          
                 2 context-switches          #    0.001 M/sec                  
                 0 cpu-migrations            #    0.000 K/sec                  
               282 page-faults               #    0.208 M/sec                  
         1,777,749 cycles                    #    1.310 GHz                     [11.54%]
   <not supported> stalled-cycles-frontend 
   <not supported> stalled-cycles-backend  
           919,636 instructions              #    0.52  insns per cycle        
           185,695 branches                  #  136.807 M/sec                  
            11,218 branch-misses             #    6.04% of all branches         [91.64%]

       0.008375258 seconds time elapsed

Um pouco pior que o segundo método. De qualquer forma, é tão eficiente quanto o terceiro método.

Você pode repetir os mesmos testes com seu arquivo e ver qual método é o melhor.

Um medidor para o segundo método:

$ perf stat sed -ne '10p' <2000000.txt 
10

 Performance counter stats for 'sed -ne 10p':

        203.278584 task-clock                #    0.998 CPUs utilized          
                 1 context-switches          #    0.005 K/sec                  
                 3 cpu-migrations            #    0.015 K/sec                  
               213 page-faults               #    0.001 M/sec                  
       403,941,976 cycles                    #    1.987 GHz                     [49.84%]
   <not supported> stalled-cycles-frontend 
   <not supported> stalled-cycles-backend  
       835,372,994 instructions              #    2.07  insns per cycle         [74.92%]
       203,327,145 branches                  # 1000.239 M/sec                   [74.90%]
           773,067 branch-misses             #    0.38% of all branches         [75.35%]

       0.203714402 seconds time elapsed

É tão ruim quanto o primeiro método

    

Answer 2

para o awk

 awk 'NR == 10 { print ; exit ;} ' file.txt

Acho que o perl é mais rápido, havia uma mesma pergunta aqui cerca de um ano atrás.

veja também

1. linha de gato X para alinhar Y em um arquivo enorme
2. Como posso obter uma linha específica de um arquivo?