आप गोल्फ कर सकते हैं?

Question

आपको एक यादृच्छिक 18-होल गोल्फ कोर्स उत्पन्न करना आवश्यक है।

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

[3 4 3 5 5 4 4 4 5 3 3 4 4 3 4 5 5 4]

नियम:

• आपके प्रोग्राम को वास्तव में 18 छेद के लिए छेद की लंबाई की एक सूची का उत्पादन करना चाहिए
• प्रत्येक छेद की लंबाई 3, 4 या 5 होनी चाहिए
• पूरे कोर्स के लिए छेद की लंबाई 72 तक होनी चाहिए
• आपका कार्यक्रम कुछ गैर-शून्य-संभाव्यता के साथ हर संभव छेद विन्यास का उत्पादन करने में सक्षम होना चाहिए (प्रत्येक कॉन्फ़िगरेशन की संभावनाएं बराबर नहीं होनी चाहिए, लेकिन यदि ऐसा है तो अतिरिक्त कुडो का दावा करने के लिए स्वतंत्र महसूस करें)

Comments

कृपया पुष्टि करें, 44152809 समाधान?

— बेबी-खरगोश

मैं भी समाधानों की सटीक संख्या पर उत्सुक हूं, हालांकि मुझे लगता है कि यह 44 मिलियन से अधिक होना चाहिए ... (मैं कोई गणितज्ञ नहीं हूं, हालांकि: - 1 (5) / 1 (3) = 306 संभावनाएं (17 * 18) | 2 (5) / 2 (3) = 69360 का अधिकार (17 * 17 * 16 * 15) | 3 (5) / 3 (3) = 11182080 का अधिकार (16 * 16 * 16 * 15 * 14 * 14 * 13) | यह सही लगता है?

— NRGdallas

@ बेबी-खरगोश: मैं जानवर बल गणना द्वारा 44,152,809 समाधानों की पुष्टि कर सकता हूं। इसके अलावा, यह सीधे इस तरह से गणना की जा सकती है: के बाद से औसत ठीक है 4, और केवल संभावनाएं हैं 3, 4या 5, संभव समाधान वर्ग हैं { no 3's or 5's, one 3 and one 5, two 3's and two 5's, ..., nine 3's and nine 5's}। इसके द्वारा गणना की जा सकती है nCr(18,0)*nCr(18,0) + nCr(18,1)*nCr(17,1) + nCr(18,2)*nCr(16,2) + ... + nCr(18,9)*nCr(9,9) = 44,152,809। इसका मतलब है कि लगभग 11.4%सभी संभावित संयोजन वैध समाधान हैं (44,152,809 / 3^18)।

— मेलमोकब

sum(factorial(18)/factorial(x)/factorial(y)/factorial(z) for x in range(25) for y in range(25) for z in range(25) if 3*x+4*y+5*z == 72 and x+y+z == 18)देता है44152809L

— संजीव मूर्ति

Answer 1

k ( १ char १ 17 १६ वर्ण)

मूल दृष्टिकोण पर वापस, सुधार के लिए सीएस को श्रेय।

(+/4-){3+18?3}/0

अन्य दृष्टिकोण (17 वर्ण), जे समाधान के समान विधि, एच / टी से सीएस

4+a,-a:9?2 -18?18

पुराना संस्करण:

(72-+/){18?3+!3}/0

स्टैक-ओवरफ्लो के लिए अतिसंवेदनशील नहीं और निश्चित मात्रा में अंतरिक्ष में चलता है।

Comments

क्या है एच / टी से सीएस?

— गारेथ

टोपी-टिप, en.wikipedia.org/wiki/Hat_tip#Metaphor

— skeevey

इस कार्यक्रम ने मुझे मेरी कश्मीर दुभाषिया में एक बग को खोजने में मदद की- धन्यवाद! मुझे पहले महसूस नहीं हुआ कि निलाड्स को एक ही तर्क पर लागू किया जा सकता है (जिसे वे अनदेखा करते हैं)।

— जॉनई

Answer 2

के, २ 28

{$[72=+/s:18?3 4 5;s;.z.s`]}

Answer 3

जम्मू, 20 18 17 अक्षर

(?~18){4+(,-)?9#2

यह पिछले उत्तर की तरह ही काम करता है, सिवाय इसके कि 9 रैंडम अंक या तो 0 या 1 हैं और इन्हें संलग्न किए जाने से पहले नकार दिया जाता है। इसका मतलब है कि जितने भी -1एस हैं, उतने हैं 1। 4 जोड़ने से मुझे 3s, 4s और 5s की सूची मिलती है जो हर बार 72 तक जुड़ती है।

पिछला उत्तर:

({~?~@#)3+(,2-])?9#3

पहले 9 छेदों को बेतरतीब ढंग से उत्पन्न करता है ?9#3, फिर उन्हें कॉपी और अयोग्य बनाता है (,2-])(अंतिम 3 को 5 में और 5 को एक 3 में बदल देता है) अंतिम 9 को उत्पन्न करने के लिए। यह गारंटी देता है कि कुल 72 होगा (क्योंकि प्रत्येक 3 में एक मिलान 5 होगा औसत प्रति छेद 4 और 4x18 = 72) होगा। यह तब बेतरतीब ढंग से परिणाम ({~?~@#)को बदल देता है ताकि यह सुनिश्चित हो सके कि हर संयोजन संभव है।

Comments

वास्तव में आप {3,5,4,4,4 उत्पन्न नहीं करेंगे ...} आप पूरे परिणाम को बेहतर बनाने से दूर हैं

— शाफ़्ट फ्रीक

@rachetfreak अच्छा बिंदु। मैं अब संपादित करूँगा।

— गारेथ

Answer 4

MS-DOS - 45 बाइट्स के तहत 16-बिट x86 मशीन कोड

Hexdump:

0E5F576A12595188ECE44088C3E44130D8240374F400C4AAE2EF595E80FC2475DFAC0432CD29B020CD29E2F5C3

Base64 कोडित बाइनरी:

Dl9XahJZUYjs5ECIw+RBMNgkA3T0AMSq4u9ZXoD8JHXfrAQyzSmwIM0p4vXD

कुछ टिप्पणियों के साथ वास्तविक स्रोत कोड:

 bits 16
 org 0x100

again:
 push cs               ; Save whatever CS we get.
 pop di                ; Use CS:DI as our course buffer..
 push di               ; Save for later use in the print loop
 push 18               ; We need 18 holes for our golf course.
 pop cx                ; ch = 0, cl = 18.
 push cx               ; Save for later use.
 mov ah, ch            ; Zero out ah.
generate_course:
 in al, 0x40           ; Port 0x40 is the 8253 PIT Counter 0.
 mov bl, al            ; Save the first "random" value in bl.
 in al, 0x41           ; Port 0x41 is the 8253 PIT Counter 1.
 xor al, bl            ; Add some more pseudo randomness.
 and al, 3             ; We only need the two lower bits.
 jz generate_course    ; If zero, re-generate a value, since we need only 3, 4, 5 holes.
 add ah, al            ; Sum in ah register.
 stosb                 ; Store in the course buffer.
 loop generate_course  ; Loop for 18 holes.
 pop cx                ; cx = 18.
 pop si                ; si = course buffer.
 cmp ah, 36            ; 72 holes?
 jne again             ; No, re-generate the whole course.

print:                 ; Yup, we have a nice course.
 lodsb                 ; Load the next hole.
 add al, '2'           ; Add ASCII '2' to get '3', '4' or '5'
 int 0x29              ; Undocumented MS-DOS print function.
 mov al, ' '           ; Print a space too for better readability.
 int 0x29              ; Print the character.
 loop print            ; Print the whole course.
 ret                   ; Return to the beginning of the PSP where a INT 0x20 happen to be.

nasm 18h.asm -o 18h.com32-बिट विंडोज संस्करण से MS-DOS (या Dosbox), या NTVDM के तहत संकलित करें और चलाएं।

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

4 5 4 5 4 5 3 4 3 4 3 4 4 5 4 3 5 3

Comments

लव असेंबलर ...

— woliveirajr

Answer 5

गणितज्ञ 71 68 66 60

टैली के सुझाव से 6 चार्ट बच गए।

RandomSample@RandomChoice@IntegerPartitions[72, {18}, {3, 4, 5}]

{5, 4, 3, 3, 5, 3, 5, 5, 3, 3, 4, 5, 3, 5, 4, 4, 5, 3}

सभी संभावित परिणाम संभव हैं, लेकिन वे समान रूप से संभव नहीं हैं।

---

विश्लेषण

IntegerPartitions[72, {18}, {3, 4, 5}]

3 के, 4 के और 5 के शामिल 18 तत्वों में 72 के सभी 10 संभावित विभाजन (संयोजन, क्रमपरिवर्तन नहीं) का उत्पादन करता है।

---

RandomChoice उन में से एक का चयन करता है।

RandomSample उस पसंद का एक क्रमचय लौटाता है।

Comments

हे, मैं लगभग लगभग एक ही उत्तर पोस्ट करने वाला था, केवल रैंडमइन्गेर के बजाय रैंडम चॉइस का उपयोग कर रहा था। मुझे लगता है कि आप ऐसा करके 4 और किरदारों को शेव कर सकते हैं।

— टैली

टैली, धन्यवाद। आपका सुझाव सहायक था।

— 19

Answer 6

आर - 41

x=0;while(sum(x)!=72)x=sample(3:5,18,T);x

# [1] 5 3 5 3 3 3 3 3 5 4 5 4 5 4 4 5 5 3

एल्गोरिथ्म @ sgrieve के समान है।

Comments

ऊपर @sgrieve के रूप में एक ही समस्या - 18 छेद में कुछ भी नहीं जाने से रोकता है।

— gt6989b

यह एक समस्या नहीं है, इस मामले में नमूना कमांड हमेशा 18 मान उत्पन्न करता है।

— sgrieve

Answer 7

गोल्फस्क्रिप्ट (26 वर्ण)

{;0{3rand.3+@@+(}18*])}do`

इल्मरी के समाधान के साथ कुछ स्पष्ट समानताएं हैं, लेकिन कुछ स्पष्ट अंतर भी हैं। विशेष रूप से, मैं इस तथ्य का फायदा उठा रहा हूं कि औसत बराबर 4 है।

Comments

लानत है, लेकिन यकीन है कि वहाँ लूप हालत के साथ एक चतुर चाल है। मैं {;0{3.rand+.@+}18*])72-}doखुद के साथ आया था , लेकिन यह पता नहीं लगा सका कि इसे वहां से कैसे कम किया जाए। +1।

— इल्मरी करोनें

Answer 8

अजगर on

कोड

from numpy.random import*;l=[]
while sum(l)!=72:l=randint(3,6,18)
print l

उत्पादन

[3 4 4 5 3 3 3 5 4 4 5 4 5 3 4 4 5 4]

आयात वास्तव में इस समाधान को मारता है। यह 3 और 5 के बीच 18 संख्याओं को उत्पन्न करने के लिए सुन्न का उपयोग करता है और सूची का योग 72 के बराबर होने तक सूचियां उत्पन्न करता रहता है।

Comments

18 छेद उत्पन्न करने से पहले कार्यक्रम को 72 कुँओं तक पहुँचने से क्या रोकता है? क्या यह 72 लंघन से रोकता है?

— डेविड सीपी

कोड हमेशा 18 छेद उत्पन्न करेगा, फिर जाँच करें कि योग 72 के बराबर है। उदाहरण के लिए, यदि 16 छेद 72 के बाद का योग है, तो यह अभी भी एक और 2 छेद पैदा करेगा, जिससे 72 के ऊपर योग धक्का और परीक्षण विफल हो जाएगा।

— sgrieve

Answer 9

GolfScript, 27 वर्ण

{;18{3.rand+}*].{+}*72-}do`

Sgrieve के पायथन समाधान के रूप में उसी अस्वीकृति नमूनाकरण विधि का उपयोग करता है। इस प्रकार, प्रत्येक वैध आउटपुट वास्तव में समान रूप से होने की संभावना है।

Answer 10

क्यू (25 अक्षर)

मूल (27)

while[72<>sum a:18?3 4 5];a

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

4 4 3 3 4 5 4 3 4 5 5 3 5 5 5 4 3 3

थोड़ा छोटा (25)

{72<>sum x}{x:18?3 4 5}/0

Answer 11

जावास्क्रिप्ट, 66 64 61 वर्ण

भारी रूप से TwoScoopsofPig (PHP) और जो टस्कन (JS) से प्रेरित है।

for(a=[s=0];s!=72;)for(s=i=0;i<18;s+=a[i++]=Math.random()*3+3|0);a

for(a=[s=0];s-72;)for(s=i=0;i<18;s+=a[i++]=Math.random()*3+3|0)a

for(a=s=[];s;)for(i=18,s=72;i;s-=a[--i]=Math.random()*3+3|0)a

Comments

s!=72s-72एक चार को बचाने के लिए किया जा सकता है। और अंतिम अर्ध-बृहदान्त्र ;aको किसी अन्य चर के लिए आवश्यक नहीं है।

— जो टस्कन

मैंने for(i=x;i;i--)पहले कभी नहीं देखा कि यह 2 चार्ट से बचाता है for(i=0;i<x;i++), धन्यवाद आदमी!

— गणित चिलर

Answer 12

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

from random import*
print sample(([3,5]*randint(0,9)+[4]*99)[:18],18)

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

यहाँ एक और है, sgrieve के समाधान के समान:

पायथन 2, 73 बाइट्स + समान संभावना

from random import*
a=[]
while sum(a)-72:a=sample([3,4,5]*18,18)
print a

Answer 13

जावास्क्रिप्ट, ११६ ९९ ६५ बाइट्स

for(i=0,h=[];i<18;)h[i++]=5;while(h.reduce(function(a,b){return a+b})!=72){i=Math.random()*18|0;h[i]=[3,4,4][i%3]}h;

h=[0];while(h.reduce(function(a,b){return a+b})-72)for(i=0;i<18;h[i++]=[3,4,5][Math.random()*3|0])h

while(i%18||(a=[i=s=0]),s+=a[i++]=Math.random()*3+3|0,s-72|i-18)a

Comments

जब मैं इसे क्रोम 21 में चलाता हूं, मुझे मिलता है i is not defined।

— मेलमोकब

Answer 14

पायथन, 128 120 116 वर्ण

import random,itertools
random.choice([g for g in itertools.product(*(range(3,6)for l in range(18))) if sum(g)==72])

import बयान अभी भी लंबाई हत्यारे हैं (23 अक्षर केवल नाम में 2 फ़ंक्शन आयात करने के लिए)

मुझे उम्मीद है कि आपको निकट भविष्य में परिणाम की आवश्यकता नहीं है, क्योंकि यह कोड पहले यादृच्छिक पर एक को चुनने से पहले सभी संभावित समाधानों का मूल्यांकन करता है। शायद इस समस्या का सबसे धीमा समाधान है।

मैं प्रत्येक विन्यास की समान संभावना के लिए अतिरिक्त यश का दावा करता हूं ...

Comments

import random,itertools

— ग्रेविटी

आप सही हैं, कि चीजों को थोड़ा छोटा करें।

— एड्रियन प्लिसन

अन्य टिप्स: import random as r,itertools as iतो का उपयोग rऔर iके बजाय randomऔर itertools। के 18*[0]बजाय का उपयोग करें range(18)और के [3,4,5,6]बजाय range(3,6):)

— एलेक्स एल

मैं अजगर 3 का उपयोग कर रहा हूं: एक सूची समझ एक जनरेटर है और इसकी कोई लंबाई नहीं है, जो choice()फ़ंक्शन के साथ इसके उपयोग को मना करता है। वह भी इस कोड को इतना धीमा बना देता है ...

— एड्रियन प्लिसन

ओह, क्षमा करें, मैंने सूची समझ और जनरेटर अभिव्यक्ति को गड़बड़ कर दिया (मैं आम तौर पर पुनरावृति के बेहतर प्रदर्शन के कारण जनरेटर अभिव्यक्ति के पक्ष में सूची की समझ से बचता हूं)। तो वास्तव में, यहां तक ​​कि python3 में मैं अभी भी कुछ पात्रों को हटा सकता हूं ... @ एलेक्स ने इसे सही किया।

— बजे एड्रियन प्लिसन

Answer 15

PHP - 77 शुल्क

<?while(array_sum($a)!=72){for($i=0;18>$i;){$a[++$i]=rand(3,5);}}print_r($a);

ज्यादातर sgrieve के समाधान की तरह, यह 18 छेदों की एक सूची बनाता है, कुल बराबर की जाँच करता है, और या तो इसे प्रिंट करता है या इसे अस्वीकार करता है और फिर से कोशिश करता है। अजीब तरह से पर्याप्त, हमारे दो समाधान समान लंबाई हैं।

गुस्से में, PHP नाम की किसी भी संक्षिप्तता के साथ सरणी कार्यों की पेशकश नहीं करता है। Array_sum और print_r मुझे मार रहे हैं। सुझाव का स्वागत करते हैं।

Comments

घुंघराले ब्रेसों की यहां आवश्यकता नहीं है, और राशि हो सकती है +=। <?while($s!=72)for($s=$i=0;18>$i;$s+=$a[++$i]=rand(3,5));print_r($a);

— ग्रैविटी

यह उपयोगी है - मैंने तर्क को लूप कॉल के लिए कभी नहीं सोचा था (और मुझे लगता है कि योग के लिए काउंटर नहीं बढ़ाना थोड़े गूंगा है)।

— TwoScoopsofPig

धन्यवाद - लेकिन यह वास्तव में मेरे लिए "घुंघराले ब्रेस की आवश्यकता नहीं" से क्या मतलब है; आप उन्हें मूल कोड में भी निकाल सकते थे:while(array_sum($a)!=72)for($i=0;18>$i;)$a[++$i]=rand(3,5);

— gravity

अच्छी तरह से सिवाय इसके कि मैं एक सख्त php.ini के खिलाफ दौड़ता हूं क्योंकि मैं काम पर गोल्फ कर रहा हूं; यह ब्रेसिज़ के लापता / बेमेल होने के बारे में कोई शिकायत नहीं करता है। आम तौर पर मैं होता।

— TwoScoopsofPig

अजीब है कि; 5.4_ E_ALL के साथ | E_STRICT कभी भी गुम होने {}की शिकायत नहीं करता है (क्योंकि PHP का सिंटैक्स स्पष्ट रूप से अनुमति देता है)।

— १ity:

Answer 16

रूबी 1.9 (62 वर्ण)

a=Array.new(18){[3,4,5].sample}until(a||[]).inject(:+)==72
p a

रेल (55 वर्ण)

में $ rails cआरईपीएल (किसी भी रेल फ़ोल्डर में):

a=Array.new(18){[3,4,5].sample}until(a||[]).sum==72
p a

नोट: यह रूबी 1.8 के साथ काम करता है, तो आप का उपयोग shuffle[0]करने के बजाय sample।

Comments

क्या आपको व्हाट्सएप की आवश्यकता है?

— कज़

@ काज आप सही हैं, इसकी जरूरत नहीं है। :) 62 वर्ण अब।

— js-coder

आप (1..18).map{rand(3)+3}यादृच्छिक सरणी प्राप्त करने के लिए उपयोग कर सकते हैं ;)

— महामारी

Answer 17

लिस्प ( 78 69 वर्ण)

(डू ((सी) (मैपकार (लैम्ब्डा (एक्स) (+ 3 (रैंडम ३))) (मेक-लिस्ट १ ())) ((= (+ लागू करें + )२) c२) c)

(do((c()(loop repeat 18 collect(+ 3(random 3)))))((=(apply'+ c)72)c))

यह sgrieve के पायथन समाधान के समान है।

N के रूप में c से शुरू करें, 72 की राशि की जाँच करें, c के लिए do"वेतन वृद्धि फ़ंक्शन" 3 और 5 के बीच 18 संख्याओं की एक सूची बनाता है, 72 के लिए फिर से जाँच करें, lather, कुल्ला, दोहराएँ।

यह देखने के लिए ताज़ा है doऔर loopअच्छी तरह से एक साथ गोल्फ खेलते हैं।

Answer 18

सी (123 वर्ण) - दक्षता पर प्रयास

डब्ल्यूसी के माध्यम से पाइप और यह 10 सेकंड के भीतर सभी 44152809 समाधान उत्पन्न करेगा ...

char s[19];g(d,t){int i;if(d--){for(i=51,t-=3;i<54;i++,t--)if(t>=3*d&&t<=5*d)s[d]=i,g(d,t);}else puts(s);}main(){g(18,72);}

ओह, ठीक है - प्रश्न को ठीक से नहीं पढ़ा - लेकिन हम सभी समाधान उत्पन्न कर रहे हैं तब समान संभावना वाले यादृच्छिक को चुनना एक स्क्रिप्टिंग अभ्यास है: पी।

Answer 19

क्लोजर - 55

(shuffle(mapcat #([[4 4][3 5]%](rand-int 2))(range 9)))

काफी मजेदार चाल .... इस समस्या की गणितीय संरचना का शोषण करती है कि 5 पार छेद के रूप में बिल्कुल 3 बराबर छेद होना चाहिए।

Answer 20

पायथन 83

import random as r;x=[]
while sum(x)!=72:x=[r.randint(3,5) for i in 18*[0]]
print x

जैसे sgrieve का घोल, लेकिन बिना खतना के

गोल्फिंग एड्रियन प्लिसन का समाधान: 120-> 108 वर्ण

import random as r,itertools as i
r.choice([g for g in i.product(*([3,4,5,6]for l in 18*[0]))if sum(g)==72])

MATLAB 53

x=[];
while sum(x)~=72
x=3+floor(rand(1,18)*3);
end
x

आउटपुट :

x = 4 3 4 4 4 4 5 4 4 3 4 4 3 5 5 4 5

Comments

अच्छा तरीका है, लेकिन आप 4 बाइट्स randi([3,5],1,18)3+floor(rand(1,18)*3)

— ब्रिंकज़

Answer 21

जावा (61 वर्ण)

while(s!=72)for(i=0,s=0;i<18;i++)s+=3+(int)(Math.random()*3);

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

5 4 3 4 5 3 4 4 3 5 4 4 4 4 3 4 4 5

Comments

मैं कोई जावा विशेषज्ञ नहीं हूं, लेकिन सिस्टम # प्रिंटलाइन (..) के लिए किसी प्रकार की घोषणा नहीं होनी चाहिए?

— hiergiltdiestfu

यह सिर्फ एक कोड स्निपेट है, एक कार्यक्रम नहीं है। और यह वास्तव में @JoeIbanez 'सी संस्करण की तरह दिखता है।

— फ्रांज डी।

Answer 22

सी (94 चार्ट)

int h[18],s=0,i;
while(s!=72)for(i=s=0;i<18;s+=h[i++]=rand()%3+3);
while(i)printf("%d ",h[--i]);

s=0पंक्ति 1 पर की आवश्यकता नहीं किया जा सकता है, क्योंकि संभावना है कि क्या कर रहे हैं एक गैर-आरंभिकृत पूर्णांक 72 के बराबर होगा? मैं सीधे सी। में असंवैधानिक मूल्यों को पढ़ना पसंद नहीं करता। इसके अलावा, यह संभवत: rand()फ़ंक्शन के लिए आवश्यक है।

उत्पादन

3 3 3 4 5 5 3 3 4 5 5 4 3 4 5 5 5 3 

Comments

तो मूल रूप से आप 18 नंबर के यादृच्छिक तार के माध्यम से लूप करने वाले हैं 3 से 5 तक जब तक कि एक समान 72 नहीं होता? अच्छी चीज की दक्षता अपेक्षित नहीं है।

— कीथ्स

@KeithS निष्पक्ष होना, कि इस सवाल का जवाब के बहुमत क्या कर रहे हैं।

— गेरेथ

Answer 23

बैश शेल स्क्रिप्ट (65 वर्ण)

shuf -e `for x in {0..8}
do echo $((r=RANDOM%3+3)) $((8-r))
done`

( सूफ GNU कोरुटिल्स पैकेज से आता है। इसके अलावा, धन्यवाद गैरेथ।)

Answer 24

C # (143 गैर-व्हाट्सएप):

()=>{
  var n=new Math.Random().Next(10);
  Enumerable.Range(1,18)
    .Select((x,i)=>i<n?3:i>=18-n?5:4)
    .OrderBy(x=>Guid.NewGuid())
    .ForEach(Console.Write);
}

Comments

new Guid()एक खाली GUID बनाता है। वास्तव में एक अद्वितीय GUID उत्पन्न करने के लिए आपको एक स्थिर विधि को कॉल करने की आवश्यकता है Guid.NewGuid।

— रॉटस्टर

और आपके पास दो ऑफ-बाय-वन त्रुटियां हैं (इसलिए बोलने के लिए): तुलनाएं i <n और i> = 18-n होनी चाहिए, अन्य तरीके से नहीं। और आप x + 1 के बजाय x और 1 के बजाय एक निरंतर 3 का उपयोग करके आकार को कम कर सकते हैं। और फिर आप Enumerable.Range द्वारा Enumerable.Repeat की जगह ले सकते हैं।

— मोरमगिल

संपादित; अभी भी 143

— चार्ट

नहीं है Math.Random, यह है System.Random।

— कोडइन्कॉस्टोस नोव

एक और C # दृष्टिकोण (143 वर्ण):var r=new Random();for(;;){var e=Enumerable.Range(1,18).Select(i=>r.Next(3,6)).ToList();if(e.Sum()==72){e.ForEach(i=>Console.Write(i));break;}}

— thepirat000

Answer 25

हास्केल, 104 102 98 चार्ट।

import System.Random
q l|sum l==72=print l|1>0=main
main=mapM(\_->randomRIO(3::Int,5))[1..18]>>=q

Comments

[1..n]>>[r]से थोड़ा छोटा है replicate n$r।

— counterclockwis चालू करने के लिए रह गए हैं

को भी बदल sequenceदिया mapM।

— रॉटसोर

Answer 26

पर्ल, 74

{@c=map{3+int rand 3}(0)x18;$s=0;$s+=$_ for@c;redo unless$s==72}print"@c"

दूसरा तरीका:

@q=((3,5)x($a=int rand 9),(4,4)x(9-$a));%t=map{(rand,$_)}(0..17);print"@q[@t{sort keys%t}]"

Answer 27

TXR (99 वर्ण)

@(bind g@(for((x(gen t(+ 3(rand 3))))y)(t)((pop x))(set y[x 0..18])(if(= [apply + y]72)(return y))))

यह अभिव्यक्ति 3 से 5 तक यादृच्छिक संख्याओं की एक अनंत आलसी सूची बनाती है:

(gen t (+ 3(rand 3)))  ;; t means true: while t is true, generate.

बाकी तर्क एक सरल लूप है जो यह जांचता है कि क्या इस सूची के पहले 18 तत्व 72 तक जोड़ते हैं। यदि नहीं, तो यह एक तत्व को बंद कर देता है और फिर से कोशिश करता है। forपाश एक अंतर्निहित बुलाया ब्लॉक शामिल हैं nilऔर इतने (return ...)पाश समाप्त कर देंगे और वापस जाने के मूल्य के लिए इस्तेमाल किया जा सकता है।

ध्यान दें कि 99 वर्ण की लंबाई में एक समाप्ति वाली नई पंक्ति शामिल है, जिसकी आवश्यकता है।

Comments

मैंने एक कमिट में रखा है जो (()) को प्रतिस्थापित करने की अनुमति देता है ()। :)

— कज़

Answer 28

एपीएल 12

4+{⍵,-⍵}?9⍴2

ध्यान दें कि मेरे पास इंडेक्स मूल 0 पर सेट है, जिसका अर्थ है कि ऐरे शुरू होता है। आप इसे इसके साथ सेट कर सकते हैं ⎕IO←0।

Comments

सवाल एक ऐसे कार्यक्रम को पूछता है जो हर संभव कॉन्फ़िगरेशन का उत्पादन कर सकता है। तुम्हारा सममित का उत्पादन कर सकते हैं। आप 555455555333333343 उदाहरण के लिए उत्पादन नहीं कर सकते, कम से कम मुझे ऐसा लगता है।

— मोरिस ज़ुक्का

Answer 29

आर, 42 बाइट्स

a=0;while(sum(a)-72)a=sample(3:5,18,r=T);a

sample, डिफ़ॉल्ट रूप से, संभव मानों के बीच समान रूप से आकर्षित करता है (यहां 3 4 5)। r=Tके लिए खड़ा है replace=TRUEऔर प्रतिस्थापन के साथ नमूना अनुमति देता है।

Answer 30

CJam, 17 14 बाइट्स

CJam इस चुनौती से नया है, लेकिन यह वैसे भी सबसे कम जवाब नहीं है, इसलिए यह वास्तव में मायने नहीं रखता है।

Z5]Amr*I4e]mrp

इसका परीक्षण यहां करें।

कुल 72 बनाए रखने के लिए, प्रत्येक 3के साथ जोड़ा जाना चाहिए 5। तो यहाँ है कि यह कैसे काम करता है:

Z5]            e# Push [3 5].
   Amr         e# Get a random number between 0 and 9.
      *        e# Repeat the [3 5] array that many times.
       I4e]    e# Pad the array to size 18 with 4s.
           mr  e# Shuffle the array.
             p e# Print it.