26

कार्य

आपके द्वारा चुने गए किसी भी तरह से इनपुट के रूप में निर्दिष्ट nसे कम एक सकारात्मक पूर्णांक को देखते हुए 2^30, आपके कोड को 0और n, के बीच एक यादृच्छिक पूर्णांक का उत्पादन करना चाहिए । आपके द्वारा उत्पन्न संख्या को यादृच्छिक रूप से समान रूप से चुना जाना चाहिए । यही कारण है कि से प्रत्येक मान है 0करने के लिए n(नियम और चेतावनियां देखें) बराबर संभावना के साथ आना चाहिए।

नियम और कैविएट

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

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

टिप्पणियाँ

randInt(0,n) यह मान्य नहीं है क्योंकि यह इनपुट को एक बेसिन या लाइब्रेरी फ़ंक्शन के तर्क के रूप में लेता है।
rand()%nहोगा नहीं सामान्य रूप में एक समान यादृच्छिक संख्या दे। Betseg द्वारा दिए गए उदाहरण के लिए, अगर intmax == 15और n = 10है, तो आप और अधिक प्राप्त होने की संभावना हो जाएगा 0-5की तुलना में 6-10।
floor(randomfloat()*(n+1)) 0 और 1 के बीच विभिन्न संभावित फ्लोटिंग पॉइंट मानों की परिमित संख्या के कारण सामान्य रूप से एक समान यादृच्छिक संख्या नहीं देगा।

— totallyhuman
स्रोत

आप कैसे पुष्टि करने जा रहे हैं कि आउटपुट समान रूप से यादृच्छिक है? यह हो सकता है कि एक दी गई भाषा / लाइब्रेरी समान रूप से यादृच्छिक संख्याओं का उत्पादन करेगी, लेकिन हेरफेर से गैर-समान आउटपुट हो सकता है। (उदाहरण rng()प्रदान करता है 0- 100, यदि n = 75, और फ़ंक्शन है rng()%75, तो 0-25 अधिक सामान्य होगा ...)

— बाल्ड्रिक

1

@Baldrickk भीड़ की समझ से :) हम केवल कोड पढ़ सकते हैं और इसके बारे में सोच सकते हैं।

सबसे सरल संभव संभाव्यता-सिद्धांत प्रश्न पूछने का दुखद निष्कर्ष: यादृच्छिकता और संभावना बहुत खराब समझी जाती है। :( (और नियम पढ़ना मुश्किल है, जाहिरा तौर पर।)

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

यह ध्यान में आता है: रैंडम नंबर

— BgrWorker

जब आप तीन छोटे होते हैं तो आपने x86 उत्तर को क्यों स्वीकार किया?

— डेनिस

25

`rdrand`अनुदेश के साथ x86 मशीनें , 10 बाइट्स

BITS 64

_try_again:

 rdrand eax
jnc _try_again

 cmp eax, edi
ja _try_again

 ret

मशीन कोड

0FC7F0 73FB 39F8 77F7 C3

इनपुट रजिस्टर rdiऔर आउटपुट में है rax।
यह SYS V AMD64 ABI का सम्मान करता है इसलिए कोड प्रभावी रूप से C फ़ंक्शन को लागू करता है

unsigned int foo(unsigned int max);

32-बिट ints के साथ।

निर्देश rdrandइंटेल द्वारा वर्णित है

RDRANDयादृच्छिक संख्याएँ जो क्रिप्टोग्राफिक रूप से सुरक्षित, निर्धारक यादृच्छिक बिट जनरेटर DRBG द्वारा आपूर्ति की जाती हैं। DRBG को NIST SP 800-90A मानक को पूरा करने के लिए डिज़ाइन किया गया है ।

CSRNG से निपटना यह निहित है कि वितरण समान है, वैसे भी, NIST SP 800-90A को उद्धृत करते हुए:

एक यादृच्छिक संख्या एक निष्पक्ष यादृच्छिक चर का एक उदाहरण है, अर्थात्, समान रूप से वितरित यादृच्छिक प्रक्रिया द्वारा उत्पादित आउटपुट ।

प्रक्रिया एक यादृच्छिक संख्या उत्पन्न करती है और अगर यह गैर-कड़ाई से इनपुट से अधिक है तो इसे वापस कर दिया जाता है।
अन्यथा, प्रक्रिया को दोहराया जाता है।

चूंकि eax32-बिट है, rdrand0 और 2 ³² -1 के बीच एक संख्या देता है , इसलिए हर n [0, 2 ³² -1] में अपेक्षित पुनरावृत्तियों की संख्या 2 ³² / (n + 1) है जो सभी n के लिए परिभाषित है। [0, 2 ^{30 में} )।

— मार्गरेट ब्लूम
स्रोत

शानदार ढंग से निम्न स्तर। धन्यवाद।

किस jncलिए है?

— l4m2

@ l4m2 rdrandसेट CFiif डेटा लौटा मान्य है। डेटा अमान्य हो सकता है क्योंकि बहुत सारे अनुरोधों ने एन्ट्रापी पूल को सूखा दिया था। Rdrand और इसके लिए मैन्युअल प्रविष्टि देखें ।

— मार्गरेट ब्लूम

20

जेली , 7 6 बाइट्स

⁴!!X%‘

1 बाइट को बंद करने के लिए @JonathanAllan को धन्यवाद!

TIO पर नहीं चलाया जा सकता क्योंकि (16!) एक बड़ी संख्या है।

यह काम किस प्रकार करता है

⁴!!X%‘  Main link. Argument: n

⁴       Set the return value to 16.
 !!     Compute (16!)!.
   X    Pseudo-randomly choose an integer between 1 and (16!)!.
        Since (16!)! is evenly divisible by any k ≤ 2**30, it is evenly divisible
        by n+1.
    %‘  Take the result modulo n+1.

— डेनिस
स्रोत

यह मेरे हटाए गए उत्तर का एक निश्चित संस्करण है, एक ही विचार है। हालांकि मेरे पास एक अनावश्यक घातांक था।

— orlp

क्षमा करें, मैंने पोस्ट करने से पहले इसे नहीं देखा।

— डेनिस

ओह यह कोई फर्क नहीं पड़ता, मैं वैसे भी इसे ठीक करने की योजना नहीं बना रहा था। मैं जेली के साथ वास्तव में इसके साथ खेलने के लिए बहुत असहज हूं।

— orlp

1

"सर मुझे नहीं पता कि आप पागल क्यों हैं। एल्गोरिथ्म लगातार समय है। यह एक अच्छी बात है, ठीक है? दरवाजे के बाहर सुरक्षा और एचआर क्यों है?"

— corsiKa

1

माना। 8 अंकों की संख्या और 417 क्विंटल अंकों की संख्या के बीच का अंतर: पी

— जोनाथन एलन

11

गणितज्ञ, 29 बाइट्स

डेनिस के जेली जवाब के आधार पर ।

RandomInteger[2*^9!-1]~Mod~#&

मैं वास्तव में इसे चलाने की सिफारिश नहीं करूंगा। 2e9!एक बहुत बड़ी संख्या है ...

यह एक बड़ी संख्या उत्पन्न करने के लिए सबसे छोटा है जो सभी संभावित इनपुटों से विभाज्य है और परिणाम को एक साधारण मोड्यूल के साथ आवश्यक सीमा तक मैप करता है।

अस्वीकृति नमूनाकरण, 34 बाइट्स

मेरा पुराना दृष्टिकोण, जिसके कारण कुछ और दिलचस्प कोड थे:

13!//.x_/;x>#:>RandomInteger[13!]&

बुनियादी अस्वीकृति नमूना। हम 13 को आउटपुट को इनिशियलाइज़ करते हैं ! (जो अधिकतम इनपुट 2 ³⁰ से बड़ा है ) और फिर बार-बार इसे 0 और 13 के बीच एक यादृच्छिक पूर्णांक से बदल देता है ! जब तक मूल्य इनपुट से बड़ा है।

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

1

क्या आपका मतलब है "इनपुट से छोटा या बराबर"?

1

@ लेम्बिक नं। हम मूल्य को पुनः प्राप्त करना चाहते हैं जब तक कि यह वांछित सीमा में नहीं आता है।

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

ओह मैं समझा। किसी कारण से मुझे लगा कि हम वांछित सीमा से बार-बार नमूना ले रहे हैं। धन्यवाद।

1

अगली बार समय सीमा जोड़ने के लिए मुझे याद दिलाएं :)

9

ब्रेकीलॉग , 9 बाइट्स

≥.∧13ḟṙ|↰

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

यह 13!मार्टिन एंडर के जवाब की तरह उपयोग करता है ( 13ḟयह एक बाइट से कम है 2^₃₀)।

ṙका उपयोग करते हुए कार्यान्वित किया जाता है random_between/3, जो अपने स्रोत को खोदते समय, उपयोग करता है, random_float/0जो कि लिंक से जुड़ा होता है, random/1जो मेरसेन ट्विस्टर एल्गोरिथ्म का उपयोग करता है जो हमारे उद्देश्यों के लिए एक समान है।

व्याख्या

≥.           Input ≥ Output
  ∧          And
   13ḟṙ      Output = rand(0, 13!)
       |     Else
        ↰    Call recursively with the same input

— Fatalize
स्रोत

7

प्रोलोग (एसडब्ल्यूआई) , 38 बाइट्स

X*Y:-Z is 2^31,random(0,Z,Y),Y=<X;X*Y.

अस्वीकृति नमूना द्वारा काम करता है।

इनपुट के कम या बराबर होने तक 0 और 2 ^ 31-1 = 2147483647 के बीच एक यादृच्छिक संख्या उत्पन्न करें ।

मुझे ऐसा लगता है जैसे मुझे दूसरे के बजाय एक कट का उपयोग करने में सक्षम होना चाहिए, लेकिन मैं यह नहीं देख सकता कि कैसे।

— Emigna
स्रोत

1

आप अन्य उपयोग से बच सकते हैं repeat, लेकिन यह 3 बाइट्स से अधिक समय तक समाप्त होता है ... मुझे यकीन नहीं है कि दोहराने की तुलना में अनंत विकल्प होने का एक छोटा तरीका है।

— घातक

@ फ़ेटलाइज़ करें: हाँ मैंने भी दोहराने की कोशिश की। मेरे पास एक ,!.बैकट्रैक को मजबूर करने के लिए कुछ का उपयोग करने की स्मृति थी , लेकिन या तो मैं इसे याद कर रहा हूं या यह इस समाधान पर लागू नहीं है।

— एमिगा

7

भूलभुलैया , 63 बाइट्स

 ?
 #00}__""*_
 ;    #"  _
{-{=  } "><)
!{ : ;"({ +
@  }}:  >`#

(यहां कुछ भारी गोल्फ के साथ मदद के लिए @MartinEnder को धन्यवाद।)

भूलभुलैया एक 2D भाषा है, और यादृच्छिकता का एकमात्र स्रोत निम्नलिखित जैसी स्थिति में है:

   x
  "<)
 " "
 " "

निर्देश सूचक मान लें xऔर नीचे की ओर बढ़ रहा है। यह अगली भूमि पर है <, जो अगर स्टैक के शीर्ष 0 है (जो कि ऊपर वास्तविक कार्यक्रम में हमेशा ऐसा ही होता है) वर्तमान पंक्ति को 1 से छोड़ देता है:

   "
 "<)
 " "
 " "

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

अनिवार्य रूप से ऊपर दिया गया कार्यक्रम 100-बिट संख्या ( #00यहां निर्दिष्ट 100 ) उत्पन्न करने के लिए यादृच्छिकता सुविधा का उपयोग करता है और तब तक लूपिंग जारी रखता है जब तक कि यह एक संख्या उत्पन्न नहीं करता है <= n।

परीक्षण के लिए, यह संभवत: #0"10-बिट नंबरों के बजाय उपयोग करने में मदद करेगा , "एक नो-ऑप पथ होने के साथ । इसे ऑनलाइन आज़माएं!

रफ स्पष्टीकरण:

 ?            <--- ? is input and starting point
 #0"}__""*_   <--- * here: first run is *0, after that is *2 to double
 ;    #"  _
{-{=  } "><)  <--- Randomness section, +0 or +1 depending on path.
!{ : ;"({ +        After <, the >s reset the row for the next inner loop.
@  }}:  >`#

 ^    ^
 |    |
 |    The " junction in this column checks whether the
 |    100-bit number has been generated, and if not then
 |    continue by turning right into }.
 |
 Minus sign junction here checks whether the generated number <= n.
 If so, head into the output area (! is output as num, @ is terminate).
 Otherwise, head up and do the outer loop all over again.

— Sp3000
स्रोत

7

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

from random import*
lambda n,x=2.**30:int(randrange(x)*-~n/x)

संपादित करें: निषिद्ध रूप से बचने के लिए अपडेट किया गया

Edit2: 2 बाइट्स सहेजे गए, धन्यवाद @ JonathanAllan

Edit3: पूरी तरह कार्यात्मक समाधान के लिए 2 बाइट्स का भुगतान - धन्यवाद @JonathanAllan

Edit4: हटाया गया f=, 2 बाइट्स बचा रहा है

Edit5: @ JonathanAllan को 1 और बाइट धन्यवाद दिया गया

Edit6: @ JonathanAllan के लिए 2 और बाइट्स का धन्यवाद

अब तक, गिट दोष मुझे बुरी चीजों के लिए, और जोनाथनॉलन की मदद करने वाले सामान के लिए इंगित करेगा।

Edit7: जब बारिश होती है, तो यह बरसती है - एक और 2 बाइट्स

Edit8: और एक और 2 बाइट्स

— iwaseatenbyagrue
स्रोत

1

यह कभी भी उत्पादन नहीं करता है n, लेकिन आप दो बाइट्स बचा सकते हैं जब आप इसे ठीक करते हैं from random import*और उपयोग करते हैं r.।

— जोनाथन एलन

1

हां, आप अन्यथा आवश्यक कोष्ठकों से बचने के लिए "टैडपोल ऑपरेटर" का उपयोग कर सकते हैं, इसलिए ...*(-~n*1.0/2**30))इसके बजाय...*((n+1)*1.0/2**30))

— जोनाथन एलन

1

वास्तव में? मिठाई! क्या आपके पास 70 नंबर के खिलाफ कुछ लंबे समय से चली आ रही शिकायत है? आपकी मदद के लिए बहुत बहुत धन्यवाद

— iwaseatenbyagrue

1

वास्तव में randrangeएक नाव को स्वीकार करने लगता है, इसलिए lambda n,x=2.**30:int(randrange(x)*-~n/x)एक और दो बचाता है [संपादित करें ...] चार!

— जोनाथन एलन

1

^ कोष्ठक हटाने के साथ एक और दो। बस अपने गुणन दिखाने के लिए जाने के लिए रास्ता था!

— जोनाथन एलन

6

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

from random import*
lambda n:map(randrange,range(1,2**31))[n]

छद्म बेतरतीब ढंग के बीच पूर्णांकों के लिए चुनता है 0 और कश्मीर के सभी मानों के लिए कश्मीर के बीच 0 और 2 ³¹ - 2 , तो पूर्णांक के लिए इसी लेता k = n ।

— डेनिस
स्रोत

5

बैच, 64 बाइट्स

@set/ar=%random%*32768+%random%
@if %r% gtr %1 %0 %1
@echo %r%

%random%केवल यादृच्छिकता के 15 बिट्स देता है, इसलिए मुझे दो यादृच्छिक संख्याओं को संयोजित करना होगा। जब तक यादृच्छिक मान वांछित सीमा के भीतर रहता है, तब तक कम होता है n; तेज़ संस्करण के लिए 98 बाइट्स:

@set/a"n=%1+1,m=~(3<<30)/n*n,r=%random%*32768+%random%
@if %r% geq %m% %0 %1
@cmd/cset/a%r%%%%n%

— नील
स्रोत

कोड धीमा हो सकता है लेकिन आपका उत्तर तेज था!

3

@ लेम्बिक मेरे पास आपके डिलीट किए गए प्रश्न में जाने के लिए तैयार उत्तर था ...

— नील

क्या यह पहले वांछित संख्या को प्रतिध्वनित नहीं करेगा, और फिर अन्य सभी संख्याएं जो इससे बड़ी हो गई हैं n?

— को एग्लोफ़र से एरिक

@EriktheOutgolfer नहीं; जब तक आप उपयोग नहीं करते हैं call, बैच स्क्रिप्ट को लागू करना वर्तमान स्क्रिप्ट को समाप्त करता है।

— नील

5

MATL , 12 बाइट्स

के लिए धन्यवाद @AdmBorkBork और करने के लिए @Suever मुझे कैसे अक्षम TIO कैश करने के लिए बताने के लिए।

`30WYrqG>}2M

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

यह एक का उपयोग करता है अस्वीकृति विधि से एक यादृच्छिक पूर्णांक उत्पन्न: 0करने के लिए 2^30-1, जबकि यह इनपुट से अधिक है, और बार-बार n। यह संभावना के साथ समाप्त करने की गारंटी है 1, लेकिन पुनरावृत्तियों की औसत संख्या है 2^30/n, और इसलिए यह nकाफी छोटे से लंबे समय लेता है 2^30।

`         % Do...while
  30W     %   Push 2^30
  Yr      %   Random integer from 1 to 2^30
  q       %   Subtract 1
  G>      %   Does it exceed the input? If so: next iteration. Else: exit
}         % Finally (execute right before exiting the loop)
  2M      %   Push the last generated integer
          % End (implicit). Display (implicit)

— लुइस मेंडो
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 55 54 बाइट्स

f=(n,m=1)=>m>n?(x=Math.random()*m|0)>n?f(n):x:f(n,m*2)

पूर्णांक को [0 ... 2 ^k - 1] श्रेणी में उत्पन्न करता है , जहां k सबसे छोटा पूर्णांक है जैसे कि 2 ^k n से बड़ा है । परिणाम 0 [n] में गिरने तक दोहराता है ।

क्यूं कर?

यह निम्नलिखित मान्यताओं पर आधारित है:

आंतरिक रूप से, जेएस इंजन द्वारा फीड करने के लिए उत्पन्न छद्म-यादृच्छिक पूर्णांक मान Math.random()किसी भी अंतराल [0 ... 2 ^k -1] ( k <32 के साथ ) पर समान हैं।
एक बार 2 की सटीक शक्ति से गुणा करने पर, IEEE 754 फ्लोट वैल्यू द्वारा लौटाए गए Math.random()ऐसे अंतराल पर अभी भी समान हैं।

अगर कोई भी इन परिकल्पनाओं की पुष्टि या खंडन कर सकता है, तो कृपया मुझे टिप्पणियों में बताएं।

डेमो

[0 ... 2] में 1 मिलियन मान उत्पन्न करता है और परिणाम आँकड़े प्रदर्शित करता है।

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

f=(n,m=1)=>m>n?(x=Math.random()*m|0)>n?f(n):x:f(n,m*2)

for(i = 0, stat = []; i < 1000000; i++) {
  r = f(2);
  stat[r] = (stat[r] || 0) + 1;
}
console.log(stat.join` `)

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

— Arnauld
स्रोत

Math.floor (Math.random () * (n + 1)) मेरे लिए कोई कम समान रूप से वितरित परिणाम नहीं देता है, इसलिए यह देखना अच्छा होगा कि क्या कोई यथार्थवादी N <2 ^ 30 है, जो किसी भी वितरण विसंगतियों का उत्पादन करेगा बिलकुल।

— ज़ेपेलिन

1

@zeppelin आपको किसी भी तरह की विसंगतियों को इंगित करने के लिए बहुत सारे ट्रायल रन की आवश्यकता होगी क्योंकि उस रेंज में एक यादृच्छिक फ्लोट 2 ^ 53 मानों में से एक होगा जो समान रूप से 2 ^ 30 परिणामों पर समान रूप से वितरित किया जाएगा। तो रेंज में बड़ी संख्या के लिए भी, त्रुटि 2 में से कुछ 1 ^ 23 की तरह होगी जिसका मतलब है कि आपको हास्यास्पद संख्या की आवश्यकता होगी। आप शायद प्रारंभिक नमूनों की संख्या (2 ^ 53) की तुलना में परिमाण के कुछ और आदेश चाहते हैं। फिर भी, यह पूरी तरह से समान नहीं हो सकता है यदि गुणक समान रूप से नमूनों की संख्या को विभाजित नहीं करता है यही कारण है कि अर्नुलड दो की शक्ति का उपयोग करता है।

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

4

बैश (+ कोरुटिल्स), 44 बाइट्स

/ देव / यूरेनियम आधारित समाधान

od -w4 -vtu4</d*/ur*|awk '($0=$2)<='$1|sed q

से 32 बिट पूर्णांक पढ़ा होगा /dev/urandom, और awkजब तक यह किसी दिए गए सीमा के भीतर एक नहीं मिल जाता है, तब तक उन्हें फ़िल्टर कर sed qदेगा।

— टसेपेल्लिन
स्रोत

4

हास्केल, 70 बाइट्स

import System.Random
g n=head.filter(<=n).randomRs(0,2^30)<$>getStdGen

बहुत कुशल एल्गोरिथ्म नहीं है, लेकिन यह काम करता है। यह पूर्णांक की एक अनंत सूची बनाता है (या जरूरत पड़ने पर तैरता है, हास्केल के प्रकार प्रणाली के कारण) [0,2 ^ 30] से घिरा हुआ है और n से पहले या उससे कम लेता है। छोटे एन के लिए यह एक लंबा समय ले सकता है। यादृच्छिक संख्या समान रूप से, वितरित किया जाना चाहिए के लिए दस्तावेज़ में बताए के रूप में randomR अंतराल [0,2 ^ 30] (1 / (2 ^ 30 + 1)) इसलिए सभी में नंबर एक ही संभावना होना चाहिए में सभी नंबरों को इतना [ 0, n] में समान संभावना है।

वैकल्पिक संस्करण:

import System.Random
g n=head.filter(<=n).map abs.randoms<$>getStdGen

यह संस्करण भयानक है, लेकिन यह पूरी बाइट बचाता है। randomsप्रकारों की अनंत सूची उत्पन्न करने के लिए प्रकार द्वारा परिभाषित एक मनमानी श्रेणी का उपयोग करता है। इसमें नकारात्मक शामिल हो सकते हैं, इसलिए हमें absउन्हें सकारात्मक (या शून्य) के लिए मजबूर करने के लिए इसे मैप करने की आवश्यकता है । यह n के किसी भी मूल्य के लिए बेहद धीमा है जो बेतुका नहीं है। संपादित करें : मुझे बाद में एहसास हुआ कि यह संस्करण समान रूप से वितरित नहीं किया गया है, क्योंकि 0 प्राप्त करने की संभावना उपयोग के कारण अन्य नंबरों की तुलना में खराब है abs। कुछ संख्या mका उत्पादन करने के लिए जनरेटर उत्पादन mकर सकता है या -m0 के मामले में केवल 0 ही काम करेगा, इसलिए इसकी संभावना अन्य संख्याओं से आधी है।

— user1472751
स्रोत

हस्केल के लिए हुर्रे (भी)!

4

जेली , 9 बाइट्स

⁴!Ẋ’>Ðḟ⁸Ṫ

इसे ऑनलाइन आज़माएं! - आकार 16 की सीमा के बाद से टीआईओ पर अभ्यस्त से ऊपर कोड! पहले बनाया जाना चाहिए (इस तथ्य का उल्लेख नहीं करने के लिए कि उन्हें फिर से फेरबदल करने और फिर फ़िल्टर करने की आवश्यकता है!), इसलिए यह एक बहुत छोटे पैमाने पर एक ही बात है, 10 के बाउंड के साथ 3 के इनपुट के लिए 30 बार दोहराया गया।

कैसे?

⁴!Ẋ’>Ðḟ⁸Ṫ - Main link: n
⁴         - 16
 !        - factorial: 20922789888000
  Ẋ       - shuffle random: builds a list of the integers 1 through to 16! inclusive and
          - returns a random permutation via Python's random.shuffle (pretty resource hungry)
   ’      - decrement (vectorises - a whole pass of this huge list!)
     Ðḟ   - filter out if: (yep, yet another pass of this huge list!)
    >     -     greater than
       ⁸  -     left argument, n
        Ṫ - tail: return the rightmost remaining entry.

नोट: यह एक ही बाइट-काउंट के लिए एक हज़ार से अधिक बार कुशल ȷ⁵होगा, यदि कोई ऐसा करेगा जो भोलेपन से उम्मीद करेगा और दस को दस लौटाएगा, लेकिन ऐसा नहीं है क्योंकि ⁵इसका उपयोग करने के लिए शाब्दिक दस के रूप में मूल्यांकन नहीं किया गया है। संख्या शाब्दिक द्वारा, ȷ...बल्कि दो अलग-अलग शाब्दिक रूप से पार्स की जाती है, ȷइसमें तीन हजार की उपज के डिफ़ॉल्ट प्रतिपादक और ⁵दस की पैदावार होती है।

— जोनाथन एलन
स्रोत

हुह, 9 अक्षर, लेकिन 22 बाइट्स

— क्रिस्टोफर सॉल-स्टॉरगार्ड

@ KristofferSall-Storgaard जेली के कोड पृष्ठ में प्रत्येक चरित्र 256 बाइट्स में से एक है , मैं शब्द बाइट्स को एक लिंक बनाना भूल गया जैसे मैं आमतौर पर करता हूं।

— जोनाथन एलन

1

वर्ष, मैंने इसे देखा और वही पता लगाया

— क्रिस्टोफर सल्ल-स्टॉरगार्ड

4

JDK 9 पर jshell, 75 59 बाइट्स

n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny()

प्रयोग

((IntFunction)(n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny())).apply(<n>)

-16 बाइट्स: धन्यवाद जैकब!
मान लें कि हम jshell को एक मान्य रनटाइम वातावरण मानते हैं।
jshell खुद, एक रनटाइम वातावरण के रूप में, कोर पुस्तकालयों के लिए स्पष्ट आयात की आवश्यकता नहीं है और अर्धविराम की आवश्यकता नहीं है।
रिटर्न ए OptionalInt। नियम यह निर्दिष्ट नहीं करते हैं कि रिटर्न प्रकार एक आदिम होना चाहिए और मैं OptionalIntपरिणाम के एक वैध प्रतिनिधित्व पर विचार कर रहा हूं ।

— पीट टेरलेप
स्रोत

1

प्रेरणा के लिए @ केविन-क्रूज़सेन को धन्यवाद। मेरा पहला कोड गोल्फ!

— पीट टेरलेप

बॉक्सिंग आउटपुट स्वीकार किया जाता है या नहीं, इस बात से अलग है कि क्या Optionalस्वीकार किया जाता है। अगर मैं तुम होता तो पोस्टर के साथ पुष्टि करता। इसके अलावा, पूरे असाइनमेंट को गिनने की आवश्यकता नहीं है; बस लंबोदर अभिव्यक्ति पर्याप्त है।

— जकॉब

1

आप लैम्ब्डा पैरामीटर के आसपास कोष्ठक हटाकर 4 बाइट्स बचा सकते हैं nऔर new Random()।

— जकॉब

3

PHP, 30 बाइट्स

    while($argn<$n=rand());echo$n;

साथ चलाना echo <N> | php -Rn '<code>'।

0 और getrandmax()(2 ** 31-1 मेरे 64 बिट मशीन पर) के बीच एक यादृच्छिक संख्या चुनता है ;
जबकि इनपुट से बड़ा है दोहराता है।

इसमें कुछ समय लग सकता है ... मेरे AMD C-50 (1 GHz) के लिए 0.3 से 130 सेकंड के बीच की आवश्यकता है N=15।

औसत के लिए एक तेज़ तरीका N( 46 बाइट्स ):

for(;++$i<$x=1+$argn;)$n+=rand()%$x;echo$n%$x;

या

for(;++$i<$x=1+$argn;$n%=$x)$n+=rand();echo$n;

N+1यादृच्छिक पूर्णांक लेता है , उन्हें समेटता है और मॉडुलो को साथ ले जाता है N+1।
C-50 की लगभग जरूरत है। 1 मिलियन रन के लिए 8 सेकंड।

19 बाइट्स के लिए एक अमान्य समाधान :

echo rand(0,$argn);

— टाइटस
स्रोत

3

पॉवरशेल , 35 बाइट्स

for(;($a=Random 1gb)-gt"$args"){}$a

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

एक और अस्वीकृति नमूनाकरण विधि। यह एक अनंत forलूप है, जो कि ( और ) के बीच पूर्णांक $aहोने का मान सेट करता है , और लूपिंग को तब तक बनाए रखता है जब तक कि पूर्णांक इनपुट को लटका दिया जाता है । एक बार लूप पूरा हो जाने के बाद, हम बस पाइपलाइन पर रख देते हैं और आउटपुट निहित होता है।Random01gb= 1073741824 = 2^30-gt$args$a

नोट: यदि इनपुट एक छोटी संख्या है, तो इसमें लंबा समय लगेगा ।

— AdmBorkBork
स्रोत

3

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

-3 बाइट्स धन्यवाद xnor के लिए ( idएक चर के रूप में निर्मित को ओवरराइड करें )

from random import*
n=input()
while id>n:id=randrange(2**30)
print id

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

randrange(2**30)एक छद्म समान रूप से वितरित संख्या (Mersenne Twister 2 ^19937-1 ) का उत्पादन रेंज [0,2 ³⁰ ) से होता है । चूंकि nयह 2 ^{30 से} नीचे होने की गारंटी है, इसलिए इसे केवल बार-बार कॉल किया जा सकता है जब तक कि यह इनपुट से अधिक न हो। यह बहुत कम मूल्यों के लिए एक लंबे समय तक अपेक्षित समय लेगा n, लेकिन आमतौर पर एक मिनट के भीतर भी इनपुट के लिए 50 के रूप में कम काम करता है।

— जोनाथन एलन
स्रोत

2

आप r=''"अनंत" के रूप में आरंभ कर सकते हैं । या, बेहतर अभी तक, प्रारंभ नहीं है rऔर इसके बजाय idहर जगह के लिए उपयोग करें r।

— xnor

2

पर्ल 6 , 29 बाइट्स

{first 0..$_,^2**30 .roll(*)}

मार्टिन एंडर के गणितज्ञ समाधान से प्रेरित ।

0 और 2 ^ 30-1 के बीच यादृच्छिक पूर्णांकों का एक आलसी अनंत अनुक्रम उत्पन्न करता है, और पहले वाले को 0 और इनपुट के बीच लेता है।

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

— SMLS
स्रोत

2

05AB1E , 11 बाइट्स

žIÝ.rDI›_Ï¤

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

व्याख्या

žIÝ          # push the inclusive range [0 ... 2^31]
   .r        # get a random permutation (pythons random.shuffle)
     D       # duplicate this list
      I      # push input
       ›_Ï   # keep only elements from the list not greater than input
          ¤  # take the last one

चूंकि सूची [0 ... 2147483648]TIO के लिए बहुत बड़ी है, इसलिए लिंक 1.000.000इसके बजाय उपयोग करता है ।

वैकल्पिक (औसतन) बहुत तेजी से 11 बाइट समाधान

[žIÝ.RD¹›_#

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

व्याख्या

[             # start loop
 žIÝ          # push the inclusive range [0 ... 2^31]
    .R        # pick a random integer (pythons random.chiose)
      D       # duplicate
       ¹      # push input
        ›_#   # break if random number is not greater than input
              # implicitly output top of stack (the random number)

— Emigna
स्रोत

žJL.R%6 के लिए जब तक मैं कुछ बड़ा याद कर रहा हूँ। पुश 2 ^ 32, 0 से 2 ^ 32, यादृच्छिक पिक की सूची। मोडुलो इनपुट। आपके पास जो दक्षता है, उस पर पूरी तरह से शिकंजा कसेगा।

— मैजिक ऑक्टोपस Urn

@ carusocomputing.You Iको सही क्रम में मापांक के लिए तर्क प्राप्त करने के लिए 7 बाइट्स के लिए एक की आवश्यकता होगी (और शायद Ýइसके बजाय L), लेकिन अन्यथा यह निश्चित रूप से एक छोटा समाधान है। मैंने डेनिस को अपने जेली उत्तर में ऐसा करते देखा, लेकिन जैसा कि यह मेरा पहला विचार था मैंने इसे रखा। चूंकि यह दृष्टिकोण इससे अलग है इसलिए आप इसे एक अलग उत्तर के रूप में पोस्ट कर सकते हैं।

— एमिग्ना

DI‹Ïलूप से बचना होगा।

— मैजिक ऑक्टोपस Urn

इसके अलावा, के रूप में, यह समाप्त करने की गारंटी नहीं है; अगर मैं गलत नहीं हूं, 0तो लगभग हमेशा के लिए अनन्त लूप में एक इनपुट परिणाम होगा, जिससे इसे समाप्त करना मुश्किल हो जाएगा। यद्यपि समाधान सभी परिदृश्यों में समाप्त होने की संभावना के लिए अनुमति देता है लेकिन यादृच्छिकता के कारण इसकी गारंटी नहीं है।

— मैजिक ऑक्टोपस Urn

@carusocomputing: बहुत छोटे इनपुट के लिए दूसरा संस्करण औसतन हाँ समाप्त करने में बहुत लंबा समय लेगा, लेकिन पर्याप्त समय दिया जाएगा।

— एमिग्ना

2

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

l=range(2**31)
import random
random.shuffle(l)
n=input()
print filter(lambda x:x<=n,l)[0]

व्याख्या

L=range(2**31)      # Create a list from 0 to 2^31 exclusive. Call it <L>.
import random       # Import the module <random>.
random.shuffle(L)   # Use 'shuffle' function from <random> module,
                    # to shuffle the list <L>.
n=input()           # Take the input -> <n>.

print
    filter(         # Create a new sequence,
    lambda x:x<=n   # where each element is less than or equal to <n>.
    ,L)             # from the list <L>.
    [0]             # Take the first element.

यह बहुत ही अयोग्य है, क्योंकि यह 2 ^ 31 पूर्णांक बनाता है , फेरबदल करता है और उन्हें फ़िल्टर करता है।

मुझे TIO लिंक साझा करने का कोई मतलब नहीं है, जहाँ यह इतनी बड़ी सूचियाँ बना रहा है, इसलिए यहाँ n= 100 के लिए एक TIO लिंक है ।

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

— Yytsi
स्रोत

2

जावा 8, 84 83 80 71 62 बाइट्स

n->{int r;for(;(r=(int)(Math.random()*(1<<30)))>n;);return r;}

-1 ऑल्ट @GliGrégoire को धन्यवाद ।
-3 बाइट्स @ जेकॉब को धन्यवाद ।
-9 जावा 8. करने के लिए जावा 7 परिवर्तित बाइट
-9 बदलकर बाइट्स java.util.Random().nextInt(1<<30)करने के लिए (int)(Math.random()*(1<<30))।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{        // Method with integer parameter and integer return-type
  int r;    //  Result-integer
  for(;(r=(int)(Math.random()*(1<<30)))>n;);
            //  Loop as long as the random integer is larger than the input
            //  (the random integer is in the range of 0 - 1,073,741,824 (2^30))
  return r; //  Return the random integer that is within specified range
}           // End method

नोट: स्पष्ट रूप से छोटे इनपुट के लिए बहुत लंबा समय लग सकता है।

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

407594936

— केविन क्रूज़सेन
स्रोत

2

@ एरोन ने मुझसे भी इस पर सवाल किया, लेकिन दूसरा बुलेट पॉइंट देखें: "बिल्ट इन या लाइब्रेरी रैंडम फंक्शन को कॉल करते समय कोई भी तर्क निरंतर होना चाहिए। यही है कि उन्हें इनपुट वैल्यू से पूरी तरह स्वतंत्र होना चाहिए।" यही कारण है कि अधिकतम इंट का उपयोग किया जाता है।

— पोक

1

2^30= 1073741824। आपने -1>>>1(= 2147483647) का उपयोग करना पसंद किया । लेकिन यह मौजूद है: 1<<30जो इसके बराबर है 2^30; और 1 बाइट छोटी है।

— ओलिवियर ग्राएगेयर

1

कैसे के बारे में int c(int n){int r;for(;(r=new java.util.Random().nextInt(1<<30))>n;);return r;}?

— जैकब

@ जाकोब धन्यवाद। मैंने इसे जावा के 7 के बजाय 7 और इसके बजाय का उपयोग करके 18 और बाइट्स से छोटा कर Math.random()दिया java.util.Random().nextInt।

— केविन क्रूज़सेन

2

पायथन 3, 51 बाइट्स

यहाँ एक अपरंपरागत यादृच्छिक स्रोत के साथ एक अजगर समाधान है।

print(list(set(map(str,range(int(input())+1))))[0])

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

तो इसको तोड़ने के लिए।

int(input())+1

इनपुट नंबर प्राप्त करता है, और 1इसे जोड़ता है।

set(range(...))

{0, 1, 2, 3, 4, ... n}सभी संभावित परिणामों के लिए सेट बनाता है ।

print(list(...)[0])

सेट लेता है, इसे सूची में परिवर्तित करता है, और पहला आइटम पकड़ता है।

यह काम करता है क्योंकि पायथन 3 में, PYTHONHASHSEEDset() द्वारा आदेश दिया गया है ( प्राप्त नहीं किया जा सकता है लेकिन स्क्रिप्ट निष्पादन पर स्थापित है)।

बेशक, मैं अनुमान लगा रहा हूं कि यह एक समान वितरण है, क्योंकि hash()मूल्य बेतरतीब ढंग से असाइन किया गया है और मैं एक विशिष्ट के साथ मूल्य को बेतरतीब ढंग से उठा रहा हूं hash(), बल्कि तब hash(input())खुद को वापस कर रहा हूं ।

अगर किसी को पता है कि यह एक समान वितरण है, या मैं इसे कैसे परीक्षण कर सकता हूं, तो कृपया टिप्पणी करें।

— द मैट
स्रोत

1

सी #, 57 बाइट्स

n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

अनाम फ़ंक्शन जो 0 और n समावेशी के बीच पूर्णांक देता है।

इनपुट संख्या जितनी कम होगी, यादृच्छिक मान वापस करने का समय उतना ही अधिक होगा।

पूरा कार्यक्रम:

using System;

class RandomNumber
{
    static void Main()
    {
        Func<int, int> f =
        n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

        // example
        Console.WriteLine(f(100000));
    }
}

— adrianmp
स्रोत

2

"अंतर्निहित या लाइब्रेरी रैंडम फ़ंक्शन को कॉल करते समय कोई भी तर्क निरंतर होना चाहिए। यह है कि वे इनपुट मूल्य से पूरी तरह से स्वतंत्र होना चाहिए।" तर्क Nextस्थिर नहीं है।

— यति

1

बैश + कोरुटिल्स, 20 बाइट्स

golfed

seq 0 $ 1 | shuf | sed 1q

shuf - यादृच्छिक क्रमपरिवर्तन उत्पन्न करें

Shuf निम्नलिखित कोड का उपयोग करेगा : क्रमपरिवर्तन उत्पन्न करने के लिए:

permutation = randperm_new (randint_source, head_lines, n_lines);

जो समाप्त होता है randint_genmax

/* Consume random data from *S to generate a random number in the range
0 .. GENMAX.  */

randint
randint_genmax (struct randint_source *s, randint genmax) 
{
      ...

      randread (source, buf, i);

      /* Increase RANDMAX by appending random bytes to RANDNUM and
         UCHAR_MAX to RANDMAX until RANDMAX is no less than
         GENMAX.  This may lose up to CHAR_BIT bits of information
         if shift_right (RANDINT_MAX) < GENMAX, but it is not
         worth the programming hassle of saving these bits since
         GENMAX is rarely that large in practice.  */
      ...
}

जो, बदले में, यादृच्छिकता के निम्न-स्तरीय स्रोत से यादृच्छिक डेटा के कुछ बाइट्स को पढ़ेगा :

/* Consume random data from *S to generate a random buffer BUF of size
   SIZE.  */

void
randread (struct randread_source *s, void *buf, size_t size)
{
  if (s->source)
    readsource (s, buf, size);
  else
    readisaac (&s->buf.isaac, buf, size);
}

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

— टसेपेल्लिन
स्रोत

6

क्या यह आपके यादृच्छिक संख्या जनरेटर के तर्क के रूप में इनपुट नहीं दे रहा है?

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

यहां तक कि अगर यह मान्य नहीं है, तो कृपया दूसरा बैश उत्तर सबमिट करें!

@MartinEnder अच्छी तरह से, सीधे नहीं, यह सिर्फ उत्पन्न पूर्णांक सीमा के लिए ऊपरी सीमा को परिभाषित करने के लिए इनपुट का उपयोग करता है और jot will arrange for all the values in the range to appear in the output with an equal probability(शायद यह सीमा रेखा है, लेकिन अभी भी)।

— ज़ेपेलिन

2

अगर मैं किसी भी यादृच्छिक संख्या जनरेटर में गहरी खुदाई करता हूं तो मुझे यकीन है कि मुझे निचले स्तर के आरएनजी में कॉल मिलेगा जो सीधे मूल तर्क का उपयोग नहीं करता है। चुनौती का विषय एक निश्चित-आकार के वितरण से एक मनमाना आकार का समान वितरण प्राप्त करना है, जो आप अभी भी नहीं कर रहे हैं।

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

1

स्माइलबासिक, 38 बाइट्स

INPUT N@L
R=RND(1<<30)ON N<=R GOTO@L?R

यादृच्छिक संख्या उत्पन्न करता है जब तक कि यह एक ऐसा न हो जाए जो इनपुट से छोटा हो।

— 12Me21
स्रोत

1

रूबी, 23 15 23 32 29 बाइट्स

->n{1while n<q=rand(2**30);q}

यह काम किस प्रकार करता है:

1while [...];कम से कम एक बार बयान निष्पादित करता है: एक झपकी के रूप में कार्य करने 1से पहलेwhile
सीमा में एक यादृच्छिक संख्या प्राप्त करें 0..2 ^ 30-1 ( 2 ^ 30 से कम , निर्दिष्ट के रूप में)
यदि इनपुट इनपुट पैरामीटर से अधिक है, तो दोहराएं (n छोटा होने पर कुछ समय ले सकता है)

— जीबी
स्रोत

1

ओम, 26 बाइट्स

IΩ
D31º#╬D0[>?D-+∞;,

स्पष्टीकरण:

IΩ                 ■Main wire
IΩ                 ■Call wire below

D31º#╬D0[>?D-+∞;,  ■"Real main" wire
D                  ■Duplicate input
 31º#╬D            ■Push random_int in [0..2^31] twice
       0[          ■Push input again
         >?    ;   ■If(random_int > input){
           D-+     ■  remove the random_int
              ∞    ■  recursion
               ;   ■}
                ,  ■Print random_int

— रोमन ग्रैफ़
स्रोत

क्या इस भाषा के लिए कोई दुभाषिया है? और कोड-पेज के बारे में क्या?

— एटीको

@ATaco: इंटरप्रेटर , कोड-पेज: CP-437

— एमिग्ना

1

चले जाओ, 63 61 बाइट्स

import."math/rand"
var n=0;func R(){q:=n;for;q<n+1;n=Int(){}}

इसे इस तरह उपयोग करें:

func main() {
    n = 5000
    R()
    print(n)
}

परीक्षण यह खेल के मैदान में रहते हैं

— क्रिस्टोफ़र साल्-स्टोर्गार्ड
स्रोत

हमारी चूक के अनुसार, पूर्वनिर्धारित चर से इनपुट लेने और पूर्वनिर्धारित चर के लिए आउटपुट लिखने की अनुमति नहीं है। आप वैश्विक चर के लिए संकेत का उपयोग कर सकते हैं

— डेनिस

1

गोलंग, 84 78 71 बाइट्स

import."math/rand"
func R(n int)int{q:=n+1;for;q>=n;q=Int(){};return q}

सरल अस्वीकृति नमूना।

ध्यान दें: चूंकि गणित / रैंड बीज एक स्थिर 1 है, कॉल करने वाले को बीज देना चाहिए जब तक कि एक निरंतर परिणाम वांछित न हो।

~~परीक्षण: https://play.golang.org/p/FBB4LKXo1r~~ 64-बिट सिस्टम पर व्यावहारिक रूप से परीक्षण योग्य नहीं है, क्योंकि यह 64-बिट यादृच्छिकता लौटा रहा है और अस्वीकृति परीक्षण का उपयोग कर रहा है।

package main

import "fmt"
import "time"

/* solution here *//* end solution */

func main() {
    Seed(time.Now().Unix())
    fmt.Println(R(1073741823))
}

— Riking
स्रोत

1

यदि आप उपयोग करते हैं import."math/rand"तो Int31वैश्विक नाम स्थान में उपलब्ध है और आप 4 बाइट्स बचा सकते हैं, intकम से कम 32 बिट्स होने की गारंटी भी है, जिससे आप एक और 6 बाइट्स बचा सकते हैं

— क्रिस्टोफर सॉल-स्टॉरगार्ड

:=एक और 3 बाइट्स के लिए सिंटैक्स का उपयोग करें

— क्रिस्टोफ़र सॉल-स्टॉरगार्ड

Int32 के बजाय int का उपयोग करने से कोई बाइट नहीं बचती है क्योंकि हमें Int31 () - 3 * int + () = 11 बाइट्स बनाम 2 * int32 = 10 बाइट्स का परिणाम डालना होगा।

— रेकिंग

1

कास्ट करने की आवश्यकता नहीं है, Int()रैंड पैकेज में एक फ़ंक्शन है, इसके अलावा, आप अंतरिक्ष को हटा सकते हैंimport

— क्रिस्टोफ़र साल्-स्टॉरगार्ड

यादृच्छिकता के एक निरंतर स्रोत का उपयोग करके 0 और n के बीच एक यादृच्छिक संख्या चुनें

rdrandअनुदेश के साथ x86 मशीनें , 10 बाइट्स

जेली , 7 6 बाइट्स

यह काम किस प्रकार करता है

गणितज्ञ, 29 बाइट्स

अस्वीकृति नमूनाकरण, 34 बाइट्स

ब्रेकीलॉग , 9 बाइट्स

व्याख्या

प्रोलोग (एसडब्ल्यूआई) , 38 बाइट्स

भूलभुलैया , 63 बाइट्स

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

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

बैच, 64 बाइट्स

MATL , 12 बाइट्स

जावास्क्रिप्ट (ईएस 6), 55 54 बाइट्स

क्यूं कर?

डेमो

बैश (+ कोरुटिल्स), 44 बाइट्स

हास्केल, 70 बाइट्स

जेली , 9 बाइट्स

कैसे?

JDK 9 पर jshell, 75 59 बाइट्स

प्रयोग

PHP, 30 बाइट्स

पॉवरशेल , 35 बाइट्स

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

पर्ल 6 , 29 बाइट्स

05AB1E , 11 बाइट्स

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

व्याख्या

जावा 8, 84 83 80 71 62 बाइट्स

पायथन 3, 51 बाइट्स

सी #, 57 बाइट्स

बैश + कोरुटिल्स, 20 बाइट्स

स्माइलबासिक, 38 बाइट्स

रूबी, 23 15 23 32 29 बाइट्स

यह काम किस प्रकार करता है:

ओम, 26 बाइट्स

चले जाओ, 63 61 बाइट्स

गोलंग, 84 78 71 बाइट्स

`rdrand`अनुदेश के साथ x86 मशीनें , 10 बाइट्स