시리즈 정보

랜덤 골프 오브 더 데이 시리즈의 게스트 항목입니다.

우선, 이것을 다른 코드 골프 도전과 같이 취급하고 시리즈에 대해 전혀 걱정하지 않고 대답 할 수 있습니다. 그러나 모든 과제에는 리더 보드가 있습니다. 첫 번째 게시물에서 시리즈 에 대한 추가 정보와 함께 리더 보드를 찾을 수 있습니다 .

입력

입력이 없습니다.

산출

선택적인 후행 줄 바꿈이있는 알파벳의 단일 문자 (대소 문자와 무관). 각 문자는 0이 아닌 확률을 선택 해야하며 26 개의 확률은 모두 고유해야합니다 . 모든 모호성을 제거하려면 : 구별은 서로 같은 두 개의 확률이 없어야 함을 의미합니다.

채점

이것은 코드 골프입니다. 바이트 단위의 최단 코드가 이깁니다.

유효한 항목은 종료되지 않을 확률이 0 인 전체 프로그램 또는 함수 입니다.

알파벳

혼동을 피하기 위해 사용되는 특정 알파벳은 라틴 알파벳입니다.

어느 한 쪽

ABCDEFGHIJKLMNOPQRSTUVWXYZ

또는

abcdefghijklmnopqrstuvwxyz

대문자 또는 소문자를 출력하도록 선택할 수 있습니다. 또는 도움이되는 경우 다른 실행에서 다른 사례를 출력하도록 선택할 수 있습니다. 주어진 문자에 대한 확률은 해당 문자가 어느 경우 에나 나타날 가능성입니다 (위 또는 아래).

설명

결과에서 전혀 명확하지 않으므로 26 개의 고유 확률을 달성 한 방법에 대한 명확한 설명을 포함하십시오.

리더 보드

( 여기에서 )

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

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

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

시리즈의 첫 번째 게시물은 전체 리더 보드도 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 모든 답변을 헤드 라인으로 시작하십시오.

## Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

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

(언어는 현재 표시되어 있지 않지만 스 니펫은이를 요구하고 구문 분석하며 향후 언어 별 리더 보드를 추가 할 수 있습니다.)

피스, 5

Os._G

여기 사용해보십시오

알파벳의 접두사를 계산합니다 ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. 그런 다음 목록을 평평하게하고 임의의 요소를 균일하게 선택합니다. 즉 a, 한 번만 나타나고 26 번 b나타나고 25 번 z나타나기 때문에 각 글자가 다르게 나타날 수 있습니다. 총 문자열은 351 자입니다.

MATL, 6 자

1Y2Xr)

설명:

Xr정규 분포의 난수를 취하여 )이것을 색인으로 만듭니다 ... 1Y2알파벳

분포는 0을 기준으로 대칭이며 숫자를 char로 변환하는 것은 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.

배경

하자 L ₀ , ..., L ₂₅ 나타내고, 그들의 자연 순으로 알파벳 문자 및 S ₀ , ..., S ₍₂₅₎ 의 균일 한에서 임의의 선택된 순열 L . 유한 시퀀스 M 을 M _n = max (L _n , S _n )로 정의하십시오 .

수정 N 에 0, ... 25 및 정의 K 인덱스 것과 같은 L _N = S _K .

확률 1/26에서 , L _n = S _n 및 n = k 이므로 M _n = L _n 및 L _n 은 M 에서 한 번 발생 합니다.

확률 26분의 25 , 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 입니다.

따라서 M 에서 L _n 의 예상 발생 횟수 는 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 입니다.

마지막으로, 우리가 무작위 로 M 의 항 m 을 무작위 로 선택 하면, 문자 L _n 은 확률 (2n + 1) / 26 / 26 = (2n + 1) / 676으로 선택 됩니다.

이것은 다음과 같은 확률 분포를 산출합니다.

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

링크를 100,000 번 호출 하여 배포를 경험적으로 확인할 수 있습니다 (몇 초 소요).

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

자바 7, 62 57 56 바이트

Poke 덕분에 5 바이트.

trichoplax 덕분에 1 바이트.

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

무시 했어!

주파수 다이어그램 (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: ***************************************************************************

펄, 24 바이트

@Martin Ender 덕분에 -4 바이트
@Dom Hastings 덕분에 -1 바이트

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

필요 -M5.010하거나 -E실행 :

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

다음 코드를 실행하면 각 문자의 발생이 표시됩니다.

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

작동 방식 : 코드가 꽤 명시 적이지만 여전히 : 0과 사이의 임의의 숫자를 선택합니다 rand 26. 따라서 0(letter A)에 가까운 숫자가 선택 될 가능성이 훨씬 높습니다 .

PHP, 44 36 29 27 바이트

^{44가 여전히 똑같습니다. 44; (}

insertusernamehere, Petah 및 Crypto에게 모든 도움을 주셔서 감사합니다

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

0에서 675 사이의 임의의 숫자를 선택하고 (= 26 ² -1) 제곱근을 취한 다음이를 내립니다 ( chr함수는 인수를 정수로 변환 함). 사각형의 간격이 서로 다르기 때문에 각 숫자가 선택 될 확률은 다릅니다. 모든 n은 확률 (2n + 1) / 676로 선택됩니다.

이 숫자에 65를 더하면에서에서 임의의 문자를 얻을 A수 Z있습니다.

1,000,000 번 실행되는 코드의 아이디어

R, 40 27 바이트

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

대체하지 않고을 향해 증가 할 확률로 생성 된 1숫자에서 26숫자 를 가져 와서 Z대문자 목록에서이 숫자의 색인을 표시합니다 LETTERS.

sample함수 의 인수는 다음 과 같습니다.

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

> <> , 14 바이트

lx
;>dd+%'A'+o

> <>는 토 로이드 형 2D 언어이며 고유 확률은 언어의 유일한 무작위 소스로 인해 자연스럽게 발생합니다. 온라인으로 사용해보십시오!

관련 명령은 다음과 같습니다.

[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

파이썬 2, 58 57 바이트

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

설명 : 간격에서 임의의 부동 소수점 숫자를 생성하고 [0, 676)제곱근을 취한 다음 바닥을 만듭니다. 그런 다음 65 ( "A"의 ASCII 값)를 더한 다음 char로 변환하여 인쇄합니다.

이는 0에서 25까지의 각 숫자에 고유 한 확률을 제공합니다. 이유를 이해하려면 다음과 같이 생각하십시오. 제곱근과 바닥을 취할 때 0이 아닌 숫자를 입력하고 정수가 아닌 것을 무시하십시오. 하나의 숫자 만 (0)이됩니다. 즉, 0의 확률은 1/676입니다. 몇 개의 숫자가 1을 생성합니까? 3은 1, 2, 3입니다 3/676. 즉, 확률은 입니다. 2는 4, 5, 6, 7 또는 8로 생성되어 확률 5, 3은 확률 7 등을 제공 할 수 있으며 연속 제곱 간의 차이가 2 씩 꾸준히 증가하기 때문에이 패턴은 매번 계속 증가합니다. 25 (Z).

누수로 인해 1 바이트가 절약되었습니다!

PowerShell v2 +, 33 31 바이트

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

의 범위를 취 65행 90(즉, ASCII A로 Z), 루프를 통해 파이프를. 반복 할 때마다 쉼표 연산자를 사용하여 해당 요소에 해당 숫자를 곱한 배열을 만듭니다. 예를 들어 65 65초, 66 66초, 67 67초 등이 만들어집니다. 큰 배열은 파이프 Get-Random(하나의 PRNG)로 하나의 요소를 선택합니다. 각 요소의 수량이 다르기 때문에 각 캐릭터의 선택 확률이 약간 다릅니다. 그런 다음이를 패런으로 캡슐화하여로 캐스팅합니다 char. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

( 게시되기 전에 몇 바이트를 골프로 한 @LeakyNun 에게 감사합니다 . : D)

확률

( ormat 연산자 의 P옵션을 보여줄 수 있도록 약간의 반올림 -f)

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

CJam, 21 17 12 바이트

5 바이트를 절약 해 준 Martin Ender에게 감사합니다!

새로운 버전

'\,:,s_el-mR

이것은 패턴 A,, AB등에 따라 문자열 배열을 형성합니다 ABC. 평평하게하고 임의의 문자를 선택합니다. 이 문자열에는 26A, 25B, 24C 등이 포함되어 있으므로 각 문자마다 고유 한 확률이 선택됩니다.

온라인으로 사용해보십시오!

설명

'\,          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기본적으로 gcc에 있으므로 (2 ^ 32 / 2)-1이라고 가정합니다. -lm플래그를 컴파일 하여 sqrt함수 를 연결하십시오 . 출력은 줄 바꿈없이 대문자로 stdout에 기록됩니다.

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

선택적으로, RAND_MAXis (2 ^ 16 / 2)-1이면 더 짧은 32 바이트 버전을 사용할 수 있습니다.

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

그냥 재미를 위해, sqrt함수를 사용하지 않거나 수학 라이브러리가 포함 된 버전을 만들었습니다 (이 라이브러리 RAND_MAX는 (2 ^ 32 / 2)-1 이어야합니다 ). 정말 멋진:

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

설명

[첫번째 프로그램]

를 사용하는 처음 두 개의 sqrt경우, 함수는 단순히 범위 [0, RAND_MAX)를 [0, 25]통해 나누기로 매핑 한 다음 A값에 65 (ASCII )를 더해 이를 출력하기 전에 ASCII 알파벳으로 바꿉니다.

[두번째 프로그램]

두 번째 프로그램은 비슷한 전략을 수행하지만 sqrt운영자 가 없어서 조금 더 복잡합니다 . 부동 소수점의 지수 비트는 정수를 할당 할 때 자동으로 계산되기 때문에 숫자의 밑이 2 인 로그를 구하기위한 효과적인 방법으로 효과적으로 사용될 수 있습니다.

우리는 범위 RAND_MAX가 인코딩 된 지수 값 25에 도달 하기를 원하기 때문에 (2 ^ 32 / 2-1) / (2 ^ 25) 계산은 약 64를 제공하며, 나누는 동안 rand매핑합니다. 이 새로운 범위로. 또한 0의 부동 소수점 표현이 다소 이상 하고이 알고리즘을 위반하므로 값에 1을 추가했습니다.

다음으로, 플로트는 정수로 타입 천공되어 비트 시프 팅 및 기타 그러한 연산을 허용한다. IEEE 754 부동 소수점 숫자에서 지수 비트는 비트 30-23이므로이 비트는 23 비트 오른쪽으로 이동하여 가수를 차단하고 원시 지수 값을 정수로 읽을 수 있습니다. 부호 비트도 지수 비트를 초과하지만 음수가 없으므로 마스크 될 필요는 없습니다.

그러나 이전과 같이이 결과에 65를 추가하는 대신 부동 소수점 지수는 0에서 255 사이의 부호없는 8 비트 정수로 표시됩니다. 여기서 지수 값 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

파이썬 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

(동일 점수하지만 다른 방법 으로, 기존의 젤리 용액 데니스).

각 문자를 산출 할 확률은 알파벳의 1 기반 인덱스이며, 26 번째 삼각형 수인 351로 나눈 것입니다.

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

1 + 2 + ... + 26 = 351이므로 P (letter) = 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

그리고 우리는 단지 분포에서 표본을 추출합니다.

자바 스크립트 (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 기본, 39 바이트

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

rand (0,1]에서 균일 한 값을 생성합니다. 이는 26 ^ rand에 1에서 26까지의 정수와 같을 확률이 다릅니다.

이전 버전, 45 바이트

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

TI- 기본 정수의 제한된 정밀도는 정규 분포가 µ ± 7.02σ 이내의 숫자를 생성하도록 제한합니다 (참조 randNorm(). 따라서 우리는 µ 0 및 σ 1을 갖는 난수의 절대 값을 얻습니다. 이전에 언급 한 실제 범위를 µ ± 28.08σ로 높이기 위해 4를 곱합니다. 그런 다음 sub(1- 인덱스 이므로 값을 바닥에 놓고 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);

모든 문자의 문자열을 작성하고 루프를 여러 번 반복 한 다음 해당 문자열에서 임의의 문자를 선택합니다. 알파벳 뒤의 글자는 결과적으로 더 높은 확률을가집니다

바이트를 줄인 insertusername 덕분에

결과적인 영아 (% 순)

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 %

비 펀지, 168 164 바이트

조금 다른 확률로, 첫 번째보다 컴팩트 한 다음 처음 ?이 1/4 "첫 번째 시도"를하는 A 인쇄의 기회를, 2/4 확률은 동일한 다시 와서 ?, 그리고 1/4을 받는 이동 다음. 의 나머지는 ?각각이 s의 1/4 그 아래에 편지를 인쇄의 기회를, 1/4 , 다시 시도 1/4 다음 글자로 이동, 1/4 이전에 이동. 다시, A를 인쇄 할 확률은 Z를 인쇄하는 것보다 훨씬 높습니다.

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

펀칭, 186 바이트

분명히 이것으로 이길 수는 없지만 그럼에도 불구하고 흥미로운 대답이라고 생각합니다. :)

v및 >각각 아래쪽과 오른쪽으로 커서를 조종. ?운영자는 무작위로 네 방향 중 하나 떨어져 커서를 보냅니다. 첫 번째 ?로 "차단"되어 v및 >하나이 (가)를 인쇄하거나 다음에 다운하기 : 그것은 단지 갈 두 가지 방법이 있으므로, 두 방향으로 ?. 따라서 처음부터 ?A를 인쇄 할 확률은 50 %입니다.

다음 ?은 B를 인쇄 할 수 있는 1/3의 기회, 1/3 의 되돌아 가기 및 1/3 의 더 아래로 내려갑니다. 등

높은 글자가 낮은 글자보다 인쇄 될 가능성이 훨씬 높다는 것은 분명하지만 각 글자의 가능성이 무엇인지 정확히 모르겠습니다.

정확한 수학에 도움이 될 것입니다 :)

적어도 첫 번째 시도에서 커서가 Z까지 끝까지 움직일 가능성 은 1/2 * 1 / 3 ^ 25 입니다.

,@ 인쇄하고 종료합니다.

 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

일명 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+

온라인으로 사용해보십시오!

이렇게하면 x1에서 26 사이 의 균일 한 난수가 생성 된 다음에 0와 사이 x-1에 추가되는 사이에 균일 한 난수가 생성 됩니다 A. 이것은 더 작은 문자로 결과를 바이어스합니다.

미로 , 19 바이트

__v6%_65+.@
" )
"^2

온라인으로 사용해보십시오!

이것은 각각의 반복에서 a) 0에서 시작하는 카운터를 증가 시키거나 b) 50 %의 확률로 종료하는 루프입니다. 루프의 끝에서, 카운터는 모듈로 26을 취해 65에 추가되어 A와 사이에 문자를 제공합니다 Z.

이것은 A단지 50 %를 약간 넘는 확률 , B25 %를 약간 넘는 확률 , 그리고 Z1/2 ^26을 약간 넘는 확률까지 제공합니다 . 이론적으로는이 실행이 영구적으로 발생할 가능성이 있지만이 이벤트는 챌린지에 필요한 확률이 0입니다 (실제로는 PRNG가 해당 기간 동안 어느 시점에서 두 가지 가능한 결과를 모두 반환하므로 어쩌면 불가능할 수도 있습니다).