0

हमें एक फ़ाइल की आवश्यकता है जिसमें इसके नंबर हों:

0000000000..1000000000

तथा

0..1000000000

हम इस प्रकार की सूचियाँ कहाँ से डाउनलोड कर सकते हैं?

उदाहरण 1:

उदाहरण # 2: 1 2 ... 999999999 1000000000

यदि मैं टोरेंट साइट्स या सिर्फ Google के लिए खोज करता हूं तो मैं केवल ~ 8 अंक रखने वाली फाइलें पा सकता हूं, लेकिन हमें 10 की आवश्यकता है।

हमने इन फ़ाइलों को बनाने की कोशिश की:

var=0; while true; do var=$((var+1)); echo $var >> sorted-generated-only-numbers-length-from-1-to-10-chars-zero-at-start-too.txt; done

लेकिन यह एक बड़ी मशीन के साथ भी, फ़ाइल को बनाने में उम्र लेगा। गंभीरता से ..

अद्यतन: हमने उपयोग करने की कोशिश की: var = 0; var2 = 100000; जबकि सच है; do tmpbuffer100k = $ (seq $ var $ var2; var = $ ((var + 100000)); var2 = $ ((var2 + 100000)); इको "$ tmpbuffer100k" >> output.txt; किया हुआ

डिस्क पर लिखने से बचने के लिए, बल्कि हम पूर्व डालते हैं: एक चर में 100 000 नंबर, फिर इसे डिस्क पर लिखें - इसे तेज़ी से बनाने के लिए, लेकिन यह अभी तक काम नहीं कर रहा है। यह केवल पहली सीमा, 1..100000 लिखता रहता है

script

— pepite
स्रोत

1

आपका वर्तमान दृष्टिकोण लिखित प्रत्येक पंक्ति के लिए फ़ाइल खोलता है। यह अविश्वसनीय रूप से अक्षम है। आप भी कभी नहीं रुकते ...?

— डैनियल बी

मैं इसे समाप्त होने पर CTRL + C कर दूंगा, लेकिन अगर मैं "पर्याप्त निकास से अधिक 0 पर पहुंच गया तो" इसे धीमा कर देगा। तो आप संख्याओं को एक चर में रखने का सुझाव दे रहे हैं, फिर जब बहुत अधिक संख्या में पहुंच गए, तो इसे एक फ़ाइल में आउटपुट करें?

— पेपेइट

6

पूरी तरह से एक XY समस्या की तरह लगता है , आपको इसके लिए क्या चाहिए?

— गोनोस्तज

4

यहाँ एक कुशल शुद्ध बैश समाधान है:

function print_numbers {
  current_num=$1
  target_num=$2
  target_num_length=${#target_num}

  while [ $current_num -le $target_num ]; do
    printf "%0${target_num_length}d\n" $current_num
    # or just "echo $current_num" if padding is not required
    current_num=$((current_num + 1))
  done
}

print_numbers 0 10 > target_file

क्योंकि यह केवल बैश बिल्ट-इन का उपयोग करता है, कोई अतिरिक्त प्रक्रिया नहीं बनाई जाती है। यह फ़ाइल को target_file एक बार खोलता है और फ़ंक्शन से सभी आउटपुट को उस फ़ाइल पर रीडायरेक्ट करता है।

लक्ष्य मान तक पहुँचने पर फ़ंक्शन स्वचालित रूप से निरस्त हो जाता है।

बेशक, एक देशी उपकरण की तुलना में seq, यह अभी भी अविश्वसनीय रूप से धीमा है:

db-nb-13:~ fuzzy$ time print_numbers 0 100000 > /dev/null

real    0m2.909s
user    0m2.761s
sys 0m0.139s
db-nb-13:~ fuzzy$ time print_numbers 0 1000000 > /dev/null

real    0m30.974s
user    0m29.074s
sys 0m1.651s

db-nb-13:~ fuzzy$ time seq -w 0 1000000 > /dev/null

real    0m0.370s
user    0m0.363s
sys 0m0.003s

चेतावनी

परिणामी फाइलें बहुत बड़ी होंगी । एक फ़ाइल जिसमें 0..1000000000, शून्य के साथ गद्देदार है, होगी

1 000 000 000 * (10 (bytes for 10 digits – ASCII!) + 1 (newline)) = 11 000 000 000 bytes

वह 10.24 GiB है ! आपको वास्तव में अपने दृष्टिकोण पर पुनर्विचार करना चाहिए जो भी समस्या आप हल करने की कोशिश कर रहे हैं।

— डैनियल बी
स्रोत

4

अकेले चेतावनी के लिए +1। ऐसी अजीब आवश्यकता एक लाल झंडा है। अनुक्रमिक संख्याओं का 10 जीबी शायद समाधान नहीं है , लेकिन पूरी तरह से अलग समस्या के लिए टूटे हुए समाधान का एक हिस्सा है।

— gronostaj

4

चलो उदाहरण 2 के लिए पहले समाधान की जाँच करें :

आपके पास लिनक्स पर seq, उदाहरण के लिए:

seq 099999990 100000000

इस सूची को प्रिंट करेंगे:

आउटपुट को फ़ाइल में निर्देशित करें:

seq 1 100000000 > the_file.txt

अब जब आप समझते हैं कि कैसे seqकाम करता है आइए उदाहरण के लिए वापस जाएं 1 :

यदि आप seqध्वज में जोड़ते हैं तो आप -fउत्पन्न अनुक्रम में एक गद्दी जोड़ सकते हैं, उदाहरण के लिए:

seq -f "%05g" 1 10

5 अंक लंबे के रूप में प्रारूप करने के लिए प्रत्येक संख्या में एक पैडिंग जोड़ देगा:

अपने विशिष्ट मामले के लिए आपको -f "%010g"10 अंकों की लंबी संख्या को प्राप्त करने के लिए उपयोग करना होगा ।

— jcbermu
स्रोत

-wझंडा ऊपरी सीमा में अंकों की राशि के लिए गद्दी उठना एक तेज़ तरीका है।

— डैनियल बी

हम कहां से नंबर डाउनलोड कर सकते हैं?

चेतावनी