เกี่ยวกับซีรี่ส์

นี่คือรายการแขกสำหรับชุดกอล์ฟสุ่มของวัน

ก่อนอื่นคุณอาจปฏิบัติเช่นนี้กับการแข่งขันกอล์ฟอื่น ๆ และตอบคำถามโดยไม่ต้องกังวลเกี่ยวกับซีรี่ส์เลย อย่างไรก็ตามมีลีดเดอร์บอร์ดสำหรับทุกความท้าทาย คุณสามารถค้นหาลีดเดอร์พร้อมกับข้อมูลบางอย่างเพิ่มเติมเกี่ยวกับซีรีส์ในโพสต์แรก

อินพุต

ไม่มีการป้อนข้อมูล

เอาท์พุต

ตัวอักษรตัวเดียว (ตัวพิมพ์ใหญ่ - เล็ก) ไม่ขึ้นบรรทัดใหม่พร้อมตัวเลือกขึ้นบรรทัดใหม่ ตัวอักษรแต่ละตัวจะต้องมีความน่าจะเป็นที่ไม่ใช่ศูนย์ที่จะถูกเลือกและทุก 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>

โพสต์แรกของซีรีส์ยังสร้างกระดานผู้นำโดยรวม

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มต้นทุกคำตอบด้วยบรรทัดแรกโดยใช้เทมเพลต Markdown ต่อไปนี้:

## Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในบรรทัดแรกโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

(ภาษาไม่ปรากฏในปัจจุบัน แต่ตัวอย่างข้อมูลต้องการและแยกวิเคราะห์และฉันอาจเพิ่มกระดานผู้นำแบบแยกภาษาในอนาคต)

Pyth, 5

Os._G

ลองที่นี่

คำนวณส่วนนำหน้าของตัวอักษรดังนี้: ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. จากนั้นจึงทำให้รายการแบนและเลือกองค์ประกอบแบบสุ่มจากองค์ประกอบนั้นอย่างสม่ำเสมอ ซึ่งหมายความว่าตั้งแต่aปรากฏเป็น 26 ครั้งในขณะที่bปรากฏขึ้น 25 ครั้งตลอดจนถึงzลักษณะที่ปรากฏเพียง 1 ตัวอักษรแต่ละตัวมีโอกาสปรากฏที่แตกต่างกัน สตริงทั้งหมดมี 351 ตัวอักษร

MATL, 6 ตัวอักษร

1Y2Xr)

คำอธิบาย:

Xrใช้หมายเลขสุ่มแบบกระจายปกติ )ใช้สิ่งนี้เพื่อทำดัชนีลงใน ... 1Y2ตัวอักษร

การแจกแจงแบบสมมาตรประมาณ 0 และการแปลตัวเลขเป็นตัวอักษรแบบสมมาตรประมาณ 0.5 ความน่าจะเป็นดังกล่าวควรมีความชัดเจน

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%

ลองออนไลน์! .

เยลลี่ 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.

พื้นหลัง

Let L ₀ , ... , L ₂₅หมายถึงตัวอักษรของตัวอักษรในการสั่งซื้อธรรมชาติของพวกเขาและS ₀ , ... , S ₂₅สม่ำเสมอในการเปลี่ยนแปลงที่เลือกสุ่มของL กำหนดขอบเขตลำดับMโดยM _n = max (L _n , S _n )

แก้ไขnใน0 ... 25และกำหนดkเป็นดัชนีดังกล่าวว่าL _n = S k

ด้วยความน่าจะเป็น26/01 , L _n = S _nและn = kดังนั้นM _n = L _nและL _n occurrs ครั้งในM

ด้วยความน่าจะเป็น25/26 , L _n ≠ S _nและn ≠ k ในกรณีนี้สิ่งต่อไปนี้จะเกิดขึ้น

• ด้วยความน่าจะเป็นn / 25 , S _nเป็นหนึ่งในL ₀ , ... , L _{n - 1}ดังนั้นL _n > S _nและM _n = L n

• อิสระยังมีความน่าจะเป็นn / 25 , kเป็นหนึ่งใน0, ... n - 1ดังนั้นS _k > L _KและM _k = S _k = L n

ดังนั้นจำนวนที่คาดหวังของการเกิดขึ้นของL _nในMคือ1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1)

สุดท้ายถ้าตอนนี้เราเลือกระยะเมตรของMสม่ำเสมอที่สุ่มตัวอักษรL _nเราเลือกด้วยความน่าจะเป็น(2n + 1) / 26/26 = (2n + 1)

นี่จะให้การแจกแจงความน่าจะเป็นต่อไปนี้

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 ครั้ง (ใช้เวลาสองสามวินาที)

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 ครั้ง กราฟถูกสร้างขึ้นจากการรันใน Matlab:

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

Java 7, 62 57 56 ไบต์

5 ไบต์ขอบคุณ Poke

1 ไบต์ขอบคุณ trichoplax

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);}

ไอเดียมัน!

แผนภาพความถี่ (การวิ่ง 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: ***************************************************************************

Perl, 24 ไบต์

-4 ไบต์ขอบคุณ @Martin Ender
-1 ไบต์ขอบคุณ @Dom Hastings

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)

PHP, 44 36 29 27 ไบต์

^{ข้ามไป 44 ยังคงเป็นปกติ 44; (}

ขอบคุณที่แทรกชื่อผู้ใช้ที่นี่, Petah และ Crypto สำหรับความช่วยเหลือทั้งหมด

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

มันเลือกตัวเลขสุ่มระหว่าง 0 และ 675 (= 26 ² -1) ใช้เวลารากที่สองของมันและชั้นมัน ( chrฟังก์ชั่นแปลงอาร์กิวเมนต์เป็นจำนวนเต็ม) เนื่องจากสแควร์สมีช่วงเวลาต่างกันความน่าจะเป็นของแต่ละหมายเลขที่เลือกนั้นแตกต่างกัน เลือก n ทุกอันด้วยความน่าจะเป็น (2n + 1) / 676

เพิ่ม 65 ไปยังหมายเลขนี้จะช่วยให้คุณเป็นตัวละครที่สุ่มจากไปAZ

Ideone ของรหัสทำงาน 1,000,000 ครั้ง

R, 40 27 ไบต์

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

นี้จะนำ1ตัวเลขจาก26ตัวเลขที่สร้างการเจริญเติบโตที่มีความน่าจะเป็นที่มีต่อโดยไม่ต้องเปลี่ยนและแสดงตัวอักษรดัชนีซึ่งเป็นจำนวนนี้จากรายการของตัวอักษรตัวพิมพ์ใหญ่ZLETTERS

อาร์กิวเมนต์ของsampleฟังก์ชันคือ:

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

> <> , 14 ไบต์

lx
;>dd+%'A'+o

> <> เป็นภาษา 2D แบบ toroidal และความน่าจะเป็นที่แตกต่างกันเกิดขึ้นเนื่องจากการสุ่มของภาษาเพียงแหล่งเดียว ลองออนไลน์!

คำสั่งที่เกี่ยวข้องคือ:

[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

Python 2, 58 57 ไบต์

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

คำอธิบาย: สิ่งนี้จะสร้างเลขทศนิยมแบบสุ่มในช่วงเวลา[0, 676)นำสแควร์รูทแล้วทำการปูพื้น จากนั้นมันจะเพิ่ม 65 (ค่า ascii ของ "A") แปลงเป็นถ่านและพิมพ์

สิ่งนี้ทำให้แต่ละหมายเลขมีความน่าจะเป็นที่ชัดเจนตั้งแต่ 0 ถึง 25 เพื่อทำความเข้าใจว่าทำไมคิดอย่างไรเกี่ยวกับเรื่องนี้ มีตัวเลขกี่ตัวที่ไม่สนใจจำนวนเต็มเมื่อคุณหาสแควร์รูทและชั้นให้ 0 จะมีเพียงหนึ่งหมายเลขเท่านั้น (ศูนย์) 1/676ซึ่งหมายความว่าที่ศูนย์มีความน่าจะเป็นของ จะผลิตได้ 1 หมายเลข 3 ความประสงค์, 1, 2 และ 3 3/676ซึ่งหมายความว่าใครมีความน่าจะเป็นของ สามารถสร้างสองด้วย 4, 5, 6, 7, หรือ 8 โดยให้ความน่าจะเป็น 5, สามมีความน่าจะเป็น 7 เป็นต้นและเนื่องจากความแตกต่างระหว่างกำลังสองต่อเนื่องจะเพิ่มขึ้นอย่างต่อเนื่องสองรูปแบบนี้จะดำเนินต่อไปเรื่อย ๆ ถึง 25 (Z)

บันทึก 1 ไบต์ขอบคุณแม่ชีที่รั่ว!

PowerShell v2 +, 33 31 ไบต์

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

ใช้ช่วงตั้งแต่65ถึง90(เช่น ASCII AถึงZ) ไพพ์มันผ่านลูป การวนซ้ำแต่ละครั้งเราใช้เครื่องหมายคอมม่าเพื่อสร้างอาร์เรย์ขององค์ประกอบนั้นคูณด้วยจำนวนนั้น ตัวอย่างเช่นสิ่งนี้จะทำให้ 65 65s, 66 66s, 67 67s, ฯลฯ อาร์เรย์ขนาดใหญ่นั้นถูกไพพ์ไปGet-Randomซึ่ง (PRNG สม่ำเสมอ) จะเลือกองค์ประกอบหนึ่งอย่าง เนื่องจากมีปริมาณขององค์ประกอบแต่ละตัวที่แตกต่างกันอักขระแต่ละตัวจึงมีโอกาสในการเลือกเปอร์เซ็นต์ที่แตกต่างกันเล็กน้อย จากนั้นเราจะสรุปว่าใน parens charและโยนมันทิ้งเป็น ที่เหลืออยู่บนไปป์ไลน์และเอาท์พุทเป็นนัย

(ขอบคุณ@LeakyNunสำหรับการเล่นกอล์ฟสักสองสามไบต์ก่อนที่จะโพสต์: D)

ความน่าจะเป็น

(ปัดเศษเล็กน้อยเพื่อให้ฉันสามารถแสดงให้เห็นถึงทางPเลือกของ-fผู้ประกอบการ ormat)

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 %

CJam, 21 17 12 ไบต์

ขอบคุณ Martin Ender ที่ช่วยฉัน 5 ไบต์!

เวอร์ชั่นใหม่

'\,:,s_el-mR

นี้เป็นอาร์เรย์ของสตริงต่อไปนี้รูปแบบA, AB, ABCและอื่น ๆ มันแบนและเลือกตัวละครแบบสุ่ม เนื่องจากสตริงนี้มี 26 A, 25 B, 24 C และอื่น ๆ ตัวอักษรแต่ละตัวจึงมีความน่าจะเป็นที่จะถูกเลือกอย่างชัดเจน

ลองออนไลน์!

คำอธิบาย

'\,          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

R, 23 ไบต์

sample(LETTERS,1,,1:26)

เพียง 'ตัวอย่าง' จดหมายจากบิวอิน 1:26เป็นเวกเตอร์ของน้ำหนักให้ตัวอักษรแต่ละตัวน่าจะแตกต่างกัน

C, 35 ไบต์

โปรแกรมนี้สมมติว่าRAND_MAXเป็น (2 ^ 32/2) - 1 เนื่องจากเป็น gcc โดยค่าเริ่มต้น คอมไพล์ด้วย-lmแฟล็กเพื่อลิงก์sqrtฟังก์ชัน เอาต์พุตถูกเขียนไปยัง stdout เป็นตัวพิมพ์ใหญ่โดยไม่ขึ้นบรรทัดใหม่

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]จนถึงการหารและเพิ่ม 65 (ASCII A) ไปยังค่าเพื่อเปลี่ยนเป็นอักษร ASCII ก่อนที่จะส่งออก

[โปรแกรมที่สอง]

โปรแกรมที่สองมีความซับซ้อนมากกว่านี้เล็กน้อยเนื่องจากเป็นกลยุทธ์ที่คล้ายกัน แต่ไม่มีsqrtผู้ดำเนินการ เนื่องจากบิตเลขชี้กำลังของจุดลอยตัวจะถูกคำนวณโดยอัตโนมัติเมื่อกำหนดจำนวนเต็มจึงสามารถใช้เป็นวิธีที่มีประสิทธิภาพในการรับลอการิทึมฐาน 2 ของจำนวน

เนื่องจากเราต้องการให้ช่วงสูงRAND_MAXถึงค่า exponent ที่เข้ารหัสเป็น 25 การคำนวณ (2 ^ 32/2 - 1) / (2 ^ 25) ให้เราเพียงประมาณ 64 ซึ่งถูกใช้ระหว่างการหารของrandแผนที่ ในช่วงใหม่นี้ ฉันยังบวก 1 เข้ากับค่าเนื่องจากการแทนค่าจุดลอยตัวของ 0 นั้นค่อนข้างแปลกและจะทำให้อัลกอริทึมนี้พัง

จากนั้นการลอยจะถูกพิมพ์เป็นจำนวนเต็มเพื่ออนุญาตให้ทำการบิตบิทและการดำเนินการอื่น ๆ เนื่องจากใน IEEE 754 จำนวนจุดลอยตัวบิตเลขชี้กำลังเป็นบิต 30-23 จากนั้นตัวเลขจะเลื่อนไปทางขวา 23 บิตตัดแมนทิสซาและอนุญาตให้อ่านค่าเลขชี้กำลังเป็นจำนวนเต็ม โปรดทราบว่าเครื่องหมายบิตยังอยู่เหนือบิตเลขชี้กำลัง แต่เนื่องจากไม่มีเชิงลบใด ๆ จึงไม่จำเป็นต้องถูกปิดบัง

แทนที่จะเพิ่ม 65 ในผลลัพธ์นี้เหมือนที่เราทำมาก่อนอย่างไรก็ตามเลขชี้กำลังจุดลอยตัวจะแสดงเป็นจำนวนเต็ม 8 บิตที่ไม่ได้ลงนามจาก 0 ถึง 255 โดยที่ค่าเลขชี้กำลังเป็น 0 คือ 127 (เพียงลบ 127 เพื่อให้ได้ค่าเลขชี้กำลัง ) เนื่องจาก 127 - 65 คือ 62 เราเพียง แต่ลบ 62 เพื่อเลื่อนทั้งสองออกจากช่วงเลขชี้กำลังจุดลอยตัวนี้และเข้าสู่ช่วงตัวอักษร ASCII ทั้งหมดในการดำเนินการครั้งเดียว

การกระจาย

ฉันไม่ใช่ผู้เชี่ยวชาญด้านคณิตศาสตร์ดังนั้นฉันจึงไม่สามารถบอกได้ว่าสูตรที่แน่นอนสำหรับการแจกแจงเหล่านี้ แต่ฉันสามารถ (และทำ) ทดสอบค่าทุกค่าในช่วง[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

Python 2, 72 ไบต์

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

คูณอักขระด้วยค่า ascii จากนั้นเลือกหนึ่งอักขระโดยการสุ่มจากสตริงผลลัพธ์

นี่คือความน่าจะเป็นสำหรับจดหมายแต่ละฉบับที่ถูกเลือกเป็นเปอร์เซ็นต์:

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

เยลลี่ 5 ไบต์

ØAxJX

(คะแนนเท่ากัน แต่เป็นวิธีที่แตกต่างกันสำหรับโซลูชัน Jelly ที่มีอยู่โดย Dennis)

ความน่าจะเป็นที่จะยอมให้ตัวอักษรแต่ละตัวเป็นดัชนีที่ใช้ 1 ตัวอักษรหารด้วย 351 - หมายเลขสามเหลี่ยมที่ 26:

• P ( A) = 1/351, P ( B) = 2/351, ... , P ( 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 รัน (รหัสเครดิตแก่ Dennis)

q, 38 ไบต์

ไม่สั้นโดยเฉพาะ แต่ ...

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

ฟังก์ชันการแจกแจงสะสมแบบไม่ต่อเนื่องเป็นลำดับ

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

และเราแค่สุ่มตัวอย่างจากการกระจายตัว

JavaScript (ES6), 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>

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;

ยกเลิกแข็งแรงเล่นกอล์ฟ

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

TI-Basic, 39 ไบต์

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

rand สร้างค่าสม่ำเสมอใน (0,1] สิ่งนี้ให้ความน่าจะเป็นที่ต่างกัน 26 ^ แรนด์ที่จะเท่ากับจำนวนเต็มจาก 1 ถึง 26

รุ่นเก่า 45 ไบต์

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

ความแม่นยำที่ จำกัด ของเลขจำนวนเต็ม TI-Basic จำกัด การแจกแจงแบบปกติสำหรับการสร้างตัวเลขภายใน µ ±7.02σ (ดูrandNorm() ดังนั้นเราจึงได้ค่าสัมบูรณ์ของตัวเลขสุ่มด้วย µ 0 และσ 1 คูณด้วยสี่เพื่อเพิ่มช่วงการใช้งานจริงที่กล่าวถึงก่อนหน้าเป็น to ±28.08σ จากนั้นเรานำค่าและเพิ่ม 1 เนื่องจากsub(มีการจัดทำดัชนีไว้ 1 ชุดทำให้เรามีช่วงตั้งแต่ 1-29 ที่มีความน่าจะเป็นที่ต่างกัน

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 => 2.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%

Befunge, 168 164 ไบต์

กะทัดรัดกว่าครั้งแรกโดยมีความน่าจะเป็นที่ต่างกันเล็กน้อย: ครั้งแรก?มีโอกาส1/4ในการพิมพ์ A บน "ลองครั้งแรก" โอกาส2/4ที่จะกลับมาเหมือนเดิม?และ1/4เพื่อย้ายไปที่ ต่อไป. ส่วนที่เหลือของ?แต่ละคนมีโอกาส1/4ในการพิมพ์จดหมายที่อยู่ด้านล่าง1/4เพื่อลองอีกครั้ง1/4ย้ายไปที่จดหมายถัดไป1/4ย้ายไปที่ก่อนหน้า อีกครั้งน่าจะเป็นของการพิมพ์ต่อ A เป็นจำนวนมากสูงกว่าพิมพ์ซี

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

Befunge, 186 ไบต์

เห็นได้ชัดว่าจะไม่ชนะกับเรื่องนี้ แต่ฉันคิดว่ามันเป็นคำตอบที่น่าสนใจกระนั้น :)

vและ>เลื่อนเคอร์เซอร์ลงตามลำดับและไปทางขวา ?ผู้ประกอบการส่งออกเคอร์เซอร์ในหนึ่งในสี่ทิศทางแบบสุ่ม ครั้งแรก?คือ "บล็อก" โดยvและ>ในสองทิศทางดังนั้นจึงมีเพียงสองทางที่จะไป: ?ทั้งการพิมพ์หรือลงไปถัดไป ดังนั้นจากคนแรก?มีโอกาส 50% ที่จะพิมพ์ A

ถัดไป?มีโอกาส1/3ในการพิมพ์ B, 1/3ของการสำรองและ1/3ของการลงไปอีก ฯลฯ

มันค่อนข้างชัดเจนว่าตัวอักษรที่สูงกว่านั้นมีโอกาสที่จะถูกพิมพ์มากกว่าตัวอักษรตัวล่าง แต่ฉันไม่แน่ใจว่าตัวอักษรแต่ละตัวมีโอกาสเท่าไหร่

ความช่วยเหลือเกี่ยวกับคณิตศาสตร์ที่แน่นอนจะได้รับการชื่นชม :)

อย่างน้อยก็มีโอกาส1/2 * 1/3 ^ 25ที่เคอร์เซอร์เลื่อนไปจนถึง Z ในการลองครั้งแรก แต่ฉันไม่แน่ใจว่าโอกาสในการเลื่อนเคอร์เซอร์ขึ้นและลงมีผลกับตัวอักษรแต่ละตัวอย่างไร

,@ พิมพ์และออก

 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">,@

J, 20 18 ไบต์

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

ล่ามออนไลน์

ตัวพิมพ์ใหญ่

ความน่าจะเป็นของตัวอักษรแต่ละตัวนั้นคือดัชนี 1 ตัวในตัวอักษร

zsh, 63 ไบต์

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

มันทำงานได้โดยการสร้างสตริงนี้:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

aka 65 คูณ A, 66 คูณ B, 67 คูณ C ...

แล้วมันจะเลือกตัวละครแบบสุ่มในนั้น

CJam, 11 ไบต์

4.mrmqC*'A+

หรือ

676.mrmq'A+

ลองออนไลน์!

วิธีนี้คล้ายกับแนวคิดของ Luis และสร้างการกระจายแบบไม่สม่ำเสมอโดยการหาสแควร์รูทของตัวแปรสุ่ม

แบตช์ 116 ไบต์

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

ทำงานโดยการเลือกตัวแปรสุ่มสองตัวที่ใหญ่กว่าหรือเล็กกว่า (ฉันลืมว่า)

Matlab, 22

มักจะส่งคืนตัวอักษรตัวแรก แต่ในทางทฤษฎีสามารถสัมผัสได้ทั้งหมด!

ใช้เวลาหนึ่งแบ่งโดยตัวเลขสุ่ม จำกัด ไว้ที่ 26 และเปลี่ยนเป็นอักขระ

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

ไม่สั้นมากนัก แต่บางทีแนวคิดอาจเป็นแรงบันดาลใจให้กับคำตอบอื่น ๆ

CJam, 10 ไบต์

CJam เข้าใกล้ # 3 ...

26mr)mr'A+

ลองออนไลน์!

นี้จะสร้างตัวเลขสุ่มสม่ำเสมอxระหว่างวันที่ 1 และ 26 และจากนั้นจะใช้ในการสร้างตัวเลขสุ่มสม่ำเสมอระหว่าง0และที่จะถูกเพิ่มx-1 Aอคตินี้ส่งผลต่อตัวละครที่เล็กกว่า

เขาวงกต , 19 ไบต์

__v6%_65+.@
" )
"^2

ลองออนไลน์!

นี่คือลูปที่แต่ละการวนซ้ำก) เพิ่มตัวนับที่เริ่มต้นที่ศูนย์หรือ b) ยุติซึ่งทั้งสองมีความน่าจะเป็น 50% ในตอนท้ายของวงที่เคาน์เตอร์จะได้รับการโมดูโล 26 และเพิ่มถึง 65 เพื่อให้ตัวอักษรระหว่างและAZ

นี้จะช่วยให้ความน่าจะเป็นสำหรับAเพียงเล็กน้อยกว่า 50% Bเพียงเล็กน้อยกว่า 25% และอื่น ๆ ได้ถึงZเพียงเล็กน้อยกว่า 1/2 26 ในทางทฤษฎีมีความเป็นไปได้ของการดำเนินการนี้ตลอดไป แต่เหตุการณ์นี้มีความน่าจะเป็นศูนย์ตามที่กำหนดโดยการท้าทาย (ในทางปฏิบัติที่อาจเป็นไปไม่ได้อยู่แล้วเพราะ PRNG จะส่งคืน