"I" के पास "i" होने का मौका है

Question

एक यादृच्छिक संख्या जनरेटर डिज़ाइन करें जहां i th संख्या में सभी 0 के लिए होने की% संभावना है I <i <14. 14. 0 होने की संभावना बिल्कुल 9% होनी चाहिए। जनरेटर के लिए बीज प्रणाली समय होना चाहिए। आप यादृच्छिक संख्या पीढ़ी के लिए पूर्व-परिभाषित फ़ंक्शन का उपयोग नहीं कर सकते।

मूल रूप से 1 में होने का 1% मौका है, 2 में 2% मौका है और इसी तरह 13 तक होने का 13% मौका है। यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

Comments

अन्य 9% संभावना के बारे में क्या?

— लीजियनममाल 978

@ LegionMammal978 मैंने पहले ही निर्दिष्ट कर दिया है। इसे

— भूत

हाँ, अब ठीक है। पहले क्या समस्या थी?

— १२:१२ पर भूत_न_थे_कोड

@ghosts_in_the_code <असमानता >से और उद्धरण ब्लॉक से एक HTML टैग बना रहे थे।

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

सेकंड का एक संकल्प ठीक है?

— xnor

Answer 1

CJam, 14 बाइट्स

E,_T9t\]ze~es=

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

व्याख्या

E,   e# Push [0 1 2 ... 12 13].
_    e# Make a copy.
T9t\ e# Set the first element to 9. Swap with the original range.
]z   e# Wrap them in an array and transpose to get [[9 0] [1 1] [2 2] ... [13 13].
e~   e# Run-length decode to get `[0 0 0 0 0 0 0 0 0 1 2 2 3 3 3 ... 13 13 ... 13 13].
es=  e# Use the current timestamp as a cyclic index into this array.

Comments

उम्म, क्यों नहीं mR?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र "जनरेटर के लिए बीज प्रणाली का समय होना चाहिए। आप यादृच्छिक संख्या पीढ़ी के लिए पूर्व-परिभाषित फ़ंक्शन का उपयोग नहीं कर सकते हैं।"

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

आह, वह हिस्सा छूट गया।

— ऑप्टिमाइज़र

Answer 2

अजगर 2, 54

import time
print((time.time()*1e4%800+1)**.5+1)//2%14

अभिव्यक्ति f(t) = ((8*t+1)**.5+1)//2अंतराल को मैप करके एक समान वितरण को त्रिकोणीय पूर्णांक वितरण में बदल देती है

[0,1)  --> 1
[1,3)  --> 2
[3,6)  --> 3
[6,10) --> 4
...

हम उस समय के मिलीसेकंड अंकों को 0 से 100 तक एक समान फ्लोट में बदल देते हैं time.time()*1e4%100। दरअसल, हम %800रूपांतरण चरण में 8 से गुणा करने के लिए करते हैं । अंत में, 14 को 0 करके परिवर्तित किया जाता है %14।

Answer 3

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

@+mZ9smRd14.d8

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

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

Answer 4

दिल्लोग एपीएल , 20 बाइट्स

⊃(⌊.1×⊃⌽⎕TS)↓(/⍨⍳13)

⍳13पूर्णांकों 1 13 यद्यपि
(/⍨... )अपने आप में दोहराने, जैसे /⍨3है 3 3 3और /⍨2 3है 2 2 3 3 3
n↓ ... ड्रॉप n तत्वों (पत्ते खाली सूची अगर n > सूची की लंबाई)
⎕TSप्रणाली समय स्टाम्प 2015 11 1 13 28 56 834 जैसे
⊃⌽पिछले तत्व, यानी वर्तमान मिलीसेकंड 0-999
⌊.1×गुणा 0.1 के साथ और
⊃पहला तत्व नीचे , 0 देता है यदि डेटा खाली है

Answer 5

प्रसंस्करण 3, 65 55 74 बाइट्स

long i=0,c=8,r=System.nanoTime()%100;for(;r>c;i++,c+=i);print(i);

0 से 99 (समावेशी) से एक यादृच्छिक संख्या प्राप्त करें। यदि संख्या 0-8 है, तो 0 प्रिंट करें, यदि यह 9 प्रिंट 1 है, यदि 10-11 प्रिंट 2, यदि 12-14 प्रिंट 3, आदि ...

किसी ने इस पर ध्यान नहीं दिया, लेकिन पुराने कोड के साथ समस्या यह है कि मिलिस () जितनी बार आवेदन चला रहा है, उतनी राशि लौटाता है, जो प्रोग्राम के बाद के रनों पर बहुत समान संख्या देता है। कम से कम अब हम नैनो परिशुद्धता है!

Answer 6

PHP, 50 बाइट्स

<?for($t=microtime()*100;0<=$t-=++$i;)?><?=$i%14;

• microtime"0.04993000 1446409253" जैसे स्ट्रिंग के रूप में समय लौटाता है, जब मैं इसे 100 से गुणा करता हूं, तो PHP स्ट्रिंग को 0.04993000 में परिणत करता है, परिणाम 4.993000। तो $tएक "यादृच्छिक" संख्या के साथ आरंभिक है[0,100)
• हम 1, 2, 3, ... को $t0 तक पहुंचने तक घटाते हैं
• परिणाम अंतिम घटाया संख्या, modulo 14 है

Comments

आप वास्तव में लिख सकते हैं ;echoके बजाय ?><?=, एक ही बाइट गिनती के लिए। लेकिन अच्छी तरह से किया!

— इस्माइल मिगुएल

Answer 7

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

सीधे आगे:

import time;print(sum([[i]*i for i in range(1,14)],[0]*9)[int(str(time.time())[-2:])])

Answer 8

जे - 28 चार

यह एक मूर्ख था।

{:({:1e3*6!:0'')$100{.#~i.14

6!:0''Y M D h m sएक 6-आइटम सूची के रूप में वर्तमान समय है, जहां मिलीसेकंड को सेकंड पर भिन्न के रूप में दर्शाया जाता है - उन पर प्राप्त करने के लिए, हमारे पास सेकंड ( {:) को गुणा करने के अलावा कोई विकल्प नहीं है 1e3। इस बीच, #~i.14तेरह 13 के माध्यम से शून्य 0s, एक 1, दो 2s, और इसी तरह की एक सूची है, और हम 100 आइटमों के साथ बाहर पैड करते हैं 100{.।

J में चक्रीय अनुक्रमण नहीं है, इसलिए बड़ी सूची अनुक्रमण करने से पहले मिलीसेकंड मोदुलो 100 लेना लुभावना हो सकता है। हालांकि, हम का उपयोग करके दो अक्षर बचा सकता है $बजाय करने के लिए चक्रीय का विस्तार हालांकि कई मिलीसेकेंड हम (0 से कहीं भी करने के लिए 100 आइटम सूची 60,999 ) और अंतिम प्रविष्टि तो ले लो।

ऐसा नहीं है कि एक 60000 तत्व सूची में पूरी तरह से उपयोग की गई मेमोरी या कुछ भी है, यह सिर्फ ओवरकिल की तरह लगता है: पी

Answer 9

जावास्क्रिप्ट (ईएस 6) 116

यह एक सरल वरीयता प्राप्त RNG का एक अनुकूलन है जो मैंने जावास्क्रिप्ट के मानक RNG के बजाय उपयोग किया है जिसे सीड नहीं किया जा सकता (और इसलिए रिपीटेबल नहीं है)

R=(s=~new Date,p=[],i=0,j=9)=>{
while(p.push(i)<100)--j?0:j=++i;
return _=>(s=(1+Math.sin(s))*1e5,p[100*(s-~~s)|0])
};

// test

var rnd=R()

t=[0,0,0,0,0,0,0,0,0,0,0,0,0,0];
rgb='000,444,666,888,aaa,ddd,f0f,ff0,0ff,0ff,0f0,00f,f00,fff'.split`,`
.map(v=>(v=parseInt(v,16),[(v&15)*17,(v>>4&15)*17,(v>>8)*17]))

cnt=400*300
//for (i=0;i<cnt;i++)t[rnd()]++;

ctx = C.getContext("2d");
img=ctx.getImageData(0, 0, 400, 300)
for(p=0,y=0;y<300;y++)for(x=0;x<400;x++)
  v=rnd(),t[v]++,
  img.data[p++]=rgb[v][0],img.data[p++]=rgb[v][1],
  img.data[p++]=rgb[v][2],img.data[p++]=255
ctx.putImageData(img, 0, 0)

o=''
for(i=0;i<14;i++)
  t[i]/=cnt, o+=`<p><i>${i}</i><b style="width:${t[i]*300}%">,</b>${(t[i]*100).toFixed(2)}%</p>`;
G.innerHTML=o

#G { width: 400px; font-size: 12px; border: 1px solid #000;  }
p { margin: 0}
b { display: inline-block; font-size:80%; background: #08c; margin: 2px }
i { display: inline-block; width: 20px; text-align: right; padding: 0 4px }
#C { width: 400px; height: 300px; }

<div id=G></div>
<canvas id=C></canvas>

Comments

मैं वास्तव में प्यार करता हूं कि आप कैसे साबित करते हैं कि लौटा हुआ मूल्य वास्तव में आवश्यकताओं के करीब है। अच्छी तरह से किया! +10 उस कैनवास पर!

— इस्माइल मिगुएल

Answer 10

टीआई-बेसिक, 18 बाइट्स

real(int(.5+2√(-4+50fPart(sub(getTime

100fPart(sub(getTime0 और 99 के बीच यादृच्छिक अवशेष प्राप्त करता है। (n-1) वें त्रिकोणीय संख्या के बराबर है (N^2+N)/2, इसलिए व्युत्क्रम के बराबर है √(2y+1)-.5। 9 से नीचे की ओर समायोजित करने के बाद इसे फर्श करें, और हमारे पास परिणाम है

एकमात्र समस्या यह है कि 8 से कम अवशेषों के लिए, हम एक काल्पनिक वर्गमूल प्राप्त करते हैं। इसलिए हम प्रोग्राम आउटपुट 0 के बजाय वास्तविक भाग लेते हैं।

Answer 11

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

50 बाइट्स + 1 के -Eबदले -e:

@_=(0)x 9;push@_,($_)x$_ for 0..13;say$_[time%100]