Tentang Seri

Ini adalah entri tamu untuk seri Golf Acak Hari ini.

Pertama, Anda dapat memperlakukan ini seperti tantangan golf kode lainnya, dan menjawabnya tanpa khawatir tentang seri sama sekali. Namun, ada papan peringkat di semua tantangan. Anda dapat menemukan papan peringkat bersama dengan beberapa informasi lebih lanjut tentang seri di posting pertama .

Memasukkan

Tidak ada input yang diambil.

Keluaran

Satu huruf alfabet (huruf tidak relevan), dengan baris tambahan opsional. Setiap huruf harus memiliki probabilitas bukan nol untuk dipilih, dan ke-26 probabilitas harus berbeda . Untuk menghapus semua ambiguitas: Perbedaan berarti bahwa tidak boleh ada dua probabilitas yang sama satu sama lain.

Mencetak gol

Ini kode golf. Kode terpendek dalam byte menang.

Entri yang valid adalah program atau fungsi lengkap yang memiliki probabilitas nol untuk tidak berakhir.

Alfabet

Untuk menghindari kebingungan, alfabet tertentu yang digunakan adalah alfabet Latin:

Antara

ABCDEFGHIJKLMNOPQRSTUVWXYZ

atau

abcdefghijklmnopqrstuvwxyz

Anda dapat memilih untuk menampilkan huruf besar atau kecil. Sebagai alternatif, Anda dapat memilih untuk menampilkan kasing yang berbeda pada run yang berbeda jika itu membantu. Probabilitas untuk huruf tertentu adalah probabilitas huruf itu muncul dalam kedua kasus (atas atau bawah).

Penjelasan

Karena tidak akan terlihat jelas dari output, harap sertakan penjelasan yang jelas tentang bagaimana Anda mencapai 26 probabilitas yang berbeda.

Papan peringkat

(dari sini )

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>

Posting pertama dari seri ini juga menghasilkan leaderboard keseluruhan.

Untuk memastikan jawaban Anda muncul, mulailah setiap jawaban dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Misalnya:

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

(Bahasa saat ini tidak ditampilkan, tetapi cuplikan memang membutuhkan dan menguraikannya, dan saya dapat menambahkan leaderboard berdasarkan bahasa di masa mendatang.)

Pyth, 5

Os._G

Coba di sini

Menghitung awalan abjad, sehingga: ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Kemudian ratakan daftar dan pilih elemen acak dari itu secara seragam. Ini berarti bahwa sejak amuncul 26 kali, sementara bmuncul 25 kali, semuanya zdengan hanya 1 penampilan, setiap huruf memiliki peluang berbeda untuk muncul. Total string memiliki 351 karakter.

MATL, 6 Karakter

1Y2Xr)

Penjelasan:

XrAmbil nomor acak yang didistribusikan secara normal )Gunakan ini untuk mengindeks ke ... 1Y2Alfabet

Distribusi simetris sekitar 0, dan terjemahan angka ke char simetris sekitar 0,5. Dengan demikian probabilitasnya harus berbeda.

05AB1E , 6 byte

Kode

A.pJ.R

Penjelasan

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

Kami sekarang memiliki string berikut:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Setelah itu, kami memilih elemen acak menggunakan .R.

Peluangnya

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%

Cobalah online! .

Jelly , 5 byte

ØA»ẊX

Cobalah online!

Bagaimana itu bekerja

Ø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.

Latar Belakang

Biarkan L ₀ , ..., L ₂₅ menunjukkan huruf-huruf alfabet dalam rangka alami mereka, dan S ₀ , ..., S ₂₅ yang seragam di permutasi yang dipilih secara acak dari L . Tentukan urutan berhingga M oleh M _n = maks (L _n , S _n ) .

Perbaiki n dalam 0, ... 25 dan tentukan k sebagai indeks sehingga L _n = S _k .

Dengan probabilitas 1/26 , L _n = S _n dan n = k , sehingga M _n = L _n dan L _n occurrs sekali dalam M .

Dengan probabilitas 25/26 , L _n ≠ S _n dan n ≠ k . Dalam hal ini, berikut ini terjadi.

• Dengan probabilitas n / 25 , S _n adalah salah satu dari L ₀ , ..., L _{n - 1} , jadi L _n > S _n dan M _n = L _n .

• Secara independen, juga dengan probabilitas n / 25 , k adalah salah satu dari 0, ... n - 1 , jadi S _k > L _k dan M _k = S _k = L _n .

Dengan demikian, jumlah kejadian yang diharapkan dari L _n di M adalah 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 .

Akhirnya, jika kita sekarang memilih istilah m dari M secara seragam secara acak, huruf L _n kita dipilih dengan probabilitas (2n + 1) / 26/26 = (2n + 1) / 676 .

Ini menghasilkan distribusi probabilitas berikut.

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

Anda dapat secara empiris memverifikasi distribusi dengan menelepon tautan 100.000 kali (butuh beberapa detik).

MATL , 10 byte

1Y2rU26*k)

Cobalah online!

Kode menghasilkan variabel acak seragam pada interval (0,1) ( r) dan menghitung kuadratnya ( U). Ini menghasilkan kepadatan probabilitas yang tidak seragam dan menurun. Mengalikan dengan 26 ( 26*) memastikan bahwa hasilnya ada pada interval (0,26), dan pembulatan ke bawah ( k) menghasilkan nilai 0,1, ..., 25 dengan penurunan probabilitas. Nilai ini digunakan sebagai indeks ( )) ke dalam huruf besar ( 1Y2). Karena MATL menggunakan pengindeksan modular berbasis 1, 0 berkorespondensi dengan Z, 1 ke A, 2 ke B dll.

Sebagai ilustrasi bahwa probabilitasnya berbeda, inilah histogram diskrit yang dihasilkan dari 10.00000 realisasi acak. Grafik diproduksi dengan menjalankan ini di Matlab:

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

Java 7, 62 57 56 byte

5 byte berkat Poke.

1 byte berkat 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);}

Ide itu!

Diagram frekuensi (berjalan 1e6, faktor penskalaan 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 byte

-4 byte terima kasih kepada @Martin Ender
-1 byte terima kasih kepada @Dom Hastings

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

Perlu -M5.010atau -Euntuk dijalankan:

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

Menjalankan kode berikut akan menunjukkan kemunculan setiap huruf:

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

Cara kerjanya : Saya kira kode ini cukup eksplisit, tetapi tetap: ia memilih nomor acak antara 0dan rand 26. Jadi ada kemungkinan yang jauh lebih tinggi bahwa angka yang dekat dengan 0(huruf A) dipilih.

PHP, 44 36 29 27 byte

^{Dicoret 44 masih teratur 44; (}

Terima kasih untuk menyisipkan nama pengguna di sini, Petah, dan Crypto untuk semua bantuannya

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

Ia memilih angka acak antara 0 dan 675 (= 26 ² -1), mengambil akar kuadratnya, dan menempatkannya ( chrfungsi mengubah argumennya menjadi bilangan bulat). Karena kuadrat memiliki interval yang berbeda di antara mereka, probabilitas setiap nomor yang dipilih berbeda. Setiap n dipilih dengan probabilitas (2n + 1) / 676.

Menambahkan 65 ke nomor ini memberi Anda karakter acak dari Ahingga Z.

Gagasan kode dijalankan 1.000.000 kali

R, 40 27 byte

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

Ini akan mengambil 1angka dari 26angka-angka yang dihasilkan dengan probabilitas yang semakin besar menuju Z, tanpa mengganti, dan menampilkan huruf yang indeksnya adalah angka ini, dari daftar huruf besar LETTERS.

Argumen samplefungsi adalah:

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

> <> , 14 byte

lx
;>dd+%'A'+o

> <> adalah bahasa 2D toroidal, dan bagian probabilitas yang berbeda secara alami terjadi karena satu-satunya sumber keacakan dari bahasa tersebut. Cobalah online!

Perintah yang relevan adalah:

[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

Dengan demikian probabilitas output adalah:

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 byte

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

Penjelasan: ini menghasilkan angka floating point acak dalam interval [0, 676), mengambil akar kuadrat dan kemudian lantai itu. Kemudian ia menambahkan 65 (nilai ascii dari "A"), mengubahnya menjadi char, dan mencetaknya.

Ini memberikan setiap angka dari 0 hingga 25 probabilitas yang berbeda. Untuk memahami mengapa, pikirkan seperti ini. Berapa banyak angka, mengabaikan non-bilangan bulat, ketika Anda mengambil akar kuadrat dan lantai memberi 0? Hanya satu angka yang akan (nol). Ini berarti nol memiliki probabilitas 1/676. Berapa angka yang akan menghasilkan 1? 3 akan, 1, 2, dan 3. Ini berarti seseorang memiliki probabilitas 3/676. Dua dapat diproduksi dengan 4, 5, 6, 7, atau 8, memberikan probabilitas 5, tiga memiliki probabilitas 7, dll. Dan karena perbedaan antara kuadrat berurutan meningkat terus dengan dua, pola ini berlanjut untuk setiap angka ke atas hingga 25 (Z).

1 byte disimpan berkat biarawati bocor!

PowerShell v2 +, 33 31 byte

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

Mengambil rentang dari 65ke 90(yaitu, ASCII Ake Z), menyalurkannya melalui loop. Setiap iterasi, kami menggunakan operator koma untuk membuat larik elemen tersebut dikali angka tersebut. Sebagai contoh, ini akan menghasilkan 65 65s, 66 66s, 67 67s, dll. Array besar itu disalurkan ke Get-Randommana (secara seragam PRNG) akan memilih satu elemen. Karena ada jumlah yang berbeda dari setiap elemen, setiap karakter memiliki peluang persentase yang sedikit berbeda untuk dipilih. Kami kemudian merangkum bahwa dalam parens dan melemparkannya sebagai char. Yang tersisa pada pipa dan output tersirat.

(Terima kasih kepada @LeakyNun untuk bermain golf beberapa byte bahkan sebelum diposting.: D)

Peluangnya

(sedikit pembulatan sehingga saya bisa menunjukkan Popsi dari -foperator 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 byte

Terima kasih kepada Martin Ender karena telah menyelamatkan saya 5 byte!

Versi baru

'\,:,s_el-mR

Ini membentuk sebuah array dari string mengikuti pola A, AB, ABC, dan sebagainya. Ini mendatar dan memilih karakter acak. Karena string ini mengandung 26 A, 25 B, 24 C, dan seterusnya, setiap huruf memiliki kemungkinan berbeda untuk dipilih.

Cobalah online!

Penjelasan

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

Versi lama

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

Mendapat probabilitas berbeda dengan membuat string di mana setiap huruf muncul beberapa kali sama dengan posisinya dalam alfabet.

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 byte

sample(LETTERS,1,,1:26)

Hanya 'sampel' surat dari builtin. yang 1:26merupakan vektor bobot memberikan setiap huruf probabilitas yang berbeda.

C, 35 byte

Program ini mengasumsikan RAND_MAXadalah (2 ^ 32/2) - 1 karena pada gcc secara default. Kompilasi dengan -lmbendera untuk menautkan sqrtfungsi. Output ditulis ke stdout sebagai huruf kapital tanpa tertinggal baris baru.

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

Secara opsional, jika RAND_MAX(2 ^ 16/2) - 1, versi 32 byte yang lebih pendek dapat digunakan:

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

Hanya untuk bersenang-senang, saya juga membuat versi yang tidak menggunakan sqrtfungsi atau memerlukan perpustakaan matematika yang disertakan (yang ini harus memiliki RAND_MAX(2 ^ 32/2) - 1), tetapi akhirnya menjadi lebih lama meskipun saya pikir itu adalah cukup keren:

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

Penjelasan

[Program Pertama]

Untuk dua yang pertama menggunakan sqrt, fungsi hanya peta kisaran [0, RAND_MAX)untuk [0, 25]melalui divisi, dan kemudian menambahkan 65 (ASCII A) untuk nilai bergeser ke dalam alfabet ASCII sebelum keluaran itu.

[Program Kedua]

Program kedua sedikit lebih rumit karena melakukan strategi yang sama, tetapi tanpa sqrtoperator. Karena bit eksponen floating point dihitung secara otomatis setelah menetapkan bilangan bulat, mereka dapat secara efektif digunakan sebagai cara kasar untuk mendapatkan logaritma basis 2 dari angka.

Karena kita hanya ingin rentang hingga RAND_MAXmencapai nilai eksponen yang dikodekan dari 25, perhitungan (2 ^ 32/2 - 1) / (2 ^ 25) memberi kita hanya sekitar 64, yang digunakan selama pembagian randuntuk memetakannya ke rentang baru ini. Saya juga menambahkan 1 ke nilai karena representasi floating point 0 agak aneh dan akan merusak algoritma ini.

Selanjutnya, float diketik dengan tipe integer untuk memungkinkan bithifting dan operasi lainnya. Karena dalam angka floating point IEEE 754 bit eksponen adalah bit 30-23, angka tersebut kemudian bergeser ke kanan 23 bit, memotong mantissa dan membiarkan nilai eksponen mentah dibaca sebagai integer. Perhatikan bahwa bit tanda juga di luar bit eksponen, tetapi karena tidak pernah ada negatif itu tidak harus ditutup.

Daripada menambahkan 65 ke hasil ini seperti yang kami lakukan sebelumnya, eksponen floating point direpresentasikan sebagai integer 8 bit yang tidak ditandatangani dari 0 hingga 255, di mana nilai eksponen 0 adalah 127 (Cukup kurangi 127 untuk mendapatkan nilai eksponen "ditandatangani" yang sebenarnya ). Karena 127 - 65 adalah 62, kami hanya mengurangi 62 untuk menggesernya keluar dari rentang eksponen titik mengambang ini dan ke dalam rentang alfabet ASCII semuanya dalam satu operasi.

Distribusi

Saya bukan ahli matematika jadi saya tidak bisa mengatakan dengan pasti rumus yang tepat untuk distribusi ini, tetapi saya dapat (dan memang) menguji setiap nilai pada rentang [0, RAND_MAX)untuk menunjukkan bahwa jarak antara di mana rentang satu huruf berakhir dan yang lainnya dimulai tidak pernah menjadi sama. (Perhatikan tes ini menganggap (2 ^ 32/2) - 1) maksimum acak)

[Program Pertama]

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

[Program Kedua]

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 byte

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

Mengalikan karakter dengan nilai ascii-nya, lalu mengambil satu karakter secara acak dari string yang dihasilkan.

Berikut adalah probabilitas untuk setiap huruf yang dipilih, dalam persentase:

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

Cobalah: https://repl.it/Cm0x

Jelly , 5 byte

ØAxJX

(Skor yang sama, tetapi metode yang berbeda , untuk solusi Jelly yang ada oleh Dennis.)

Peluang menghasilkan setiap huruf adalah indeks berbasis-1 dalam alfabet dibagi dengan 351 - angka segitiga ke-26:

• P ( A) = 1/351, P ( B) = 2/351, ..., P ( Z) = 26/351.

Karena 1 + 2 + ... + 26 = 351, P (huruf) = 1.

Penerapan:

Ø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

Uji di TryItOnline atau dapatkan distribusi 100 ribu berjalan (kode kredit ke Dennis)

q, 38 byte

Tidak terlalu pendek tapi ...

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

Fungsi distribusi kumulatif diskrit adalah urutannya

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

Dan kami hanya mengambil sampel dari distribusi.

JavaScript (ES6), 45 byte

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

Mencapai distribusi tidak seragam dengan mengkuadratkan nilai acak. Math.random()mengembalikan float dari rentang [0,1)sehingga hasil kuadrat ini cenderung ke arah 0(atau a).

Uji

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 byte

Menggunakan posisi karakter dalam alfabet sebagai probabilitas

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;

Tidak bermain golf

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 byte

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

rand menghasilkan nilai seragam dalam (0,1) .Ini memberikan 26 ^ rand probabilitas yang berbeda untuk sama dengan bilangan bulat dari 1 hingga 26.

Versi yang lebih lama, 45 byte

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

Ketepatan terbatas dari bilangan bulat TI-Basic membatasi distribusi normal untuk menghasilkan angka dalam μ ± 7.02σ (lihat randNorm(). Jadi kita mendapatkan nilai absolut dari angka acak dengan μ 0 dan σ 1, dikalikan empat untuk meningkatkan rentang praktis yang disebutkan sebelumnya menjadi μ ± 28.08σ. Kemudian, kami memberi nilai dan menambahkan 1, karena sub(1-diindeks, memberi kami kisaran 1-29 dengan probabilitas masing-masing yang berbeda.

PHP, 92 84 byte

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

Buat string dari semua huruf, ulangi berapa kali melalui loop kita, dan kemudian ambil surat dari string itu secara acak. Surat-surat kemudian dalam alfabet memiliki probabilitas yang lebih tinggi sebagai hasilnya

Terima kasih untuk menyisipkan nama pengguna di sini untuk memotong byte

probabilitas hasil (dipesan oleh%)

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,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 byte

Lebih ringkas daripada yang pertama, dengan probabilitas yang sedikit berbeda: Yang pertama ?memiliki peluang 1/4 untuk mencetak nilai A pada "percobaan pertama", peluang 2/4 untuk kembali ke yang sama ?, dan 1/4 untuk pindah ke lanjut. Sisanya ?masing-masing memiliki 1/4 peluang untuk mencetak surat di bawahnya, 1/4 untuk mencoba lagi, 1/4 pindah ke surat berikutnya, 1/4 pindah ke yang sebelumnya. Sekali lagi, probabilitas mencetak huruf A jauh lebih tinggi daripada mencetak huruf Z.

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

Befunge, 186 byte

Jelas tidak akan menang dengan ini, tapi saya pikir ini adalah jawaban yang menarik :)

vdan >mengarahkan kursor masing-masing ke bawah dan ke kanan. The ?Operator mengirimkan kursor off di salah satu dari empat arah secara acak. Yang pertama ?"diblokir" oleh vdan >dalam dua arah, sehingga hanya memiliki dua cara untuk pergi: Baik untuk mencetak A, atau turun ke yang berikutnya ?. Jadi, dari yang pertama ?saja ada kemungkinan 50% untuk mencetak A.

Yang berikutnya ?memiliki peluang 1/3 untuk mencetak B, 1/3 untuk kembali ke atas, dan 1/3 untuk lebih jauh ke bawah. Dll.

Seharusnya cukup jelas bahwa huruf-huruf yang lebih tinggi memiliki peluang lebih besar untuk dicetak daripada huruf-huruf yang lebih rendah, tetapi saya tidak begitu yakin dengan peluang masing-masing huruf.

Beberapa bantuan dengan matematika pasti akan dihargai :)

Setidaknya ada peluang 1/2 * 1/3 ^ 25 bahwa kursor bergerak ke Z pada percobaan pertama, tapi saya tidak yakin bagaimana peluang kursor bergerak ke atas dan ke bawah memengaruhi setiap huruf.

,@ cetakan dan berhenti.

 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 byte

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

Penerjemah online

Huruf besar.

Probabilitas setiap huruf adalah indeks berbasis 1 dalam alfabet.

zsh, 63 byte

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

ini bekerja dengan membuat string ini:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

alias 65 kali A, 66 kali B, 67 kali ...

dan kemudian memilih karakter acak di dalamnya

CJam, 11 byte

4.mrmqC*'A+

atau

676.mrmq'A+

Cobalah online!

Solusi ini mirip dengan ide Luis dan menciptakan distribusi yang tidak seragam dengan mengambil akar kuadrat dari variabel acak.

Batch, 116 byte

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

Bekerja dengan memilih yang lebih besar atau lebih kecil (saya lupa yang mana) dari dua variabel acak.

Matlab, 22

Akan sering mengembalikan surat awal, tetapi secara teoritis dapat menyentuh semuanya!

Membawa satu yang dibagi dengan angka acak, membatasi ini hingga 26 dan mengubahnya menjadi karakter.

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

Tentu saja tidak terlalu singkat, tetapi mungkin konsepnya dapat menginspirasi jawaban lain.

CJam, 10 byte

Pendekatan CJam # 3 ...

26mr)mr'A+

Cobalah online!

Ini membuat angka acak seragam xantara 1 dan 26 dan kemudian menggunakannya untuk membuat angka acak seragam antara 0dan x-1yang ditambahkan A. Bias ini menghasilkan karakter yang lebih kecil.

Labirin , 19 byte

__v6%_65+.@
" )
"^2

Cobalah online!

Ini adalah loop yang, pada setiap iterasi, baik a) menambah penghitung yang dimulai dari nol atau b) berakhir, keduanya dengan probabilitas 50%. Pada akhir loop, penghitung diambil modulo 26 dan ditambahkan ke 65 untuk memberikan surat antara Adan Z.

Ini memberikan kemungkinan Ahanya sedikit di atas 50%, Bhanya sedikit di atas 25% dan seterusnya hingga Zhanya sedikit di atas 1/2 ²⁶ . Secara teori, ada kemungkinan ini berjalan selamanya, tetapi acara ini memiliki probabilitas nol seperti yang dipersyaratkan oleh tantangan (dalam praktiknya itu mungkin tidak mungkin karena PRNG akan mengembalikan kedua hasil yang mungkin di beberapa titik selama periode tersebut).