Bu zorluk, tüm dosyayı belleğe okumadan potansiyel olarak büyük bir dosyadan rastgele satırları okumakla ilgilidir.

Giriş

Bir tamsayı nve bir metin dosyasının adı.

Çıktı

n metin dosyasının satırları değiştirilmeden rastgele rastgele seçilmiştir.

nDosyadaki satır sayısı ile 1 aralığında olduğunu varsayabilirsiniz .

nAldığınız cevabın eşit olduğu aralıktan rastgele sayıları örneklerken dikkatli olun . rand()%nC'de örneğin muntazam değildir. Her sonuç eşit derecede olası olmalıdır.

Kurallar ve kısıtlamalar

Metin dosyasının her satırı aynı sayıda karaktere sahip olacaktır ve bu 80'den fazla olmayacaktır.

Kodunuz aşağıdakiler dışında metin dosyasının içeriğini okumamalıdır:

• Çıkardığı çizgiler.
• Metin dosyasında satır başına kaç karakter olduğunu hesaplayan ilk satır.

Metin dosyasındaki her karakterin tam olarak bir bayt sürdüğünü varsayabiliriz.

Hat ayırıcıların 1 bayt uzunluğunda olduğu varsayılır. Çözümler, yalnızca bu gereksinimi belirttiklerinde 2 bayt uzunluğunda satır ayırıcılar kullanabilir. Ayrıca, son satırın bir satır ayırıcı tarafından sonlandığını varsayabilirsiniz.

Cevabınız tam bir program olmalıdır, ancak girdiyi uygun olan herhangi bir şekilde belirleyebilirsiniz.

Diller ve kütüphaneler

İstediğiniz dil veya kitaplığı kullanabilirsiniz.

notlar

Dosyadaki satır sayısını hesaplama konusunda bir endişe vardı. Nimi yorumlarda belirtildiği gibi, bunu dosya boyutundan ve satır başına karakter sayısından çıkarabilirsiniz.

Motivasyon

Sohbette bazı insanlar bunun gerçekten "Y olmadan X Yap" sorusu olup olmadığını sordu. Bunu, kısıtlamaların olağandışı yapay olup olmadığını sormak için yorumluyorum.

Devasa dosyalardan rasgele örnekleme görevi nadir değildir ve aslında bazen yapmak zorunda olduğum bir şeydir. Bunu yapmanın bir yolu bash'tır:

shuf -n <num-lines>

Ancak bu, tüm dosyada okunduğu gibi büyük dosyalar için çok yavaştır.

Dyalog APL , 63 bayt

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

Dosya adı sorulur, ardından kaç tane rasgele satır istenir.

açıklama

⍞Metin girişi istemi (dosya adı)
⎕NTIE 0Dosyayı bir sonraki kullanılabilir bağlantı numarasını kullanarak bağla (temiz bir sistemde -1)
t←Seçilen bağlantı numarasını t
83 80,⍨Ek [83,80] veren [-1,83,80] olarak kaydedin
⎕NREADİlk 80 baytı okuyun -1'in 8 bit tamsayılar olarak dönüştürülmesi (dönüşüm kodu 83)
10⍳⍨İlk sayının dizinini bulma 10 (LF)
l←Satır uzunluğunu l
(⎕NSIZE t)÷Dosya -1 boyutunu Satır uzunluğu ile
⎕bölün Sayısal giriş istemi (istenen satır sayısı) )
?X rastgele seçimler (değiştirilmeden) ilk Y doğal sayıyı dışarıya çıkarır
¯1+0 kökenli satır numaralarını elde etmek için -1 ekleyin *
l×Başlangıç ​​baytlarını almak için satır uzunluğuyla çarpın
t 82l∘,¨Her başlangıç ​​baytına [-1,82, LineLength] ekleyin (oluşturur) için bağımsız değişkenler listesi ⎕NREAD)
⎕NREAD¨ Her satırı 8 bit karakter olarak okuyun (dönüşüm kodu 82)

Pratik örnek

/Tmp/records.txt dosyası şunları içerir:

Hello
Think
12345
Klaus
Nilad

APL oturumuna aşağıdakileri girerek RandLines programının yukarıdaki kod kelimesini içerdiğinden emin olun:

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

APL oturumuna yazın RandLinesve Enter tuşuna basın.

Sistem imleci, karakter verileri için 0 uzunluklu bir istem olan bir sonraki satıra taşır; girin /tmp/records.txt.

Sistem şimdi ⎕:sayısal girdi çıkarır ve bekler; girin 4.

Sistem dört rastgele çizgi çıkarır.

Gerçek hayat

Gerçekte, dosya adı vermek ve bağımsız değişken olarak saymak ve sonucu tablo olarak almak isteyebilirsiniz. Bu, aşağıdakileri girerek yapılabilir:

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

Şimdi MyLines'ın üç rastgele çizgi içermesini sağlayın:

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

Sayı belirtilmezse yalnızca tek bir rastgele satır döndürmeye ne dersiniz:

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

Şimdi her ikisini de yapabilirsiniz:

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

ve (sol argümanın olmadığına dikkat edin):

MyLine←RandL'/tmp/records.txt'

Kodu okunabilir yapma

Golf APL tek gömlekleri kötü bir fikirdir. Bir üretim sistemine şöyle yazarım:

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
}

^{* Bazı APL sistemlerinde standart olan 0 kökenli modda çalışarak bir bayt kaydedebilirim: daha önce kaldırın ¯1+ve takın .1+10}

Yakut, 104 94 92 90 bayt

Dosya adı ve satır sayısı komut satırına iletilir. Örneğin, program shuffle.rbve dosya adı ise a.txt, ruby shuffle.rb a.txt 3üç rasgele satır için çalıştırın .

-4 bayt openyerine Ruby'de sözdizimini keşfetmekFile.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}

Ayrıca, bir dize ve bir sayıyı bağımsız değişken olarak alan 85 baytlık anonim bir işlev çözümü.

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

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

Stdin'den dosya ve n okur.

Nasıl çalışır:

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

Korkunç verimsiz bir shuffleişlev nedeniyle, bu programı birçok satırlı dosyalar için çalıştırmak çok zaman ve bellek gerektirir .

Düzenleme: Ben "yedek olmadan rastgele" bölümünü kaçırdım (fark için @feersum teşekkürler!).

PowerShell v2 +, 209 bayt

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}

Girdiyi $adosya adı ve $nsatır sayısı olarak alır. Bunun $atam yol dosya adı olması ve ANSI kodlaması olduğu varsayılır.

Daha sonra yeni bir inşa FileStreamnesne ve dosyaya erişmek için söylemek $aile Openayrıcalık.

forDöngü .Read()bir çarpana kadar birinci hat üzerinden s \nbizim hat uzunluğu sayacı her karakter bir arttırılarak karakter. Daha sonra $tdosyanın boyutuna (yani, akışın ne kadar sürdüğüne), satır başına kaç karakterin (artı bir sonlandırıcıyı saydığına), eksi bire (sıfır indeksli olduğumuzdan) bölündük. Daha sonra tamponumuzu $zçizgi uzunluğu olacak şekilde yapılandırırız .

Son satır, ..aralık operatörü ile dinamik bir dizi oluşturur . ¹ Tekrarlamadan rasgele satır numaralarını seçmek için Get-Randombir dizi ile bağlantı -Ckurarız . Şanslı sayılar ile bir döngüye eklenir . Her iterasyon biz belirli bir konuma, ve sonra bir satır değerinde karakter, depolanır . Bir char-array olarak yeniden yayınlarız ve bunu birlikte yaparız , sonuçta ortaya çıkan dizeyi boru hattında bırakır ve çıktı programın sonunda örtük olur.$n$n|%{...}.Seek.Read$z$z-join

Teknik$f.Close() olarak dosyayı kapatmak için bir çağrı ile bitirmeliyiz, ancak bu bayt maliyeti! : p

Misal

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 

_{¹ Teknik olarak, bu, dinamik olarak bu şekilde oluşturulabilecek en büyük aralık olduğu için yalnızca maksimum 50.000 satırı destekleyebileceğimiz anlamına gelir. : - / Ama, sadece bir Get-Randomkomut $nsürelerini döngüye sokamayız, her bir döngüyü yinelemeden atarız, çünkü bu deterministik değildir ...}

Python 3, 146139 bayt

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^

Girdi: [dosyaadı] \ n [satır] \ n

Bu çözüm @pppery'den yoğun bir şekilde çalındı, ancak sadece python3.5 ve tam bir program.

Düzenleme: Satır içi aralığı ve python3.x uyumluluğu için @Mego'ya teşekkürler. Edit2: Baskı hakkında nerede Açıklama çünkü ben bu konuda iki yorum var. (Yorum açıkça kodun veya bayt sayısının bir parçası değildir.)

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

Satır kesmeleri için 2 bayt kullanır. 2 için 1 için 1 değiştirin. Ben sadece 2 olarak var çünkü test dosyam vardı.

PHP girişi altında kendimi var, ama hala 2. sırada (şu anda). Lanet olsun Ruby girişi!

Bash (kuyu, çekirdekler), 100 bayt

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

açıklama

Bu dd, dosyayı tamamen okumadan ihtiyaç duyduğumuz dosyanın bölümlerini çıkarmak için tüm dosyayı okumayı önler , maalesef belirtmemiz gereken tüm seçeneklerle oldukça büyük sonuç verir:

ifgirdi dosyası
bsblok boyutudur (burada onu $nilk satırın uzunluğunun
skipayıklanan rasgele tamsayılara ayarlandığı shufve ibsatlama değerine eşit olduğu şekilde ayarladıkskip * ibsbayt
countsayısı ibsgeri uzunluk bölümleri
status=noneatmak için gerekli olan normalde çıktısı alan bilgilerdd

Kullanarak satır uzunluğunu head -1 $2|wc -cve ile dosya boyutunu elde ederiz stat -c%s $2.

kullanım

Yukarıda olduğu gibi kaydedin file.shve kullanarak çalıştırın file.sh n filename.

zamanlamalar

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

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

vs.

time shuf -n4 test.txt
1204350
3496441
3472713
3985479

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

68MiB dosyası için yukarıdaki süreler kullanılarak oluşturuldu seq 1000000 9999999 > test.txt.

-1 ipucu için @PeterCordes'a teşekkürler !

Python 3-1616 160149 bayt

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

Bu kod, şöyle adlandırılan bir işlevi tanımlar: f(10,'input.txt')

Kopya olmadan C # 259 bayt

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());}}

Ungolfed

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 tembeldir. Bu, tüm hatların farklı uzunluğa sahip olabileceği ek bir avantaja sahiptir.

Çalıştırmak şöyle olur:

sample.exe a.txt 10000

Kopyaları ile C # 206 bayt

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());}}

Ungolfed

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

Her hattı eşit olasılıkla tutar, borularla da kullanın. Yine de sorunun ileri atlama sınırlamasına cevap vermiyor ...

Kullanım cat largefile | python randxlines.py 100veya python randxlines 100 < largefile(@petercordes'ın işaret ettiği gibi)

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