पर्ल के साथ फाइल से मुझे बिल्कुल यादृच्छिक रेखाएं कैसे मिल सकती हैं?

Question

this प्रश्न के बाद, मुझे फ़ाइल के यादृच्छिक रूप से n लाइनों को ठीक से प्राप्त करने की आवश्यकता है (या stdin)। यह head या tail के समान होगा, सिवाय इसके कि मैं कुछ मध्य से चाहता हूं।

अब, लिंक किए गए प्रश्न के समाधान के साथ फ़ाइल पर लूप करने के अलावा, एक रन में n लाइनों को पाने का सबसे अच्छा तरीका क्या है?

संदर्भ के लिए, मैंने कोशिश की यह:

#!/usr/bin/perl -w 
use strict; 
my $ratio = shift; 
print $ratio, "\n"; 
while() { 
    print if ((int rand $ratio) == 1); 
} 

जहां $ratio लाइनों मैं चाहता हूँ के किसी न किसी प्रतिशत है।

aaa> foreach i (0 1 2 3 4 5 6 7 8 9) 
foreach? random_select 10 a.list | wc -l 
foreach? end 
4739 
4865 
4739 
4889 
4934 
4809 
4712 
4842 
4814 
4817 

अन्य विचार मैं था इनपुट फ़ाइल slurping गया था और तब चुनने:

random_select 10 a.list 

बहरहाल, यह मुझे एक सटीक राशि नहीं दे करता है: उदाहरण के लिए, अगर मैं 10 में 1 लाइनों चाहते हैं n सरणी से यादृच्छिक रूप से, लेकिन यह एक समस्या है यदि मेरे पास वास्तव में बड़ी फ़ाइल है।

कोई भी विचार?

संपादित करें: यह this प्रश्न का एक सटीक डुप्लिकेट है।

Answer 1

यहां एक अच्छा एक-पास एल्गोरिदम है जो मैं अभी आया था, जिसमें ओ (एन) समय जटिलता और ओ (एम) स्पेस जटिलता है, एन-लाइन फ़ाइल से एम लाइन पढ़ने के लिए।

मान लें एम < = एन

1. Let चुना लाइनों के सेट हो S। फाइल के पहले M लाइनों में S आरंभ करें। यदि अंतिम परिणाम का ऑर्डर करना महत्वपूर्ण है, तो अब S को घुमाएं।
2. अगली पंक्ति l में पढ़ें। अब तक, हमने n = M + 1 कुल लाइनें पढ़ी हैं। संभावना है कि हम l चुनना चाहते हैं क्योंकि हमारी अंतिम लाइनों में से एक M/n है।
3. संभाव्यता M/n के साथ l स्वीकार करें; l को स्वीकार या अस्वीकार करने के लिए यह तय करने के लिए एक आरएनजी का उपयोग करें।
4. यदि l स्वीकार कर लिया गया है, तो S में यादृच्छिक रूप से किसी एक पंक्ति का चयन करें और इसे l के साथ बदलें।
5. दोहराएँ चरण 2-4 तक फ़ाइल लाइनों के समाप्त हो गया है, हर नई लाइन पढ़ने के साथ n incrementing।
6. चयनित लाइनों के सेट S पर लौटें।

Answer 2

संभव समाधान:

1. स्कैन फिर
2. स्कैन लाइनों की संख्या की गिनती करने के
3. तय लाइन नंबर बेतरतीब ढंग से लेने के लिए एक बार, लाइन

Answer 3

लेने छद्म में कोड:

use List::Util qw[shuffle]; 

# read and shuffle the whole file 
@list = shuffle(<>); 

# take the first 'n' from the list 
splice(@list, ...); 

यह सबसे छोटा कार्यान्वयन है, लेकिन आपको पहले पूरी फ़ाइल को पढ़ना होगा, जिसके लिए आपको पर्याप्त मेमोरी उपलब्ध होगी।

Answer 4

@result =(); 

$k = 0; 
while(<>) { 
    $k++; 
    if (scalar @result < $n) { 
     push @result, $_; 
    } else { 
     if (rand <= $n/$k) { 
      $result[int rand $n] = $_; 
     } 
    } 
} 

print for @result; 

Answer 5

यह एक एकल कमांड लाइन तर्क है, जो पहली एन लाइनों आयोजित कर रहे हैं आप चाहते हैं लाइन की संख्या, एन है, जैसा कि आप किसी भी अधिक नहीं देख सकता है लेता है। इसके बाद, आप यादृच्छिक रूप से तय करते हैं कि अगली पंक्ति लेना है या नहीं। और यदि आप करते हैं, तो आप यादृच्छिक रूप से तय करते हैं कि मौजूदा सूची-एन-एन में ओवरराइट करने के लिए कौन सी रेखा है।

#!/usr/bin/perl 
my $bufsize = shift; 
my @list =(); 

srand(); 
while (<>) 
{ 
    push(@list, $_), next if (@list < $bufsize); 
    $list[ rand(@list) ] = $_ if (rand($./$bufsize) < 1); 
} 
print foreach @list; 

Answer 6

यहां कुछ वर्बोज़ पर्ल कोड है जो बड़ी फ़ाइलों के साथ काम करना चाहिए।

इस कोड का दिल यह है कि यह पूरी फ़ाइल को स्मृति में संग्रहीत नहीं करता है, लेकिन केवल फ़ाइल में ऑफसेट स्टोर करता है।

उपयोग tell ऑफसेट मिलता है। फिर लाइनों को पुनर्प्राप्त करने के लिए उपयुक्त स्थानों पर seek।

लक्ष्य फ़ाइल का बेहतर विनिर्देश और प्राप्त करने के लिए लाइनों की संख्या I से कम आलसी लोगों के लिए एक अभ्यास के रूप में छोड़ी गई है। उन समस्याओं को हल किया गया है।

#!/usr/bin/perl 

use strict; 
use warnings; 

use List::Util qw(shuffle); 

my $GET_LINES = 10; 

my @line_starts; 
open(my $fh, '<', 'big_text_file') 
    or die "Oh, fudge: $!\n"; 

do { 
    push @line_starts, tell $fh 
} while (<$fh>); 

my $count = @line_starts; 
print "Got $count lines\n"; 

my @shuffled_starts = (shuffle @line_starts)[0..$GET_LINES-1]; 

for my $start (@shuffled_starts) { 

    seek $fh, $start, 0 
     or die "Unable to seek to line - $!\n"; 

    print scalar <$fh>; 
} 

Answer 7

फ़ाइल में वास्तविक पंक्ति संख्या जानने की कोई आवश्यकता नहीं है। बस एक यादृच्छिक जगह की तलाश करें और अगले लाइन रखें। (वर्तमान लाइन सबसे अधिक आंशिक रेखा होगी।)

यह दृष्टिकोण बड़ी फ़ाइलों के लिए बहुत तेज़ होना चाहिए, लेकिन यह एसटीडीआईएन के लिए काम नहीं करेगा। बिल्ली, स्मृति में पूरी फाइल को कैशिंग करने के लिए कुछ भी नहीं एसटीडीआईएन के लिए काम करेगा। इसलिए, यदि आपके पास STDIN होना चाहिए, तो मुझे नहीं लगता कि आप बड़ी फ़ाइलों के लिए तेज़/सस्ते कैसे हो सकते हैं।

आप एसटीडीआईएन का पता लगा सकते हैं और एक कैश किए गए दृष्टिकोण पर स्विच कर सकते हैं, अन्यथा तेज़ हो सकते हैं।

 
#!perl 
use strict; 

my $file='file.txt'; 
my $count=shift || 10; 
my $size=-s $file; 

open(FILE,$file) || die "Can't open $file\n"; 

while ($count--) { 
    seek(FILE,int(rand($size)),0); 
    $_=readline(FILE);       # ignore partial line 
    redo unless defined ($_ = readline(FILE)); # catch EOF 
    print $_; 
}