Giới thiệu về bộ

Đây là một mục khách cho loạt trò chơi Golf ngẫu nhiên trong ngày.

Trước hết, bạn có thể coi điều này giống như bất kỳ thử thách golf mã nào khác, và trả lời nó mà không phải lo lắng về loạt bài này. Tuy nhiên, có một bảng xếp hạng trên tất cả các thách thức. Bạn có thể tìm thấy bảng xếp hạng cùng với một số thông tin khác về loạt bài trong bài đầu tiên .

Đầu vào

Không có đầu vào được thực hiện.

Đầu ra

Một chữ cái duy nhất của bảng chữ cái (trường hợp không liên quan), với một dòng mới tùy chọn. Mỗi chữ cái phải có xác suất khác không được chọn và tất cả 26 xác suất phải khác biệt . Để loại bỏ tất cả sự mơ hồ: Khác biệt có nghĩa là không được có hai xác suất bằng nhau.

Chấm điểm

Đây là mã golf. Mã ngắn nhất trong byte thắng.

Một mục hợp lệ là một chương trình hoặc chức năng đầy đủ có xác suất không kết thúc.

Bảng chữ cái

Để tránh nhầm lẫn, bảng chữ cái cụ thể được sử dụng là bảng chữ cái Latinh:

Hoặc

ABCDEFGHIJKLMNOPQRSTUVWXYZ

hoặc là

abcdefghijklmnopqrstuvwxyz

Bạn có thể chọn xuất chữ hoa hoặc chữ thường Ngoài ra, bạn có thể chọn xuất các trường hợp khác nhau trên các lần chạy khác nhau nếu điều đó có ích. Xác suất cho một chữ cái đã cho là xác suất của chữ cái đó xuất hiện trong cả hai trường hợp (trên hoặc dưới).

Giải trình

Vì nó hoàn toàn không rõ ràng từ đầu ra, vui lòng bao gồm một lời giải thích rõ ràng về cách bạn đạt được 26 xác suất khác biệt.

Bảng xếp hạng

(từ đây )

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>

Bài đầu tiên của loạt bài cũng tạo ra một bảng xếp hạng tổng thể.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu mọi câu trả lời bằng tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

(Ngôn ngữ hiện không được hiển thị, nhưng đoạn mã yêu cầu và phân tích nó và tôi có thể thêm bảng xếp hạng ngôn ngữ trong tương lai.)

Bình thường, 5

Os._G

Hãy thử nó ở đây

Tính các tiền tố của bảng chữ cái, vì vậy : ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Sau đó làm phẳng danh sách và chọn một yếu tố ngẫu nhiên từ nó một cách thống nhất. Điều này có nghĩa là kể từ khi axuất hiện 26 lần, trong khi bxuất hiện 25 lần, tất cả các cách zchỉ với 1 lần xuất hiện, mỗi chữ cái có một cơ hội xuất hiện khác nhau. Tổng chuỗi có 351 ký tự.

MATL, 6 nhân vật

1Y2Xr)

Giải trình:

XrLấy số ngẫu nhiên được phân phối bình thường )Sử dụng số này để lập chỉ mục vào ... 1Y2Bảng chữ cái

Phân bố đối xứng quanh 0 và dịch số sang char đối xứng khoảng 0,5. Vì vậy, xác suất nên được phân biệt.

05AB1E , 6 byte

Mã

A.pJ.R

Giải trình

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

Bây giờ chúng ta có chuỗi sau:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Sau đó, chúng tôi chọn một yếu tố ngẫu nhiên bằng cách sử dụng .R.

Xác suất

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%

Hãy thử trực tuyến! .

Thạch , 5 byte

ØA»ẊX

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Lý lịch

Hãy L ₀ , ..., L ₂₅ biểu thị các chữ cái của bảng chữ cái theo thứ tự tự nhiên của họ, và S ₀ , ..., S ₂₅ một thống nhất một cách ngẫu nhiên hoán vị được lựa chọn của L . Xác định dãy hữu hạn M theo M _n = max (L _n , S _n ) .

Sửa n trong 0, 18 và xác định k là chỉ số sao cho L _n = S _k .

Với xác suất 1/26 , L _n = S _n và n = k , vì vậy M _n = L _n và L _n occurrs lần trong M .

Với xác suất 25/26 , L _n ≠ S _n và n ≠ k . Trong trường hợp này, sau đây xảy ra.

• Với xác suất n / 25 , S _n là một trong L ₀ , Mạnh, L _{n - 1} , do đó L _n > S _n và M _n = L _n .

• Một cách độc lập, cũng với xác suất n / 25 , k là một trong 0, cách n - 1 , do đó S _k > L _k và M _k = S _k = L _n .

Do đó, số lần xuất hiện dự kiến ​​của L _n trong M là 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 .

Cuối cùng, nếu bây giờ chúng ta chọn một thuật ngữ m của M một cách ngẫu nhiên, chữ L _n chúng ta được chọn với xác suất (2n + 1) / 26/26 = (2n + 1) / 676 .

Điều này mang lại sự phân phối xác suất sau đây.

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

Bạn có thể xác minh thực nghiệm phân phối bằng cách gọi liên kết 100.000 lần (mất vài giây).

MATL , 10 byte

1Y2rU26*k)

Hãy thử trực tuyến!

Mã này tạo ra một biến ngẫu nhiên thống nhất trên khoảng (0,1) ( r) và tính bình phương của nó ( U). Điều này dẫn đến mật độ xác suất không đồng đều, giảm. Nhân với 26 ( 26*) đảm bảo rằng kết quả nằm trong khoảng (0,26) và làm tròn xuống ( k) tạo ra các giá trị 0,1, ..., 25 với xác suất giảm. Giá trị được sử dụng như một chỉ mục ( )) vào bảng chữ cái in hoa ( 1Y2). Vì MATL sử dụng lập chỉ mục mô-đun dựa trên 1, 0 tương ứng với Z, 1 đến A, 2 đến B, v.v.

Như một minh họa rằng các xác suất là khác biệt, đây là một biểu đồ rời rạc do 1000000 hiện thực ngẫu nhiên. Biểu đồ được tạo ra bằng cách chạy này trong Matlab:

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

Java 7, 62 57 56 byte

5 byte nhờ Poke.

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

Nghĩa là nó!

Biểu đồ tần suất (1e6 chạy, hệ số tỷ lệ 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 nhờ @Martin Ender
-1 byte nhờ @Dom Hastings

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

Cần -M5.010hoặc -Eđể chạy:

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

Chạy đoạn mã sau sẽ hiển thị sự xuất hiện của mỗi chữ cái:

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

Cách thức hoạt động : Tôi đoán mã khá rõ ràng, nhưng vẫn: nó chọn một số ngẫu nhiên giữa 0và rand 26. Vì vậy, có nhiều khả năng cao hơn là các số gần với 0(chữ cái A) được chọn.

PHP, 44 36 29 27 byte

^{Vượt qua 44 vẫn là 44 thường xuyên (}

Cảm ơn insertusernamehere, Petah và Crypto vì tất cả sự giúp đỡ

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

Nó chọn một số ngẫu nhiên trong khoảng từ 0 đến 675 (= 26 ² -1), lấy căn bậc hai của nó và lấy nó ( chrhàm chuyển đổi đối số của nó thành một số nguyên). Vì các ô vuông có các khoảng khác nhau giữa chúng, nên xác suất của mỗi số được chọn là khác nhau. Mỗi n được chọn với xác suất (2n + 1) / 676.

Thêm 65 vào số này cung cấp cho bạn một ký tự ngẫu nhiên từ Ađến Z.

Mã của mã chạy 1.000.000 lần

R, 40 27 byte

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

Điều này sẽ lấy 1số từ các 26số được tạo với xác suất tăng dần về phía Z, mà không thay thế và hiển thị một chữ cái chỉ số là số này, từ danh sách các chữ cái viết hoa LETTERS.

Các đối số của samplehàm là:

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

> <> là ngôn ngữ 2D hình xuyến và phần xác suất riêng biệt chỉ xảy ra một cách tự nhiên do nguồn ngẫu nhiên duy nhất của ngôn ngữ. Hãy thử trực tuyến!

Các lệnh có liên quan là:

[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

Do đó, xác suất đầu ra là:

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

Giải thích: điều này tạo ra một số dấu phẩy động ngẫu nhiên trong khoảng [0, 676), lấy căn bậc hai và sau đó xếp nó. Sau đó, nó thêm 65 (giá trị ascii của "A"), chuyển đổi nó thành char và in nó.

Điều này cho mỗi số từ 0 đến 25 một xác suất riêng biệt. Để hiểu tại sao, hãy nghĩ về nó như thế này. Có bao nhiêu số, bỏ qua các số nguyên, khi bạn lấy căn bậc hai và sàn cho 0? Chỉ một số sẽ (không). Điều này có nghĩa là số không có xác suất 1/676. Có bao nhiêu số sẽ tạo ra 1? 3 sẽ, 1, 2 và 3. Điều này có nghĩa là người ta có xác suất 3/676. Một hai có thể được tạo ra với 4, 5, 6, 7 hoặc 8, cho xác suất 5, ba có xác suất 7, v.v. và vì sự khác biệt giữa các ô vuông liên tiếp tăng đều đặn hai, mẫu này tiếp tục cho mỗi số tăng đến 25 (Z).

Lưu 1 byte nhờ nữ tu bị rò rỉ!

PowerShell v2 +, 33 31 byte

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

Đưa một phạm vi từ 65đến 90(tức là ASCII Ađến Z), dẫn nó qua một vòng lặp. Mỗi lần lặp, chúng tôi sử dụng toán tử dấu phẩy để tạo một mảng của phần tử đó nhân số đó. Ví dụ, điều này sẽ tạo ra 65 65giây, 66 66giây, 67 67giây, v.v. Mảng lớn đó được dẫn đến Get-Random(PRNG thống nhất) sẽ chọn một yếu tố. Vì có số lượng khác nhau của mỗi yếu tố, mỗi nhân vật có tỷ lệ phần trăm khác biệt được chọn. Sau đó chúng tôi gói gọn nó trong parens và đúc nó như một char. Đó là còn lại trên đường ống và đầu ra là ẩn.

(Cảm ơn @LeakyNun vì đã chơi gôn một vài byte ngay cả trước khi nó được đăng. D)

Xác suất

(làm tròn nhẹ để tôi có thể chứng minh Ptùy chọn của -ftoán tử 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

Cảm ơn Martin Ender đã tiết kiệm cho tôi 5 byte!

Phiên bản mới

'\,:,s_el-mR

Điều này tạo nên một mảng các chuỗi sau đây mô hình A, AB, ABC, và vân vân. Nó làm phẳng nó và chọn một nhân vật ngẫu nhiên. Vì chuỗi này chứa 26 A, 25 B, 24 C, v.v., mỗi chữ cái có xác suất được chọn riêng biệt.

Hãy thử trực tuyến!

Giải trình

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

Phiên bản cũ

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

Có được xác suất riêng biệt bằng cách tạo một chuỗi trong đó mỗi chữ cái xuất hiện một số lần bằng với vị trí của nó trong bảng chữ cái.

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)

Chỉ cần 'mẫu' một lá thư từ nội dung. đó 1:26là một vectơ trọng số cho mỗi chữ cái một xác suất khác nhau.

C, 35 byte

Chương trình này giả định RAND_MAXlà (2 ^ 32/2) - 1 vì nó là trên gcc theo mặc định. Biên dịch với -lmcờ để liên kết sqrtchức năng. Đầu ra được ghi vào thiết bị xuất chuẩn dưới dạng chữ in hoa mà không theo dõi dòng mới.

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

Tùy chọn, nếu RAND_MAXlà (2 ^ 16/2) - 1, có thể sử dụng phiên bản 32 byte ngắn hơn:

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

Để giải trí, tôi cũng đã tạo một phiên bản không sử dụng sqrthàm hoặc yêu cầu thư viện toán học đi kèm (phiên bản này phải có RAND_MAX(2 ^ 32/2) - 1), nhưng cuối cùng nó vẫn dài hơn mặc dù tôi nghĩ rằng đó là tuyệt đấy:

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

Giải trình

[Chương trình đầu tiên]

Trong hai đầu tiên sử dụng sqrt, chức năng đơn giản là bản đồ phạm vi [0, RAND_MAX)để [0, 25]qua chia, và sau đó thêm 65 (ASCII A) với giá trị chuyển nó vào bảng chữ cái ASCII trước khi xuất nó.

[Chương trình thứ hai]

Chương trình thứ hai phức tạp hơn một chút vì nó thực hiện một chiến lược tương tự, nhưng không có sqrttoán tử. Do các bit số mũ của một dấu phẩy động được tự động tính toán khi gán một số nguyên, nên chúng có thể được sử dụng một cách hiệu quả như một cách thô sơ để lấy logarit cơ sở 2 của một số.

Vì chúng tôi chỉ muốn phạm vi lên tới RAND_MAXgiá trị lũy thừa được mã hóa là 25, nên phép tính (2 ^ 32/2 - 1) / (2 ^ 25) cho chúng tôi chỉ khoảng 64, được sử dụng trong quá trình phân chia randđể ánh xạ nó đến phạm vi mới này. Tôi cũng đã thêm 1 vào giá trị vì biểu diễn dấu phẩy động của 0 khá kỳ lạ và sẽ phá vỡ thuật toán này.

Tiếp theo, float được loại hình thành một số nguyên để cho phép bẻ khóa và các hoạt động khác như vậy. Vì trong các số dấu phẩy động của IEEE 754, các bit số mũ là các bit 30-23, sau đó số này được dịch sang phải 23 bit, cắt bỏ phần tử và cho phép đọc giá trị số mũ thô dưới dạng số nguyên. Xin lưu ý rằng bit dấu cũng nằm ngoài bit lũy thừa, nhưng vì không bao giờ có bất kỳ tiêu cực nào nên nó không phải bị che đi.

Tuy nhiên, thay vì thêm 65 vào kết quả này như chúng tôi đã làm trước đây, số mũ của dấu phẩy động được biểu diễn dưới dạng số nguyên 8 bit không dấu từ 0 đến 255, trong đó giá trị số mũ của 0 là 127 (Chỉ cần trừ 127 để lấy giá trị số mũ "đã ký" thực tế ). Vì 127 - 65 là 62, thay vào đó, chúng ta chỉ cần trừ 62 để chuyển nó ra khỏi phạm vi số mũ của dấu phẩy động này và vào phạm vi bảng chữ cái ASCII trong một thao tác.

Phân phối

Tôi không phải là chuyên gia toán học nên tôi không thể nói chắc chắn công thức chính xác cho các phân phối này, nhưng tôi có thể (và đã) kiểm tra mọi giá trị trên phạm vi [0, RAND_MAX)để chỉ ra rằng khoảng cách giữa nơi một phạm vi chữ cái kết thúc và bắt đầu khác không bao giờ là tương tự. (Lưu ý các thử nghiệm này giả định (2 ^ 32/2) - 1) tối đa ngẫu nhiên)

[Chương trình đầu tiên]

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

[Chương trình thứ hai]

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

Nhân bội ký tự theo giá trị ascii của nó, sau đó chọn ngẫu nhiên một ký tự từ chuỗi kết quả.

Dưới đây là xác suất cho mỗi chữ cái được chọn, tính theo tỷ lệ phần trăm:

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

Hãy dùng thử: https://repl.it/Cm0x

Thạch , 5 byte

ØAxJX

(Điểm bằng nhau, nhưng là một phương pháp khác , đối với giải pháp Jelly hiện có của Dennis.)

Xác suất đạt được mỗi chữ cái là chỉ số dựa trên 1 trong bảng chữ cái chia cho 351 - số tam giác thứ 26:

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

Vì 1 + 2 + ... + 26 = 351, P (chữ cái) = 1.

Thực hiện:

Ø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

Kiểm tra nó trên TryItOnline hoặc nhận phân phối 100 nghìn lượt chạy (mã tín dụng cho Dennis)

q, 38 byte

Không đặc biệt ngắn nhưng ...

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

Hàm phân phối tích lũy rời rạc là chuỗi

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

Và chúng tôi chỉ đơn thuần là mẫu từ phân phối.

JavaScript (ES6), 45 byte

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

Đạt được phân phối không đồng đều bằng cách bình phương giá trị ngẫu nhiên. Math.random()trả về một số float của phạm vi [0,1)để kết quả bình phương này có xu hướng 0(hoặc a).

Kiểm tra

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

Sử dụng vị trí ký tự trong bảng chữ cái làm xác suất

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;

Không chơi gôn

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 tạo ra một giá trị đồng nhất trong (0,1]. Điều này mang lại cho 26 ^ rand một xác suất khác để bằng các số nguyên từ 1 đến 26.

Phiên bản cũ hơn, 45 byte

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

Độ chính xác giới hạn của các số nguyên TI-Basic giới hạn các phân phối bình thường trong việc tạo ra các số trong phạm vi ± ± 7.02σ (xem randNorm(). Vì vậy, chúng tôi nhận được giá trị tuyệt đối của một số ngẫu nhiên với Số 0 và σ 1, nhân với bốn để tăng phạm vi thực tế được đề cập trước đó đến Câu ± 28,08σ. Sau đó, chúng tôi xếp tầng giá trị và thêm 1, vì sub(được lập chỉ mục 1, cung cấp cho chúng tôi phạm vi từ 1-29 với các xác suất khác nhau của mỗi loại.

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

Xây dựng một chuỗi gồm tất cả các chữ cái, lặp lại số lần thông qua vòng lặp chúng ta và sau đó chọn một chữ cái từ chuỗi đó một cách ngẫu nhiên. Các chữ cái sau trong bảng chữ cái có xác suất cao hơn do kết quả

Cảm ơn insertusernamehere để cạo byte

xác suất kết quả (được sắp xếp theo%)

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 byte

Nhỏ gọn hơn lần đầu tiên, với một chút xác suất khác nhau: Lần đầu tiên ?có 1/4 cơ hội in A trên "lần thử đầu tiên", 2/4 cơ hội quay lại như cũ ?và 1/4 để chuyển sang kế tiếp. Phần còn lại của ?mỗi s có 1/4 cơ hội in chữ bên dưới chúng, 1/4 để thử lại, 1/4 chuyển sang chữ tiếp theo, 1/4 chuyển sang chữ trước. Một lần nữa, xác suất in A cao hơn rất nhiều so với in Z.

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

Befunge, 186 byte

Rõ ràng là sẽ không chiến thắng với điều này, nhưng tôi nghĩ dù sao đó cũng là một câu trả lời thú vị :)

vvà >điều khiển con trỏ tương ứng xuống dưới và sang phải. Các ?nhà điều hành sẽ gửi con trỏ ở một trong bốn hướng một cách ngẫu nhiên. Đầu tiên ?là "bị chặn" bởi vvà >theo hai hướng, vì vậy nó chỉ có hai cách để đi: Hoặc là in chữ A hoặc xuống theo hướng tiếp theo ?. Vì vậy, ngay từ lần đầu tiên, ?có 50% cơ hội in chữ A.

Tiếp theo ?có 1/3 cơ hội in B, 1/3 quay trở lại và 1/3 tiếp tục đi xuống. Vân vân.

Rõ ràng là các chữ cái cao hơn có cơ hội được in lớn hơn nhiều so với các chữ cái thấp hơn, nhưng tôi không chắc chắn chính xác cơ hội của mỗi chữ cái là gì.

Một số trợ giúp với toán chính xác sẽ được đánh giá cao :)

Ít nhất có 1/2 * 1/3 ^ 25 cơ hội con trỏ di chuyển xuống Z trong lần thử đầu tiên, nhưng tôi không chắc chắn khả năng con trỏ di chuyển lên xuống ảnh hưởng đến từng chữ cái như thế nào.

,@ in và thoát.

 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

Phiên dịch trực tuyến

Chữ hoa.

Xác suất của mỗi chữ cái là chỉ số dựa trên 1 của nó trong bảng chữ cái.

zsh, 63 byte

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

nó hoạt động bằng cách tạo chuỗi này:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

aka 65 lần A, 66 lần B, 67 lần C ...

và sau đó nó chọn một nhân vật ngẫu nhiên trong đó

CJam, 11 byte

4.mrmqC*'A+

hoặc là

676.mrmq'A+

Hãy thử trực tuyến!

Giải pháp này tương tự như ý tưởng của Luis và tạo ra một phân phối không đồng nhất bằng cách lấy căn bậc hai của biến ngẫu nhiên.

Hàng loạt, 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%%

Hoạt động bằng cách chọn lớn hơn hoặc nhỏ hơn (tôi quên cái nào) của hai biến ngẫu nhiên.

Matlab, 22

Sẽ thường trả lại các chữ cái sớm, nhưng về mặt lý thuyết có thể chạm vào tất cả chúng!

Làm cho một người bị lệch bởi một số ngẫu nhiên, giới hạn số này thành 26 và biến nó thành một ký tự.

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

Tất nhiên không phải là rất ngắn, nhưng có lẽ khái niệm này có thể truyền cảm hứng cho các câu trả lời khác.

CJam, 10 byte

Cách tiếp cận của CJam # 3 ...

26mr)mr'A+

Hãy thử trực tuyến!

Điều này tạo ra một số ngẫu nhiên thống nhất xtrong khoảng từ 1 đến 26 và sau đó sử dụng số đó để tạo một số ngẫu nhiên đồng nhất giữa 0và x-1được thêm vào A. Sự thiên vị này dẫn đến các nhân vật nhỏ hơn.

Mê cung , 19 byte

__v6%_65+.@
" )
"^2

Hãy thử trực tuyến!

Đây là một vòng lặp, ở mỗi lần lặp, a) sẽ tăng một bộ đếm bắt đầu từ 0 hoặc b) kết thúc, cả hai đều có xác suất 50%. Vào cuối vòng lặp, bộ đếm được lấy modulo 26 và thêm vào 65 để đưa ra một chữ cái giữa Avà Z.

Điều này đưa ra xác suất Achỉ hơn 50% Bmột chút , chỉ hơn 25% một chút và cứ như vậy Zchỉ hơn 1/2 ²⁶ một chút . Về lý thuyết, có khả năng điều này sẽ diễn ra mãi mãi, nhưng sự kiện này có xác suất bằng 0 theo yêu cầu của thử thách (trong thực tế điều đó có lẽ không thể xảy ra vì PRNG sẽ trả về cả hai kết quả có thể tại một thời điểm nào đó trong giai đoạn của nó).