17

आपका कार्यक्रम / समारोह होना चाहिए

उत्पादन बिल्कुल एक पूर्णांक
सकारात्मक संभावना के साथ किसी भी पूर्णांक का उत्पादन
कम से कम 50% संभावना के साथ 1.000.000 या उससे कम -1.000.000 से अधिक पूर्णांक उत्पादन।

उदाहरण आउटपुट (सभी संभव होना चाहिए):

59875669123
12
-42
-4640055890
0
2014
12
24
-7190464664658648640055894646646586486400558904644646646586486400558904646649001

स्पष्टीकरण:

अनुगामी रेखा विराम की अनुमति है।
अग्रणी शून्य की अनुमति नहीं है।
-0 अनुमति दी है।

सबसे छोटा कोड जीतता है।

code-golf number random

— randomra
स्रोत

2

@ ओप्टिमाइज़र आप एक समान संभावना क्यों मान रहे हैं? प्रश्न यह नहीं बताता है। वास्तव में यह उस बिंदु से स्पष्ट लगता है कि वितरण को एक समान होने की आवश्यकता नहीं है जब तक कि इसका कम से कम 50% हिस्सा [-1 मिलियन, 1 मिलियन] के बाहर न हो जाए।

— होब्स

10

एक समाधान जो " सभी पूर्णांकों में एक समान वितरण " पैदा करता है, असंभव है। असीम रूप से कई पूर्णांक हैं, इसलिए प्रत्येक व्यक्तिगत पूर्णांक 0. की संभावना के साथ दिखाई देगा (या: एक परिमित संख्या का उत्पादन करने का मतलब होगा कि आप असीम रूप से कई अन्य लोगों की उपेक्षा कर रहे हैं!) पी को प्राप्त करने के लिए किसी भी समाधान को उच्च मूल्यों को त्यागना होगा! ) 1 =।

— joeytwiddle

2

@Ypnypn कंप्यूटर की रैम एक सीमा नहीं है। आपको अपना आंशिक उत्पादन कहीं भी संग्रहीत नहीं करना है।

— jimmy23013

4

@GiantTree - way too long to fit in an integer- यह केवल सच है यदि आप मानते हैं कि 32/64 बिट आर्च पर डेटाटाइप का integerअर्थ है int, जो जरूरी नहीं कि मान्य धारणा है। "इंटेगर" एक गणित शब्द के रूप में शुरू हुआ , जिसमें कोई आकार की कमी नहीं है।

— फेक नेम

5

आउटपुट पर अपने निर्णय लेने के लिए एक छद्म यादृच्छिक संख्या जनरेटर का उपयोग करने वाला कोई भी लगभग सभी पूर्णांकों को बाहर कर देगा, और पूर्णांकों के आकार पर एक ऊपरी सीमा रख सकता है जिसे उत्पादन किया जा सकता है (यह मानते हुए कि PRNG एक परिमित अवधि है)। क्या यह जवाबों की अवहेलना हो सकती है या एक वैध जवाब के लिए एक सच्चे यादृच्छिक संख्या जनरेटर की आवश्यकता होती है?

— trichoplax

12

CJam, 16 14 13 बाइट्स

0{Kmr(+esmr}g

यह बहुत लंबे समय तक चलेगा , क्योंकि यह वर्तमान टाइमस्टैम्प (10 ¹² के आदेश पर ) यह निर्धारित करने के लिए उपयोग करता है कि क्या लूप समाप्त हो गया है। मैं इसे सबमिशन के रूप में उपयोग कर रहा हूं, क्योंकि यह सबसे छोटा है, लेकिन दो 14-बाइट विकल्प हैं, जिनकी अपनी योग्यता है:

0{esmr(+esmr}g

यह एक है PRNG की अवधि तक सीमित नहीं है , क्योंकि सभी यादृच्छिक संख्याओं की सीमा वर्तमान टाइमस्टैम्प पर निर्भर करती है। इसलिए, यह किसी भी संख्या का उत्पादन करने में सक्षम होना चाहिए, हालांकि नकारात्मक के लिए संभावना, या यहां तक कि छोटे सकारात्मक संख्याएं गायब हो गईं।

नीचे एक समान संस्करण है जो उपयोग करता है 3e5 टाइमस्टैम्प के बजाय । और 20पहली श्रेणी के लिए (13-बाइट सबमिशन के रूप में)। यह बहुत तेज़ है और सभी नियमों का अनुपालन भी करता है। उचित रनटाइम और छोटे कोड-आकार को रखते हुए, 1,000,000 से अधिक संख्या के लिए 50% संभावना प्राप्त करना सीमित मामला है। स्पष्टीकरण और गणितीय औचित्य इस संस्करण का संदर्भ देते हैं:

0{Kmr(+3e5mr}g

आमतौर पर इसे चलाने में कुछ सेकंड लगते हैं। आप बदल सकते हैं 5एक साथ 2यह भी तेजी से चलाने के बनाने के लिए। लेकिन तब 50% संभावना पर आवश्यकता केवल 1,000,000 के बजाय 1,000 के लिए पूरी होगी।

मैं 0 पर शुरू कर रहा हूं। फिर मुझे एक लूप मिला है, जिसे मैं प्रायिकता 1 / (3 * 10 ⁵ ) से तोड़ता हूं । उस लूप के भीतर मैं अपने रनिंग टोटल में -1 और 18 (सम्मिलित) के बीच एक यादृच्छिक पूर्णांक जोड़ता हूं। एक परिमित (यद्यपि छोटा) संभावना है कि प्रत्येक पूर्णांक आउटपुट होगा, सकारात्मक पूर्णांक नकारात्मक लोगों की तुलना में बहुत अधिक होने की संभावना है (मुझे नहीं लगता कि आप अपने जीवनकाल में नकारात्मक एक देखेंगे)। इस तरह की एक छोटी संभावना के साथ बाहर तोड़ना, और ज्यादातर समय में वृद्धि (और घटाना की तुलना में बहुत अधिक जोड़ना) यह सुनिश्चित करता है कि हम आमतौर पर 1,000,000 से आगे निकल जाएंगे।

0              "Push a 0.";
 {          }g "Do while...";
  Kmr          "Get a random integer in 0..19.";
     (         "Decrement to give -1..18.";
      +        "Add.";
       3e5mr   "Get a random integer in 0..299,999. Aborts if this is 0.";

कुछ गणितीय औचित्य:

प्रत्येक चरण में हम औसतन 8.5 जोड़ते हैं।
1,000,000 के लिए हमें इन चरणों की 117,647 की आवश्यकता है।
इस चरण की संख्या से कम हम करने की संभावना है
```
sum(n=0..117,646) (299,999/300,000)^n * 1/300,000
```
जो मूल्यांकन करता है 0.324402। इसलिए, लगभग दो तिहाई मामलों में, हम अधिक से अधिक 117,647 कदम उठाएंगे, और आसानी से प्रत्येक 1,000,000।
(ध्यान दें कि यह सटीक संभावना नहीं है, क्योंकि उन औसत 8.5 के बारे में कुछ उतार-चढ़ाव होगा, लेकिन 50% तक पहुंचने के लिए, हमें 117,646 से लगभग 210,000 चरणों से आगे जाने की आवश्यकता है।)
यदि संदेह है, तो हम 9e9किसी भी बाइट (लेकिन रनटाइम के वर्षों) को जोड़ने के बिना , समाप्ति की संभावना के हर को आसानी से उड़ा सकते हैं ।

... या 11 बाइट्स?

अंत में, एक 11 बाइट संस्करण है, जो कि PRNG की अवधि तक भी सीमित नहीं है, लेकिन जो हर बार मेमोरी से बाहर चलेगा। यह केवल प्रत्येक पुनरावृत्ति के आधार पर एक यादृच्छिक संख्या (टाइमस्टैम्प के आधार पर) उत्पन्न करता है, और इसे वेतन वृद्धि और समाप्ति दोनों के लिए उपयोग करता है। प्रत्येक पुनरावृत्ति के परिणाम स्टैक पर बने रहते हैं और केवल अंत में सम्‍मिलित होते हैं। इस विचार के लिए डेनिस का धन्यवाद:

{esmr(}h]:+

— मार्टिन एंडर
स्रोत

मैंने यह सवाल करने के लिए एक टिप्पणी जोड़ी है कि क्या नियमों को एक सच्चे यादृच्छिक संख्या जनरेटर की आवश्यकता है, लेकिन मैंने अनुमान लगाया कि आप पैदल सेना की सराहना करेंगे। क्या आपका यादृच्छिक स्रोत यहाँ छद्म यादृच्छिक है? यह आपके PRNG की अधिकांश अवधि में संभावित आउटपुट के सेट के आकार को प्रतिबंधित करेगा, है ना?

— त्रिकोप्लक्स

(सरल लालित्य के लिए परवाह किए बिना)

— ट्राइकोप्लाक्स

हां मैं अब तक सभी का अनुमान लगा रहा हूं। मैं यह देखने के लिए उत्सुक हूं कि क्या कोई व्यक्ति उस समस्या के बिना उत्तर देता है ...

— trichoplax

मैं देख रहा हूँ कि ओपी ने कहा है कि आप मान सकते हैं कि आपका रैंडम नंबर जनरेटर एक सच्चा रैंडम नंबर जेनरेटर है या नहीं - तो यह अब बेमानी है ... :)

— ट्राइकोप्लाक्स

Kmrएक अवधि का योग अभी भी संभावना है कि अवधि की तुलना में हमेशा एक बड़ी सकारात्मक संख्या होती है। और यह उस मामले में हर संभव संख्या का उत्पादन नहीं कर सकता है।

— jimmy23013

11

जावा, 133 149

void f(){String s=x(2)<1?"-":"";for(s+=x(9)+1;x(50)>0;s+=x(10));System.out.print(x(9)<1?0:s);}int x(int i){return new java.util.Random().nextInt(i);}

उदाहरण आउटपुट

-8288612864831065123773
0
660850844164689214
-92190983694570102879284616600593698307556468079819964903404819
3264

Ungolfed

void f() {
    String s = x(2)<1 ? "-" : "";       // start with optional negative sign
    s+=x(9)+1;                          // add a random non-zero digit
    for(; x(50)>0; )                    // with a 98% probability...
        s+=x(10)                        // append a random digit
    System.out.print(x(9)<1 ? 0 : s);   // 10% chance of printing 0 instead
}

int x(int i) {
    return new java.util.Random().nextInt(i);
}

पुराना उत्तर (नियम बदलने से पहले)

void f(){if(Math.random()<.5)System.out.print('-');do System.out.print(new java.util.Random().nextInt(10));while(Math.random()>.02);}

— Ypnypn
स्रोत

आप दोनों सही हैं, लेकिन सवाल यह है कि संभावना कम से कम 50% की सीमा में नहीं है +/- 1.000.000

— GiantTree

@ ऑप्टिमाइज़र रेडोन।

— यपनिप

यदि आप द्विआधारी शाब्दिक का उपयोग करते हैं तो आपको प्रिंट नहीं करना है -।

— TheNumberOne

4

गणितज्ञ - ४hem

Round@RandomVariate@NormalDistribution[0,15*^5]

मूल रूप से बस 1500000 के बराबर विचरण के साथ सामान्य वितरण का उपयोग करके यादृच्छिक संख्या उत्पन्न करते हैं। यह -10 ^ 6 और 10 ^ 6 के बीच पूर्णता के साथ पूर्णता 49.5015 का उत्पादन करेगा।

— बेंत की मार
स्रोत

"यह 50.4985% संभावना के साथ -10 ^ 6 और 10 ^ 6 के बीच पूर्णांक का उत्पादन करेगा।" - यह काफी नहीं है। क्या आपने युक्ति को गलत बताया? शायद आपका मतलब 10 ^ 7 को विचरण के रूप में इस्तेमाल करना था?

— जॉन ड्वोरक

@JDDvorak गलत संभावना, क्षमा करें। अब यह सही है।

— बेंत की मार

क्या गणितज्ञों में इसे लागू करना वास्तव में सभी पूर्णांक को कवर करता है? मेरे पास स्रोत तक पहुंच नहीं है, लेकिन मुझे लगता है कि नहीं ...

— trichoplax

@githubphagocyte यह वर्तमान परिशुद्धता पर निर्भर करेगा।

— swish

4

मेरा मतलब है कि किसी भी विशिष्ट परिशुद्धता को निर्दिष्ट करने से बड़ी संख्या को बाहर रखा जाएगा। एकमात्र तरीका यह काम कर सकता है यदि आप असीमित परिशुद्धता निर्दिष्ट कर सकते हैं।

— ट्राइकोप्लाक्स

4

पायथन 2, 75 69 बाइट्स

from random import*;s=0;j=randrange
while j(12):s=s*9+j(-8,9)
print s

यह जांचना तुच्छ है कि बीच में लूप सभी पूर्णांक (शून्य के प्रति पक्षपाती) उत्पन्न कर सकता है। "12" को इस तरह चुना जाता है कि संख्या लगभग "10 ⁶ से अधिक हो ।

पुराना समाधान:

पायथन 2, 44 बाइट्स

~~गणितज्ञ समाधान के आधार पर ।~~

from random import*;print int(gauss(0,8**7))

वास्तव में काम नहीं करता है क्योंकि पायथन floatमें केवल परिमित परिशुद्धता है।

— kennytm
स्रोत

यह सभी पूर्णांकों को उत्पन्न करने में सक्षम नहीं होगा, क्योंकि छद्म यादृच्छिक संख्या जनरेटर में आंतरिक स्थिति की एक सीमित मात्रा होती है। प्रलेखन के अनुसार पायथन मेर्सेन ट्विस्टर का उपयोग करता है, इसलिए राज्य काफी बड़ा है। लेकिन यह अनंत नहीं है, इसलिए यह केवल सभी पूर्णांकों का एक सूक्ष्म उपसमूह पैदा कर सकता है।

— स्टारब्ले

@starblue: ओपी से: "आप मान सकते हैं कि आपकी भाषा का यादृच्छिक संख्या जनरेटर एक सच्चा यादृच्छिक संख्या जनरेटर है, भले ही ऐसा न हो।"

— kennytm

3

रूबी, 70

f=->{m=10**6
r=rand -m..m
r<1?(r>-5e5??-:'')+r.to_s+f[][/\d+/]:r.to_s}

बहुत बड़ी संख्या को संभव बनाने के लिए, मैं Stringएक लंबोदर के रूप में संख्या वापस कर रहा हूं । यदि इसकी अनुमति नहीं है, puts f[]तो इसे एक फ़ंक्शन के बजाय एक प्रोग्राम बनाने के लिए 8 वर्णों को अतिरिक्त (के लिए ) गिनें।

व्याख्या

-1,000,000और के बीच एक संख्या उत्पन्न करें 1,000,000। यदि संख्या 1अधिक या अधिक है, तो संख्या a के रूप में वापस आ जाती है String।

यदि संख्या से कम है 1, तो संख्या सीमा के बाहर संख्या वापस करने के लिए फ़ंक्शन को पुनरावर्ती कहा जाता है। यह सुनिश्चित करने के लिए कि ऋणात्मक संख्याएँ भी उत्पन्न की जा सकती हैं, एक -है जिसके परिणामस्वरूप परिणामी उपसर्ग है Stringयदि प्रारंभिक संख्या इससे अधिक है -500,000।

मुझे आशा है कि मैंने चुनौती को सही ढंग से समझा!

— britishtea
स्रोत

3

आर, 38

library(Rmpfr)
round(rnorm(1,2e6,1e6))

माध्य 2,000,000 के साथ गौसियन वितरण से ड्रॉ, यादृच्छिक रूप से चुना गया, और मानक विचलन 1,000,000, ताकि ड्रॉ के लगभग 2/3 1,000,000 और 3,000,000 के भीतर झूठ होंगे। वितरण अनबाउंड है इसलिए सिद्धांत रूप में यह किसी भी पूर्णांक को उत्पन्न कर सकता है। Rmpfr पैकेज आर की जगह डबल फ्लोट्स में बनाया गया है जिसमें मनमानी परिशुद्धता है।

— shadowtalker
स्रोत

हाँ मुझे एहसास हुआ कि मैंने कल्पना को गलत बताया है। और मुझे लगता है कि यह गणितज्ञ के साथ मशीन परिशुद्धता पर समान सीमाएं हैं

— छायांकनकर्ता

हम्म उस मामले में मुझे यकीन नहीं है। मुझे इसमें देखना पड़ेगा; इस उत्तर पर "अभी पकड़" पर विचार करें

— छायाकार

@ मार्टिनबटनर ने तय किया कि मुझे लगता है

— छायाकार 15

दिलचस्प। मुझे नहीं लगता कि आपको पूरे sample(c(1,-1),1)विचार की आवश्यकता है । बस 1e6 पर केंद्रित होना चाहिए ..

— मार्टिन

@ मार्टिनबटनर ओह, दोनों छोर पर 50% होने की आवश्यकता नहीं है? यह स्पष्ट नहीं था

— छायाकार

2

पर्ल, 53 वर्ण

print"-"if rand>.5;do{print int rand 10}while rand>.1

मैं निश्चित रूप से पूर्णांक के साथ काम करने का कोई कारण नहीं देखता हूं जब एक मुद्रण होता है :)

एक अग्रणी के साथ या उसके बिना किसी संख्या को प्रिंट करने की समान संभावना है "-"।

1-अंकों की संख्या 10%, समय का 2-अंकीय संख्या 9%, समय का 3-अंकीय संख्या 8.1%, समय का 4-अंकीय संख्या 7.29%, 5-अंकीय संख्या प्रिंट करता है 6.56% समय, 6-अंकीय संख्या 5.9% समय, आदि। किसी भी लंबाई संभव है, घटती संभावना के साथ। एक-थ्रू पांच अंकों की संख्या में आउटपुट मामलों का लगभग 41.5% हिस्सा होता है, और 1,000,000 (या -1,000,000) संख्या केवल एक प्रतिशत का 6 मिलियन होती है, इसलिए आउटपुट संख्या 1,000,000 से 54,000 के माध्यम से -1,000,000 की सीमा के बाहर होगी। % समय की।

दोनों "0" और "-0" संभव आउटपुट हैं, जो मुझे आशा है कि कोई समस्या नहीं है।

— हॉब्स
स्रोत

क्या यह प्रिंट "संख्या" जैसे -00000000167 नहीं है? यह वास्तव में पूर्णांक नहीं है।

— isaacg

1

@ आइसाकग मैं यह नहीं देखता कि पूर्णांक क्यों नहीं है।

— ऑप्टिमाइज़र

2

@ ऑप्टिमाइज़र यह है, लेकिन ओपी ने स्पष्ट रूप से मना किया है अग्रणी 0.

— मार्टिन एंडर

आप लूप से पहले, -9 से +9 तक एक यादृच्छिक गैर-शून्य अग्रणी अंक उत्पन्न कर सकते हैं। print int(rand(20)-10)||1। मुझे आउटपुट के रूप में 0 उत्पन्न करने के लिए एक तरीका चाहिए, हालाँकि। शायद || मरो ०, अगर शून्य के बाद अनुगामी कचरा। शून्य को मुद्रित करने और आगे आउटपुट के बिना बाहर निकलने के लिए एक छोटे तरीके की आवश्यकता होती है यदि int(rand(20)-10)==0।

— पीटर कॉर्ड्स

@PeterCordes ने सहमति व्यक्त की, यह एक सभ्य दृष्टिकोण है लेकिन मुझे इसे लिखने का मन नहीं है और मुझे नहीं लगता कि यह प्रतिस्पर्धी लंबाई-वार होगा। बेझिझक इसे अपने दम पर सबमिट करें :)

— hobbs

2

पर्ल, 114 शुल्क

use Math::BigInt;sub r{$x=Math::BigInt->new(0);while(rand(99)!=0){$x->badd(rand(2**99)-2**98);}print($x->bstr());}

टूट - फूट:

use Math::BigInt;               -- include BigIntegers
  sub r{                        -- Define subroutine "r"
    $x=Math::BigInt->new(0);    -- Create BigInteger $x with initial value "0"
      while(rand(99)!=0){       -- Loop around until rand(99) equals "0" (may be a long time)
        $x->badd(               -- Add a value to that BigInt
          rand(2**99)-2**98);   -- Generate a random number between -2^98 and +2^98-1
        }print($x->bstr());}    -- print the value of the BigInt

-1.000.000 और 1.000.000 के बीच मान प्राप्त करने की संभावना शून्य BUT की ओर प्रवृत्त हो रही है यह संभव है।

नोट: यह सबरूटीन लंबे समय तक चल सकता है और "मेमोरी से बाहर!" त्रुटि लेकिन यह तकनीकी रूप से किसी भी पूर्णांक को उत्पन्न कर रही है जैसा कि प्रश्न में कहा गया है।

पर्ल, २५

~~sub r{rand(2**99)-2**98;}~~

+/- 2 ^ 99 की सीमा के भीतर एक यादृच्छिक पूर्णांक बनाता है।

टूट - फूट

sub r{                    -- Define subroutine "r"
     rand(2**99)          -- Generate a random integer between 0 and 2^99
                -2**98;}  -- Subtract 2^98 to get negative values as well

1 मिलियन नमूनों के साथ परीक्षण किया गया:

~5 are inside the range of +/-1.000.000
~999.995 are outside that range
= a probability of ~99,99% of generating an integer outside that range.
Compare that number to the probability of 2.000.000 in 2^99: It is approx. the same.

यह सभी नियमों को पूरा करता है:

1 पूर्णांक
किसी भी पूर्णांक संभव है
सभी उत्पन्न पूर्णांक के कम से कम 50% (मेरे मामले में 99,99%) +/- 1.000.000 की सीमा के बाहर हैं।

यह काम करता है क्योंकि अंतर्निहित यादृच्छिक संख्या जनरेटर उत्पन्न होने वाली हर बिट के लिए समान संभावना को परिभाषित करता है, इस प्रकार उत्पन्न पूर्णांक पर भी ऐसा करता है।
प्रत्येक पूर्णांक में 1/2 ^ 99 उत्पन्न होने की संभावना है।

संपादित करें:

मुझे घातांक बढ़ाना पड़ा ताकि बड़े पूर्णांक उत्पन्न हो रहे हैं। मैंने 99 को चुना है क्योंकि यह कोड को यथासंभव छोटा रखता है।

— GiantTree
स्रोत

क्या हम इस बात से सहमत नहीं थे कि कोई ऊपरी / निचली सीमा नहीं होनी चाहिए? उदाहरण के लिए, पूर्णांक 2 ^ 31 + 1 में 0 प्रायिकता है, नियम 2 को तोड़ते हुए

— ऑप्टिमाइज़र

@ मेरे लिए एक पूर्णांक को कई प्रोग्रामिंग भाषाओं में परिभाषित किया गया है: -2^31और +2^31-1(32 बिट्स) की सीमा के भीतर एक संख्या । यदि आप बड़े पूर्णांक उत्पन्न करना चाहते हैं तो आप आसानी से घातांक बढ़ा सकते हैं, लेकिन यह पर्ल के कार्यान्वयन के आधार पर विफल हो सकता है।

— जाइंटट्री डिक

मैंने अभी देखा कि हास्यास्पद रूप से बड़े पूर्णांक को भी उत्पन्न किया जाना है। मैं अपना कोड शीघ्रता से संपादित करूंगा।

— जाइंटट्री

@ मार्टिनबटनर मैंने प्रश्न की कल्पना को पूरा करने की पूरी कोशिश की। यह मेरे लिए संभव नहीं है (कम से कम बिना मदद के) असीम रूप से बड़े पूर्णांक उत्पन्न करने के लिए। पर्ल का सबसे बड़ा पूर्णांक लगभग 1.7e308 है जो एक सीमा है जिसे मैं नियंत्रित नहीं कर सकता।

— जाइंटट्री

@ मार्टिनबटनर दोनों संभव हैं लेकिन उदा। स्ट्रिंग डेटा के 2gb के बाद अतिप्रवाह करेगा जिससे यह फिर से परिमित होगा। यह कहना मुश्किल है कि स्मृति के साथ समस्या होने पर एक संख्या असीम रूप से बड़ी होनी चाहिए। मैं BigInts का उपयोग करके जल्द ही एक अलग दृष्टिकोण के साथ आऊंगा। इसके अलावा पूर्णांक 1.7e308 पर अतिप्रवाह नहीं करता है, यह सिर्फ infite में परिवर्तित हो जाता है ( 1.#INFसटीक होने के लिए)

— GiantTree

2

सी#, 126 107 बाइट्स

string F(){var a=new System.Random();var b=a.Next(-1E6,1E6+1)+"";while(a.Next(1)>0)b+=a.Next(10);return b;}

Ungolfed:

string F()
{
    System.Random rand = new System.Random();
    string rtn = rand.Next(-1E6, 1E6 + 1) + "";
    while (rand.Next(1) > 0)
         rtn += a.Next(10);
    return rtn;
}

N की संख्या उत्पन्न करने के लिए मौका अंक 1/2 ^ (n-10) है, जो सभी सकारात्मक n के लिए 0 से अधिक है, और n = 11 के लिए 1/2 है।साथ ही अग्रणी शून्य बनाता है, जो मूल प्रश्न या उसकी किसी भी टिप्पणी में अस्वीकृत नहीं लगता है।

— LegionMammal978
स्रोत

उपयोग करते समय using System;, आपको System.Randomदो बार की आवश्यकता नहीं है , लेकिन बस Random, सही है?

— चार्ली

@ चार्ली यह एक समारोह है, इसलिए मैं usingबयानों का उपयोग नहीं कर सकता । यह केवल 1 char को बचाएगा।

— लेजियन मम्मल 978 12

1

आप अंतरिक्ष को हटाकर 1 char को बचा सकते हैं -1E6, 1E6+1।

— प्रोग्राम फॉक्स

2

पर्ल, 62 बाइट्स

print $n=int rand(20)-10;while($n&&rand>.1){print int rand 10}

मेरे पास एक समय में एक अंक बनाने के @Hobbs के समान विचार था, लेकिन उनके कोड ने जोड़ा नो-अग्रणी-शून्य आवश्यकता को पूरा नहीं किया। केवल संकेत के बजाय पहला अंक उत्पन्न करना जो हल हो गया। और जब तक कि हम शून्य, या प्रमुख -9 से 9 उत्पन्न करने के लिए एक छोटा रास्ता नहीं छोड़ते हैं, तब तक बाहर निकलने का एक छोटा तरीका है, इसे आकार में करना चाहिए।

एक शेल लूप में: while perl -e '...'; do echo;done |less

मुझे लगता है कि यह सबसे कम में से एक है जिसे समस्या को पूरा करने के लिए अनंत रैम की आवश्यकता नहीं है। एक बोनस के रूप में, आउटपुट किसी भी चीज़ के प्रति दृढ़ता से पक्षपाती नहीं है, और रनटाइम बहुत तेज़ है।

मैंने बिटवाइज़ का उपयोग करने की कोशिश की और उस स्थिति में एक चरित्र को बचाने के लिए, लेकिन मुझे लगता है कि यह अधिक बार सच होता है, इसलिए लूप जल्द ही समाप्त हो जाता है। एब्स (आउटपुट)> 1M उत्पन्न करने की संभावना बनाए रखने के लिए, काउंटर करने के लिए अन्य चीजों को समायोजित करने के लिए और अधिक वर्णों की आवश्यकता होगी।

— पीटर कॉर्डेस
स्रोत

अच्छा, आपने कुछ ऐसी बातें बताईं, जिनके बारे में मैंने सोचा नहीं था :)

— hobbs

1

जावास्क्रिप्ट (73)

यह समाधान उपयोग करता है कि आप पिछली संख्या को n के साथ गुणा करके और आधार n में एक अंक जोड़कर आधार n के साथ एक संख्या का निर्माण कर सकते हैं । सभी नकारात्मक पूर्णांक बनाने में सक्षम होने के लिए हमारे पास एक अतिरिक्त है। निम्न कोड को ब्राउज़र कंसोल में परीक्षण किया जाना चाहिए।..?..:..

b=Math.round;c=Math.random;x=0;while(b(c()*99)){x*=b(c())?2:-2;x+=b(c())}

पूर्णांक प्राप्त करने की संभावना> = 2^1(या <= -(2^1)) इस संभावना के बराबर है कि लूप 2 बार चला गया है। ऐसा होने की संभावना है (98/99)^2। एक संख्या प्राप्त करने का मौका जो 2^20(या <= -(2^20)) से अधिक है इसलिए (98/99)^21 = 0.808या 81% है। हालांकि यह सभी सिद्धांत में है, और यह मानते हुए कि Math.random ट्रैंडली यादृच्छिक है। यह स्पष्ट रूप से नहीं है।

स्निपेट इस कोड का परीक्षण कर रहा है। इसके अलावा एक और अधिक पठनीय फैशन में।

कोड स्निपेट दिखाएं

var interval = 0;
var epic_unicorns = 0;
var unicorns = 0;

function gimmerandom() {
  var b = Math.round;
  var c = Math.random;
  var x = 0;
  while( b(c()*99) ) {
    x *= b(c()) ? 2 : -2;
    x += b(c());
  }
  return x;
}

function randomcount() {
  var a = gimmerandom();
  if( a <= -1000000 || a >= 1000000 ) {
    epic_unicorns++;
  }
  unicorns++;
  updatedisplay();
}

function updatedisplay() {
  $('#num_of_epicunicorns').text( epic_unicorns );
  $('#num_of_unicorns').text( unicorns );
  var perc = unicorns > 0 ? Math.round( (epic_unicorns / unicorns) * 1000 ) / 10 : 0;
  $('#perc_of_unicorns').text( perc );
}

$('#a').on( 'click', function() {
  clearInterval( interval );
  interval = setInterval( randomcount, 10 );
} );

$('#b').on( 'click', function() {
  clearInterval( interval );
} );

$('#c').on( 'click', function() {
  epic_unicorns = 0;
  unicorns = 0;
  updatedisplay();
} );

updatedisplay();

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<span id="num_of_epicunicorns"></span> / <span id="num_of_unicorns"></span> (<span id="perc_of_unicorns"></span>%) were larger than 1.000.000 or less than 1.000.000.

<br><br>
<input type="button" id="a" value="Start"> 
<input type="button" id="b" value="Stop"> 
<input type="button" id="c" value="Reset">

स्निपेट का विस्तार करें

— Sumurai8
स्रोत

1

ओपी ने अब पुष्टि की है कि आप मान सकते हैं कि आपका PRNG वास्तव में यादृच्छिक है, भले ही वह ऐसा न हो।

— ट्रिकोप्लॉक्स

1

गोल्फस्क्रिप्ट, 20 बाइट्स

0{)8.?rand}do.2&(*4/

हाँ, यह एक तरह का धीमा है।

सीजेम और पायथ जैसी भाषाओं की तुलना में, गोल्फस्क्रिप्ट एक वर्बोज़ यादृच्छिक संख्या पीढ़ी कीवर्ड ( rand) से ग्रस्त है । इस बाधा को दूर करने के लिए, मुझे इसे केवल एक बार उपयोग करने का एक तरीका खोजने की आवश्यकता थी।

यह कोड 0 और 8 ⁸ 161 = 16,777,215 के बीच एक यादृच्छिक संख्या को बार-बार उठाकर काम करता है , और एक काउंटर को बढ़ाता है जब तक कि यादृच्छिक संख्या 0. नहीं होती है। परिणामी काउंटर मूल्य में औसत -1 / लॉग _{2 के} साथ एक ज्यामितीय वितरण होता है (1 - 1/8 ⁸ ) 29 11,629,080, इसलिए यह "समय के कम से कम 50% से अधिक 1,000,000" परीक्षण से मिलता है।

काश, इस प्रकार उत्पन्न यादृच्छिक संख्या हमेशा कड़ाई से सकारात्मक होती है। इस प्रकार, .2&(*4/इसे नकारात्मक या शून्य होने देने के लिए अतिरिक्त भाग की आवश्यकता होती है। यह संख्या के दूसरे-सबसे कम बिट (जो कि या तो 0 या 2 है) को निकालकर, इसे -1 या 1 बनाने के लिए घटाकर, मूल संख्या के साथ गुणा करके और परिणाम को 4 से विभाजित करके काम करता है (छुटकारा पाने के लिए) सबसे कम दो बिट्स, जो अब संकेत के साथ सहसंबद्ध हैं, और परिणाम को शून्य बनने की अनुमति देने के लिए भी)। 4 से विभाजन के बाद भी, यादृच्छिक संख्या के निरपेक्ष मूल्य में अभी भी -1 / लॉग ₂ (1 - 1/8 ⁸ ) / 4) 2,907,270 का माध्य है, इसलिए यह अभी भी 50% परीक्षण से गुजरता है।

— इल्मरी
स्रोत

1

जावास्क्रिप्ट, 81 बाइट्स

यह कोड सभी नियमों को पूरा करता है:

सकारात्मक संभावना के साथ किसी भी पूर्णांक को आउटपुट करें
कम से कम 50% संभावना के साथ +/- 1000000 की सीमा के बाहर आउटपुट पूर्णांक
0आउटपुट में कोई अग्रणी नहीं है

एक बोनस के रूप में, एल्गोरिथ्म ओ (लॉग ₁₀ एन) की समय जटिलता के साथ चलता है इसलिए यह पूर्णांक को लगभग तुरंत लौटाता है।

for(s="",r=Math.random;r()>.1;s+=10*r()|0);r(s=s.replace(/^0*/,"")||0)<.5?"-"+s:s

यह एक REPL वातावरण मानता है। अपने ब्राउज़र के कंसोल में उपरोक्त कोड चलाने का प्रयास करें, या नीचे दिए गए स्टैक स्निपेट का उपयोग करें:

D.onclick = function() {
  for(s="", r=Math.random;r()>.1; s+=10*r()|0);
  P.innerHTML += (r(s=s.replace(/^0*/,"") || 0) <.5 ?"-" + s : s) + "<br>"
}

<button id=D>Generate a random number</button><pre id=P></pre>

स्निपेट का विस्तार करें

एल्गोरिथम :

sजब तक स्ट्रिंग करने के लिए यादृच्छिक अंक जोड़ना जारी रखें Math.random() > 0.1।
के आधार पर Math.random() > 0.5, संख्या को ऋणात्मक बनाएं (स्ट्रिंग sको पहले से बताकर -)।

इस एल्गोरिथ्म में सभी पूर्णांकों में एक समान वितरण नहीं है। उच्च अंकों की संख्या वाले इंटीजर कम लोगों की तुलना में कम संभावित होते हैं। लूप पुनरावृत्ति के लिए प्रत्येक में, 10% संभावना है कि मैं वर्तमान अंक पर रोक दूंगा। मुझे बस यह सुनिश्चित करना है कि मैं 6 अंकों के बाद 50% से अधिक समय के बाद रुक जाऊं।

@Nutki द्वारा यह समीकरण उपरोक्त स्थिति के आधार पर मौका प्रतिशत को रोकने का अधिकतम मूल्य बताता है:

1 - 50%^(1/6) ≈ 0.11

इस प्रकार प्रश्न के तीनों नियमों को पूरा करने के लिए 0.1 अच्छी तरह से सीमा के भीतर है।

— ऑप्टिमाइज़र
स्रोत

कुछ चीजें हैं जो मुझे इस जवाब के बारे में भ्रमित करती हैं। क्या आपने मान लिया है कि Math.random () यादृच्छिक संख्याओं का एक समान वितरण उत्पन्न करता है, क्योंकि कल्पना बताती है कि यह कार्यान्वयन पर निर्भर है। यह मानते हुए कि यह एक समान वितरण है, P (Math.random ()> 0.1) = 0.9 इसलिए एक बड़ी संभावना है कि यह प्रत्येक पुनरावृत्ति के बीच समाप्त हो जाएगा। फ़ायरफ़ॉक्स 34.0 उबंटू पर चलने वाले आपके एल्गोरिथ्म का एक कार्यान्वयन मुझे हर बार होने वाली ~ 0.47 (<0.5) की संभावना देता है: मैं इसका परीक्षण करता हूं: jsfiddle.net/WK_of_Angmar/dh8gq4pb

— Ww_of_Angmar

इसके अलावा, आपने एक इनपुट के बिना एल्गोरिथ्म के लिए समय जटिलता की गणना कैसे की है?

— Wk_of_Angmar

1

टीआई-बेसिक, 14 बाइट्स

1-2int(2rand:randNorm(AnsE6,9

@ Ssdecontrol के R उत्तर के समान, यह गौसियन डिस्ट्रीब्यूशन से होता है, जिसका मतलब होता है -1,000,000 या 1,000,000, बेतरतीब ढंग से चुना जाता है, और मानक विचलन 9. वितरण बिना सिद्धांत के होता है इसलिए यह किसी भी पूर्णांक को उत्पन्न कर सकता है।

स्पष्टीकरण :

1-2int(2rand     - get a random integer 0 or 1, then multiply by 2 and subtract 1
:                - this gives the number 1 or -1 (with equal probability) to Ans
randNorm(AnsE6,9 - displays Gaussian distribution with mean (Ans * 1,000,000) and std. dev. 9

— Timtech
स्रोत

लेकिन क्या यह "2" या "-2" उत्पन्न कर सकता है?

— kennytm

हाँ, ज़ाहिर है। tibasicdev.wikidot.com/randnorm

— टिमटेक

1

ठीक से कोड को गलत तरीके से पढ़ें (विचार का :अर्थ है कि "प्रिंट" कैसे स्पष्टीकरण प्रस्तुत किया गया है)। लेकिन क्या यह 20 अंकों से अधिक संख्या उत्पन्न कर सकता है?

— kennytm

आउटपुट के रूप में कोई भी मनमाना लंबा पूर्णांक संभव है? क्या यह सीमा तक सीमित नहीं है randNorm?

— ऑप्टिमाइज़र

"वितरण अनबाउंड है इसलिए सिद्धांत रूप में यह किसी भी पूर्णांक को उत्पन्न कर सकता है।" कोई सीमा नहीं है।

— टाइमटेक

1

बैश, 66

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/random

यह लगभग हमेशा 5000000 प्रिंट करता है। लेकिन अगर इसमें एक वैध संख्या मिली है /dev/random, तो यह उस नंबर को प्रिंट करेगा।

और यह तेज है:

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/urandom

— jimmy23013
स्रोत

1

@Optimizer यह धीमा माना जाता है। ऐसा इसलिए है क्योंकि यह एक वास्तविक यादृच्छिक स्रोत है। लेकिन आप इसका परीक्षण कर सकते हैं /dev/urandomजिसके साथ कम यादृच्छिकता है।

— jimmy23013

@Optimizer कैसे मैन्युअल इनपुट ले रहा होगा? यह एक फ़ाइल पढ़ रहा है, लेकिन सब कुछ एक फ़ाइल है।

— लीख

@ ओप्टिमाइज़र मैं बस उस बिंदु को नहीं समझता, जिसके लिए आप जा रहे हैं।

— नितिन

/dev/urandomशेल स्क्रिप्ट में पढ़ना मूल रूप rand()से अन्य भाषाओं में कॉलिंग के समान है । यद्यपि यदि आप वास्तव में bash का उपयोग कर रहे हैं, तो POSIX sh नहीं, तो आप यादृच्छिक संख्या प्राप्त कर सकते हैं echo $RANDOM। wiki.ubuntu.com/DashAsBinShhexdump /dev/urandom नंगे-पोसिक्स-न्यूनतम के बराबर देता है /bin/dash।

— पीटर कॉर्डेस

1

सी ++, 95 बाइट्स

void f(){int d=-18,s=-1;while(s<9){d=(rand()%19+d+9)%10;cout<<d;s=9-rand()%10*min(d*d+s+1,1);}}

विस्तारित:

void f() {
    int d=-18,s=-1;
    while(s<9) {
        d=(rand()%19+d+9)%10;
        cout<<d;
        s=9-rand()%10*min(d*d+s+1,1);
    }
}

स्पष्टीकरण:

फ़ंक्शन लगातार यादृच्छिक अंकों को प्रिंट करता रहता है जब तक कि एक यादृच्छिक मूल्यवान स्विच फ़ंक्शन को रोकने के लिए आवश्यक मान नहीं लेता है। d वह चर है जो अगले अंक के मूल्य को मुद्रित करता है। s वह स्विच वैरिएबल है जो अंतराल में यादृच्छिक पूर्णांक मान लेता है [0, 9], यदि s == 9 तो कोई और अंक मुद्रित नहीं होता है और फ़न समाप्ति समाप्त हो जाती है।

पहले अंक के लिए विशेष उपचार देने के लिए चर और घ को आरंभ किया जाता है (इसे अंतराल से ले जाना [-9, 9] और यदि पहला अंक शून्य है तो अग्रणी शून्य से बचने के लिए फ़ंक्शन समाप्त होना चाहिए)। D का मान d = rand ()% 10 के रूप में सौंपा जा सकता है, लेकिन तब पहला अंक ऋणात्मक नहीं हो सकता है। d को d = (रैंड) (% 19 + d + 9)% 10 के बजाय असाइन किया गया है और -18 पर आरंभ किया गया है, इसलिए d का पहला मान [-9, 9] से होगा और अगला मान हमेशा [0 से होगा , ९]।

चर s [0, 9] से यादृच्छिक रूप से होता है, और यदि s 9 के बराबर होता है, तो फ़ंक्शन समाप्त होता है, इसलिए पहले अंक को प्रिंट करने के बाद अगले एक को 90% (रैंड को मानते हुए) की संभावना के साथ मुद्रित किया जाएगा और वास्तव में यादृच्छिक है, और तीसरी शर्त को पूरा करने के लिए)। s को आसानी से s = rand ()% 10 के रूप में सौंपा जा सकता है, हालाँकि, एक अपवाद है, यदि पहला अंक शून्य है, तो फ़ंक्शन समाप्त हो जाएगा। इस तरह के अपवाद को संभालने के लिए, s को 9 = रैंड ()% 10 * मिनट (d * d + s + 1,1) और -1 के रूप में आरंभीकृत किया गया है। यदि पहला अंक शून्य है, तो मंत्री 0 पर लौटेगा और 9-0 = 9 के बराबर होगा। चर का असाइनमेंट हमेशा [0, 9] से होता है, इसलिए अपवाद केवल पहले अंक में हो सकता है।

विशेषताएँ (रैंड मानकर) वास्तव में यादृच्छिक है

पूर्णांक अंक द्वारा मुद्रित अंक है, पिछले एक को प्रिंट करने के बाद किसी अन्य अंक को प्रिंट करने की 90% की निश्चित संभावना के साथ।
0 पूर्णांक में मुद्रित होने की संभावना के साथ पूर्णांक है, जिसमें लगभग 5.2% की संभावना है।
अंतराल पर एक पूर्णांक प्रिंट करने की संभावना [-10 ^ 6, 10 ^ 6] लगभग 44% है (गणना यहां नहीं लिखी गई है)।
सकारात्मक और नकारात्मक पूर्णांक समान संभावना (~ 47.4%) के साथ मुद्रित होते हैं।
सभी अंक समान संभावना के साथ मुद्रित नहीं होते हैं। उदाहरण के लिए: पूर्णांक को प्रिंट करने के बीच में, यदि अंतिम अंक 5 था, तो अंक 3 में अगले मुद्रित होने की थोड़ी कम संभावना होगी। सामान्य तौर पर, यदि अंतिम अंक d था, तो अंक (d + 18)% 10 में अगले मुद्रित होने की थोड़ी कम संभावना होगी।

उदाहरण आउटपुट (10 निष्पादन)

-548856139437
7358950092214
507
912709491283845942316784
-68
-6
-87614261
0
-5139524
7

Process returned 0 (0x0)   execution time : 0.928 s
Press any key to continue.

— डैनियल टर्ज़ो
स्रोत

1

बैश, 42 बाइट्स

printf "%d\n" 0x$(xxd -p -l5 /dev/random)
OSX पर / dev / random बस यादृच्छिक बाइट्स है, और xxd -p -l5ascii वर्णों के 5 को हेक्स में रूपांतरित करता है, और printfदशमलव प्रारूप में बदल देता है।

— कैमडेन
स्रोत

0

अजगर , 11 बाइट्स

WOyG~ZtOT)Z

नोट: यह प्रोग्राम संभवतः किसी वास्तविक कंप्यूटर पर मेमोरी त्रुटि के साथ क्रैश होगा। इसे जांचने के लिए, Gएक छोटी स्ट्रिंग के साथ बदलने का प्रयास करें , जैसे कि इस कोड में, जो लगभग 28000 की औसत संख्या उत्पन्न करता है:

pyth -c 'WOy"abcdefghijklm"~ZtOUT)Z'

यह कोड लूप्स, Zप्रत्येक रिप्लेसमेंट पर लूप से बाहर निकलने की 2 ^ -26 संभावना के साथ -1 से 8 तक एक यादृच्छिक संख्या जोड़ रहा है। 2 ^ -26 प्रायिकता वर्णमाला ( ) Oके सभी सबसेट ( y) के सेट के एक यादृच्छिक तत्व ( ) का चयन करके प्राप्त की जाती है G।

तकनीकी विवरण और औचित्य:

संभावना 2 ^ -26 दो तथ्यों से ली गई है: yजब अनुक्रमों पर कॉल किया जाता है, तो पावर-सेट फ़ंक्शन होता है, जो इनपुट के सभी सबसेट की सूची का निर्माण करता है। चूंकि इनपुट, G26 वर्ण लंबा है, इस पावर-सेट yGमें 2 ^ 26 प्रविष्टियां हैं। OyGउन 2 ^ 26 प्रविष्टियों में से एक यादृच्छिक तत्व का चयन करता है। उन प्रविष्टियों में से एक, खाली स्ट्रिंग, पास होने पर मिथ्या के रूप में मूल्यांकन करेगीW जब लूप , । इसलिए, प्रत्येक बार लूप से बाहर निकलने की 2 ^ -26 संभावना है।

किसी भी निश्चित संख्या में लूप साइकल K में, संख्या K * 3.5 + m और K * 3.5 - m प्राप्त करने की संभावना बराबर है, क्योंकि जोड़ के प्रत्येक क्रम जो एक कुल प्राप्त करता है, उलटा हो सकता है, -1 -> 8, 0 -> 7, आदि, दूसरे को प्राप्त करने के लिए। इसके अतिरिक्त, K * 3.5 के करीब संख्या स्पष्ट रूप से संख्याओं की तुलना में अधिक दूर है। इस प्रकार, यदि K> 2000000 / 3.5 = 571428.5, 1000000 से अधिक संख्या प्राप्त करने की संभावना 75% से अधिक है, क्योंकि उस संख्या से ऊपर के कुछ परिणाम नीचे दिए गए सभी परिणामों के साथ एक-से-एक पत्राचार में डाले जा सकते हैं। संख्या, और ऊपरी कम-से-आधा, 1000000 से कम लोगों के साथ एक-से-एक पत्राचार में डाला जा सकता है। कम से कम 571429 लूप प्राप्त करने की संभावना है (1-2 ^ -26) ^ 571429, जो नहीं है से कम (1-2 ^ -26 * 571429), पहले 571429 कोशिशों पर लूप छोड़ने की अपेक्षित संख्या, जो 99.1% है। इस प्रकार, 99.1% या अधिक परीक्षणों पर, कम से कम 1000000 मिलने की 75% या अधिक संभावना है, इसलिए 1000000 से अधिक प्राप्त करने की 50% से अधिक संभावना है।

यह कोड उस व्यवहार पर निर्भर करता है Oजहां 3 दिन पहले गलती से एक बग पेश किया गया था और आज तय किया गया था। यह दिसंबर 22 से पहले या आज के बाद पायथ 3 के किसी भी संस्करण पर काम करना चाहिए। निम्नलिखित कोड समकक्ष है, और हमेशा काम किया है:

WOyG~ZtOUT)Z

— isaacg
स्रोत

ऑनलाइन कंपाइलर का क्या हुआ?

— ऑप्टिमाइज़र

वेबसाइट पर @Optimizer जारी करता है, मैं इस पर काम करूंगा।

— इसहाक

आह कूल। कल मेरे CJam जवाब के पायथ अनुवाद पर काम करना चाहता था और पाया कि यह 404 देता है।

— ऑप्टिमाइज़र

0

जावा, 113 बाइट्स

void g(){String a=Math.random()>0?"10":"01";for(;Math.random()>0;)a+=(int)(Math.random()*2);System.out.print(a);}

यह प्रोग्राम मानक आउटपुट स्ट्रीम में एक बाइनरी नंबर प्रिंट करता है। आपको कुछ समय इंतजार करना पड़ सकता है क्योंकि इसकी संख्या समाप्त होने की संभावना (या यह सकारात्मक है) लगभग 0. है यह विचार कि उत्पन्न संख्या का पूर्ण मान 1 मिलियन से कम है, मनोरंजक है, फिर भी संभव है।

Ungolfed:

void g(){
    String a=Math.random()>0?"10":"01";             //Make sure there are no trailing zeroes.
    for(;Math.random()>0;)a+=(int)(Math.random()*2);//Add digits
    System.out.print(a);                            //Print
}

नमूना आउटपुट: जब कोई नंबर जेनरेट किया जाता है तो पोस्ट करेगा।

— नंबर एक
स्रोत

0

जावा (JDK) , 140 127 बाइट्स

()->{int i;var o=System.out;for(o.print(i=(int)(19*Math.random())-10);i!=0&Math.random()<.9;)o.print((int)(11*Math.random()));}

-13 bytes लूप हेडर में और अधिक तर्क चुपके से - @ceilingcat के लिए धन्यवाद

इसे ऑनलाइन आज़माएं!

— सारा जे
स्रोत

कोई भी यादृच्छिक पूर्णांक उत्पन्न करें

CJam, 16 14 13 बाइट्स

... या 11 बाइट्स?

जावा, 133 149

उदाहरण आउटपुट

Ungolfed

पुराना उत्तर (नियम बदलने से पहले)

गणितज्ञ - ४hem

पायथन 2, 75 69 बाइट्स

पायथन 2, 44 बाइट्स

रूबी, 70

व्याख्या

आर, 38

पर्ल, 53 वर्ण

पर्ल, 114 शुल्क

टूट - फूट:

पर्ल, २५

टूट - फूट

संपादित करें:

सी#, 126 107 बाइट्स

पर्ल, 62 बाइट्स

जावास्क्रिप्ट (73)

गोल्फस्क्रिप्ट, 20 बाइट्स

जावास्क्रिप्ट, 81 बाइट्स

टीआई-बेसिक, 14 बाइट्स

बैश, 66

सी ++, 95 बाइट्स

विस्तारित:

स्पष्टीकरण:

विशेषताएँ (रैंड मानकर) वास्तव में यादृच्छिक है

उदाहरण आउटपुट (10 निष्पादन)

बैश, 42 बाइट्स

अजगर , 11 बाइट्स

जावा, 113 बाइट्स

जावा (JDK) , 140 127 बाइट्स