Thử thách này là về việc đọc các dòng ngẫu nhiên từ một tệp có khả năng rất lớn mà không cần đọc toàn bộ tệp vào bộ nhớ.

Đầu vào

Một số nguyên nvà tên của một tệp văn bản.

Đầu ra

n các dòng của tệp văn bản được chọn thống nhất ngẫu nhiên mà không thay thế.

Bạn có thể giả sử rằng ntrong phạm vi 1 đến số dòng trong tệp.

Hãy cẩn thận khi lấy mẫu nsố ngẫu nhiên trong phạm vi mà câu trả lời bạn nhận được là thống nhất. rand()%ntrong C không đồng nhất chẳng hạn. Mọi kết quả đều phải có khả năng như nhau.

Các quy tắc và hạn chế

Mỗi dòng của tệp văn bản sẽ có cùng số lượng ký tự và sẽ không quá 80.

Mã của bạn không được đọc bất kỳ nội dung nào của tệp văn bản ngoại trừ:

• Những dòng nó đầu ra.
• Dòng đầu tiên để tìm ra có bao nhiêu ký tự trên mỗi dòng trong tệp văn bản.

Chúng ta có thể giả sử mỗi ký tự trong tệp văn bản mất chính xác một byte.

Dấu phân cách dòng được giả sử là dài 1 byte. Các giải pháp có thể sử dụng dấu phân cách dòng dài 2 byte chỉ khi chúng chỉ định nhu cầu này. Bạn cũng có thể giả sử dòng cuối cùng được kết thúc bằng dấu phân cách dòng.

Câu trả lời của bạn phải là một chương trình hoàn chỉnh nhưng bạn có thể chỉ định đầu vào theo bất kỳ cách nào thuận tiện.

Ngôn ngữ và thư viện

Bạn có thể sử dụng bất kỳ ngôn ngữ hoặc thư viện nào bạn thích.

Ghi chú

Có một mối quan tâm về việc tính toán số lượng dòng trong tệp. Như nimi chỉ ra trong các bình luận, bạn có thể suy ra điều này từ kích thước tệp và số ký tự trên mỗi dòng.

Động lực

Trong cuộc trò chuyện, một số người hỏi liệu đây có thực sự là câu hỏi "Làm X mà không có Y" không. Tôi giải thích điều này để hỏi nếu các hạn chế là nhân tạo bất thường.

Nhiệm vụ lấy mẫu ngẫu nhiên các dòng từ các tệp lớn không phải là hiếm và trên thực tế đôi khi tôi phải làm. Một cách để làm điều này là trong bash:

shuf -n <num-lines>

Tuy nhiên, điều này rất chậm đối với các tệp lớn vì nó đọc trong toàn bộ tệp.

APL Dyalog , 63 byte

⎕NREAD¨t 82l∘,¨lׯ1+⎕?(⎕NSIZE t)÷l←10⍳⍨⎕NREAD 83 80,⍨t←⍞⎕NTIE 0

Nhắc tên tệp, sau đó cho bao nhiêu dòng ngẫu nhiên mong muốn.

Giải trình

⍞Nhắc nhở nhập văn bản (tên tệp)
⎕NTIE 0Buộc tệp bằng số liên kết có sẵn tiếp theo (-1 trên hệ thống sạch)
t←Lưu số cà vạt đã chọn là t
83 80,⍨Nối [83,80] mang lại [-1,83,80]
⎕NREADĐọc 80 byte đầu tiên của tệp -1 dưới dạng số nguyên 8 bit (mã chuyển đổi 83)
10⍳⍨Tìm chỉ mục của số 10 đầu tiên (LF)
l←Lưu trữ độ dài dòng dưới dạng l
(⎕NSIZE t)÷Chia kích thước của tệp -1 với độ dài dòng
⎕Nhắc cho đầu vào số (số dòng mong muốn )
?X lựa chọn ngẫu nhiên (không thay thế) ngoài các số tự nhiên Y đầu tiên
¯1+Thêm -1 để lấy số dòng gốc 0 *
l×Nhân với độ dài dòng để lấy byte bắt đầu
t 82l∘,¨Chuẩn bị [-1,82, LineLạng] cho mỗi byte bắt đầu (tạo danh sách các đối số cho ⎕NREAD)
⎕NREAD¨ Đọc từng dòng dưới dạng ký tự 8 bit (mã chuyển đổi 82)

Ví dụ thực tế

Tệp /tmp/records.txt chứa:

Hello
Think
12345
Klaus
Nilad

Làm cho chương trình RandLines chứa mã nguyên văn ở trên bằng cách nhập đoạn mã sau vào phiên APL:

∇RandLines
⎕NREAD¨t 82l∘,¨lׯ1+⎕?(⎕NSIZE t)÷l←10⍳⍨⎕NREAD 83 80,⍨t←⍞⎕NTIE 0
∇

Trong loại phiên APL RandLinesvà nhấn Enter.

Hệ thống di chuyển con trỏ đến dòng tiếp theo, đó là lời nhắc 0 độ dài cho dữ liệu ký tự; nhập /tmp/records.txt.

Hệ thống hiện xuất ra ⎕:và chờ đầu vào số; nhập 4.

Hệ thống xuất ra bốn dòng ngẫu nhiên.

Đời thực

Trong thực tế, bạn có thể muốn cung cấp tên tệp và tính là đối số và nhận kết quả dưới dạng bảng. Điều này có thể được thực hiện bằng cách nhập:

RandLs←{↑⎕NREAD¨t 82l∘,¨lׯ1+⍺?(⎕NSIZE t)÷l←10⍳⍨⎕NREAD 83 80,⍨t←⍵⎕NTIE 0}

Bây giờ bạn tạo MyLines chứa ba dòng ngẫu nhiên với:

MyLines←3 RandLs'/tmp/records.txt'

Làm thế nào về việc chỉ trả về một dòng ngẫu nhiên duy nhất nếu số lượng không được chỉ định:

RandL←{⍺←1 ⋄ ↑⎕NREAD¨t 82l∘,¨lׯ1+⍺?(⎕NSIZE t)÷l←10⍳⍨⎕NREAD 83 80,⍨t←⍵⎕NTIE 0}

Bây giờ bạn có thể làm cả hai:

MyLines←2 RandL'/tmp/records.txt'

và (thông báo không có đối số bên trái):

MyLine←RandL'/tmp/records.txt'

Làm cho mã có thể đọc được

Golf một lớp lót APL là một ý tưởng tồi. Đây là cách tôi sẽ viết trong một hệ thống sản xuất:

RandL←{ ⍝ Read X random lines from file Y without reading entire file
    ⍺←1 ⍝ default count
    tie←⍵⎕NTIE 0 ⍝ tie file
    length←10⍳⍨⎕NREAD 83 80,⍨tie ⍝ find first NL
    size←⎕NSIZE tie ⍝ total file length
    starts←lengthׯ1+⍺?size÷length ⍝ beginning of each line
    ↑⎕NREAD¨tie 82length∘,¨starts ⍝ read each line as character and convert list to table
}

^{* Tôi có thể lưu một byte bằng cách chạy ở chế độ 0 gốc, là tiêu chuẩn trên một số hệ thống APL: xóa ¯1+và chèn 1+trước đó 10.}

Ruby, 104 94 92 90 byte

Tên tệp và số dòng được truyền vào dòng lệnh. Ví dụ: nếu chương trình là shuffle.rbvà tên tệp là a.txt, hãy chạy ruby shuffle.rb a.txt 3ba dòng ngẫu nhiên.

-4 byte từ việc khám phá opencú pháp trong Ruby thay vìFile.new

f=open$*[0]
puts [*0..f.size/n=f.gets.size+1].sample($*[1].to_i).map{|e|f.seek n*e;f.gets}

Ngoài ra, đây là một giải pháp hàm ẩn danh 85 byte lấy một chuỗi và một số làm đối số của nó.

->f,l{f=open f;puts [*0..f.size/n=f.gets.size+1].sample(l).map{|e|f.seek n*e;f.gets}}

Haskell, 240 224 236 byte

import Test.QuickCheck
import System.IO
g=hGetLine
main=do;f<-getLine;n<-readLn;h<-openFile f ReadMode;l<-(\x->1+sum[1|_<-x])<$>g h;s<-hFileSize h;generate(shuffle[0..div s l-1])>>=mapM(\p->hSeek h(toEnum 0)(l*p)>>g h>>=putStrLn).take n

Đọc tên tệp và n từ stdin.

Làm thế nào nó hoạt động:

main=do
  f<-getLine                   -- read file name from stdin
  n<-readLn                    -- read n from stdin
  h<-openFile f ReadMode       -- open the file
  l<-(\x->1+sum[1|_<-x])<$>g h -- read first line and bind l to it's length +1
                               -- sum[1|_<-x] is a custom length function
                               -- because of type restrictions, otherwise I'd have
                               -- to use "toInteger.length"
  s<-hFileSize h               -- get file size
  generate(shuffle[0..div s l-1])>>=
                               -- shuffle all possible line numbers 
  mapM (\->p  ...  ).take n    -- for each of the first n shuffled line numbers 
     hSeek h(toEnum 0).(l*p)>> -- jump to that line ("toEnum 0" is short for "AbsoluteSeek")
     g h>>=                    -- read a line from current position
     putStrLn                  -- and print

Phải mất rất nhiều thời gian và bộ nhớ để chạy chương trình này cho các tệp có nhiều dòng, vì một shufflechức năng không hiệu quả khủng khiếp .

Chỉnh sửa: Tôi đã bỏ lỡ phần "ngẫu nhiên mà không thay thế" (cảm ơn @feersum vì đã chú ý!).

PowerShell v2 +, 209 byte

param($a,$n)
$f=New-Object System.IO.FileStream $a,"Open"
for(;$f.ReadByte()-ne10){$l++}
$t=$f.Length/++$l-1
[byte[]]$z=,0*$l
0..$t|Get-Random -c $n|%{$a=$f.Seek($l*$_,0);$a=$f.Read($z,0,$l-1);-join[char[]]$z}

Lấy đầu vào $alà tên tệp và $nnhư số dòng. Lưu ý rằng $aphải là tên tệp đường dẫn đầy đủ và được coi là mã hóa ANSI.

Sau đó chúng tôi xây dựng một FileStreamđối tượng mới và bảo nó truy cập tệp $avới Openđặc quyền.

Các forvòng lặp .Read()là thông qua dòng đầu tiên cho đến khi chúng ta đánh một \nnhân vật, incrementing line-chiều dài của chúng tôi truy cập mỗi nhân vật. Sau đó, chúng tôi đặt $tbằng kích thước của tệp (nghĩa là luồng dài bao nhiêu) chia cho bao nhiêu ký tự trên mỗi dòng (cộng với một ký tự để đếm số đầu cuối), trừ đi một (vì chúng tôi không có chỉ mục). Sau đó, chúng tôi xây dựng bộ đệm của chúng tôi $zcũng là chiều dài dòng.

Dòng cuối cùng xây dựng một mảng động với ..toán tử phạm vi. ¹ Chúng tôi sắp xếp mảng đó Get-Randomvới một -Count $nđể chọn ngẫu nhiên các $nsố dòng mà không lặp lại. Những con số may mắn được dẫn vào một vòng lặp với |%{...}. Mỗi lần lặp chúng ta .Seekđến một vị trí cụ thể, và sau đó .Readtrong các ký tự có giá trị của một dòng, được lưu trữ vào $z. Chúng tôi đúc lại $zdưới dạng một mảng char và -joinnó cùng nhau, để lại chuỗi kết quả trên đường ống và đầu ra được ẩn ở cuối chương trình.

Về mặt kỹ thuật, chúng ta nên kết thúc bằng một $f.Close()cuộc gọi để đóng tệp, nhưng chi phí đó là byte! : p

Thí dụ

a.txt:
a0000000000000000000000000000000000000000000000001
a0000000000000000000000000000000000000000000000002
a0000000000000000000000000000000000000000000000003
a0000000000000000000000000000000000000000000000004
a0000000000000000000000000000000000000000000000005
a0000000000000000000000000000000000000000000000006
a0000000000000000000000000000000000000000000000007
a0000000000000000000000000000000000000000000000008
a0000000000000000000000000000000000000000000000009
a0000000000000000000000000000000000000000000000010

PS C:\Tools\Scripts\golfing> .\read-n-random-lines.ps1 "c:\tools\scripts\golfing\a.txt" 5
a0000000000000000000000000000000000000000000000002 
a0000000000000000000000000000000000000000000000001 
a0000000000000000000000000000000000000000000000004 
a0000000000000000000000000000000000000000000000010 
a0000000000000000000000000000000000000000000000006 

_{¹ Về mặt kỹ thuật, các phương tiện này, chúng tôi chỉ có thể hỗ trợ tối đa 50.000 dòng, vì đó là phạm vi lớn nhất có thể được tự động tạo ra theo cách này. : - / Nhưng, chúng ta không thể chỉ lặp một lần Get-Randomlệnh $n, loại bỏ trùng lặp mỗi vòng lặp, vì điều đó không mang tính quyết định ...}

Python 3, 146 139 byte

from random import*
i=input
f=open(i())
l=len(f.readline())
[(f.seek(v*l),print(f.read(l)))for v in sample(range(f.seek(0,2)//l),int(i()))]
#print is here^

Đầu vào: [tên tệp] \ n [dòng] \ n

Giải pháp này đã đánh cắp rất nhiều từ @pppery nhưng chỉ là python3.5 và là một chương trình hoàn chỉnh.

Chỉnh sửa: Cảm ơn @Mego cho phạm vi nội tuyến và khả năng tương thích python3.x. Edit2: Làm rõ nơi in là vì tôi nhận được hai bình luận về nó. (Nhận xét rõ ràng không phải là một phần của mã hoặc số byte.)

Lua, 126 122

r=io.read;f=io.open(r())c=2+f:read():len()for i=1,r()do f:seek("set",c*math.random(0,f:seek("end")/c-1))print(f:read())end

Sử dụng 2 byte để ngắt dòng. Thay đổi 2 thành 1 thành 1. Tôi chỉ có 2 vì đó là những gì tệp thử nghiệm của tôi có.

Có bản thân tôi dưới mục PHP, nhưng vẫn ở vị trí thứ 2 (hiện tại). Nguyền rủa bạn, Ruby nhập!

Bash (tốt, coreutils), 100 byte

n=`head -1 $2|wc -c`;shuf -i0-$[`stat -c%s $2`/$n] -n$1|xargs -i dd if=$2 bs=$n skip={} count=1 2>&-

Giải trình

Điều này tránh đọc toàn bộ tập tin bằng cách sử dụng dd trích xuất các phần của tệp mà chúng ta cần mà không đọc toàn bộ tệp, thật không may, nó kết thúc khá lớn với tất cả các tùy chọn chúng ta phải chỉ định:

iflà tệp đầu vào
bscó kích thước khối (ở đây chúng tôi đặt nó $nlà độ dài của dòng đầu tiên
skipđược đặt thành các số nguyên ngẫu nhiên được trích xuất từ shufvà tương đương với ibsgiá trị bỏ qua skip* ibsbyte
countsố ibsphần có độ dài cần trả về
status=noneđể loại bỏ thông tin thường xuất ra bởidd

Chúng tôi nhận được độ dài dòng sử dụng head -1 $2|wc -cvà kích thước tập tin với stat -c%s $2.

Sử dụng

Lưu ở trên file.shvà chạy bằng cách sử dụng file.sh n filename.

Thời gian

time ~/randlines.sh 4 test.txt
9412647
4124435
7401105
1132619

real    0m0.125s
user    0m0.035s
sys     0m0.061s

so với

time shuf -n4 test.txt
1204350
3496441
3472713
3985479

real    0m1.280s
user    0m0.287s
sys     0m0.272s

Lần trên cho một tệp 68MiB được tạo bằng cách sử dụng seq 1000000 9999999 > test.txt.

Cảm ơn @PeterCordes cho mẹo -1 của anh ấy!

Python 3 - 161 160 149 byte

from random import*;
def f(n,g):f=open(g);l=len(f.readline());r=list(range(f.seek(0,2)/l));shuffle(r);[(f.seek(v*l),print(f.read(l)))for v in r[:k]]

Mã này định nghĩa một hàm được gọi là như f(10,'input.txt')

C # 259 byte không trùng lặp

class Program{static void Main(string[]a){int c=Convert.ToInt32(a[1]);var h=File.ReadLines(a[0]);HashSet<int>n=new HashSet<int>();while(n.Count<c)n.Add(new Random().Next(0,h.Count()));for(;c>0;c--)Console.WriteLine(h.Skip(n.ElementAt(c-1)).Take(1).First());}}

Bị đánh cắp

class Program{static void Main(string[] a)
{
        int c = Convert.ToInt32(a[1]);
        var h = File.ReadLines(a[0]);
        HashSet<int> n = new HashSet<int>();
        while (n.Count < c)
            n.Add(new Random().Next(0, h.Count()));           
        for (; c > 0; c--)
            Console.WriteLine(h.Skip(n.ElementAt(c-1)).Take(1).First());
    }
}

File.ReadLines là lười biếng. Điều này có lợi ích bổ sung rằng tất cả các dòng có thể có chiều dài khác nhau.

Chạy nó sẽ là:

sample.exe a.txt 10000

C # 206 byte có trùng lặp

class Program{static void Main(string[]a){var n=new Random();int c=Convert.ToInt32(a[1]);var h=File.ReadLines(a[0]);for(;c>0;c--)Console.WriteLine(h.Skip((int)(n.NextDouble()*h.Count())).Take(1).First());}}

Bị đánh cắp

class Program
{
    static void Main(string[] a)
    {
        Random n = new Random();
        int c = Convert.ToInt32(a[1]);
        var h = File.ReadLines(a[0]);
        for (; c > 0; c--)
            Console.WriteLine(h.Skip((int)(n.NextDouble()*h.Count())).Take(1).First());
    }
}

Python (141 byte)

Giữ mỗi dòng có xác suất bằng nhau, sử dụng với đường ống quá. Nó không trả lời bỏ qua giới hạn trước của câu hỏi mặc dù ...

Cách sử dụng cat largefile | python randxlines.py 100hoặc python randxlines 100 < largefile(như @petercordes đã chỉ ra)

import random,sys
N=int(sys.argv[1])
x=['']*N
for c,L in enumerate(sys.stdin):
    t=random.randrange(c+1)
    if(t<N):x[t] = L
print("".join(x))