यह अंततः बंद हो जाएगा ...

41

इनपुट स्ट्रिंग को देखते हुए S, Sनिम्न तरीके से एक गैर-खाली विभाजक द्वारा प्रिंट करें :

  • चरण 1: मुद्रित होने Sका एक 1/2मौका है, और 1/2कार्यक्रम को समाप्त करने का एक मौका है।

  • चरण 2: मुद्रित होने Sका एक 2/3मौका है, और 1/3कार्यक्रम को समाप्त करने का एक मौका है।

  • चरण 3: मुद्रित होने Sका एक 3/4मौका है, और 1/4कार्यक्रम को समाप्त करने का एक मौका है।

  • ...

  • चरण n: मुद्रित होने Sका एक n/(n+1)मौका है, और 1/(n+1)कार्यक्रम को समाप्त करने का एक मौका है।

टिप्पणियाँ

  • इनपुट स्ट्रिंग में केवल वे अक्षर होंगे जो आपकी भाषा के स्ट्रिंग प्रकार में स्वीकार्य हैं।

  • किसी भी गैर-खाली विभाजक का उपयोग किया जा सकता है, जब तक कि यह हमेशा समान होता है। यह उम्मीद की जाती है कि Sकार्यक्रम समाप्त होने से पहले विभाजक को अंतिम प्रिंट के बाद मुद्रित किया जाता है ।

  • कार्यक्रम में 1/2कुछ भी छापने से पहले समाप्त करने का मौका है।

  • एक अनुगामी नई रेखा स्वीकार्य है।

  • आपका उत्तर वर्णित संभावनाओं का सम्मान करने के लिए एक वास्तविक प्रयास करना चाहिए। जाहिर है, जब nबड़ा होगा तो यह कम और कम सच होगा। आपके उत्तर में संभावनाओं की गणना कैसे की जाती है (और क्यों वे चश्मे का सम्मान करते हैं, छद्म यादृच्छिकता और बड़ी संख्या की समस्याओं की उपेक्षा करते हैं) की एक उचित व्याख्या पर्याप्त है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

code-golf  string  random 
— Fatalize
स्रोत
क्या विभाजक एक खाली स्ट्रिंग हो सकता है?
— rturnbull
16
@rturnbull खैर नहीं, क्योंकि उस मामले में कोई विभाजक नहीं है।
— घातक
क्या हमें एक के बाद एक इन प्रिंट करना है, या जब कार्यक्रम समाप्त हो जाता है तो क्या हम इन सभी को प्रिंट कर सकते हैं?
— डेनिस
@ डेनिस एक के बाद एक।
— घातक

जवाबों:

18

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

WOh=hZQ

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

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

स्यूडोकोड:

while rand_int_below(1 + (Z += 1)):
    print(input)
— लीक नन
स्रोत
Pyth की धड़कन 05AB1E फिर से नहीं है?
— आउटगॉल्फ
क्या समाप्ति विवरण के साथ प्रिंट स्टेटमेंट की स्वयं की संभावना नहीं है?
— tuskiomi
1
@tuskiomi Nah, n / (n + 1) सिर्फ 1-1 / (n + 1), या 1 - (समाप्ति की संभावना) है।
— अदोव्रत
29

सी #, 94 85 बाइट्स

मेरा पहला जवाब!

using System;s=>{var r=new Random();for(var i=2;r.Next(i++)>0;)Console.Write(s+" ");}

पिछला प्रयास (मुझे वह पसंद आया goto):

using System;s=>{var i=2;var r=new Random();a:if(r.Next(i++)>0){Console.Write(s+" ");goto a;}}

Ungolfed:

using System;
class P
{
    static void Main()
    {
        Action<string> f = s =>
        {
            var r = new Random();
            for (var i = 2; r.Next(i++) > 0;) Console.Write(s + " ");
        };

        f("test");

        Console.ReadKey();
    }
}

नोट: C # में Random.Next(N)विधि एक nonnegative पूर्णांक को [0, N-1] श्रेणी में लौटाती है, इसलिए हम केवल यह जांच सकते हैं कि लौटाई गई संख्या 0 से अधिक है या नहीं।

— चार्ली
स्रोत
1
आपको using System;अपनी बाइट गिनती में शामिल करने की आवश्यकता है । आप घोषणा कर सकते हैं r, इनलाइन एक चर के लिए सेट करने की कोई जरूरत: new Random().Next(i++)। आपको गोल्फ की दुर्गंध पर अनुगामी अर्धविराम की आवश्यकता नहीं है।
— TheLethalCoder
1
ओह और अच्छा पहला जवाब! मेरे प्रयास से कम होगा :)
— TheLethalCoder
@ TheLethalCoder आपकी टिप्पणियों के लिए धन्यवाद! मैंने उपयोग करने की कोशिश की, new Random().Next(i++)लेकिन जब मैंने उस पर अमल करने की कोशिश की, तो परिणाम हमेशा या तो कार्यक्रम कुछ भी छापे बिना बंद हो जाता है, या कार्यक्रम कभी भी बंद नहीं होता है। जब मैं चर की घोषणा r=new Random()और उपयोग करता हूं r, तो प्रोग्राम अधिक यादृच्छिक रूप से बंद हो जाता है क्योंकि ओपी पूछता है।
— चार्ली
अहह प्रॉप्स करता है क्योंकि लूप इतना टाइट है।
— TheLethalCoder
2
@TheLethalCoder - हां, थ्रेड लूप का मतलब है कि जनरेटर का बीज एक समान होगा। देखें: msdn.microsoft.com/en-us/library/system.random.aspx#Instantiate
— Erno
12

आर, 47 46 43 बाइट्स

टिप्पणियों में रॉबिन राइडर के कारण 43 बाइट्स।

s=scan(,"")
while(sample(T<-T+1)-1)print(s)

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

व्याख्या

s=scan(,"")  # Takes input from stdin.
             T<-T+1    # T is 1 by default, so this
                       # evaluates to 2, and will increment
                       # at each step.
      sample(T<-T+1)   # Take a sample of size 2, i.e. generate
                       # a list of integers from 1 to 2 in random order
      sample(T<-T+1)-1 # Subtract one from every element of this list.
while(sample(T<-T+1)-1)# while() will treat the first value in this list
                       # as a logical value, i.e. FALSE for zero and TRUE
                       # for nonzero values. The other elements of the list
                       # are ignored, triggering a warning.
                       print(s) # print s
— rturnbull
स्रोत
क्या यह कभी समाप्त होता है?
— Mfloren
@mfloren हां, अन्य सभी उत्तरों की तरह, यह स्टोचस्टिक है, समाप्ति की संभावना कम होने के साथ जैसे-जैसे यह आगे बढ़ेगा, लेकिन यह अंततः समाप्त हो जाएगा। वहाँ एक -5 मौका है यह कुछ भी नहीं मुद्रित करेगा! इसे कई बार चलाने की कोशिश करें और आउटपुट की तुलना करें।
— सितंबर को rturnbull
function(s)से कम हैs=scan(,'');
— JAD
1
और pryr::f(while(runif(1)<T/(T<-T+1))print(s))उससे भी छोटा है।
— JAD
1
@JarkoDubbeldam दुर्भाग्य से आप (एब) का उपयोग नहीं कर सकते हैं Tऔर Fअनाम कार्यों के साथ, क्योंकि यह एक वैश्विक चर को संशोधित करता है और इसका मतलब है कि फ़ंक्शन केवल एक बार कहा जा सकता है। यहां देखें : "समाधान फ़ंक्शन लगातार परवाह करता है कि कितनी बार इसे पहले कहा गया है"।
— रिटनबुल
11

05AB1E , 8 बाइट्स

[NÌL.R#,

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

व्याख्या

[         # start loop
 NÌL      # push range [1 ... current_iteration+2]
    .R    # pick a random number
      #   # if true (1), exit loop
       ,  # print input
— Emigna
स्रोत
@ घातक: यह मेरे लिए है। इसे कुछ बार चलाने की कोशिश करें। आपके पास कुछ भी आउटपुट न करने का 50% मौका है, इसलिए आप "अशुभ" हो सकते हैं।
— इमीना
11
यादृच्छिक कार्यों की विरासत की समस्या। कभी-कभी सभी ऑड्स आपके खिलाफ होते हैं।
— J_F_B_M
@J_F_B_M अंतर्निहित है?
— लीक नून
1
@LeakyNun नहीं, यह "इनहेरिट प्रॉब्लम" है (घटनाओं की संभावना पिछले घटनाओं से विरासत में नहीं मिली है)। J_F_B_M स्पष्ट रूप से जुआरी के पतन का उल्लेख कर रहा था।
— ऐनाबिस
11

जावास्क्रिप्ट, 60 58 54 बाइट्स

f=(s,n=1)=>Math.random()<n/++n?console.log(s)+f(s,n):0

आउटपुट स्ट्रिंग करेंगे s। विभाजक जो करता है, तो कार्यक्रम समाप्त हो जाता है मुद्रित किया जाता है NaNया 0।

f=(s,n=1)=>Math.random()<n/++n?console.log(s)+f(s,n):0

f('test')
स्निपेट का विस्तार करें

Math.random()0 और 1. के बीच का मान लौटाता है। यदि वह मान कम है n/(n+1), तो sउसे वापस भेज दिया जाएगा।

4 बाइट्स ने @ धन्यवाद का धन्यवाद बचाया

— थॉमस डब्ल्यू
स्रोत
1
उपयोग क्यों नहीं n/++n?
— नील
1
@ नील धन्यवाद, 4 बाइट्स बचाए!
— थॉमस डब्ल्यू
2
यदि आपका वातावरण एक ब्राउज़र था जिसे आप 6 बाइट्स को बचाने के alertबजाय उपयोग कर सकते हैं console.log- alert = console.logयदि वांछित हो तो स्निपेट नॉन ऑब्सट्रक्टिव आउटपुट दिखाने के लिए सेट हो सकता है (यदि अनुमत हो - बाइट्स नहीं बचाता है, बस एक फलक रखने में मदद करता है)
— क्रेग आयरे
10

जावा 8, 72 62 61 बाइट्स

s->{for(int n=2;Math.random()<1f/n++;System.out.println(s));}

-10 बाइट्स @cliffroot की बदौलत ।
-1 बाइट @ जौली जोकर को धन्यवाद ।

परिसीमन एक नई पंक्ति है।

स्पष्टीकरण:

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

s->{                          // Method with String parameter and no return-type
  for(                        //  Loop
    int n=2;                  //   Start `n` on 2
    Math.random()<1f/n++;     //   Continue loop as long as a random decimal (0.0-1.0)
                              //   is smaller than 1/`n` (and increase `n` by 1 afterwards)
    System.out.println(s)     //   Print the input-String
  );                          //  End of loop
}                             // End of method
— केविन क्रूज़सेन
स्रोत
2
मैं पल में जांच करने में असमर्थ हूं, लेकिन हालत ब्लॉक के ifअंदर क्यों नहीं forडालूं?
— क्लिफरॉट
@cliffroot यह है में forपाश।
— ओकेक्स
1
@ ओएक्सएक्स का मतलब था जब forलूप खत्म होना चाहिए, ताकि इसे स्पष्ट होने की आवश्यकता न हो return। बयान के लिए अंदर दूसरी अभिव्यक्ति।
— क्लिफरॉट
@cliffroot आह, मैं समझता हूँ।
— ओकेक्स
1
करेगा int n=2और 1f/n++काम करेगा?
— जॉली जोकर
9

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

(n=1;While[RandomInteger@n>0,Print@#;n++])&

JungHwan Min ने 1 बाइट (ऊपर) को बचाया और कुछ बेहतर (नीचे) सुझाया

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

For[n=1,RandomInteger@n++>0,Print@#]&
— J42161217
स्रोत
1
RandomInteger@n!=0RandomInteger@n<1इस मामले में भी ऐसा ही है , और n++इसे मिला दिया जा सकता है RandomInteger@n। इसके अलावा, For(लगभग हमेशा) से कम है While: -5 बाइट्सFor[n=1,RandomInteger@n++>0,Print@#]&
— जंगहवान मिन
“जीत” के लिए! मैंने आपका उत्तर भी पोस्ट किया
— J42161217
For[n=1,!n∣Hash[# n++],Print@#]&यह भी 34 बाइट्स पर काम करेगा, यह मानते हुए कि हैश काफी यादृच्छिक है। यादृच्छिकता इनपुट पर निर्भर करती है, हालांकि। उदाहरण के लिए कोशिश करें% /@ Alphabet[]
— केली लोल्डर
8

क्लोजर, 61 56 बाइट्स

ओह, मैं forपहली जगह में क्यों नहीं गया? लेकिन वास्तव में पांडित्य doseqका उपयोग किया जाना चाहिए क्योंकि forआलसी का मूल्यांकन किया जाता है।

#(doseq[n(range):while(>(rand-int(+ n 2))0)](println %))

मूल:

#(loop[n 2](if(>(rand-int n)0)(do(println %)(recur(inc n)))))
— NikoNyrh
स्रोत
(>(+(rand-int n)2)0)हमेशा सच नहीं है?
— क्लिफरॉट
आह अच्छी पकड़, मेरा मतलब है वेतन वृद्धि n!
— निकोनिरह
8

> <> , 124 112 बाइट्स

i:0( ?v
 &5a ~/
&p0[^ >"\_\^x0!>"0&1+:&p1&:&p2&:&p3&:&p4&:&p0&1+:&p3&:&p4&:
=?v[/!}l]:?!;1
{:   ?^  >
:o>_ {:?!^

इसे ऑनलाइन आज़माएं! (आप इसे मछली के खेल के मैदान में भी देख सकते हैं , लेकिन कुछ कीड़ों के कारण आपको चौथी पंक्ति में एक }आफ्टर lजोड़ना होगा और कोड के ठीक बाद नईलाइन्स का एक गुच्छा जोड़ना होगा ताकि यह ठीक से काम कर सके।)

यादृच्छिकता> <> में मुश्किल है। एकमात्र यादृच्छिक निर्देश है x, जो चार विकल्पों (बाएं, दाएं, ऊपर और नीचे) से मछली की दिशा को बेतरतीब ढंग से उठाता है, इसलिए संभावना 1 / n के साथ किसी चीज में बदलना सीधा नहीं है।

जिस तरह से यह कोड इसका उपयोग करता है वह कोड के नीचे रैंडमनेस का निर्माण करने के लिए <> की स्व-संशोधित क्षमताओं का उपयोग करता है, इसलिए चौथे चरण में, उदाहरण के लिए, कोड इस तरह दिखता है:

i:0( ?v
 &5a ~/
&p0[^ >"\_\^x0!>"0&1+:&p1&:&p2&:&p3&:&p4&:&p0&1+:&p3&:&p4&:
=?v[/!}l]:?!;1
{:   ?^  >
:o>_ {:?!^
>!0x^
\  _\
>!0x^
\  _\
>!0x^
\  _\
>!0x^
\  _\

मछली टॉवर के नीचे से शुरू होती है। टॉवर के प्रत्येक स्तर पर, xदो दर्पणों के बीच फंसा हुआ है, इसलिए मछली केवल बाएं या दाएं भागकर बच सकती है। या तो ये दिशाएं मछली को टॉवर के अगले स्तर तक भेजती हैं, लेकिन बाईं ओर 0जाने से स्टैक को भी धक्का पहुंचता है। जब तक मछली टॉवर के शीर्ष पर पहुंच जाती है, तब तक स्टैक में कुछ संख्याएं होती हैं 0, और यह संख्या n परीक्षण और पी  = 1/2 के साथ द्विपद वितरण का अनुसरण करती है ।

यदि स्टैक की लंबाई 0 है (जिसमें संभावना 1/2 एन है ), तो कार्यक्रम रुक जाता है। यदि लंबाई 1 (संभावना n / 2 n के साथ ) है, तो मछली इनपुट और एक नई रेखा प्रिंट करती है और टॉवर का एक और स्तर बनाती है। यदि लंबाई कुछ और है, तो मछली स्टैक को हटाती है और टॉवर के नीचे वापस जाती है। वास्तव में, संभावनाओं में से जो वास्तव में कुछ करते हैं, उनमें से n इनपुट स्ट्रिंग को प्रिंट करते हैं और उनमें से एक कार्यक्रम को रोक देता है, जिससे आवश्यक संभावनाएं मिलती हैं।

— पेड़ नहीं
स्रोत
7

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

  • जोनाथन एलन के लिए 3 बाइट्स बचाए गए : शॉर्टहैंड आयात करें और 2 से गिनती शुरू करें।
  • L3viathan के लिए 3 बाइट्स सहेजे गए : इंगित रैंडिन्ट () समावेशी था और स्थिति के दौरान छोटा भी था।
from random import*
s=input();i=1
while randint(0,i):print(s);i+=1

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

— officialaimm
स्रोत
1
आउटपुट कैश को बंद करने के लिए एक सेटिंग है - जैसे
— जोनाथन एलन
2
मुझे लगता है कि बड़े एन के लिए "बंद" होना स्वीकार्य है (मुझे गियर में अंग्रेजी मस्तिष्क नहीं मिल सकता है, "... (और वे चश्मे का सम्मान क्यों करते हैं, छद्म यादृच्छिकता और बड़ी संख्या की समस्याओं की उपेक्षा करते हुए) ..." उपेक्षा - सही?) यदि ऐसा है तो आप कर सकते हैं random()<1/i।
— जोनाथन एलन
1
क्या यह संभावना prob से शुरू नहीं होता है? randintसमावेशी है। फिर आप उस लाइन को छोटा कर सकते हैंwhile randint(0,i):print(s);i+=1
— L3viathan
1
मैं बस एक ही समाधान के साथ आया था।
— फल तोड़
अपडेट किया गया TIO लिंक। अब बाइट काउंट फ्लोटिंग पॉइंट संस्करण के समान है।
— जोनाथन एलन
6

QBIC , 19 17 बाइट्स

गिरा =1दिया, बंद हालत, 2 बाइट्स बचाया

{p=p+1~_rp||?;\_X

व्याख्या

{       Infinitely DO
p=p+1   Add 1 to p (p starts as 0, so on first loop is set to 1, then 2 etc...)
~       IF
  _rp|| a random number between 0 and p
        (implicitly: is anything but 0)
?;      THEN print A$ (which gets read from the cmd line)
\_X     ELSE QUIT
        END IF and LOOP are auto-added at EOF
— steenbergh
स्रोत
6

ब्रिंगोल्फ , 23 बाइट्स

#|V12[R!&@v!r?<1+>1+]|;

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

यादृच्छिक संख्या उत्पन्न करता है xजहां 0 <= x < n+1, x0 होने पर समाप्त होता है, अन्यथा वेतन वृद्धि nऔर लूप। विभाजक है|

स्पष्टीकरण:

#|V12[R!&@v!r?<1+>1+]|;  Implicit input of commandline args to stack
#|                       Push |
  V                      Create stack2 and switch to it
   12                    Push 1, then 2
     [..............]    Do-While loop, will run indefinitely unless conditional skips
                         Closing bracket
      R                  Return to stack1
       !&@               Print entire stack without popping
          v              Switch to stack2
           !r            Generate random number 0 <= x < n where n is last item on stack
             ?           If last item is greater than 0..
              <          ..Move first item to end of stack
               1+        ..and increment, this is the loop counter number
                 >       ..Move back
                  1+     ..and increment, this is the upper range of the RNG
                    ]    ..end loop
                     |   Endif
                      ;  Suppress implicit output
— Skidsdev
स्रोत
6

ऐलिस , 18 बाइट्स

/?!\v
\iO/>]qhUn$@

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

व्याख्या

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string and push it to the stack.
!     Store the string on the tape.
/     Reflect to E. Switch to Cardinal.
>     Ensure that the IP moves east. This begins the main loop.

  ]   Move the tape head to the right. We'll be using the tape head's 
      position as a counter variable. Note that this tape head is independent
      of the one used in Ordinal mode to point at the input string.
  q   Push the tape head's position to the stack.
  h   Increment it (so that it's 2 initially).
  U   Get a uniformly random number in [0,n).
  n   Logical NOT. Gives 1 with probability 1/n and 0 otherwise.
  $@  Terminate the program if we got a  1.
  \   Reflect to NE. Switch to Ordinal.
  ?   Retrieve the input from the tape.
  O   Print it with a trailing linefeed.
  \   Reflect to E. Switch to Cardinal.

v     Send the IP south where it runs into the > to start the next
      loop iteration.
— मार्टिन एंडर
स्रोत
3

चारकोल , 14 बाइट्स

Ａ²γＷ‽γ«θ_Ａ⁺γ¹γ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। _विभाजक के रूप में उपयोग करता है । नोट: आउटपुट कैशिंग अक्षम है, इसलिए कृपया डेनिस के सर्वर को हथौड़ा न दें!

— नील
स्रोत
3

MATL , 9 बाइट्स

`G@QYrq]x

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

व्याख्या

`        % Do...while
  G      %   Push input
  @      %   Push iteration index k, starting at 1
  QYrq   %   Random integer uniformly distributed in {0, 1, ..., k}. This is the
         %   loop condition. If non-zero (which occurs with probability k/(1+k))
         %   proceed with next iteration; else exit loop
]        % End
x        % Delete, as there are one too many strings. Implicitly display the stack
— लुइस मेंडो
स्रोत
3

पर्ल 6 ,  50 41 38 36  26 बाइट्स

{put $_//last for (($,$_),*⊎$_...*).map(*.pick)}

कोशिश करो

{eager ->{(++$).rand>.5??.put!!last}...*}

कोशिश करो

{eager ->{(++$).rand>.5??.put!!0}...0}

कोशिश करो

{eager ->{(++$).rand>.5&&.put}...!*}

कोशिश करो

.put while (++$/).rand>.5

( -nकमांडलाइन तर्क के साथ )

कोशिश करो

— ब्रैड गिल्बर्ट b2gills
स्रोत
3

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

v=s=input();i=2
while hash(v)%i:print(s);i+=1;v=hash(v)

व्याख्या

यादृच्छिक आयात करने से बचाने के लिए, मैंने इस तथ्य का फायदा उठाया है कि हैश बिल्ट-इन बेतरतीब ढंग से हर बार एक अजगर प्रक्रिया को निकाल दिया जाता है (कम से कम मैकओएस में)। अंतिम हैश के प्रत्येक हैश को छद्म यादृच्छिक पूर्णांक की एक श्रृंखला उत्पन्न करनी चाहिए।

यदि हैश पर्याप्त छद्म यादृच्छिक है, तो iसंभावना वाला शून्य शून्य है 1/i।

टिप्पणियाँ

मैं निरर्थक हैश से थोड़ा परेशान हूं, लेकिन पायथन में एक-के-बिना, या इन-कंडीशन असाइनमेंट के बिना, मैं थोड़ा फंस गया हूं।

— किट हाम
स्रोत
क्या आप जानते हैं कि क्या हैरतअंगेज हैशिंग हमेशा यादृच्छिक संख्याओं के पूर्ण स्थान को कवर करने वाला है, या क्या यह संभवतः एक चक्र में फंस सकता है? अधिकांश प्रोग्रामिंग लैंग्वेज आजकल यादृच्छिक हैश एल्गोरिदम का उपयोग करती हैं ताकि लोग जानबूझकर हैश टकराव पैदा करने से बच सकें, लेकिन मुझे यकीन नहीं है कि हैश एल्गोरिदम की यादृच्छिकता एक PRNG की तुलना में कैसे होती है।
यह एक उचित बिंदु है। और मुझे यकीन नहीं है, यह जांच करने के लिए पायथन हैश कार्यान्वयन के कुछ विश्लेषण (अधिक विस्तृत जांच के बिना) ले जाएगा। मैंने सोचा कि यह एक मजेदार समाधान था, भले ही एक मौका हो कि यह 100% छद्म यादृच्छिक-पी नहीं हो सकता है
— किट हैम
I'm a little bothered...प्रत्यावर्तन?
— फेलिप नारदी बतिस्ता
3

सी#

यह शीर्ष C # उत्तर के समान लंबाई है, लेकिन:

using System;s=>{var x=(1<<31)/new Random().Next();for(;++x>0;)Console.Write(s+" ");}

बस यह इंगित करना चाहता था कि कुछ गणित सही संभावना पैदा कर सकते हैं।

int.MaxValue/new Random().Next()-1

के बराबर है

(int)(1 / new Random().NextDouble()) - 1;

और फ़ंक्शन f (x) = 1 / x-1 है:

f (1) = 0

f (1/2) = 1

f (1/3) = 2

f (1/4) = 3

तो १/२ को मौका दिया जा सकता है ०, १/६ को गोल किया जा सकता है, १ को गोल किया जा सकता है, और १ / (एन + १) (एन + २) को गोल करने का मौका दिया जाता है।

हो सकता है कि कुछ अन्य भाषा इस पर पूंजी लगा सके।

संपादित करें: मेरी गलती तय की

मैंने इसे छोटा बनाने के लिए कुछ सोचा।

EDIT EDIT: मैं हर तरह का गलत हूं। रैंडम को लूप से बाहर निकाल दिया क्योंकि अगर इसका कई बार मूल्यांकन किया जाता है, तो यह काम नहीं करेगा।

EDIT EDIT EDIT: मैं चर से छुटकारा पा गया। मैं अब इसे सिकोड़ने की कोशिश बंद करने जा रहा हूं। नहीं, झूठ बोला। एक और बाइट से छुटकारा मिल गया।

— जेफ्री
स्रोत
2

सी, 41 बाइट्स

n;f(char*s){for(n=1;rand()%++n;puts(s));}

मान लिया randजाता है। इसे ऑनलाइन आज़माएं!

— एमडी एक्सएफ
स्रोत
"मान लिया randजाता है।" - क्या यह मान्य धारणा है? randडिफ़ॉल्ट रूप से 1 के निश्चित बीज मान के मानक के लिए आवश्यक है और सभी कार्यान्वयन जिन्हें मैं जानता हूं कि बस। यदि यह फ़ंक्शन केवल वही करता है जो अन्य कोड के साथ संयुक्त होने पर चुनौती पूछता है, तो मुझे लगता है कि अन्य कोड को उत्तर और बाइट काउंट में शामिल करने की आवश्यकता है।
— hvd
2

ब्रेकिंगस्म , 22 बाइट्स

संपादित करें: एक ही बाइट गिनती, लेकिन मुझे एहसास हुआ कि मैं नए टेप की Lनकल सुविधा में चुपके कर सकता हूं ।

,[>,]>L+[+$rzQ>[.>]:>]

0विभाजक के रूप में उपयोग करता है । इस तरह काम करता है:

,[>,]                   Read a byte and move to next cell until end of input.
     >                  After the loop we're in an empty cell;
                          Leave it empty and move to the next.
      L                 Set tape limit here:
                          The tape will then wrap around if we move further.
       +                Increase current cell by one.
                          This cell will be our counter.
        [            ]  Loop until the counter is zero.
                          That won't happen, so it's an infinite loop.
         +              Increase again, so the first time the counter is 2.
          $r            Get a random number, 0 <= r > current cell
            zQ          Quit the program if that random number was 0
              >         Wrap around to the start of the tape.
               [.>]     Print the input stored on the tape
                          The loop will stop at the blank cell.
                   :    Print the blank cell as a number ("0")
                    >   Go to the next (last) cell
— daniero
स्रोत
2

पायथन , 54 बाइट्स

lambda s:int(1/random()-1)*(s+'|')
from random import*

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

के रूप में प्रतियों की संख्या जनरेट किया गया floor(1/p)-1साथ pसमान रूप से इकाई अंतराल से चुना। प्रतियों की संख्या nजब 1/p-1बीच में आती है nऔर n+1, जो तब होती है 1/(n+2) < p < 1/(n+1)। ऐसा प्रायिकता के साथ होता है 1/(n+1)-1/(n+2)या 1/((n+1)*(n+2)। यह outputting के वांछित संभावना है n: प्रतियां 1/20 की समस्या, 1/61 की समस्या, 1/122 की समस्या ...

— XNOR
स्रोत
form random import*सबसे नीचे क्यों है ?
— कैलक्यूलेटरफ्लीन
@CalculatorFeline आदेश कोई फर्क नहीं पड़ता। फ़ंक्शन परिभाषा किसी भी तरह से काम करती है।
— xnor
@CalculatorFeline लिखने f=और
— टीआईओ
यह समझ आता है।
— कैलक्यूलेटरफैनलाइन
2

सी ++, 97 96 57 बाइट्स

यहाँ कोडगुल्फ़ पर मेरी पहली कोशिश :)

#include<iostream>
int main(){std::string S;std::cin>>S;int i=1;while(rand()%++i)puts(S.data());}

मैंने एक-एक बाइट बचाकर इस्तेमाल किया for

#include<iostream>
int main(){std::string S;std::cin>>S;for(int i=1;rand()%++i;)puts(S.data());}

सहेजे गए 39 बाइट्स में कोई भी शामिल नहीं है

void p(string S){for(int i=1;rand()%++i;)puts(S.data());}

ungolfed

#include <iostream>
int main()
{
  // Create and read string from inputstream
  std::string S;
  std::cin >> S;       

  // rand % i: create random int in range [0, i-1]
  // Zero is seen as false and all positive int as true
  int i = 1;
  while (rand() % ++i) 
    puts(S.data());    
}
— मिचेल यूट हीट ब्रोक
स्रोत
आप कमांड लाइन से एक तर्क के रूप में स्ट्रिंग ले सकते हैं
— Maliafo
शामिल हैं, जब तक कि आप एक संकलक नहीं ढूंढते हैं, जिन्हें डिफ़ॉल्ट रूप से शामिल किया जाता है
— फेलिप नारदी बतिस्ता
2

एफ #, 161 बाइट्स

निश्चित रूप से गोल्फ के लिए सबसे अच्छी भाषा नहीं है, लेकिन मैंने इसे एक कोशिश देने का फैसला किया (इसके अलावा, मुझे एफ # के बारे में कुछ भी नहीं पता है, इसलिए मेरे जवाब में सुधार करने के लिए कोई भी सुझाव स्वागत योग्य होगा)।

let f s=
 let r,z=System.Random(),(<>)0
 let p _=printfn"%s"s
 seq {for i in 2|>Seq.unfold(fun i->Some(i,i+1))do yield r.Next(i)}|>Seq.takeWhile z|>Seq.iter p

के साथ निष्पादित करें:

[<EntryPoint>]
let main argv =
    "test" |> f
    0

विभाजक के रूप में एक नई रेखा लिखता है।

— चार्ली
स्रोत
2

रूबी , 29 + 1 = 30 बाइट्स

-nझंडे का उपयोग करता है ।

i=1;puts$_ while i>rand(i+=1)

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

— मूल्य स्याही
स्रोत
चूँकि आप बिलकुल एक लाइन का इनपुट ले रहे हैं, आप $ का उपयोग कर सकते हैं । के बजाय विशेष चर । बेशक आप भी जगह ले सकता है puts$_के साथ print, लेकिन यह स्पष्ट नहीं है कि नियमों समर्थन करते हैं।
— हिस्टोक्रेट
2

जेएस (ईएस 6), 47 बाइट्स

x=>{for(i=1;Math.random()<i/(i+1);i++)alert(x)}

अन्य ES6 उत्तर के विपरीत, यह पुनरावृत्ति के बजाय लूप और अलर्ट बम के लिए उपयोग करता है। प्रोग्राम के रुकने पर जो सेपरेटर छपा होता है, वह अपरिभाषित होता है।

1

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

अन्य पायथन का उत्तर छोटा है, लेकिन मैं इसे एक अलग तरीके से आज़माना चाहता था:

from random import*
f=lambda d=1,s=input():randint(0,d)and s+'!'+f(d+1)or''
— L3viathan
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.