दिन के यादृच्छिक गोल्फ # 7: एक विशिष्ट यादृच्छिक चरित्र

Question

श्रृंखला के बारे में

यह रैंडम गोल्फ ऑफ़ द डे श्रृंखला के लिए एक अतिथि प्रविष्टि है।

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

इनपुट

कोई इनपुट नहीं लिया गया है।

उत्पादन

एक वैकल्पिक अनुगामी न्यूलाइन के साथ वर्णमाला का एक अक्षर (मामला अप्रासंगिक)। प्रत्येक पत्र में चुने जाने की गैर-शून्य संभावना होनी चाहिए , और सभी 26 संभावनाएं अलग-अलग होनी चाहिए । सभी अस्पष्टता को दूर करने के लिए: विचलित का मतलब है कि दो संभावनाएं नहीं होनी चाहिए जो एक दूसरे के बराबर हैं।

स्कोरिंग

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

एक वैध प्रविष्टि एक पूर्ण कार्यक्रम या फ़ंक्शन है जिसमें शून्य समाप्ति की संभावना नहीं है।

वर्णमाला

भ्रम से बचने के लिए, उपयोग की जाने वाली विशेष वर्णमाला लैटिन वर्णमाला है:

भी

ABCDEFGHIJKLMNOPQRSTUVWXYZ

या

abcdefghijklmnopqrstuvwxyz

आप ऊपरी मामले या निचले मामले का उत्पादन करना चुन सकते हैं। वैकल्पिक रूप से, आप अलग-अलग मामलों को अलग-अलग रनों पर आउटपुट करने के लिए चुन सकते हैं यदि यह मदद करता है। किसी दिए गए पत्र की संभावना उस पत्र की संभावना है जो किसी भी स्थिति (ऊपरी या निचले) में दिखाई देता है।

व्याख्या

जैसा कि यह आउटपुट से बिल्कुल स्पष्ट नहीं होगा, कृपया स्पष्ट विवरण शामिल करें कि आपने 26 अलग-अलग संभावनाएं कैसे प्राप्त कीं।

लीडरबोर्ड

( यहां से )

var QUESTION_ID=89621,OVERRIDE_USER=20283;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

श्रृंखला की पहली पोस्ट एक समग्र लीडरबोर्ड भी बनाती है।

यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाए गए हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्केड टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

(भाषा को वर्तमान में नहीं दिखाया गया है, लेकिन स्निपेट की आवश्यकता होती है और इसे पार्स किया जाता है, और मैं भविष्य में एक उप-भाषा लीडरबोर्ड जोड़ सकता हूं।)

Comments

आप 26 अलग-अलग संभावनाओं को कैसे मापेंगे? 26 बार प्रोग्राम चलाकर?

— आप

@YOU के समाधान के माध्यम से एक नज़र है - उत्कृष्ट स्पष्टीकरण के साथ कुछ अलग तरीके हैं

— ट्राइकोप्लाक्स

यदि यह एक फ़ंक्शन है तो क्या इसे प्रिंट करने की आवश्यकता है या क्या यह केवल चरित्र मान लौटा सकता है?

— ज्यॉफ कॉमेडी

@Geoff इनपुट और आउटपुट के लिए हमारे डिफॉल्ट्स के अनुसार , या तो STDOUT में प्रिंटिंग या किसी कैरेक्टर को वापस करना ठीक है।

— ट्राइकोप्लाक्स

@Geoff ध्यान दें कि यह एक चरित्र होना चाहिए, न कि केवल इसका प्रतिनिधित्व करने वाला एक नंबर मूल्य। उदाहरण के लिए, Aबजाय 65।

— ट्राइकोप्लाक्स

Answer 1

अजगर, ५

Os._G

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

वर्णमाला के उपसर्गों की गणना करता है, इसलिए ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]:। फिर सूची को समतल करता है और समान रूप से एक यादृच्छिक तत्व का चयन करता है। इसका मतलब यह है कि चूंकि a26 बार दिखाई देता है, जबकि b25 बार दिखाई देता है, सभी तरह zसे केवल 1 उपस्थिति के साथ, प्रत्येक अक्षर को प्रदर्शित होने का एक अलग मौका है। कुल स्ट्रिंग में 351 वर्ण हैं।

Comments

मुझे वह जवाब पसंद है। बहुत चालाक।

— एलन फिशर

Answer 2

MATL, 6 वर्ण

1Y2Xr)

स्पष्टीकरण:

Xrसामान्य रूप से वितरित रैंडम संख्या लें। )इसे अनुक्रमित करने के लिए उपयोग करें ... 1Y2वर्णमाला

वितरण 0 के आसपास सममित है, और संख्या का अनुवाद लगभग 0.5 के सममित है। जैसे कि संभावनाएँ अलग होनी चाहिए।

Comments

ओह, एक गाऊसी वितरण का उपयोग करने के लिए बहुत अच्छा विचार है!

— लुइस मेंडो

नौकरी के लिए "सर्वश्रेष्ठ" भाषा, फिर भी जेली द्वारा पीटा गया। हालांकि उत्कृष्ट समाधान।

— सुकरात फीनिक्स

Answer 3

05AB1E , 6 बाइट्स

कोड

A.pJ.R

व्याख्या

A        # Pushes the alphabet
 .p      # Computes all prefixes
   J     # Join them together

अब हमारे पास निम्नलिखित स्ट्रिंग हैं:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

उसके बाद, हम एक यादृच्छिक तत्व का उपयोग करते हैं .R।

संभावनाएं

a > 7.4074074074074066%
b > 7.122507122507122%
c > 6.837606837606838%
d > 6.552706552706553%
e > 6.267806267806268%
f > 5.982905982905983%
g > 5.698005698005698%
h > 5.413105413105414%
i > 5.128205128205128%
j > 4.843304843304843%
k > 4.5584045584045585%
l > 4.273504273504274%
m > 3.988603988603989%
n > 3.7037037037037033%
o > 3.418803418803419%
p > 3.133903133903134%
q > 2.849002849002849%
r > 2.564102564102564%
s > 2.2792022792022792%
t > 1.9943019943019944%
u > 1.7094017094017095%
v > 1.4245014245014245%
w > 1.1396011396011396%
x > 0.8547008547008548%
y > 0.5698005698005698%
z > 0.2849002849002849%

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

Answer 4

जेली , 5 बाइट्स

ØA»ẊX

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

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

ØA«ẊX  Main link. No arguments.

ØA     Set argument and return value to the alphabet.
   Ẋ   Shuffle it.
  »    Yield the maximum of each letter in the sorted alphabet, and the
       corresponding character in the shuffled one.
    X  Pseudo-randomly select a letter of the resulting array.

पृष्ठभूमि

चलो एल ₀ , ..., एल ₂₅ को दर्शाता है उनके प्राकृतिक क्रम में वर्णमाला के अक्षरों, और एस ₀ , ..., एस ₂₅ के एक यादृच्छिक चयनित क्रमचय समान रूप में एल । परिमित अनुक्रम M को M _n = max (L _n , S _n ) द्वारा परिभाषित करें ।

N को 0,… 25 में ठीक करें और k को सूचकांक के रूप में परिभाषित करें जैसे कि L _n = S _k ।

संभावना के साथ 1/26 , एल _एन = एस _एन और एन = कश्मीर , तो एम _एन = एल _एन और एल _एन occurrs में एक बार एम ।

संभाव्यता के साथ 25/26 , L _n ability S _n और n 26 k । इस स्थिति में, निम्न होता है।

• संभावना के साथ n / 25 , एस _एन में से एक है एल ₀ , ..., एल _{n - 1} , इसलिए एल _एन > एस _एन और एम _एन = एल _एन ।

• स्वतंत्र रूप से, यह भी संभावना के साथ n / 25 , कश्मीर में से एक है 1 - 0, ... n हां, एस _{कश्मीर} > एल _{कश्मीर} और एम _{कश्मीर} = एस _{कश्मीर} = एल _एन ।

इस प्रकार, के उत्पन्न होने की उम्मीद नंबर एल _एन में एम है 1/26 + 25/26 · (एन / 25 + n / 25) = (2n + 1) / 26 ।

अंत में, यदि हम अब यादृच्छिक रूप से M के एक शब्द m का चयन करते हैं, तो L _{n को} हम प्रायिकता (2n + 1) / 26/26 = (2n + 1) / 676 के साथ चुना जाता है ।

इससे संभावनाओं का निम्नलिखित वितरण होता है।

p(m = A) =  1/676 ≈ 0.00148
p(m = B) =  3/676 ≈ 0.00444
p(m = C) =  5/676 ≈ 0.00740
p(m = D) =  7/676 ≈ 0.01036
p(m = E) =  9/676 ≈ 0.01331
p(m = F) = 11/676 ≈ 0.01627
p(m = G) = 13/676 ≈ 0.01923
p(m = H) = 15/676 ≈ 0.02219
p(m = I) = 17/676 ≈ 0.02515
p(m = J) = 19/676 ≈ 0.02811
p(m = K) = 21/676 ≈ 0.03107
p(m = L) = 23/676 ≈ 0.03402
p(m = M) = 25/676 ≈ 0.03698
p(m = N) = 27/676 ≈ 0.03994
p(m = O) = 29/676 ≈ 0.04290
p(m = P) = 31/676 ≈ 0.04586
p(m = Q) = 33/676 ≈ 0.04882
p(m = R) = 35/676 ≈ 0.05178
p(m = S) = 37/676 ≈ 0.05473
p(m = T) = 39/676 ≈ 0.05769
p(m = U) = 41/676 ≈ 0.06065
p(m = V) = 43/676 ≈ 0.06361
p(m = W) = 45/676 ≈ 0.06657
p(m = X) = 47/676 ≈ 0.06953
p(m = Y) = 49/676 ≈ 0.07249
p(m = Z) = 51/676 ≈ 0.07544

आप 100,000 बार लिंक को कॉल करके वितरण को सत्यापित कर सकते हैं (कुछ सेकंड लगते हैं)।

Comments

@RobertFraser फेरबदल और उपज कदम एक ए के साथ एक सूची का उत्पादन करता है कहीं भी एक ए या तो सूची में दिखाई दिया, एक बी जहां एक बी या तो सूची में दिखाई दिया और अन्य सूची में ए के अलावा कुछ भी नहीं है, ... एक जेड कहीं भी है कि जेड दोनों सूचियों में दिखाई दिया। इसलिए परिणाम में लगभग A के रूप में Z के रूप में लगभग 52x हैं।

— Sparr

@RobertFraser मैंने एक स्पष्टीकरण जोड़ा है।

— डेनिस

@DennisJaheruddin UTF-8 में, हाँ। हालांकि, जेली एक कस्टम कोड पेज का उपयोग करता है जो उन सभी वर्णों को कूटबद्ध करता है जिन्हें वह प्रत्येक बाइट के रूप में समझता है। बाइट्स यह करने के लिए शीर्ष लेख अंक में जोड़ देते हैं।

— डेनिस

मैं देखता हूं, जब मैंने स्पष्टीकरण पढ़ा तो यह तुरंत स्पष्ट नहीं था कि आप नियमित रूप से UTF-8 रेंज का लाभ नहीं उठा सकते हैं। इसलिए, क्या मुझे यह मान लेना सही है कि इंटरप्रेटर बदलकर और सभी पात्रों पर मानचित्रण करके आप सभी के लिए समान कोड (बस कम पठनीय / टाइप करने योग्य) होगा? - यदि हां, तो इस स्पष्टीकरण का विस्तार करने पर विचार करें कि गोल्फ प्रयोजनों के लिए एक चार बाइट के लिए गिनती होनी चाहिए।

— डेनिस जहरुद्दीन

@DennisJaheruddin जैसा कि README (हेडर में पहली कड़ी) में बताया गया है, दुभाषिया में दो मोड (जेली कोड पेज और UTF-8) हैं, इसलिए आप इस प्रोग्राम को वास्तविक 5-बाइट फ़ाइल में सहेज सकते हैं। मैं उस हर जानकारी को मेरे द्वारा लिखे गए हर उत्तर में जोड़ सकता था, लेकिन उनमें से सैकड़ों हैं, इसलिए मैंने इसके बजाय लिंक करना चुना।

— डेनिस

Answer 5

MATL , 10 बाइट्स

1Y2rU26*k)

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

कोड अंतराल (0,1) ( r) पर एक समान यादृच्छिक चर उत्पन्न करता है और इसके वर्ग ( U) की गणना करता है । यह गैर-समरूपता में घटती है, संभावना घनत्व में कमी। 26 से गुणा ( 26*) यह सुनिश्चित करता है कि परिणाम अंतराल (0,26) पर है, और नीचे ( k) को गोल करने से मानों में कमी के साथ 0,1, ..., 25 का उत्पादन होता है। मान का उपयोग एक सूचकांक ( )) के रूप में अपरकेस वर्णमाला ( 1Y2) में किया जाता है। चूंकि MATL 1-आधारित मॉड्यूलर अनुक्रमण का उपयोग करता है, 0 Z, 1 से A, 2 से B आदि से मेल खाता है।

एक दृष्टांत के रूप में कि संभावनाएँ अलग-अलग हैं, यहाँ एक असतत हिस्टोग्राम है, जिसके परिणामस्वरूप 1000000 यादृच्छिक अहसास होते हैं। मतलाब में इसे चलाकर ग्राफ का निर्माण किया जाता है:

bar(0:25, histc(floor(26*rand(1,1e6).^2), 0:25))

Comments

अच्छा! सबसे अच्छा समाधान मैं के साथ आ सकता है 16 बाइट्स

— DJMcMayhem

@DJMcMayhem अच्छा तरीका!

— लुइस मेंडो

हो सकता है, लेकिन बहुत लंबा। : पी

— DJMcMayhem

एक और मजेदार विकल्प: matl.suever.net/…

— Suever

वास्तव में आप की जरूरत नहीं है k! यह देखते हुए कि कोडगॉल्फ.स्टैकएक्सचेंज.com

— डेनिस जहरुद्दीन

Answer 6

जावा 7, 62 57 56 बाइट्स

5 बाइट्स पोक के लिए धन्यवाद।

ट्राइकोप्लेक्स के लिए 1 बाइट धन्यवाद।

char r(){return(char)(65+(int)Math.sqrt(Math.random()*676));}
char r(){return(char)(65+Math.sqrt(Math.random()*676));}
char r(){return(char)(65+Math.sqrt(Math.random())*26);}

Ideone यह!

फ्रिक्वेंसी डायग्राम (1e6 रन, स्केलिंग फैक्टर 1/1000)

A: *
B: ****
C: *******
D: **********
E: *************
F: ****************
G: *******************
H: **********************
I: *************************
J: ***************************
K: ******************************
L: **********************************
M: ************************************
N: ***************************************
O: *******************************************
P: *********************************************
Q: ************************************************
R: ***************************************************
S: ******************************************************
T: *********************************************************
U: ************************************************************
V: ***************************************************************
W: ******************************************************************
X: *********************************************************************
Y: ************************************************************************
Z: ***************************************************************************

Comments

मुझे नहीं लगता कि आपको int

— Poke

@ पोक धन्यवाद, गोल्फ।

— लीक

क्या आप कोष्ठकों के बाहर 676 को स्थानांतरित करके एक बाइट बचा सकते हैं?

— ट्राइकोप्लाक्स

@trichoplax का क्या मतलब है?

— लीक

sqrt(x*y*y) = sqrt(x)*y

— ट्राइकोप्लाक्स

Answer 7

पर्ल, 24 बाइट्स

-4 बाइट्स @Martin एंडर
-1 बाइट के लिए धन्यवाद @ डॉम हेस्टिंग्स को धन्यवाद

say+(A..Z)[rand rand 26]

जरूरत है -M5.010या -Eचलाने के लिए:

perl -E 'say+(A..Z)[rand rand 26]'

निम्नलिखित कोड चलाने से प्रत्येक अक्षर की घटना दिखाई देगी:

perl -MData::Printer -E '$h{(A..Z)[rand rand 26]}++ for 1 .. 1_000_000;$h{$_} = int($h{$_} / 100) / 100 for A .. Z;p %h;'
A 16.4
B 11.02
C 8.99
...
Z 0.07

यह कैसे काम करता है : मुझे लगता है कि कोड बहुत स्पष्ट है, लेकिन फिर भी: यह 0और के बीच एक यादृच्छिक संख्या चुनता है rand 26। तो वहाँ एक बहुत अधिक संभावना है कि संख्या 0(अक्षर A) के करीब हैं चुना जाता है।

Comments

स्पष्टीकरण मुझे समझ में आता है :)

— ट्राइकोप्लाक्स

अच्छा समाधान! आप एक नंगे सूची और + का उपयोग करके 1 बाइट बचा सकते हैं:say+(A..Z)[rand rand 26]

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

@DomHastings aarf, मैं बेवकूफ हूं। मैंने कोशिश की (A..Z)[...]और यह काम नहीं किया, इसलिए मैंने सोचा कि मैं एक अनाम सरणी का उपयोग कर सकता हूं, लेकिन यह सिर्फ इसलिए था say.. धन्यवाद! :)

— दादा

Answer 8

PHP, 44 36 29 27 बाइट्स

^{पार किया 44 अभी भी नियमित है 44 ;;}

सभी मदद के लिए सम्मिलित करने के लिए धन्यवाद, पेटा, और क्रिप्टो

<?=chr(65+rand(0,675)**.5);

यह 0 और 675 (= 26 ² -1) के बीच एक यादृच्छिक संख्या चुनता है , इसकी वर्गमूल लेता है, और इसे फर्श करता है ( chrफ़ंक्शन इसके तर्क को पूर्णांक में परिवर्तित करता है)। चूंकि वर्गों में उनके बीच अलग-अलग अंतराल हैं, इसलिए प्रत्येक संख्या को चुने जाने की संभावना अलग है। हर n को प्रायिकता (2n + 1) / 676 के साथ चुना जाता है।

इस संख्या में 65 जोड़ने से आपको एक यादृच्छिक चरित्र मिलता Aहै Z।

1,000,000 बार चलने वाले कोड का आइडोन

Comments

आप बंद गोल्फ कर सकते हैं 4 बाइट : range(A,Z)।

— सम्मिलित

@insertusernamehere: टिप के लिए धन्यवाद, लेकिन मैं बिल्कुल भी रेंज का उपयोग न करके और केवल उपयोग करके 8 बाइट्स करने में सक्षम था chr()।

— बिजनेस कैट

और भी बेहतर। दुर्भाग्य से ४४ को पार कर जाना अभी भी ४४ नियमित है । :)

— एक्सिस

@insertusernamehere आप बहुत आसानी से छोड़ देते हैं :-)<s>&nbsp;44&nbsp;</s>

— मंकीज़ेउस

<?=chr(65+sqrt(rand(0,675)));

— पेटा

Answer 9

आर, 40 27 बाइट्स

LETTERS[sample(26,1,,1:26)]

यह बढ़ती हुई संभावना के साथ उत्पन्न संख्याओं 1से 26संख्या Zलेगा, बिना प्रतिस्थापित किए, और एक अक्षर को प्रदर्शित करेगा जिसमें यह संख्या है, अपरकेस अक्षरों की सूची से LETTERS।

sampleफ़ंक्शन के तर्क हैं:

sample(
       26, #How many numbers to generate
        1, #How many numbers to sample
         , #Replacing ? Here, no by default
     1:26, #Weight of probabilities
       )

Comments

हाँ, यह काम नहीं करेगा। वहाँ मुझे एक चतुर रास्ता हो सकता है!

— फ्रैडरिक

खैर, हमेशा एक अस्तर होगा कहीं! होगा 'लगता है कि यह ...

— Frédéric

फिक्स्ड और छोटा - प्रभावशाली :)

— trichoplax

@trichoplax धन्यवाद! अच्छा चैलेंज btw!

— Frédéric

@AlbertMasclans: यह वास्तव में हो सकता है, लेकिन यह पहले से ही किसी और के जवाब में हो चुका है, इसलिए मैं "कॉपी" नहीं करना चाहता! लेकिन फिर भी धन्यवाद ! ;)

— फ्रेडेरिक

Answer 10

> <> , 14 बाइट्स

lx
;>dd+%'A'+o

> <> एक टॉरॉइडल 2 डी भाषा है, और भाषा के एकमात्र स्रोत यादृच्छिकता के कारण अलग-अलग संभावनाएं स्वाभाविक रूप से होती हैं। इसे ऑनलाइन आज़माएं!

प्रासंगिक आदेश हैं:

[Row 1]
l          Push length of stack
x          Change the instruction pointer direction to one of up/down/left/right
           This gives a 50/50 chance of continuing on the first row (moving
           left/right) or going to the next row (moving up/down, wrapping if up)

[Row 2]
>          Change IP direction to right
dd+%       Take top of stack mod 26 (dd+ = 13+13 = 26)
'A'+       Add 65
o          Output as character
;          Halt

इस प्रकार उत्पादन संभावनाएं हैं:

A:  1/2^1  + 1/2^27 + 1/2^53 + ... = 33554432 / 67108863 ~ 0.50000000745
B:  1/2^2  + 1/2^28 + 1/2^54 + ... = half of chance for A
C:  1/2^3  + 1/2^29 + 1/2^55 + ... = half of chance for B
...
Z:  1/2^26 + 1/2^52 + 1/2^78 + ... = half of chance for Y

Answer 11

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

from random import*
print chr(int(65+(random()*676)**.5))

स्पष्टीकरण: यह अंतराल में एक यादृच्छिक फ्लोटिंग पॉइंट नंबर उत्पन्न करता है [0, 676), वर्गमूल लेता है और फिर इसे फर्श करता है। फिर यह 65 ("ए" का एससीआई मूल्य) जोड़ता है, इसे एक चर में परिवर्तित करता है, और इसे प्रिंट करता है।

यह प्रत्येक संख्या को 0 से 25 तक एक अलग संभावना देता है। यह समझने के लिए कि, इसके बारे में इस तरह क्यों सोचें। गैर-पूर्णांकों को अनदेखा करते हुए, जब आप वर्गमूल और तल को 0 देते हैं, तो कितनी संख्या है? केवल एक संख्या होगी (शून्य)। इसका मतलब है कि शून्य की संभावना है 1/676। 1 की संख्या कितनी होगी? 3 होगा, 1, 2, और 3. इसका मतलब है कि एक की संभावना है 3/676। 4, 5, 6, 7, या 8 के साथ एक दो का उत्पादन किया जा सकता है, यह संभाव्यता 5, एक तीन में संभाव्यता 7, आदि देता है और चूंकि लगातार वर्गों के बीच का अंतर दो से लगातार बढ़ता है, यह पैटर्न हर संख्या के लिए जारी है। से 25 (Z)।

1 बाइट बची नन की बदौलत!

Comments

chr(int(65+randint(676)**.5))

— लीक

आप कर सकते थे chr(int(65+random()**.5*26))। यह समान रूप से एक ही चीज है क्योंकि 26 == .676। और अब संचालन का क्रम आपके पक्ष में है

— गेहूं जादूगर

@EamonOlive एक अन्य बाइट **2*26के लिए व्युत्क्रम वितरण के लिए इस्तेमाल किया जा सकता है।

— user81655

1/random()%26काम भी करना चाहिए।

— xnor

@xnor जो कभी-कभी 1/0% 26 देगा

— ट्राइकोप्लाक्स

Answer 12

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

[char](65..90|%{,$_*$_}|Random)

से एक सीमा लेता 65करने के लिए 90(यानी, ASCII Aकरने के लिए Z), एक पाश के माध्यम से पाइप यह। प्रत्येक पुनरावृत्ति, हम उस तत्व समय की संख्या बनाने के लिए अल्पविराम-संचालक का उपयोग करते हैं। उदाहरण के लिए, यह 65 65एस, 66 66एस, 67 67एस इत्यादि Get-Randomबनाएगा, जो कि बड़े सरणी को पाइप किया जाता है, जो (समान रूप से PRNG) एक तत्व का चयन करेगा। चूंकि प्रत्येक तत्व की अलग-अलग मात्रा होती है, इसलिए प्रत्येक पात्र को उठाया जाने का थोड़ा अलग प्रतिशत संभावना है। हम इसके बाद पार्सन्स में एनकैप्सुलेट करते हैं और इसे कास्ट करते हैं char। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

( पोस्ट किए जाने से पहले ही कुछ बाइट्स गोल्फिंग के लिए @LeakyNun को धन्यवाद ।: D)

---

संभावनाएं

(थोड़ा गोलाई ताकि मैं ऑर्माट ऑपरेटर Pका विकल्प प्रदर्शित कर -fसकूं)

PS C:\Tools\Scripts\golfing> 65..90|%{"$([char]$_): {0:P}"-f($_/2015)}
A: 3.23 %
B: 3.28 %
C: 3.33 %
D: 3.37 %
E: 3.42 %
F: 3.47 %
G: 3.52 %
H: 3.57 %
I: 3.62 %
J: 3.67 %
K: 3.72 %
L: 3.77 %
M: 3.82 %
N: 3.87 %
O: 3.92 %
P: 3.97 %
Q: 4.02 %
R: 4.07 %
S: 4.12 %
T: 4.17 %
U: 4.22 %
V: 4.27 %
W: 4.32 %
X: 4.37 %
Y: 4.42 %
Z: 4.47 %

Comments

मैंने बिना किसी उत्तर को देखे शुरू कर दिया; galआउटपुट पर निर्माण करने की कोशिश की ( [char[]]"uz$(gal|out-string)"-cmatch'[a-z]'|random) 50 वर्णों को मिला, फिर 48, संख्याओं पर स्विच किया गया और 42 प्राप्त किया, फिर 31 और वहीं रुक गया; लीडरबोर्ड पर देखा कि मुझे कहां रखा जाएगा। यहीं। चरित्र समान के लिए चरित्र। वेल्ड, मैं शायद इसे हरा नहीं सकता।

— TessellatingHeckler

Answer 13

सीजाम, 21 17 12 बाइट्स

मुझे 5 बाइट्स बचाने के लिए मार्टिन एंडर का धन्यवाद!

नया संस्करण

'\,:,s_el-mR

यह पैटर्न निम्नलिखित तार की एक सरणी का निर्माण करती है A, AB, ABC, और इतने पर। यह इसे समतल करता है और एक यादृच्छिक चरित्र चुनता है। चूंकि इस तार में 26 ए, 25 बी, 24 सी, और इसी तरह प्रत्येक अक्षर को चुने जाने की एक अलग संभावना है।

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

व्याख्या

'\,          e# Push the range of all characters up to 'Z'
   :,        e# For each one, take the range of all characters up to it
     s       e# Convert the array of ranges to one string
      _el-   e# Subtract the lower case version of the string from itself
             e# This leaves only capital letters in the string
          mR e# Take a random character from it

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

26,:)'[,'A,- .*M*mr0=

एक स्ट्रिंग बनाकर अलग-अलग संभावनाओं को प्राप्त करता है जिसमें प्रत्येक अक्षर वर्णमाला में अपनी स्थिति के बराबर कई बार दिखाई देता है।

26,:)                 e# Push 1, 2, ... 26
     '[,'A,-          e# Push 'A', 'B', ... 'Z'
             .*       e# Vectorize: repeat each letter the corresponding number of times
               M*     e# Join with no separator
                 mr   e# Shuffle the string
                   0= e# Get the first character

Answer 14

आर, 23 बाइट्स

sample(LETTERS,1,,1:26)

एक बिलिन से सिर्फ 'नमूने'। 1:26वजन प्रत्येक अक्षर के लिए एक अलग संभावना देने के एक वेक्टर है।

Comments

1:26प्रत्येक अक्षर के लिए वेट का एक वेक्टर है

— user5957401

यह इसका एक वैध उत्तर है। यह एक स्पष्टीकरण में संपादन के लायक है ताकि आर से परिचित लोग यह न समझ सकें कि यह कैसे काम करता है।

— ट्राइकोप्लाक्स

मैं जा रहा था, और तब मुझे एहसास हुआ कि मेरे ऊपर के व्यक्ति ने अपने कोड में बहुत कुछ किया था और गहराई से समझाने वाले में दिया था।

— 14:

यह अच्छा है कि आपने एक स्पष्टीकरण जोड़ा - जिस क्रम में पृष्ठ पर समाधान दिखाई देते हैं वह भिन्न हो सकते हैं क्योंकि वोट "ऊपर" आते हैं, बाद में ऊपर नहीं हो सकते हैं।

— Trichoplax

Answer 15

सी, 35 बाइट्स

यह प्रोग्राम मानता RAND_MAXहै (2 ^ 32/2) - 1 क्योंकि यह डिफ़ॉल्ट रूप से gcc पर है। फ़ंक्शन -lmको लिंक करने के लिए ध्वज के साथ संकलित करें sqrt। आउटपुट को नए अक्षरों को पीछे हटाए बिना बड़े अक्षरों के रूप में लिखा जाता है।

f(){putchar(sqrt(rand())/1783+65);}

वैकल्पिक रूप से, यदि RAND_MAX(2 ^ 16/2) - 1 है, तो 32 बाइट संस्करण का उपयोग किया जा सकता है:

f(){putchar(sqrt(rand())/7+65);}

बस मज़े के लिए, मैंने एक संस्करण भी बनाया जो sqrtफ़ंक्शन का उपयोग नहीं करता है या इसमें शामिल गणित पुस्तकालय की आवश्यकता होती है (यह एक के RAND_MAXरूप में होना चाहिए (2 ^ 32/2) - 1), लेकिन यह लंबे समय तक समाप्त हो रहा था, हालांकि मुझे लगा कि यह था बहुत अच्छा:

f(){float r=rand()/64+1;putchar((*(int*)&r>>23)-62);}

व्याख्या

[पहला कार्यक्रम]

पहले दो का उपयोग करते हुए sqrt, फ़ंक्शन केवल श्रेणी [0, RAND_MAX)को [0, 25]विभाजन के माध्यम से मैप करता है , और फिर Aआउटपुट करने से पहले ASCII वर्णमाला में इसे स्थानांतरित करने के लिए मूल्य में 65 (ASCII ) जोड़ता है।

[दूसरा कार्यक्रम]

दूसरा कार्यक्रम थोड़ा अधिक जटिल है क्योंकि यह एक समान रणनीति करता है, लेकिन sqrtऑपरेटर के बिना । चूँकि एक फ्लोटिंग पॉइंट के प्रतिपादक बिट्स को पूर्णांक निर्दिष्ट करने पर स्वचालित रूप से गणना की जाती है, उन्हें प्रभावी रूप से एक संख्या के आधार 2 लघुगणक को प्राप्त करने के लिए एक कच्चे रास्ते के रूप में उपयोग किया जा सकता है।

चूंकि हम केवल सीमा RAND_MAX25 तक एन्कोडेड एक्सपोनेंट मान तक पहुंचने के लिए चाहते हैं , गणना (2 ^ 32/2 - 1) / (2 ^ 25) हमें सिर्फ 64 के बारे में बताती है, जिसका उपयोग randइसे मैप करने के लिए विभाजन के दौरान किया जाता है। इस नई रेंज के लिए। मैंने 1 से मान को भी जोड़ा क्योंकि 0 का फ्लोटिंग पॉइंट प्रतिनिधित्व अजीब है और इस एल्गोरिदम को तोड़ देगा।

इसके बाद, फ़्लोट को एक पूर्णांक में बिटशिफ्टिंग और ऐसे अन्य कार्यों के लिए अनुमति देने के लिए टाइप किया जाता है। चूँकि IEEE 754 फ़्लोटिंग पॉइंट नंबरों में घातांक बिट्स 30-23 हैं, फिर संख्या को सही 23 बिट्स स्थानांतरित कर दिया जाता है, मेंटिसा को काट दिया जाता है और कच्चे घातांक मान को पूर्णांक के रूप में पढ़ा जा सकता है। ध्यान दें कि साइन बिट भी घातांक बिट्स से परे है, लेकिन चूंकि कभी कोई नकारात्मकता नहीं होती है इसलिए इसे बाहर निकालने की आवश्यकता नहीं होती है।

इस परिणाम में 65 जोड़ने के बजाय जैसे हमने पहले किया था, फ़्लोटिंग पॉइंट एक्सपोर्टर को 0 से 255 तक अहस्ताक्षरित 8 बिट पूर्णांक के रूप में दर्शाया गया है, जहाँ 0 का घातांक मान 127 है (वास्तविक "हस्ताक्षरित" प्रतिपादक मान प्राप्त करने के लिए केवल 127 को घटाएं) )। चूंकि 127 - 65 62 है, हम इसके बजाय 62 को घटाते हैं, दोनों इसे इस फ्लोटिंग पॉइंट एक्सपोनेंट रेंज से बाहर स्थानांतरित करते हैं और एएससीआईआई वर्णमाला रेंज में सभी एक ऑपरेशन में।

वितरण

मैं गणित विशेषज्ञ नहीं हूं, इसलिए मैं इन वितरणों के लिए सटीक सूत्र सुनिश्चित करने के लिए नहीं कह सकता, लेकिन मैं यह (और किया) रेंज के हर मूल्य का परीक्षण कर सकता हूं [0, RAND_MAX)कि यह दिखाने के लिए कि एक अक्षर की सीमा के बीच की दूरी और दूसरी शुरुआत कभी नहीं होती है वही। (इन परीक्षणों पर ध्यान दें (2 ^ 32/2) - 1) यादृच्छिक अधिकतम)

[पहला कार्यक्रम]

Letter - Starting Location
A - 0
B - 3179089
C - 12716356
D - 28611801
E - 50865424
F - 79477225
G - 114447204
H - 155775361
I - 203461696
J - 257506209
K - 317908900
L - 384669769
M - 457788816
N - 537266041
O - 623101444
P - 715295025
Q - 813846784
R - 918756721
S - 1030024836
T - 1147651129
U - 1271635600
V - 1401978249
W - 1538679076
X - 1681738081
Y - 1831155264
Z - 1986930625

[दूसरा कार्यक्रम]

Letter - Starting Location
A - 0
B - 64
C - 192
D - 448
E - 960
F - 1984
G - 4032
H - 8128
I - 16320
J - 32704
K - 65472
L - 131008
M - 262080
N - 524224
O - 1048512
P - 2097088
Q - 4194240
R - 8388544
S - 16777152
T - 33554368
U - 67108800
V - 134217664
W - 268435392
X - 536870848
Y - 1073741760
Z - 2147483520

Comments

क्या इसे मुद्रित करने की तुलना में केवल अध्यादेश वापस करना कम नहीं होगा? चूंकि charसी में एक अभिन्न प्रकार है, जो स्वीकार्य होना चाहिए।

— मेगो

@ ओह ओह अच्छी तरह से यदि आप ऐसा कर सकते हैं, तो मैं सिर्फ गोल्फ के लिए नया हूं इसलिए मैं स्वीकार्य उत्पादन से परिचित नहीं हूं।

— नींबू ड्रॉप

Answer 16

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

from random import*
print choice(''.join(i*chr(i)for i in range(65,91)))

चरित्र को उसके अस्सी मूल्य से गुणा करता है, फिर परिणामी स्ट्रिंग से यादृच्छिक पर एक चरित्र चुनता है।

यहां प्रत्येक पत्र के प्रतिशत में होने की संभावनाएं हैं:

A 3.23
B 3.28
C 3.33
D 3.37
E 3.42
F 3.47
G 3.52
H 3.57
I 3.62
J 3.67
K 3.72
L 3.77
M 3.82
N 3.87
O 3.92
P 3.97
Q 4.02
R 4.07
S 4.12
T 4.17
U 4.22
V 4.27
W 4.32
X 4.37
Y 4.42
Z 4.47

इसे आज़माएं: https://repl.it/Cm0x

Answer 17

जेली , 5 बाइट्स

ØAxJX

( डेनिस द्वारा एक मौजूदा जेली समाधान के लिए समान स्कोर, लेकिन एक अलग विधि ।)

प्रत्येक पत्र की पैदावार की संभावना यह 1-आधारित सूचकांक है जो वर्णमाला में 351 से विभाजित है - 26 वीं त्रिकोणीय संख्या:

• पी ( A) = 1/351, पी ( B) = 2/351, ..., पी ( Z) = 26/351।

चूँकि 1 + 2 + ... + 26 = 351, P (अक्षर) = 1।

कार्यान्वयन:

ØAxJX    - no input taken
ØA       - yield the alphabet: 'ABC...Z'
   J     - yield [1,...,len(Left)]: [1,2,3,...26]
  x      - Left times Right: 'abbccc...zzzzzzzzzzzzzzzzzzzzzzzzzz'
    X    - choose random element from Left

TryItOnline पर इसका परीक्षण करें या 100K रन का वितरण प्राप्त करें (डेनिस को कोड क्रेडिट)

Comments

आप जेली में कितना अच्छा बनना सीखेंगे? मुझे यह विश्वास करना कठिन है कि जेली पीपीसीजी के बाहर सामान्य ज्ञान होगा।

— Addison Crump

@ सिक्सर मैंने सिर्फ विकी को देखा और दूर भाग गया - अभी भी यह सब नहीं मिला :)

— जोनाथन एलन

ठीक है फिर। PPCG में आपका स्वागत है, एक वोट करें।

— Addison Crump

Answer 18

क्यू, 38 बाइट्स

विशेष रूप से कम नहीं लेकिन ...

.Q.A(reverse 0.9 xexp til 26)binr 1?1f

असतत संचयी वितरण फ़ंक्शन अनुक्रम है

0.9 ^ 26, 0.9 ^ 25, ..., 0.9 ^ 0

और हम वितरण से केवल नमूना लेते हैं।

Answer 19

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

_=>(n=Math.random(),10+n*n*26|0).toString(36)

यादृच्छिक मान को चुकता करके गैर-समान वितरण प्राप्त करता है। Math.random()सीमा का एक फ्लोट लौटाता है [0,1)इसलिए इस वर्ग का परिणाम 0(या a) की ओर जाता है ।

परीक्षा

var solution =

_=>(n=Math.random(),10+n*n*26|0).toString(36)

var frequency = Array(26).fill(0);
for (var i = 0, tests = 1000000; i < tests; i++)
  frequency[solution().charCodeAt(0) - 97]++;
result.textContent = frequency
  .map((n, i) => [ String.fromCharCode(97 + i), n ])
  .sort((a, b) => b[1] - a[1])
  .map((x) => `${x[0]}: ${(x[1] / tests * 100).toFixed(2)}%`)
  .join('\n');

<pre id="result"></pre>

Comments

42 बी,(n=Math.random(),10+26*n+n|0).toString(36)

— एपिलॉन डांटलर

Answer 20

Oracle SQL 11.2, 212 बाइट्स

वर्णमाला में वर्ण स्थिति का उपयोग संभाव्यता के रूप में करना

SELECT c FROM(SELECT dbms_random.value(0,351)v FROM DUAL),(SELECT c,e,LAG(e,1,0)OVER(ORDER BY c)s FROM(SELECT CHR(LEVEL+64)c,SUM(LEVEL)OVER(ORDER BY LEVEL)e FROM DUAL CONNECT BY LEVEL<27))WHERE v BETWEEN s AND e;

संयुक्त राष्ट्र के golfed

SELECT c FROM
  (SELECT dbms_random.value(0,351)v FROM DUAL), -- random value
  (
    SELECT c,e,LAG(e,1,0)OVER(ORDER BY c)s -- Mapping each character to its interval 
    FROM   (
             -- Each char has it's position in the alphabet as probability
             SELECT CHR(LEVEL+64)c,SUM(LEVEL)OVER(ORDER BY LEVEL)e 
             FROM   DUAL 
             CONNECT BY LEVEL<27
           )  
  )
WHERE v BETWEEN s AND e -- match the random value to an interval

Answer 21

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

sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",int(26^rand),1

rand (0,1] में एक समान मूल्य उत्पन्न करता है। यह 26 ^ को 1 से 26 तक पूर्णांक के बराबर होने की एक अलग संभावना देता है।

पुराने संस्करण, 45 बाइट्स

sub("ABCDEFGHIJKLMNOPQRSTUVWXYZAAA",1+int(4abs(invNorm(rand))),1

टीआई-बेसिक पूर्णांकों की सीमित शुद्धता सामान्य वितरण को ± σ 7.02σ (देखें randNorm() के भीतर संख्या उत्पन्न करने के लिए सीमित करती है । इसलिए हमें σ σ 28.08 multip से पहले बताई गई व्यावहारिक सीमा को बढ़ाने के लिए यादृच्छिक संख्या का पूर्ण मान σ 0 और random 1 के साथ मिलता है, जो कि चार से गुणा होता है। फिर, हम मान को जोड़ते हैं और 1 को जोड़ते हैं, क्योंकि sub(1-अनुक्रमित है, हमें प्रत्येक की विभिन्न संभावनाओं के साथ 1-29 से एक सीमा देता है।

Comments

@trichoplax यह मेरी गलती थी, मेरे पास पुराने संस्करण से 30 बचे थे [0,29]। मैंने अब इसे ठीक कर दिया।

— टाइमटेक

अंतराल (0,1) माना जाता है [0,1)।

— kamoroso94

@ kamoroso94 क्या आपने जाँच की है? "नोट: यादृच्छिक संख्या उत्पन्न एल्गोरिथ्म की बारीकियों के कारण, उत्पन्न करने के लिए संभव छोटी संख्या 0. से थोड़ी अधिक है। सबसे बड़ी संख्या संभव है वास्तव में 1" - tibasicdev.wikidot.com/rand

— टाइमटेक

Answer 22

PHP, 92 84 बाइट्स

for($i=65,$x=0;$i<91;$a.=str_repeat(chr($i++),$x))$x++;echo substr($a,rand(0,$x),1);

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

बाइट्स शेविंग के लिए सम्मिलित करने के लिए धन्यवाद

परिणाम संभाव्यताएं (% द्वारा आदेशित)

A => 0.29%
B => 0.62%
C => 0.82%
D => 1.15%
E => 1.50%
F => 1.65%
G => 2.00%
H => 2.27%
I => 2.52%
J => +80%
K => 3.13%
L => 3.47%
M => 3.72%
N => 3.93%
O => 4.15%
P => 4.59%
Q => 4.81%
R => 5.17%
S => 5.44%
T = 5.68%
U => 6.06%
V => 6.13%
W => 6.60%
X => 6.95%
Y => 7.17%
Z => 7.38%

Comments

वास्तव में नियमों का पालन करने के लिए बदल दिया है। मेरी गलती

— gabe3886

@insertusernamehere मुझे अपरिभाषित चर नोटिस मिलता है जब मैं उसे चलाता हूं और कोई पत्र आउटपुट नहीं होता है

— gabe3886

ओह मुझे खेद है। मुझे लगता है कि मुझे हटा दिया गया और हटा दिया गया $x=0जो स्पष्ट रूप से आवश्यक है। यहाँ एक 84 बाइट्स संस्करण है: for($i=65,$x=0;$i<91;$a.=str_repeat(chr($i++),$x))$x++;echo substr($a,rand(0,$x),1);क्या आपने कभी Gअपना कोड चलाते समय अधिक मूल्य प्राप्त करने का प्रबंधन किया था ? वैसे भी, आप हमेशा noticeगोल्फ को नजरअंदाज कर सकते हैं ।

— आवेषण

मैंने किया था, लेकिन फसल होने में थोड़ा समय लगता है। मैंने इसे 100k पुनरावृत्तियों के माध्यम से जांचने के लिए

— चलाया

strlenकी $a351 है, लेकिन आप केवल पहले से बाहर एक यादृच्छिक चरित्र उठा रहे हैं $x(26) वर्ण। आप इसे ठीक करने और अंतिम का एक परिवर्तन के साथ अपनी संभावनाओं रख सकते $xकरने के लिए 350+1 बाइट के लिए। यहाँ एक 77 बाइट संस्करण है जो समस्या को ठीक करता है लेकिन संभावनाओं को एक साथ बहुत करीब लाता है:for($i=65;$i<91;$a.=str_repeat(chr($i),$i++));echo substr($a,rand(0,2014),1);

— जो।

Answer 23

Befunge, 168 164 बाइट्स

पहले वाले की तुलना में अधिक कॉम्पैक्ट, थोड़ी अलग संभावनाओं के साथ: पहले के ?पास "पहले प्रयास" पर ए छापने का 1/4 मौका है , उसी पर वापस आने के लिए 2/4 मौका है ?, और 1/4 को स्थानांतरित करने के लिए। आगे। के बाकी ?है प्रत्येक 1/4 उन्हें नीचे पत्र मुद्रण का मौका, 1/4 , फिर से कोशिश करने 1/4 अगले अक्षर चलती, 1/4 पिछले करने के लिए घूम रहा है। फिर, ए की छपाई की संभावना एक जेड मुद्रण की तुलना में बहुत अधिक है।

??????????????????????????>
""""""""""""""""""""""""""
ABCDEFGHIJKLMNOPQRSTUVWXYZ
""""""""""""""""""""""""""
>>>>>>>>>>>>>>>>>>>>>>>>>>,@
##########################

बेगुंज, 186 बाइट्स

जाहिर है कि इससे जीतने वाला नहीं है, लेकिन मुझे लगता है कि यह एक दिलचस्प जवाब है फिर भी :)

vऔर >कर्सर को क्रमशः नीचे और दाईं ओर रखता है। ?ऑपरेटर बेतरतीब ढंग से चारों दिशाओं में से एक में बंद कर्सर भेजता है। पहले ?से "अवरुद्ध" है vऔर >, दो दिशाओं में तो यह केवल दो रास्ते जाने के लिए है: या तो या अगले करने के लिए नीचे एक मुद्रित करने के लिए, ?। तो पहले ?अकेले से ए को छापने का 50% मौका है।

अगले ?एक है 1/3 एक बी, मुद्रण की संभावना 1/3 जाने का बैक अप, और 1/3 और नीचे जाने का। आदि आदि।

यह बिल्कुल स्पष्ट होना चाहिए कि उच्च अक्षरों में निचले लोगों की तुलना में मुद्रित होने की बहुत बड़ी संभावना है, लेकिन मुझे बिल्कुल यकीन नहीं है कि प्रत्येक अक्षर के मौके क्या हैं।

सटीक गणित के साथ कुछ मदद की सराहना की जाएगी :)

कम से कम एक 1/2 * 1/3 ^ 25 मौका है कि कर्सर पहले प्रयास में जेड तक नीचे की ओर बढ़ता है, लेकिन मैं अनिश्चित हूं कि कर्सर के ऊपर और नीचे जाने की संभावना प्रत्येक अक्षर को कैसे प्रभावित करती है।

,@ प्रिंट और quits।

 v
>?"A"v
>?"B"v
>?"C"v
>?"D"v
>?"E"v
>?"F"v
>?"G"v
>?"H"v
>?"I"v
>?"J"v
>?"K"v
>?"L"v
>?"M"v
>?"N"v
>?"O"v
>?"P"v
>?"Q"v
>?"R"v
>?"S"v
>?"T"v
>?"U"v
>?"V"v
>?"W"v
>?"X"v
>?"Y"v
>?"Z">,@

Answer 24

जे, 20 18 बाइट्स

(? {~ @ #) यू: 64 + # ~ 1 + i.26
(? {~ @ #) यू: 64 + # ~ i.27

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

अपरकेस।

प्रत्येक अक्षर की संभावना वर्णमाला में इसका 1-आधारित सूचकांक है।

Answer 25

zsh, 63 बाइट्स

for i in {A..Z};for j in {1..$[#i]};s+=$i;echo $s[RANDOM%$#s+1]

यह स्ट्रिंग बनाकर काम करता है:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

उर्फ 65 बार ए, 66 बार बी, 67 बार सी ...

और फिर इसमें एक यादृच्छिक चरित्र चुनता है

Comments

आप 65 में क्यों शुरू करेंगे?

— gcampbell

@gcampbell 65 असिसी Aमें है। आप 1 से शुरू कर सकते हैं, लेकिन फिर आंतरिक लूप बन जाता है, {65..$[#i]}जो 1 char लंबा है

— izabera

Answer 26

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

4.mrmqC*'A+

या

676.mrmq'A+

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

यह समाधान लुइस के विचार के समान है और यादृच्छिक चर के वर्गमूल को ले कर एक गैर-समान वितरण बनाता है।

Answer 27

बैच, 116 बाइट्स

@set/ar=%random%%%676,s=r/26,r%%=26,s-=(r-s)*(r-s^>^>31)
@set a=ABCDEFGHIJKLMNOPQRSTUVWXYZ
@call echo %%a:~%s%,1%%

दो यादृच्छिक चर के बड़े या छोटे (मैं भूल जाता हूं) को उठाकर काम करता है।

Answer 28

मतलूब, २२

अक्सर प्रारंभिक पत्र लौटाएंगे, लेकिन सैद्धांतिक रूप से उन सभी को छू सकते हैं!

एक यादृच्छिक संख्या के आधार पर एक को ले जाता है, इसे 26 तक सीमित करता है और इसे एक चरित्र में बदल देता है।

['' 96+min(1/rand,26)]

निश्चित रूप से बहुत कम नहीं, लेकिन शायद अवधारणा अन्य उत्तरों को प्रेरित कर सकती है।

Comments

क्या randमान 0 [, 1) में वापस आता है? यानी शून्य सहित, लेकिन एक भी शामिल नहीं है। यदि यह कभी-कभी 1/0 में परिणाम देता है, तब min(1/0,26)भी 26 या कोई त्रुटि होगी?

— ट्राइकोप्लाक्स

जहाँ तक मुझे पता है कि randएक मान (0,1) में लौटा है, इसलिए कोई समस्या नहीं होनी चाहिए

— paul.oderso

@trichoplax भले ही आप randअभ्यास में 0 नहीं देखेंगे , min(1/0,26)वास्तव में 26 रिटर्न करते हैं।

— डेनिस जहरुद्दीन

उस मामले में, अच्छा समाधान :)

— trichoplax

Answer 29

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

CJam दृष्टिकोण # 3 ...

26mr)mr'A+

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

यह x1 और 26 के बीच एक समान यादृच्छिक संख्या बनाता है और फिर उपयोग करता है कि बीच में एक समान यादृच्छिक संख्या बनाने के लिए 0और x-1जो जोड़ा जाता है A। इस पूर्वाग्रह का परिणाम छोटे पात्रों की ओर होता है।

Answer 30

भूलभुलैया , 19 बाइट्स

__v6%_65+.@
" )
"^2

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

यह एक लूप है जो प्रत्येक पुनरावृत्ति पर, या तो) एक काउंटर को बढ़ाता है जो शून्य या बी पर शुरू होता है) समाप्त होता है, दोनों संभावना 50% के साथ। लूप के अंत में, काउंटर को मोडुलो 26 लिया जाता है और 65 के बीच Aऔर एक अक्षर देने के लिए जोड़ा जाता है और Z।

यह A50% से अधिक के लिए एक संभाव्यता देता है , Bबस 25% से थोड़ा अधिक और इसी तरह Z1/2 ²⁶ से थोड़ा अधिक तक । सिद्धांत रूप में, हमेशा के लिए इस चलने की संभावना है, लेकिन इस घटना में संभावना के रूप में संभावना शून्य है (व्यवहार में यह संभवतः वैसे भी संभव नहीं है क्योंकि PRNG अपनी अवधि में कुछ बिंदु पर दोनों संभावित परिणाम लौटाएगा)।