पावरबॉल एक अमेरिकी लॉटरी है जिसने हाल ही में ध्यान आकर्षित किया है क्योंकि वर्तमान जैकपॉट (11 जनवरी, 2016 तक) इतिहास में सबसे बड़ा लोट्टो पुरस्कार है , लगभग 1.5 बिलियन डॉलर ( यूएसडी )।

पावरबॉल खिलाड़ी 69 गिने हुए सफेद गेंदों में से 5 अलग-अलग संख्याएँ चुनते हैं, और 26 गिने हुए लाल गेंदों में से एक 1 "पावरबॉल" नंबर। वे जैकपॉट जीतते हैं यदि उनकी पांच सफेद गेंद पसंद से मेल खाती है जो किसी भी क्रम में तैयार की गई थी, और यदि उन्होंने सही "पॉवरबॉल" नंबर चुना।

तो जैकपॉट जीतने की संभावना 1 में (69 choose 5)*(26 choose 1)या 1 है ((69*68*67*66*65)/(5*4*3*2*1))*26, जो 292,201,338 में 1 है

9 जनवरी 2016 को सबसे हालिया ड्राइंग में किसी ने जैकपॉट नहीं जीता , लेकिन शायद कोई अगले ड्राइंग को 13 जनवरी 2016, 10:59 बजे ईटी में जीत जाएगा।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो पावरबॉल ड्राइंग का अनुकरण करता है, कोई इनपुट नहीं ले रहा है, लेकिन 1 से 69 समावेशी से 5 अलग-अलग यादृच्छिक संख्याओं का उत्पादन कर रहा है, और फिर 1 से 26 समावेशी तक एक यादृच्छिक "पावरबॉल" संख्या (जो 5 में से एक का पुनरावर्तन हो सकता है) प्रारंभिक संख्या)।

"पॉवरबॉल" नंबर हमेशा आउटपुट में अंतिम नंबर होना चाहिए, लेकिन अन्यथा पहले 5 नंबर का क्रम मायने नहीं रखता है।

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

तो ये वैध आउटपुट होंगे ( अंतिम आरेखण से संख्याओं का उपयोग करना ):

32 16 19 57 34 13

सभी 292201338 संभावित परिणाम एक समान संभावना के साथ संभव होने चाहिए। आप अंतर्निहित छद्म यादृच्छिक संख्या जनरेटर का उपयोग कर सकते हैं और मान सकते हैं कि वे इस मानक को पूरा करते हैं।

यहाँ एक अनियंत्रित संदर्भ कार्यान्वयन है जो पायथन 2 या 3 में काम करता है:

import random
print(' '.join(map(str, random.sample(range(1,70), 5) + [random.randint(1, 26)])))

बाइट्स में सबसे छोटा कोड जीतता है।

^{ध्यान दें कि पावरबॉल के साथ मेरा कोई संबंध नहीं है और वास्तव में सुझाव नहीं है कि आप खेलते हैं। लेकिन अगर आप यहां के कार्यक्रमों में से एक से उत्पन्न संख्या से कुछ भी जीतते हैं, तो मुझे यकीन है कि हम इसके बारे में सुनना पसंद करेंगे। : डी}

— केल्विन के शौक
स्रोत

12

जीत का हिस्सा मांगने का एक मौका चूक गया कि यहां किसी को जैकपॉट मिल जाए।

— एलेक्स ए।

क्या 5 नंबर क्रम में होना चाहिए?

— नील

@ नील "" पॉवरबॉल "नंबर हमेशा आउटपुट में अंतिम नंबर होना चाहिए, लेकिन अन्यथा पहले 5 नंबर का क्रम मायने नहीं रखता है।"

— केल्विन के शौक

3

मुझे यकीन है कि कोई भी भ्रमित नहीं है, लेकिन आप वास्तव में चुनौती में पूर्णांक का मतलब है ।

— jpmc26

1

@CanadianLuke पहले 5 नंबरों का क्रम मायने नहीं रखता। कर रहे हैं 5! = 5*4*3*2*1, 5 चीजें व्यवस्था करने के लिए ताकि आप उस को अलग तरीके।

— केल्विन के शौक

29

Dyalog एपीएल, 10 बाइट्स

(5?69),?26

डायएडिक ?[1,,] में विशिष्ट यादृच्छिक संख्याएं हैं, और ?एक एकल यादृच्छिक संख्या है।

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

— lirtosiast
स्रोत

J के लगभग समान को छोड़कर आपको 0 आधारित अनुक्रमण के कारण 1 जोड़ना होगा 1+(5?69),?26:।

— 13

13

सीजेएम, 16 बाइट्स

69,mr5<26mr+:)S*

69,   range(69)
mr    shuffle the generated array
5<    first 5 elements
26mr  random number 0..25
+     concat to array
:)    increment each array element
S*    join with spaces

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

— Doorknob
स्रोत

1

मुझे पसंद है कि कैसे :)चीजें बस थोड़ी बड़ी होती हैं, जैसे कैसे एक अजनबी की मुस्कुराहट आपको बस थोड़ा खुश कर सकती है।

— निधि मोनिका का मुकदमा

1

मुझे लगता है कि :)अगर मैंने लॉटरी जीती तो मुझे बहुत अच्छा लगेगा । +1

— आर्कटिकस

9

MATL , 10 बाइट्स

69 5Zr26Yr

भाषा / संकलक के वर्तमान संस्करण (9.2.0) का उपयोग करता है ।

उदाहरण

Matlab पर संकलक चलाने के साथ:

>> matl
 > 69 5Zr26Yr
 > 
66
59
64
56
29
12

ऑक्टेव पर संकलक चलाने के साथ:

>> matl
 > 69 5Zr26Yr
 >
2 69 41 44 23
22

पहले पांच नंबर को स्पेस द्वारा अलग किया जाता है, न्यूलाइन द्वारा नहीं। यह ऑक्टेव के अंतर्निहित randsampleफ़ंक्शन के कारण होता है जो कि मटलब से अलग व्यवहार करता है (और संकलक के एक नए संस्करण में इसे ठीक किया गया है)। वैसे भी, न्यूलाइन और स्पेस दोनों को चुनौती की अनुमति है।

संपादित करें (4 अप्रैल, 2016) : इसे ऑनलाइन आज़माएं!

व्याख्या

69 5Zr    % randsample(69,5), without replacement by default. Gives a 5x1 column vector
26Yr      % randi(26). Gives single number
          % implicit display

प्रासंगिक Matlab फ़ंक्शन देखें: randsampleऔर randi।

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

7

रूबी, ३३ ३२

p *[*1..69].sample(5),rand(26)+1

रूबी में एक अंतर्निहित पद्धति, नमूना होता है, जो प्रतिस्थापन के बिना एक सरणी से यादृच्छिक मूल्यों का चयन करता है। यह इंगित करने के लिए QPaysTaxes का धन्यवाद कि मुझे पारेंस की आवश्यकता नहीं है।

— histocrat
स्रोत

क्या आप सुनिश्चित हैं कि आपको कोष्ठकों की आवश्यकता है? मुझे लगता है कि आप एक बाइट को दस छोड़ कर और p और * के बीच एक जगह होने के साथ ट्रिम कर सकते हैं। मैं अब जाँच कर रहा हूँ। संपादित करें: परीक्षण और AFAICT यह काम करता है।

— निधि मोनिका का मुकदमा

हा, यह करता है, धन्यवाद। मैं एक irb उदाहरण में परीक्षण कर रहा था जहाँ मैंने pकुछ बिंदु पर सौंपा था , जो वास्तव में उस संस्करण के लिए वाक्यविन्यास पार्सिंग को तोड़ता है।

— हिस्टोक्रेट

6

आर, 30 29 बाइट्स

cat((s=sample)(69,5),s(26,1))

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

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

— एलेक्स ए।
स्रोत

आप cइसके बजाय दो पूरे बाइट्स बचा सकते हैंcat

— डीन मैकग्रेगर

@DeanMacGregor सुझाव के लिए धन्यवाद, लेकिन यहाँ प्रस्तुतियाँ या तो पूर्ण कार्यक्रम होनी चाहिए जो STDOUT या मान लिखने वाले फ़ंक्शंस में लिखें। इस मामले में मैंने पूर्व का विकल्प चुना है। अगर मैं उपयोग कर रहा था c, तो यह केवल एक स्निपेट होगा, जिसे डिफ़ॉल्ट रूप से अनुमति नहीं है।

— एलेक्स ए।

हाँ! मैंने देखा। मैं एक शौकीन चावला गोल्फ खिलाड़ी नहीं हूं इसलिए मैं उससे परिचित नहीं था।

— डीन मैकग्रेगर

@DeanMacGregor कोई समस्या नहीं है। सुझाव के लिए वैसे भी धन्यवाद। :)

— एलेक्स ए।

6

पायथन 3.5, 63 बाइट्स

from random import*
print(*sample(range(1,70),5),randint(1,26))

यह मूल रूप से संदर्भ कार्यान्वयन गोल्फ है। ध्यान दें कि 3.5 गैर-अंतिम तर्क में विभाजित करने के लिए आवश्यक है।

— Sp3000
स्रोत

6

ऑक्टेव, 35 32 बाइट्स

केल्विन के शौक ने पुष्टि की कि ans =एक फ़ंक्शन का उपयोग करते समय ठीक था, इसलिए:

@()[randperm(69)(1:5),randi(26)]

मेमिंग के उत्तर में समानताएं हैं , लेकिन यह प्रत्यक्ष अनुक्रमण का उपयोग करता है जो केवल ओक्टेव में संभव है, और यह 5 7 बाइट्स छोटा है, इसलिए मुझे लगा कि यह वैसे भी पोस्ट करने लायक था।

randperm(69)1-69 की संख्या के यादृच्छिक क्रमांकन के साथ एक सूची बनाता है। यह सूची को सीधे सूचीबद्ध करना संभव है (MATLAB में संभव नहीं) केवल इस तरह से पहले 5 नंबर प्राप्त करने के लिए (1;5)। सूची के बाद randi(26)1 और 26 के बीच एक एकल नंबर देता है।

पुराना:

disp([randperm(69)(1:5),randi(26)])

परिणामी सूची का उपयोग करके प्रदर्शित किया जाता है disp।

— स्टीवी ग्रिफिन
स्रोत

6

PowerShell v2 +, 31 27 बाइट्स

1..69|Random -c 5;Random 27

संस्करण 2 या नए की आवश्यकता है, जैसा Get-Randomकि v1 में मौजूद नहीं था ( Get-निहित है, और -Maximumस्थितीय है)। आउटपुट न्यूलाइन अलग है।

Ungolfed:

Get-Random -InputObject (1..69) -Count 5
Get-Random -Maximum 27

— AdmBorkBork
स्रोत

Random -ma 27बस के Random 27रूप -Maximumमें स्थिति 0 से मिलान किया जा सकता है

— मैट

@ मैट थैंक्स - मैं वो भूल गया।

— AdmBorkBork

5

शेल + कोरुटिल्स, 31

shuf -i1-69 -n5
shuf -i1-26 -n1

— डिजिटल आघात
स्रोत

4

MATLAB, 40

x=randperm(69);disp([x(1:5) randi(26)])

मुझे पता है। यह उबाऊ समाधान है।

— Memming
स्रोत

4

PHP, 69 बाइट्स

<?foreach(array_rand(range(1,69),5)as$k)echo$k+1," ";echo rand(1,26);

बहुत सीधा सीधा जवाब। 1-69 उत्पन्न करें range, फिर array_randसरणी से 5 यादृच्छिक कुंजियों को पकड़ने के लिए उपयोग करें, और $k+1मूल्य (0-अनुक्रमित) को प्रतिध्वनित करें, फिर 1-26 से एक यादृच्छिक अंतर को प्रतिध्वनित करें।

— Samsquanch
स्रोत

4

सी #, 153 बाइट्स 140 बाइट्स

"मैकके" के लिए धन्यवाद:

string.Join(" ",Enumerable.Range(1,69).OrderBy(e=>Guid.NewGuid()).Take(5).Concat(Enumerable.Range(1,26).OrderBy(e=>Guid.NewGuid()).Take(1)))

153 बाइट्स समाधान:

string.Join(" ",Enumerable.Range(1,69).OrderBy(e=>Guid.NewGuid()).Take(5))+" "+string.Join(" ",Enumerable.Range(1,26).OrderBy(e=>Guid.NewGuid()).Take(1))

GUID का उपयोग करके Linq और फेरबदल का उपयोग करते हुए सरल समाधान।

— ivaan
स्रोत

1

पावरबॉल नंबर भाग में स्ट्रिंग को शामिल होने की आवश्यकता नहीं है और आप

— पावरबॉटल

और यदि आप स्ट्रिंग समंजन के बजाय अनुक्रम को बदलते हैं, तो आपको स्पेस 3 बार निर्दिष्ट करने की आवश्यकता नहीं है, यह अधिक कुशल भी होगा। जैसेstring.Join(" ", ....take(5).Concat(....Take(1)))

— मैकके

4

पायथ - 13 14 13 बाइट्स

प्रमुख गोल्फिंग संभव है, यह सिर्फ एक FGITW था।

jb>5.SS69hO26

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

— Maltysen
स्रोत

क्या आप कोड की व्याख्या कर सकते हैं ताकि यह जांचा जा सके कि यह वास्तव में एक समान है?

— मासक्लिन

आप बदल सकते हैं <... 5करने के लिए >5...। अंतिम कोडjb>5.SS69hO26

— ब्लू

2

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

1:5e,68{I`random(I)+1=Z`Z=w,"
"w}\;25:1&

व्याख्या

Brachylog निर्मित एक यादृच्छिक संख्या के लिए नहीं है (अभी तक ...) तो हम उसके लिए एक SWI-Prolog विधेय का उपयोग करना होगा: random/1। हम backquotes का उपयोग करके Brachylog में SWI-Prolog कोड इनपुट कर सकते हैं।

1:5e,                             \  § Enumerate from 1 to 5 using \ (backtrack), which
                                     § evaluates to false and thus constructs a loop

     68{                         }   § Declare sub-predicate 1 and call it with 68 as input

        I`random(I)+1=Z`             § Z is the arithmetic expression 'random(I) + 1' where
                                     § I is the input of the sub-predicate

                        Z=w,         § Evaluate Z and write it
                            "\n"w    § Write a new line

;                                    § Else (we will reach this after the 5th iteration of
                                     § the enumeration, since \ is always false)

25:1&                                § Call the sub-predicate 1 with 25 as input

— Fatalize
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 106 86 84 बाइट्स

F=(s=new Set,r=Math.random)=>s.size<5?F(s.add(r()*69+1|0)):[...s,r()*26|0+1].join` `

चूंकि हम जावास्क्रिप्ट में विशिष्ट रूप से नमूना रैंडम नहीं कर सकते हैं, यह एक सेट (जो केवल अद्वितीय मान रखता है) बनाकर काम करता है, पुनरावर्ती रूप से रैंडम (1-69) जोड़ने तक 5 अद्वितीय होते हैं, एक यादृच्छिक संख्या (1-26) जोड़ते हैं, फिर इसमें शामिल होना और इसे वापस करना।

— Mwr247
स्रोत

2

अमृत , 83 बाइट्स

Enum.reduce Enum.take_random(1..69,5)++[Enum.random(1..26)],fn(x,a)->"#{a} #{x}"end

जब केवल IO.putsपूर्णांकों की एक सरणी होती है, तो अमृत पूर्णांक को वर्णों के रूप में व्याख्या करेगा और इसलिए वांछित पावरबॉल संख्याओं के बजाय कुछ स्ट्रिंग का उत्पादन करेगा। तो, हमें पूर्णांक सरणी को एक स्ट्रिंग तक कम करना होगा।

— srecnig
स्रोत

2

रूबी, 47 43 39 बाइट्स

puts *(1..69).to_a.sample(5),rand(26)+1

मुझे लगता है कि इसे और अधिक गढ़ा जा सकता है, लेकिन मैं इस पर काम करूंगा कि एक बार जब मैं इस कोड को कितना सुंदर लगता हूं, तो मैं इस पर विचार करूंगा।

यह बाकी चीजों की तरह ही बहुत अधिक काम करता है: नंबर 1 से 69 की एक सरणी लें, उन्हें फेरबदल करें, पहले पांच प्राप्त करें, उन पर आउटपुट करें, फिर 1 और 26 के बीच एक यादृच्छिक संख्या का उत्पादन करें।

मैंने इसे पोस्ट करने से पहले कुछ पुनरावृत्तियों के माध्यम से जाना:

puts (1..69).to_a.shuffle.first(5).join(' ')+" #{rand(26)+1}"  #61
puts (1..69).to_a.shuffle[0..5].join(' ')+" #{rand(26)+1}"     #58
puts (1..69).to_a.shuffle[0..5].join('<newline>'),rand(26)+1   #52
puts *('1'..'69').to_a.shuffle[0..5],rand(26)+1                #47
puts *('1'..'69').to_a.sample(5),rand(26)+1                    #43

(कहा पे <newline> एक वास्तविक न्यूलाइन के साथ प्रतिस्थापित किया गया है)

संपादित करें: वूप्स, रेंगने वाले रूबी का जवाब नहीं देखा। मैं लड़खड़ा गया sampleऔर अपने जवाब को संपादित करने के लिए नीचे स्क्रॉल कर रहा था, लेकिन फिर मैंने देखा ... ओह ठीक है। मेरा अंतिम स्कोर 43 बाइट्स है, लेकिन मैं यह देखने के लिए थोड़ा गोल्फिंग करूंगा कि मैं कितना अच्छा कर सकता हूं।

— निधि मोनिका का मुकदमा
स्रोत

2

मैथेमेटिका, 64 बाइट्स

StringRiffle@Append[Range@69~RandomSample~5,RandomInteger@25+1]&

काफी सरल।

— LegionMammal978
स्रोत

आउटपुट में ब्रेसिज़ और कॉमा हैं।

— चार्ल्स

उपरोक्त कारण से -1 अमान्य

— कैलक्यूलेटरफ़ेलीन

StringJoin=""<>##&

— कैलक्यूलेटरफ़लाइन

@CatsAreFluffy ने इस बार वास्तव में तय किया। बस मेरे कार्यों को मिलाया ...

— LegionMammal978

मुझे लगता है कि आप इसे छोटा कर सकते हैं यदि आप केवल रेंज / रैंडम सैंपल का उपयोग करते हैं और रैंडमइंटर का उपयोग करने के बजाय इसे दो सूचियों में ट्रांसपोज़ किया है। रैंडम सैंपल [रेंज [# 1], # 2] और @@@ {{69,5}, {26,1}}]

— जैसा कुछ

1

पर्ल 5, 59 बाइट्स

{say for(sort{-1+2*int rand 2}1..69)[0..5];say$==1+rand 25}

यह एक सबरूटीन है; इसे इस प्रकार उपयोग करें:

perl -M5.010 -e'sub f{...}f'

— msh210
स्रोत

आप -Eइसके बजाय-M5.010 -e

— andlrc

कठबोली आप के -1+2*int rand 2साथ बदल सकते हैं rand>.5?1:-1?

— andlrc

और न आप को बदल कर एक और कुछ को बचाने के लिए सक्षम होना चाहिए ;say$==के साथ,$==

— andlrc

@ देव-नल धन्यवाद! -M5.010वैसे भी शामिल नहीं किये जाते तो मैं यह abbreviating परेशान नहीं किया। मुझे लगता है कि मैंने दूसरे के बजाय अल्पविराम की कोशिश की sayऔर यह काम नहीं किया। लेकिन नए तरह का नियम एक अच्छा विचार है, धन्यवाद। मैं मौका मिलने पर इसका परीक्षण करूंगा और इसे संपादित

— करूंगा

1

PHP, 65 बाइट्स

<?=join(' ',array_rand(array_flip(range(1,69)),5))." ".rand()%26;

इस पृष्ठ पर अन्य PHP उत्तर के लिए धन्यवाद। मैंने अपने दम पर एक कार्यक्रम लिखा, और यह ठीक उसी उत्तर के रूप में निकला, जो सैमसक्वाच द्वारा लिखा गया था, जिसने मुझे कुछ बाइट्स बचाने के लिए एक कदम आगे ले जाने के लिए प्रेरित किया।

अगर किसी को एक सरणी को दूसरे में जोड़ने का तरीका पता चल सकता है, तो यह 5 बाइट्स से कम है जो मुझे पॉवरबॉल नंबर में शामिल होने के बाद ले जाता है, मैं इसकी बहुत सराहना करूंगा, क्योंकि यह मुझे पागल कर रहा है! सबसे अच्छा मैं साथ आ सकता है , array_randपहले और बाद में join, एक बयान जैसा कुछ हो सकता है +[5=>rand()%25], लेकिन यह एक अतिरिक्त बाइट है बस इसे बाद में समेटना।

<?=                                                              // This represents an inline 'echo' statement
                                  range(1,69)                    // Get an array of all numbers from 1 to 69 inclusive
                       array_flip(           )                   // Swap the keys and values.
            array_rand(                       ,5)                // Get a random subset of five keys.
   join(' ',                                     ).rand()%26     // Concatenate the array with spaces, along with the powerball number

इसे कमांड लाइन के माध्यम से चलाएं। नमूना:

C:\(filepath)>php powerball.php

आउटपुट:

 12 24 33 67 69 4

— Xanderhall
स्रोत

1

PARI / GP, 71 70 बाइट्स

apply(n->print(n),numtoperm(69,random(69!))[1..5]);print(random(26)+1)

यह [1..69] का एक यादृच्छिक क्रमांकन उत्पन्न करता है, फिर पहले 5 लेता है।

दुर्भाग्य से यह यादृच्छिकता का एक अक्षम्य उपयोगकर्ता है, जो सूचना के सिद्धांत-आदर्श 3.5 की तुलना में एन्ट्रापी के औसत 87 बाइट्स का उपभोग करता है। यह मुख्य रूप से है क्योंकि संपूर्ण क्रमपरिवर्तन केवल पहले 5 सदस्यों के बजाय उत्पन्न होता है, और इसलिए भी कि परमिट का आदेश दिया जाता है (lg 5! = ~ 7 बिट्स)। इसके अलावा, randomअंकगणित कोडिंग का उपयोग करने के बजाय एक अस्वीकृति रणनीति का उपयोग करता है। (ऐसा इसलिए है क्योंकि PARI ब्रेंट के एक्सग्रेन का उपयोग करता है, जो काफी तेज है कि अधिक जटिल रणनीतियों से ओवरहेड शायद ही सार्थक है।)

तीन 'स्पष्ट' परिवर्तन हैं जो जीपी के वर्तमान (2.8.0) संस्करण के तहत काम नहीं करते हैं। randomऔर printचर में संग्रहीत किया जा सकता है, और printगुमनाम ->समारोह के बजाय सीधे बुलाया जा सकता है :

r=random;apply(p=print,numtoperm(69,r(69!))[1..5]);p(r(26)+1)

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

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

0

इंटेल x86 मशीन कोड, 85 बाइट्स

¿I ±‰ø1Ò»E ÷óB‰Ðè+ ‰þÑç÷ƒÇþÉ„Éuâ‰ø1Ò» ÷óB‰Ðè
 0äÍ¸ Í±ëÆÔ
00†Äˆã´ÍˆØÍ° ÍÃ

वैसे यह कभी-कभी एक ही नंबर प्रिंट करता है यदि ऐसा है, तो बस एक कुंजी दबाकर फिर से प्रयास करें।

संकलन:

nasm file.asm -o file.bin

इसे vm पर माउंट करने के लिए इसे फ्लॉपी आकार (अंत में शून्य जोड़ें) पर संरेखित करना सुनिश्चित करें (इसे किसी ऑपरेटिंग सिस्टम की आवश्यकता नहीं है)।

disassembly:

BITS 16
ORG 0x7c00

mov di,73 ;starting seed
mov cl,5 ;we need five numbers

loop:

mov ax,di

xor dx,dx
mov bx,69
div bx
inc dx
mov ax,dx

call print_rnd_number

mov si,di
shl di,1
add di,si
add di,7

dec cl

test cl,cl
jne loop

mov ax,di

xor dx,dx
mov bx,26
div bx
inc dx
mov ax,dx

call print_rnd_number

xor ah,ah
int 0x16
mov ax,0x0002
int 0x10
mov cl,5
jmp loop

print_rnd_number:
aam
add ax,0x3030
xchg al,ah
mov bl,ah
mov ah,0x0E
int 0x10
mov al,bl
int 0x10
mov al,' '
int 0x10
ret

— ByteBit
स्रोत

6

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मशीन कोड देखना हमेशा प्रभावशाली होता है, लेकिन अगर यह अवसरों पर बार-बार नंबर प्रिंट करता है, तो मुझे डर है कि आपका सबमिशन अमान्य है।

— डेनिस

1

हां यह है, लेकिन मैं सिर्फ यह साझा करना चाहता था :)

— बाइटबिट

2

मैं समझता हूं, लेकिन हमने हाल ही में इस पर चर्चा की , और समुदाय की सहमति थी कि अमान्य उत्तर या तो तय किए जाने चाहिए या हटाए जाने चाहिए।

— डेनिस

अगर तुम ठीक करोगे तो मैं बेवक्त हूँ; कृपया मुझे पिंग करें।

— lirtosiast

0

सी, 142 बाइट्स

i,x[6],n;main(j){for(srand(time(0));i<6;n-i?0:printf("%d ",x[i]),i++)for(x[n=j=i]=(69-i/5*43)*(rand()/2147483647.)+1;i<6&&j--;)i-=x[i]==x[j];}

इस समाधान से बहुत खुश नहीं हैं क्योंकि यह महसूस करता है कि अधिक गोल्फिंग अवसर होना चाहिए। मैं इसे कल फिर से नई आँखों से देखूँगा। इसे यहाँ आज़माएँ ।

— कोल कैमरून
स्रोत

0

स्विफ्ट, 165 बाइट्स

import UIKit;var a=[Int]();for i in 0...5{func z()->Int{return Int(arc4random_uniform(i<5 ?68:25)+1)};var n=z();while i<5&&a.contains(n){n=z()};a.append(n);print(n)}

जल्दी से एक Xcode Playground में चलाया जा सकता है।

EDIT: यहाँ पर वर्तमान समस्या यह है कि सैद्धांतिक रूप से यह संभव है कि यह हमेशा के लिए लूप में चले जाए अगर arc4random_uniform किसी तरह एक ही नंबर खींचती रहे। किसी भी महत्वपूर्ण लंबाई के लिए होने वाली बाधाओं, शायद पॉवरबॉल जीतने के बाधाओं से बेहतर हैं।

— timgcarlson
स्रोत

यह कैसे गारंटी देता है कि कोई भी डुप्लिकेट मान नहीं होगा?

— सुपरकैट

@ सुपरकैट, यह पहले नहीं था, लेकिन अब यह करता है।

— टाइमगर्लसन

0

पर्ल 6 , 32 31 बाइट्स

# space is necessary so that the parens denote a list
# rather than being part of the call to `put`
put (pick(5,1..69),(1..26).pick) # 32 bytes
# 25 35 57 67 62 24␤

इसे एक फ़ंक्शन में बदलना जो एक स्ट्रिंग लौटाता है, मैं put␠केवल 3 जोड़ते हुए 4 बाइट्स ( ) निकाल सकता हूं ( {~ })

{~(pick(5,1..69),(1..26).pick)} # 31 bytes

उपयोग:

say {...}().perl; # use .perl to prove it returns a string
# "25 35 57 67 62 24"

यदि किसी फ़ंक्शन को मानों की सूची वापस करने की अनुमति दी गई थी, तो निम्नलिखित भी काम करेगा।

(अन्यथा यह ऊपर लेकिन भीतर भी वैसा ही होगा { })

फ़ंक्शन जो एकल फ्लैट सूची देता है
```
{|pick(5,1..69),(1..26).pick} # 29 bytes
# (25,35,57,67,62,24)
```
एक उप सूची में पहले 5 नंबरों के साथ एक सूची लौटाता है
```
{pick(5,1..69),(1..26).pick} # 28 bytes
# ((25,35,57,67,62),24)
```
एक उप सूची में पहले 5 और दूसरी उप सूची में पावरबॉल के साथ एक सूची देता है
```
{pick(5,1..69),pick 1,1..26} # 28 bytes
# ((25,35,57,67,62),(24,))
```

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

0

गंभीरता से, 35 बाइट्स

गोल्फिंग भाषा में जवाब देने का मेरा पहला प्रयास।

लगता है की तुलना में यह होना चाहिए।
पुनरावृत्ति की संभावना डब्ल्यू के साथ हटा दी जा सकती है , लेकिन ऐसा लगता है कि यह ऑनलाइन दुभाषिया में टूट गया है और मैं बिना कोड के पोस्ट नहीं करना चाहता।

बहुत बुरा { सूचियों पर काम नहीं करता है।

कोड:

:70:1xi J{. J{. J{. J{. J{.:26:Ju.

हेक्स डंप:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

स्पष्टीकरण:

:70:1x                       # Push a list of the numbers 1-69
i                            # Explode list
 J{.                         # rotate stack random(len(stack)) times and pop/print
 J{. J{. J{. J{.             # same thing 4 more times
:26:Ju.                      # print random number in 1-26
                             # (7F) unprintable, terminate without explicit printing

ऑनलाइन दुभाषिया

— Emigna
स्रोत

0

लुआ, 96 बाइट्स

एक सरल समाधान, इसके अंदर मूल्य डालकर एक तालिका के रूप में उपयोग करना, यह table[value]=truthy/falsyजांचने में सक्षम होना चाहिए कि वे इसके अंदर हैं या नहीं।

मैं 5 बाइट्स खो देता हूं क्योंकि मुझे अपनी तालिका का पहला मूल्य निर्धारित करना होगा, अन्यथा मैं while(o[n])लूप के अंदर नहीं जाऊंगा और nयादृच्छिक फ़ंक्शन का उपयोग करने से पहले बस आउटपुट करूंगा । जैसा कि लुआ 1-आधारित तालिकाओं का उपयोग करता है, मुझे इसे सेल पर अपना पहला मूल्य लगाने के लिए भी मजबूर करना होगा [0], अन्यथा मैं आउटपुट नहीं कर सकता 1।

m,n,o=math.random,0,{[0]=0}for i=1,5 do while(o[n])do n=m(69)end o[n]=0 print(n)end print(m(26))

Ungolfed:

m,n,o=math.random,0,{[0]=0}
for i=1,5
do
  while(o[n])
  do
    n=m(69)
  end
  o[n]=0
  print(n)
end
print(m(26))

— Katenkyo
स्रोत

0

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

golfed:

#include<iostream>
#include <random>

int main(){std::random_device rd;std::mt19937 gen(rd());std::uniform_int_distribution<> dis(1,69);for(int c=0;c<=5;c++){std::cout<<dis(gen)<<" ";}int x=dis(gen);while(x>26||x<1){x=dis(gen);}std::cout<<x;return 0;}

Ungolfed:

#include<iostream>
#include <random>

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 69);
    for(int c = 0; c <= 5; c++){
        std::cout<<dis(gen)<<" ";
    }
    int x = dis(gen);
    while (x > 26 || x < 1){
        x = dis(gen);
    }
    std::cout<<x;
    return 0;
}

— मिशेलफ्रांसिस बस्टिलोस
स्रोत

पावरबॉल नंबर चुनें!

चुनौती

Dyalog एपीएल, 10 बाइट्स

सीजेएम, 16 बाइट्स

MATL , 10 बाइट्स

उदाहरण

व्याख्या

रूबी, ३३ ३२

आर, 30 29 बाइट्स

पायथन 3.5, 63 बाइट्स

ऑक्टेव, 35 32 बाइट्स

PowerShell v2 +, 31 27 बाइट्स

Ungolfed:

शेल + कोरुटिल्स, 31

MATLAB, 40

PHP, 69 बाइट्स

सी #, 153 बाइट्स 140 बाइट्स

पायथ - 13 14 13 बाइट्स

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

व्याख्या

जावास्क्रिप्ट (ईएस 6), 106 86 84 बाइट्स

अमृत , 83 बाइट्स

रूबी, 47 43 39 बाइट्स

मैथेमेटिका, 64 बाइट्स

पर्ल 5, 59 बाइट्स

PHP, 65 बाइट्स

PARI / GP, 71 70 बाइट्स

इंटेल x86 मशीन कोड, 85 बाइट्स

सी, 142 बाइट्स

स्विफ्ट, 165 बाइट्स

पर्ल 6 , 32 31 बाइट्स

यदि किसी फ़ंक्शन को मानों की सूची वापस करने की अनुमति दी गई थी, तो निम्नलिखित भी काम करेगा।

गंभीरता से, 35 बाइट्स

लुआ, 96 बाइट्स

Ungolfed:

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

golfed:

Ungolfed: