29

चुनौती

एक सकारात्मक पूर्णांक (K)आउटपुट को देखते हुए (Y)बीच में एक समान रूप से यादृच्छिक पूर्णांक [0, K)।

यदि Y > 0मान लें K = Yऔर जब तक प्रक्रिया को दोहराएं Y = 0।

नियम

इनपुट पहले मुद्रित किया जाना चाहिए
अपनी इच्छानुसार आउटपुट स्वरूप
आपका कार्यक्रम समाप्त होना चाहिए।
0 अंतिम आउटपुट होना चाहिए, वैकल्पिक रूप से इसके बजाय एक खाली लाइन 0

code-golf random

— लुइस फेलिप डी जीसस मुनोज
स्रोत

यदि सबमिशन एक फ़ंक्शन है, तो क्या इसे प्रिंट करने के अलावा 0 वापस आ सकता है?

— एडम जूल 9'18

1

@ Adám हां, आप इसके अलावा लौट सकते हैं

— लुइस फेलिप डी

क्या मुझे अपना RNG बीजने की आवश्यकता है?

— SIGSTACKFAULT

क्या हम बिना सीमांक के प्रिंट कर सकते हैं?

— टाइटस

मुझे उत्सुकता हुई। यह साबित करना काफी आसान है कि इस कार्यक्रम की औसत संख्या H को समाप्त करने से पहले यह कदम है (K-1) + 1 जहां H (K) K'th हार्मोनिक संख्या है । N = 1000 के लिए, यह औसतन 8.484 कदम है।

— जे।

19

अजगर , 6 5 4 बाइट्स

.uOW

यहाँ यह कोशिश करो!

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

.uOW पूरा कार्यक्रम एसटीडीआईएन से पूर्णांक बनाता है और एसटीडीयूएसटी की सूची तैयार करता है।
.यू संचयी निश्चित-बिंदु। दिए गए फ़ंक्शन को दिए गए प्रारंभिक मान के साथ लागू करें,
        जो इनपुट के लिए निहित है, जब तक कि परिणाम नहीं हुआ है 
        पहले पाया जाता है। मध्यवर्ती परिणामों की सूची लौटाता है।
   डब्ल्यू सशर्त आवेदन। यदि तर्क (वर्तमान मूल्य) सत्य है, तो
        नीचे दिए गए फ़ंक्शन को लागू करें, अन्यथा इसे अपरिवर्तित छोड़ दें।
  O [0, N) श्रेणी में रैंडम पूर्णांक।
        IOW: .u के प्रत्येक पुनरावृत्ति पर, वर्तमान मूल्य के लिए एक चर N असाइन करें, शुरू करें
        इनपुट के साथ यदि N 0 नहीं है, तो [0, N) में एक यादृच्छिक पूर्णांक चुनें, अन्यथा
        वापसी N अपरिवर्तित। जब भी हम एक 0 का सामना करते हैं, तो अगली पुनरावृत्ति भी होनी चाहिए
        परिणाम 0 में है, और इसलिए लूप वहां रुक जाता है।

— श्री Xcoder
स्रोत

1

मैंने पायथ में ऐसा करने का एक तरीका देखा लेकिन मैं एक शुरुआती हूं। आदर करना। अगस्त में महीने की भाषा शायद?

— एलप्रेड्रो

15

सी (जीसीसी) , 42 बाइट्स

f(_){printf("%d\n",_);(_=rand()%_)&&f(_);}

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

लघु परिचालित तार्किक का उपयोग करता है और।

f(_){                 // f(int _) {
    printf("%d\n",_); // print argument and a newline
    (_=rand()%_)      // set _ to rand()%_
    &&f(_);}          // short-circuit AND to recursively call f if _ not zero

सी (जीसीसी) , 40 बाइट्स (डब्ल्यू / ओ प्रिंटिंग प्रारंभिक मूल्य)

f(_){printf("%d\n",_=rand()%_);_&&f(_);}

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

लघु परिचालित तार्किक का उपयोग करता है और।

f(_){              // f(int _) {
    printf("%d\n", // print an integer and a newline 
    _=             // The integer is _ which we set to...
    rand()%_);     // a random value modulo the input _
    _&&f(_);}      // short-circuit AND to recursively call f if _ not zero

— LambdaBeta
स्रोत

4

rand()%_वर्दी नहीं है

— njzk2

(यदि आप आश्वस्त नहीं हैं, तो इस पद्धति का उपयोग करके एक [

— १५५

3

मुझे पूरी तरह से पता है कि रैंड () लगभग हमेशा पक्षपाती (छंटनी के कारण) है, लेकिन मानक इसकी गारंटी नहीं देता है (सिद्धांत में RAND_MAX हमारे सभी नंबरों की एक बहु हो सकती है, बस भाग्य से: पी हालांकि आमतौर पर यह ~ 65k है )। जिन श्रेणियों के लिए हम काम कर रहे हैं, उनके लिए इस चुनौती में समान प्रस्तुतियाँ के खिलाफ खड़े नहीं होने के लिए पर्याप्त रूप से यादृच्छिक दिखाई देगा।

— लैम्ब्डाटा

1

यह चुनौती "आउटपुट एक समान-यादृच्छिक पूर्णांक" से है, इसलिए, कड़ाई से बोलते हुए, यह मान्य नहीं है

— njzk2

3

कड़ाई से सभी भाषाएँ यहाँ बोलना prng का उपयोग करें। उनमें से कोई भी एक सच्चे समान यादृच्छिक संख्या नहीं देगा (जिसे एन्ट्रापी के एक आदर्श स्रोत की आवश्यकता होगी)। जबकि कई इससे अधिक समान हैं, जो लॉग (k) पुनरावृत्तियों में ध्यान देने योग्य नहीं है।

— लाम्बेबेटा

10

आर , 66 60 56 43 41 बाइट्स

function(n)while(print(n))n=sample(n,1)-1

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

— एन जी एम
स्रोत

मुझे नहीं लगता कि आपको ज़रूरत है >0और cat(n,"")(खाली स्ट्रिंग) भी काम करेगी।

— ग्यूसेप

लेकिन मुझे लगता printहै कि यहां अधिक कुशल है, क्योंकि यह अपना तर्क देता है: 56 बाइट्स

— Giuseppe

साथ ही 56 बाइट्स:k=scan();while(x<-sample(1:k-1,1))k=c(x,k);cat(rev(k),0)

— JAD

1

मैं घुंघराले कोष्ठक को हटाना भूल गया, इसलिए आप 2 और बाइट्स बचा सकते हैं;) इसे ऑनलाइन आज़माएं!

— 18-21 बजे डिगेटेकल जूल

2

39 बाइट्स:n=scan();while(print(n))n=sample(n,1)-1

— djhurio

6

MATL , 6 बाइट्स

`tYrqt

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

व्याख्या

`        % Do...while
  t      %   Duplicate. Takes input (implicit) the first time
  Yr     %   Uniform random integer from 1 to n, included
  q      %   Subtract 1
  t      %   Duplicate. This will be used as loop condition
         % End (implicit). Proceeds with next iteration if non-zero
         % Display stack (implicit)

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

6

पेपे , 25 बाइट्स

पेपे उपयोगकर्ता सोकु द्वारा बनाई गई एक प्रोग्रामिंग भाषा है ।

REeErEErReEEreeEREEeEEree

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

स्पष्टीकरण:

REeErEErReEEreeEREEeEEree # full program

REeE                      # input as num, in stack 1
    rEE                   # create loop in stack 2 with name 0
       rReEE              # - output and preserve the number in stack 1
            reeE          # - output a newline "\n"
                REEeEE    # - random number by 0 to input
                      ree # goto loop with name 0 if stack 1 is not equal
                            to stack 2

— u_ndefined
स्रोत

5

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

{$_,(^*).pick...0}

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

अनाम कोड ब्लॉक जो मानों की सूची लौटाता है। यदि आप संख्याओं को लेकर कोई आपत्ति नहीं रखते हैं, तो आप यह कर सकते हैं:

{^$_,^*.pick...0}

17 बाइट्स के लिए। मजेदार रूप से पर्याप्त है, एक अन्य बिल्टइन रैंडम फ़ंक्शन, rollइस उदाहरण में बाइट्स की समान मात्रा के लिए समान व्यवहार है।

— मजाक कर रहा है
स्रोत

5

पर्ल 5 .10.0 `-pl`, 26 बाइट्स

say;say while$_=int rand$_

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

— wastl
स्रोत

2

अच्छा! 22 के लिए बहुत समान दृष्टिकोण के साथ आया था: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

अन्य समान: 20 + 2 बाइट्स ।

— डेनिस इबाएव जूल

5

जेली , 4 3 बाइट्स

XƬ0

यह एक मोनडिक लिंक (फ़ंक्शन) है जो किसी सरणी को प्रिंट करता है और 0 देता है ।

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

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

XƬ0  Monadic link. Argument: n

XƬ   Pseudo-randomly pick (X) an integer k in [1, ..., n], set n = k, and repeat.
     Do this 'til (Ƭ) the results are no longer unique and return the array of
     unique results, including the initial value of n.
     This stops once X returns k with argument k. The second k will be omitted
     from the return value.
  0  Print the resulting array and set the return value to 0.

— डेनिस
स्रोत

4 का बहुत अच्छा स्ट्राइकथ्रू!

— एन जी एम

1

हम नियमित 4 की तरह दिखने के लिए 4 को पार नहीं करेंगे, क्या हम करेंगे?

— डेनिस

4

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

ẉ?ℕ₁-₁ṙ↰

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

व्याख्या

ẉ          Write the input followed by a linebreak
 ?ℕ₁       The input must be in [1, …, +∞)
    -₁ṙ    Generate an integer in [0, …, input - 1] uniformly at random
       ↰   Recursive call with that random integer as the new input

एक बार ?ℕ₁विफल होने पर पुनरावृत्ति रुक जाएगी , अर्थात जब इनपुट होता है 0।

— Fatalize
स्रोत

4

05AB1E , 8 7 बाइट्स

Δ=L<Ω0M

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

व्याख्या

Δ         # loop until value doesn't change
 =        # print current value
  L<Ω     # push a random number in ([1 ... X] - 1)
          # will return -1 when X=0
     0M   # push max of that and 0

— Emigna
स्रोत

1

Δ=Ý¨Ω0Mसमतुल्य है।

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

4

जे, 13 बाइट्स

[:}:? ::]^:a:

मेट्रो पर, TIO की कमी के लिए माफी (उम्मीद है कि शुद्धता की कमी नहीं है)।

मानों की सूची आउटपुट करता है।

संभवतः APL दृष्टिकोण कम होगा, लेकिन यह वही है जो मैंने सोचा था।

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

^:a: अभिसरण तक बार-बार आवेदन करें, एक सरणी में मध्यवर्ती परिणाम संग्रहीत करें।

?0. से अधिक 0 के [0, K)लिए रेंज में यादृच्छिक पूर्णांक K, यह सीमा में एक यादृच्छिक पूर्णांक देता है (0,1)। एक फ्लोटिंग पॉइंट नंबर के लिए, यह एरर करता है।

::]किसी इनपुट के लिए त्रुटि पकड़ना ?और इरिटेट करने के बजाय, उस इनपुट को आउटपुट करना जो त्रुटि का कारण बना।

}: सरणी में अंतिम मान से छुटकारा पाएं (यह एक अस्थायी बिंदु संख्या आउटपुट नहीं है)।

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

— गोभी
स्रोत

यह सिर्फ मैं या कोड समान आउटपुट देता है?

— लुइस फेलिप डी जीसस मुनोज

@LuisfelipeDejesusMunoz कोई ऐसा व्यक्ति जो J को मुझसे बेहतर जानता हो, उसे समझाने में सक्षम हो सकता है, लेकिन मुझे लगता है कि RNG हमेशा एक ही बीज से शुरू होता है। निश्चित बीज भी है ?., लेकिन मुझे नहीं लगता कि मैं इसका उपयोग कर रहा हूं।

— कोल

@ आप सही हैं।

— योना

4

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

-1 बाइट थैंक्यू @Arnauld

f=n=>[n,...n?f(Math.random()*n|0):[]]

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

f=n=>[n,...n?f(Math.random()*n|0):[]]

<input type=number id=a><button onclick="console.log(f(+a.value))">Test</button>

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

— हरमन एल
स्रोत

क्या आप math.random को कम कर सकते हैं? जैसे कि codegolf.stackexchange.com/a/35648/67066 के

— मेरी

1

@Marie का उपयोग new Date%nवास्तव में यहाँ काम नहीं करता है, क्योंकि यह कई यादृच्छिक संख्याओं को उत्पन्न करने के लिए बहुत तेज़ी से उपयोगी नहीं होता है

— Herman L

4

सी, 38 बाइट्स

f(k){printf("%d ",k);k?f(rand()%k):0;}

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

Ungolfed

void f(int k){
    printf("%d ",k);
    if(k)
        f(rand()%k);
}

— भू
स्रोत

1

आप टर्नरी ऑपरेटर को ए के साथ बदलकर एक बाइट बचा सकते हैं &&; इसके अलावा, आप अपने mainफ़ंक्शन में RNG को बोने पर विचार कर सकते हैं : इसे ऑनलाइन आज़माएं!

— एरिक

1

तुम भी पूरी तरह से त्रिगुट से छुटकारा पा सकते हैं और एक त्रुटि में समाप्त कर सकते हैं। 34 बाइट्स

— जो किंग

4

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

W
~O

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

यह मूल रूप से एल्गोरिथ्म को लागू करता है:

$\begin{align} % Unknown environment algorithm :( &Q \gets \text{input} \\ &\mathbf{Repeat} \\ &\begin{array}{cl} 1. & temp \gets Q \\ 2. & Q \gets \text{unif}\{ 0, Q - 1 \} \\ 3. & \mathtt{Print}(temp) \end{array} \\ &\mathbf{Until} \quad temp = 0 \end{align}$

एल्गोरिथ्म में पायथ का अनुवाद करने के लिए, हम अधिकतर यह जांच सकते हैं कि प्रत्येक वर्ण का क्या अर्थ है। चूंकि Pyth उपसर्ग अंकन में लिखा है (यानी * + 1 2 3है (1 + 2) * 3) हम बहस में छोड़ दिया और भरने से शुरू कर सकते हैं के रूप में हम चले।

Wएक पारंपरिक लूप शुरू करता है। इसके बाद का पहला स्टेटमेंट लूप कंडीशन है और दूसरा स्टेटमेंट उसके बाद लूप बॉडी है। यदि दूसरा स्टेटमेंट खाली है तो यह नो-ऑप बन जाता है । यह जबकि बिल्कुल अजगर की तरह काम करता है, इसलिए यह गैर-शून्य पूर्णांकों को सही और शून्य के रूप में गलत के रूप में मूल्यांकन करेगा।

कुछ समय के बाद पहला कथन न्यूलाइन वर्ण से शुरू होता है। यह पाइथ के "प्रिंट और एक नई लाइन के साथ वापसी" फ़ंक्शन से मेल खाती है। यह एक तर्क लेता है, जो तब मुद्रित होता है और बिना किसी शर्त के वापस भी लौट आता है। यह हमें आवश्यक संचालन करते हुए मध्यवर्ती चरणों को मुद्रित करने की अनुमति देता है।

इस प्रिंट फ़ंक्शन के लिए दिया गया तर्क शुरू होता है ~जो थोड़ा विशेष है। यदि वर्ण के तुरंत बाद ~एक चर है तो इसे दो तर्क लगते हैं, अन्यथा यह एक लेता है। चूँकि Oएक चर ~केवल एक तर्क का उपभोग नहीं करेगा। ~कार्यों थोड़ा की तरह +=कई परम्परागत भाषाओं में करता है, हालांकि निकटतम ऑपरेटर के बाद वेतन वृद्धि ऑपरेटर होगा ++से C। आप जान सकते हैं कि वर्तमान मूल्य के रूप में x++उपयोग करना होगा x, लेकिन इसके बाद xहोगा x+1। ~एक ही विचार है, लेकिन पहले तर्क का परिणाम जो भी हो, सामान्यीकृत है। यह कैसे पता चलता है कि किस चर को बाद में संबोधित करना है।

का तर्क ~है Oजो बहुत सरल है। जब इसका एक तर्क एक पूर्णांक Oहोता है, तो 0 से एक से एक मान कम होता है जो पूर्णांक से कम है।

अब आपने देखा होगा Oकि कोई तर्क नहीं है। यहाँ Pyth दुभाषिया कृपया एक अनुमान में भरता है, जो यहाँ परिवर्तनशील है Q। Qपायथ में एक विशेष अर्थ है: जब भी यह एक कार्यक्रम में मौजूद होता है, तो पायथ कार्यक्रम कार्यक्रम Qके इनपुट को असाइन करने के साथ शुरू होता है । चूंकि यह पहले चर में होने वाली है ~का तर्क Qभी अब चर कि है ~करने के लिए एक मूल्य प्रदान करेंगे।

हमारे "पठनीय" कार्यक्रम की तरह लग सकता है:

while print_and_return( assign_variable( Q, unif(0, Q-1) ) ):
    pass

और एक नमूना "रन-थ्रू" जैसा दिख सकता है:

क्यू = 5
Oरिटर्न 3, ~रिटर्न 5, \nरिटर्न और प्रिंट 5 जो कि सत्य है
क्यू = ३
Oरिटर्न ०, ~रिटर्न ३, \nरिटर्न और प्रिंट ३ जो कि सत्य है
क्यू = 0
Oकुछ अप्रासंगिक, ~रिटर्न 0, \nरिटर्न और प्रिंट 0 देता है जो कि गलत है
क्यू = कुछ अप्रासंगिक
बर्खास्त

— FryAmTheEggman
स्रोत

3

एपीएल (डायलॉग यूनिकोड) , 12 9 बाइट्स

बेनामी tacit उपसर्ग समारोह। मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0है, जो कई सिस्टम पर डिफ़ॉल्ट है। रन करते समय प्रिंटिंग के अलावा अंतिम मूल्य (0) लौटाता है।

{⌊?⎕←⍵}⍣=

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

{… }⍣= स्थिर होने तक निम्न फ़ंक्शन लागू करें:

⎕←⍵ तर्क का उत्पादन करें

? उस -1 के माध्यम से श्रेणी 0 में एक समान रूप से वितरित यादृच्छिक संख्या लौटाएं

⌊ राउंड डाउन (क्योंकि ?0एक (0,1) फ्लोट देता है)

— एडम
स्रोत

3

सी (जीसीसी) , 40 42 बाइट्स

कुछ बेवकूफ ™ प्रारंभिक मूल्य को पहले प्रिंट करना भूल गए।

f(K){while(K)printf("%d\n",K,K=rand()%K);}

घबराओ मत।

— SIGSTACKFAULT
स्रोत

आपने मुझे बांध दिया, प्रश्न के लिए यह भी आवश्यक है कि आप प्रारंभिक K को प्रिंट करें। इसके बिना मुझे भी 40 मिल गए। आप भी इसी तरह से 42 पूरी तरह से संगत संस्करण प्राप्त कर सकते हैं: f(K){while(K)printf("%d\n",K),K=rand()%K;} । फिर भी आपने एक समान समाधान के लिए मेरा +1 प्राप्त किया!

— लैंबडाबेटा

इससे भी बेहतर:f(K){while(K)printf("%d\n",K,K=rand()%K);}

— SIGSTACKFAULT

3

x86 + रैंड्रैंड, 19 बाइट्स

सीधा कार्यान्वयन। इनपुट K को अंदर ले जाता है ecxऔर एक बफर में आउटपुट करता है ebx।

0000000a <start>:
   a:   0f c7 f0                rdrand %eax
   d:   31 d2                   xor    %edx,%edx
   f:   f7 f1                   div    %ecx
  11:   89 13                   mov    %edx,(%ebx)
  13:   83 c3 04                add    $0x4,%ebx
  16:   89 d1                   mov    %edx,%ecx
  18:   85 c9                   test   %ecx,%ecx
  1a:   75 ee                   jne    a <start>
  1c:   c3                      ret

— qwr
स्रोत

3

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

f=lambda k:print(k)or f(hash('.'*k)%k)

शायद सबसे क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिक संख्या जनरेटर नहीं है, लेकिन मानव आंख के लिए यह पर्याप्त यादृच्छिक लगता है ...

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

— लुका सिटी
स्रोत

नोट्स: 1) प्रविष्टि हर बार एक नए दुभाषिया में चलने के लिए (आमतौर पर) अलग-अलग परिणाम देती है, लेकिन एक ही परिणाम दे सकती है यदि एक ही पायथन सत्र के भीतर चला जाए। 2) मेरा मानना है कि स्पष्ट रूप से जाँच के बिना एक त्रुटि के माध्यम से समाप्त k=0करना स्वीकार्य है।

— लुका सिटी

क्षमा करें, लेकिन कार्यों को एक ही वातावरण में अक्सर मनमाने ढंग से पुन: प्रयोज्य किया जाना चाहिए । एक त्रुटि को समाप्त करना हालांकि स्वीकार्य है

— जो किंग

कार्य को दी गई सीमा से एक समान यादृच्छिक संख्या की आवश्यकता होती है । बनाए रखने की hash() कोशिश करता है, लेकिन इस संपत्ति की गारंटी नहीं देता है। उस कार्य के लिए आपको randomमॉड्यूल का उपयोग करना चाहिए ।

— डेविड फ़ॉस्टर 01

केवल 57 बाइट्स के साथ आप समान रूप से यादृच्छिक संख्याओं का उपयोग करने के लिए अपने समाधान में संशोधन कर सकते हैं random.randrange():from random import*;f=lambda k:print(k)or f(randrange(k))

— डेविड फ़ॉस्टर

3

टीआई-बेसिक (TI-84 Plus CE), 17 13 बाइट्स

While Ans
Disp Ans
int(randAns
End
Ans

मिशा लावरोव से -4 बाइट्स

के Ansरूप में इनपुट लेता है 50:prgmNAME।

TI-Basic एक टोकन भाषा है । यहां इस्तेमाल होने वाले सभी टोकन एक बाइट हैं।

स्पष्टीकरण:

While Ans    # 3 bytes, While the number we hold is not zero:
Disp Ans     # 3 bytes,   Display it on its own line
int(randAns  # 4 bytes,   and replace it with a number randomly
                        # chosen from 0 to one less than it (inclusive)
End          # 2 bytes, end While loop
Ans          # 1 byte,  Display (and return) zero

मीशा लावरोव द्वारा सुझाया गया एक 11-बाइट समाधान enterजिसे पहले प्रत्येक पंक्ति के बाद दबाने की आवश्यकता होती है ।

Ans
While Ans
Pause int(randAns
End

— pizzapants184
स्रोत

1

int(Ansrandछोटा है। इसके अलावा, के Pauseबजाय का उपयोग करते हुए Disp, आप लूप में केवल वही बयान कर सकते हैं Pause int(Ansrand, जो अपडेट भी करता है Ans।

— मिशा लावरोव

3

पायथन 2 , 64 62 60 बाइट्स

from random import*
k=input()
while k:print k;k=randrange(k)

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

बचाया

-2 बाइट्स, जोनाथन एलन के लिए धन्यवाद

— TFeld
स्रोत

"इनपुट पहले मुद्रित होना चाहिए" ... while 1:print k;k=randint(0,~-k)काम करना चाहिए (अंत में एक त्रुटि के साथ)

— जोनाथन एलन

... और फिर while 1:print k;k=randrange(k)दो को बचाता है।

— जोनाथन एलन

1

@JonathanAllan धन्यवाद :), सवाल कहता है कि मैं 0 के बजाय एक खाली लाइन का उपयोग कर सकता हूं, इसलिए कोई त्रुटि नहीं है।

— TFeld

3

C ++ (gcc), 98 बाइट्स

#import<cstdio>
#import<cstdlib>
#define d printf("%i ",x 
int p(int x){d);while(x>0)d=rand()%x);}

यहाँ यह कोशिश करो!

प्रयोग

int main() {
    p(100);
}

यह मेरा पहला कोड गोल्फ प्रयास है। किसी भी प्रतिक्रिया या टिप्पणी का स्वागत है।

संपादित करें: जैसा कि इसे वैध बनाने का सुझाव दिया गया, मुख्य कार्य को हटा दिया गया।

— eKKiM
स्रोत

1

नमस्ते, और PPCG में आपका स्वागत है :) आपको अपने बाइट काउंट में नमूना कॉल को शामिल करने की आवश्यकता नहीं है (अर्थात आपको मुख्य फ़ंक्शन को लिखने की आवश्यकता नहीं है) क्योंकि हम कार्यों को मान्य सबमिशन के रूप में स्वीकार करते हैं। अन्यथा, आपका सबमिशन तकनीकी रूप से मान्य नहीं है क्योंकि यदि इनपुट कुछ दो या अधिक अंकों की संख्या का था तो आउटपुट अस्पष्ट हो सकता है। यदि आप अपने मैक्रो में प्रारूप स्ट्रिंग के अंत में एक स्थान जोड़ते हैं तो आपको ठीक होना चाहिए। हैप्पी गोल्फिंग!

— FryAmTheEggman

संकलक ध्वज जोड़ना -Dd='printf("%i,",x' बजाय #defineआपको कुछ बाइट्स (-4) बचाएंगे, और जब तक आप अपने परिणाम की ओर बाइट्स गिनते हैं, तब तक की अनुमति है (क्योंकि यह एक गैर-मानक प्रीप्रोसेसर निर्देश है। आप आयातों को भी छोड़ सकते हैं) कम से कम -std=c++98और -w, जो बाइट्स के लिए गणना नहीं करते हैं), और चर प्रकार। इसलिए, आपके पास होगा p(x){d);while(x>0)d=rand()%x;}और -Dd='printf("%i,",x'।

इसके अलावा, आपको संभवतः C में गोल्फिंग के लिए स्टैंडर्ड लोफॉल्स एंड टिप्स की जांच करनी चाहिए , अगर आपने पहले से ही नहीं किया है :)

3

> <>, 92 + 2 बाइट्स

:nao:0=?;0_1>:{:}(?\\
}(?!\$2*1>x~\$+1$*2/\~00:{{:@}
8+1.\~:{:}\+>$1+f
~~@~~47*0.\(a2*1@@?!.

+ 2 बी -v ध्वज के लिए

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

> <> यादृच्छिकता का एकमात्र स्रोत 'x' निर्देश से आता है, जो निर्देश सूचक की दिशा को यादृच्छिक मान में सेट करता है। जैसे, 0 से n तक एक यादृच्छिक संख्या उत्पन्न करना तुच्छ नहीं है।

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

स्पष्टीकरण:

:nao                              Print the current number followed by a newline
    :0=?;                         If the current n is 0, terminate

Calculate how many random bits we need to be generating:
         0 1                      Initialise the variables for this loop: 
                                      numberOfBits = 0, maxValue = 1
             :{:}(?\              If maxValue >= n, break out of the loop
                 *2               maxValue *= 2
             $+1$                 numberOfBits += 1

Generate the random number:
                     ~            Delete maxValue
                      00          Initialise randomNumber = 0, i = 0
}(?!\                   :{{:@}    If i >= numberOfBits, break out of the (inner) loop
     $2*                          randomNumber *= 2
          _
        1>x~\                     The random bit: If the IP goes up or 
          \+>                     left, it'll be redirected back onto the 'x', 
                                  if it goes down, it adds one to randomNumber
                                  If it goes right, it does nothing to randomNumber

             $1+                  increment i
8+1.            f                 Jump back to the start of the inner loop

After we've generated our number, check that it's actually below n
     ~                            Delete i
      :{:} (      ?               Test that the number is less than n
            a2*1    .             If it's not, jump back to the start 
                                  of the number generation section
  @~~                             Otherwise delete the old value of n, and numberOfBits
     47*0.                        Then jump back to the start of the program

— साशा
स्रोत

बहुत अच्छा! मैं स्वतंत्र रूप से एक ही विचार के साथ आया था; व्हॉट्सएप के बिना, मेरा समाधान आपके मुकाबले कई वर्णों का उपयोग करता है, लेकिन आप कोड के बहुत अधिक कॉम्पैक्ट ब्लॉक बनाने में कामयाब रहे हैं।

— थियोफाइल

2

वर्तमान मेटा सर्वसम्मति यह है कि आपको झंडे पर उपयोग किए जाने वाले बाइट्स की गणना करने की आवश्यकता नहीं है

— जो किंग

3

MATLAB ( 49 46 बाइट्स)

@(k)eval('while k;disp(k);k=randi(k)-1;end;0')

नमूना उत्पादन:

>> @(k)eval('while k;disp(k);k=randi(k)-1;end;0')
ans(5)

ans = 

    @(k)eval('while k;disp(k);k=randi(k)-1;end;0')

     5    
     3    
     2    
     1   

ans =    
     0

— आआआआ कहती है मोनिका को बहाल करो
स्रोत

1

मुझे लगता है कि आप k=randi(k)-1कुछ बाइट्स कम कर सकते हैं ।

— सैन जूस

2

रेटिना , 21 बाइट्स

.+
*
L$`.
$.`
+¶<)G?`

इसे ऑनलाइन आज़माएं!स्पष्टीकरण:

तब तक दोहराएं जब तक मान बदलना बंद न हो जाए (यानी 0)।

¶<)

प्रत्येक लूप से गुजरने से पहले मान को प्रिंट करें।

.+
*

यूनीरी में बदलें।

L$`.
$.`

रेंज बनाएं और दशमलव में कनवर्ट करें।

G?`

एक यादृच्छिक तत्व चुनें।

— नील
स्रोत

2

पायथ , 6 7 बाइट्स

QWQ=OQQ

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

प्रारंभिक इनपुट मान को प्रिंट करने के लिए +1।

जबकि Q सत्य है, Q को 0 और Q और प्रिंट Q के बीच एक यादृच्छिक पूर्णांक होना चाहिए।

कम से कम अजगर का जवाब नहीं है, लेकिन मैं सिर्फ सीख रहा हूं और केवल पोस्टिंग की वजह से हाल ही में चर्चा कर रहा हूं कि कोई भी किसी और का उपयोग नहीं करता है :)

— ElPedro
स्रोत

2

मैं संचयी कम का उपयोग कर टाई करने में कामयाब रहा, लेकिन इसे एक प्रक्रियात्मक कार्यक्रम के रूप में रखा। एक गोल्फ पर काम करने की प्रेरणा के लिए धन्यवाद :)

— FryAmTheEggman

यह अच्छा है। फिर भी यह कैसे (क्यों) काम करने की कोशिश कर रहा है।

— ElPedro

डिफ़ॉल्ट रूप से, दोनों = और ~चर है कि अगर एक निर्दिष्ट नहीं है आवंटित किया जाएगा के रूप में एक अभिव्यक्ति के पहले चर का उपयोग करें। उदाहरण के लिए 10. लौटते समय 11 पर ~hTसेट Tहो जाएगा । केवल अन्य फैंसी चाल यह है कि न्यूलाइन वर्ण अपने इनपुट को प्रिंट करता है और फिर उस मूल्य को अनमॉडिफाइड लौटाता है, इसलिए हमारे पास एक खाली लूप बॉडी हो सकती है। मुझे पता है अगर कुछ और भ्रामक है :)

— FryAmTheEggman

1

@FryAmTheEggman यह सुंदर है।

— isaacg

1

@isaacg धन्यवाद! मैं मूल रूप से इसका मतलब सिर्फ यहां संपादित करने के लिए था, लेकिन मैंने कुछ लिखने का फैसला किया क्योंकि मैं MathJax की कोशिश करना चाहता था। इस तरह के पायथ उत्तर हमेशा से मेरे पसंदीदा थे क्योंकि वे दोनों जानबूझकर लेकिन अपमानजनक भी महसूस करते हैं :)

— FryAmTheEggman

2

हास्केल , 74 71 बाइट्स

^{-3 बाइट्स वास्तव में कर रहे हैं जो चश्मा कहते हैं कि इसे करना चाहिए।}

import System.Random
f 0=pure[0]
f x=randomRIO(0::Int,x-1)>>=fmap(x:).f

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

— ბიმო
स्रोत

2

आईबीएम / लोटस नोट्स फॉर्मूला, 48 बाइट्स

o:=i;@While(i>0;i:=@Integer(i*@Random);o:=o:i);o

फ़ील्ड फॉर्मूला जो किसी अन्य फ़ील्ड से इनपुट लेता है i ।

सूत्र के लिए कोई TIO नहीं है, इसलिए यहां नमूना आउटपुट का स्क्रीनशॉट है:

— ElPedro
स्रोत

2

पॉवरशेल, ३६ 32 बाइट्स

-4 बाइट्स AdmBorkBork धन्यवाद

filter f{$_;if($_){Random $_|f}}

Testscript:

filter f{$_;if($_){Random $_|f}}

100 |f

आउटपुट:

— Mazzy
स्रोत

2

Get-है निहित है, तो आप के लिए इसे हटा सकते हैं -4 बाइट्स यह ऑनलाइन कोशिश करो!

— AdmBorkBork

2

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

for($a="$args";$a;$a=Random $a){$a}

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

पूरा कार्यक्रम। इनपुट लेता है $args, इसे स्टोर करता है $a, और एक forलूप में प्रवेश करता है । प्रत्येक पुनरावृत्ति हम जाँच रहे हैं कि क्या $aअभी भी सकारात्मक है (जैसा 0कि PowerShell में गलत है)। फिर हम $aपाइपलाइन पर छोड़ देते हैं और अगले पुनरावृत्ति में चले जाते हैं, जहां हम $aउस परिणाम का निर्धारण करते हैं Get-Random $a, जो सीमा में पूर्णांक देता है 0..($a-1)।

(Ab) इस तथ्य का उपयोग करता है कि PowerShell अंतिम शून्य (वर्तमान में लिखे गए नियमों द्वारा अनुमत) के उत्पादन के बदले में एक अतिरिक्त अनुगामी नईलाइन का उत्पादन करता है।

— AdmBorkBork
स्रोत

"$args"- अच्छा है। मैं $args[0]इस मामले में फंस गया था

— mazzy

2

लुआ , 58 बाइट्स

p,r=print,...+0 p(r)while r>0 do r=math.random(0,r)p(r)end

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

कुछ और लव के लिए यहाँ प्यार :)

— Lycea
स्रोत

अरे, आप rघोषणा पर +0 को हटा सकते हैं और इसे rसमय पर बयान पर स्थानांतरित कर सकते हैं, ऐसा करके आप अंतरिक्ष के लिए 1 कम बाइट का उपयोग करेंगे ( p,r=print,...p(r)while)।

— विस्कमार्ट

0 तक यादृच्छिकता

अजगर , 6 5 4 बाइट्स

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

सी (जीसीसी) , 42 बाइट्स

सी (जीसीसी) , 40 बाइट्स (डब्ल्यू / ओ प्रिंटिंग प्रारंभिक मूल्य)

आर , 66 60 56 43 41 बाइट्स

MATL , 6 बाइट्स

व्याख्या

पेपे , 25 बाइट्स

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

पर्ल 5 .10.0 -pl, 26 बाइट्स

जेली , 4 3 बाइट्स

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

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

व्याख्या

05AB1E , 8 7 बाइट्स

जे, 13 बाइट्स

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

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

सी, 38 बाइट्स

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

एपीएल (डायलॉग यूनिकोड) , 12 9 बाइट्स

सी (जीसीसी) , 40 42 बाइट्स

x86 + रैंड्रैंड, 19 बाइट्स

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

टीआई-बेसिक (TI-84 Plus CE), 17 13 बाइट्स

पायथन 2 , 64 62 60 बाइट्स

C ++ (gcc), 98 बाइट्स

> <>, 92 + 2 बाइट्स

स्पष्टीकरण:

MATLAB ( 49 46 बाइट्स)

रेटिना , 21 बाइट्स

पायथ , 6 7 बाइट्स

हास्केल , 74 71 बाइट्स

आईबीएम / लोटस नोट्स फॉर्मूला, 48 बाइट्स

पॉवरशेल, ३६ 32 बाइट्स

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

लुआ , 58 बाइट्स

पर्ल 5 .10.0 `-pl`, 26 बाइट्स