O serii

To jest gościnny wpis do serii Random Golf of the Day.

Po pierwsze, możesz potraktować to jak każde inne wyzwanie związane z golfem i odpowiedzieć na nie, nie martwiąc się w ogóle serią. Istnieje jednak tabela wyników dla wszystkich wyzwań. Możesz znaleźć tabelę liderów wraz z kilkoma więcej informacji o serii w pierwszym poście .

Wejście

Brak danych wejściowych.

Wynik

Pojedyncza litera alfabetu (nie ma znaczenia wielkość liter), z opcjonalnym końcowym znakiem nowej linii. Każda litera musi mieć niezerowe prawdopodobieństwo wybrania, a wszystkie 26 prawdopodobieństw musi być odrębnych . Aby usunąć wszelką dwuznaczność: Wyraźny oznacza, że ​​nie mogą istnieć dwa prawdopodobieństwa, które są sobie równe.

Punktacja

To jest kod golfowy. Najkrótszy kod w bajtach wygrywa.

Poprawny wpis to pełny program lub funkcja, która ma zerowe prawdopodobieństwo, że nie zostanie zakończona.

Alfabet

Aby uniknąć nieporozumień, należy użyć alfabetu łacińskiego:

Zarówno

ABCDEFGHIJKLMNOPQRSTUVWXYZ

lub

abcdefghijklmnopqrstuvwxyz

Możesz wybrać wyświetlanie dużych lub małych liter. Alternatywnie możesz wybrać wyświetlanie różnych przypadków w różnych przebiegach, jeśli to pomoże. Prawdopodobieństwo dla danej litery to prawdopodobieństwo pojawienia się litery w obu przypadkach (górnej lub dolnej).

Wyjaśnienie

Ponieważ wynik nie będzie wcale oczywisty, dołącz jasne wyjaśnienie, w jaki sposób osiągnąłeś 26 różnych prawdopodobieństw.

Tabela liderów

( stąd )

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>

Pierwszy post z serii generuje również ogólną tabelę wyników.

Aby mieć pewność, że Twoje odpowiedzi się pojawią, zacznij każdą odpowiedź od nagłówka, używając następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

(Język nie jest obecnie wyświetlany, ale fragment go wymaga i analizuje, a w przyszłości mogę dodać tabelę wyników według języków).

Pyth, 5

Os._G

Wypróbuj tutaj

Oblicza prefiksy alfabetu, więc: ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Następnie spłaszcza listę i wybiera równomiernie z niej losowy element. Oznacza to, że ponieważ apojawia się 26 razy, a bpojawia się 25 razy, aż do zzaledwie jednego wyglądu, każda litera ma inną szansę pojawienia się. Łączny ciąg ma 351 znaków.

MATL, 6 znaków

1Y2Xr)

Wyjaśnienie:

XrWeź normalnie rozłożoną liczbę losową )Użyj tego, aby indeksować do ... 1Y2Alfabetu

Rozkład jest symetryczny wokół 0, a translacja liczby na char jest symetryczna wokół 0,5. Jako takie prawdopodobieństwa powinny być wyraźne.

05AB1E , 6 bajtów

Kod

A.pJ.R

Wyjaśnienie

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

Mamy teraz następujący ciąg:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Następnie wybieramy losowy element za pomocą .R.

Prawdopodobieństwa

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%

Wypróbuj online! .

Galaretka , 5 bajtów

ØA»ẊX

Wypróbuj online!

Jak to działa

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

tło

Niech L ₀ , ..., L ₂₅ oznacza litery alfabetu, w celu ich naturalnych i S ₀ , ..., S ₂₅ równomiernie losowo wybranych permutacji L . Zdefiniuj sekwencję skończoną M o M _n = max (L _n , S _n ) .

Napraw n w 0,… 25 i zdefiniuj k jako indeks taki, że L _n = S _k .

Z prawdopodobieństwem 1/26 , l _n = s _n a n = k , tak M _n = l _n i L _n occurrs raz M .

Z prawdopodobieństwem 25/26 , L _n ≠ S _n i n ≠ k . W takim przypadku dzieje się tak.

• Z prawdopodobieństwem n / 25 , S _n jest jednym z L ₀ ,…, L _{n - 1} , więc L _n > S _n i M _n = L _n .

• Niezależnie, również z prawdopodobieństwem n / 25 , k jest jednym z 0,… n - 1 , więc S _k > L _k i M _k = S _k = L _n .

Zatem oczekiwana liczba wystąpień L _n w M wynosi 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 .

W końcu, jeśli teraz wybrać termin m o M równomiernie losowo litery L _n , że wybiera się z prawdopodobieństwem (2N + 1) / 26/26 = (2n + 1) / 676 .

Daje to następujący rozkład prawdopodobieństw.

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

Możesz empirycznie zweryfikować dystrybucję, wywołując link 100 000 razy (zajmuje to kilka sekund).

MATL , 10 bajtów

1Y2rU26*k)

Wypróbuj online!

Kod generuje jednolitą zmienną losową na przedziale (0,1) ( r) i oblicza jej kwadrat ( U). Powoduje to nierównomierną, malejącą gęstość prawdopodobieństwa. Pomnożenie przez 26 ( 26*) zapewnia, że ​​wynik jest w przedziale (0,26), a zaokrąglenie w dół ( k) daje wartości 0,1, ..., 25 ze zmniejszającym się prawdopodobieństwem. Wartość jest używana jako indeks ( )) do wielkich liter alfabetu ( 1Y2). Ponieważ MATL stosuje modułowe indeksowanie 1, 0 odpowiada Z, 1 do A, 2 do B itd.

Jako ilustrację, że prawdopodobieństwa są różne, oto dyskretny histogram wynikający z 1000000 losowych realizacji. Wykres jest tworzony przez uruchomienie tego w Matlab:

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

Java 7, 62 57 56 bajtów

5 bajtów dzięki Poke.

1 bajt dzięki 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);}

Ideone to!

Wykres częstotliwości (przebiegi 1e6, współczynnik skalowania 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 bajty

-4 bajty dzięki @Martin Ender
-1 bajt dzięki @Dom Hastings

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

Potrzebuje -M5.010lub -Euruchomić:

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

Uruchomienie następującego kodu pokaże występowanie każdej litery:

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

Jak to działa : Myślę, że kod jest dość wyraźny, ale nadal: wybiera losową liczbę między 0a rand 26. Istnieje więc znacznie większe prawdopodobieństwo, że wybrane zostaną liczby zbliżone do 0(litery A).

PHP, 44 36 29 27 bajtów

^{Przekreślone 44 jest nadal regularne 44; (}

Dzięki inserttusernamehere, Petah i Crypto za całą pomoc

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

Wybiera liczbę losową z przedziału od 0 do 675 (= 26 ² -1), bierze pierwiastek kwadratowy i wykłada podłogę ( chrfunkcja przekształca argument na liczbę całkowitą). Ponieważ kwadraty mają różne odstępy między nimi, prawdopodobieństwo wybrania każdej liczby jest odrębne. Każdy n jest wybierany z prawdopodobieństwem (2n + 1) / 676.

Dodanie 65 do tej liczby daje losową postać od Ado Z.

Ideone kodu działającego 1 000 000 razy

R, 40 27 bajtów

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

Spowoduje to pobranie 1liczby z 26liczb generowanych z rosnącym prawdopodobieństwem w kierunku Z, bez zamiany, i wyświetlenie litery, której indeksem jest ta liczba, z listy wielkich liter LETTERS.

Argumenty samplefunkcji to:

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

> <> , 14 bajtów

lx
;>dd+%'A'+o

> <> to toroidalny język 2D, a część prawdopodobieństwa po prostu dzieje się naturalnie ze względu na jedyne źródło losowości tego języka. Wypróbuj online!

Odpowiednie polecenia to:

[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

Zatem prawdopodobieństwa wyjściowe wynoszą:

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 bajtów

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

Objaśnienie: generuje losową liczbę zmiennoprzecinkową w przedziale [0, 676), pobiera pierwiastek kwadratowy, a następnie wprowadza go do podłogi. Następnie dodaje 65 (wartość ascii „A”), konwertuje go na char i drukuje.

Daje to każdemu numerowi od 0 do 25 wyraźne prawdopodobieństwo. Aby zrozumieć dlaczego, pomyśl o tym w ten sposób. Ile liczb, ignorując liczby całkowite, gdy weźmiesz pierwiastek kwadratowy i piętro, dajesz 0? Tylko jedna liczba będzie (zero). Oznacza to, że zero ma prawdopodobieństwo 1/676. Ile liczb da 1? 3 będzie, 1, 2 i 3. Oznacza to, że istnieje prawdopodobieństwo 3/676. Dwa mogą być produkowane z 4, 5, 6, 7 lub 8, co daje prawdopodobieństwo 5, trzy ma prawdopodobieństwo 7 itd., A ponieważ różnica między kolejnymi kwadratami stale rośnie o dwa, ten wzór jest kontynuowany przy każdym zwiększeniu liczby do 25 (Z).

1 bajt zapisany dzięki nieszczelnej zakonnicy!

PowerShell v2 +, 33 31 bajtów

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

Przyjmuje zakres od 65do 90(tj. ASCII Ado Z), przepuszcza go przez pętlę. W każdej iteracji używamy operatora przecinka, aby utworzyć tablicę tego elementu razy tę liczbę. Na przykład spowoduje to 65 65s, 66 66s, 67 67s itd. Ta duża tablica jest podłączona do potoku, do Get-Randomktórej (jednolicie PRNG) wybierze jeden element. Ponieważ istnieją różne ilości każdego elementu, każda postać ma nieco wyraźną procentową szansę na wybranie. Następnie enkapsulujemy to w pareny i rzucamy jako char. Pozostaje to w potoku, a dane wyjściowe są niejawne.

(Dzięki @LeakyNun za grę w golfa na kilka bajtów, jeszcze zanim został opublikowany.: D)

Prawdopodobieństwa

(niewielkie zaokrąglenie, dzięki czemu mógłbym zademonstrować Popcję -foperatora 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 bajtów

Dzięki Martinowi Enderowi za uratowanie mnie 5 bajtów!

Nowa wersja

'\,:,s_el-mR

Tworzy tablicę ciągów poniższy wzór A, AB, ABC, i tak dalej. Spłaszcza go i wybiera losową postać. Ponieważ ten ciąg zawiera 26 A, 25 B, 24 C i tak dalej, każda litera ma wyraźne prawdopodobieństwo wyboru.

Wypróbuj online!

Wyjaśnienie

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

Stara wersja

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

Pobiera różne prawdopodobieństwa, tworząc ciąg, w którym każda litera pojawia się kilka razy równa jej pozycji w alfabecie.

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 bajty

sample(LETTERS,1,,1:26)

Wystarczy „pobrać” próbkę z wbudowanego listu. 1:26jest wektorem wag dając każda litera inny prawdopodobieństwa.

C, 35 bajtów

Ten program zakłada RAND_MAX(2 ^ 32/2) - 1 domyślnie na gcc. Skompiluj z -lmflagą, aby połączyć sqrtfunkcję. Dane wyjściowe są zapisywane na stdout jako wielkie litery bez końcowych znaków nowego wiersza.

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

Opcjonalnie, jeśli RAND_MAXjest (2 ^ 16/2) - 1, można użyć krótszej 32-bajtowej wersji:

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

Dla zabawy stworzyłem również wersję, która nie używa tej sqrtfunkcji ani nie wymaga dołączonej biblioteki matematycznej (ta musi mieć RAND_MAXjako (2 ^ 32/2) - 1), ale skończyła się na dłuższym czasie, chociaż myślałem, że to była całkiem fajne:

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

Wyjaśnienie

[Pierwszy program]

Przy pierwszych dwóch zastosowaniach sqrtfunkcja po prostu odwzorowuje zakres [0, RAND_MAX)na [0, 25]dzielenie przelotne, a następnie dodaje 65 (ASCII A) do wartości, aby przesunąć ją na alfabet ASCII przed wysłaniem.

[Drugi program]

Drugi program jest nieco bardziej złożony, ponieważ ma podobną strategię, ale bez sqrtoperatora. Ponieważ bity wykładnikowe zmiennoprzecinkowe są automatycznie obliczane po przypisaniu liczby całkowitej, można je skutecznie wykorzystać jako surowy sposób uzyskania logarytmu podstawowego 2 liczby.

Ponieważ chcemy, aby zakres RAND_MAXdo osiągnięcia zakodowanej wartości wykładniczej wynoszącej 25, obliczenia (2 ^ 32/2 - 1) / (2 ^ 25) dają nam tylko około 64, które jest używane podczas podziału randna mapowanie do tego nowego asortymentu. Dodałem również 1 do wartości, ponieważ reprezentacja zmiennoprzecinkowa 0 jest raczej dziwna i złamałaby ten algorytm.

Następnie liczba zmiennoprzecinkowa jest wpisywana na liczbę całkowitą, aby umożliwić przesunięcie bitów i inne tego typu operacje. Ponieważ w liczbach zmiennoprzecinkowych IEEE 754 bity wykładnikowe są bitami 30–23, liczba jest następnie przesuwana w prawo o 23 bity, odcinając mantysę i umożliwiając odczytanie wartości surowego wykładnika jako liczbę całkowitą. Zauważ, że bit znaku również wykracza poza bity wykładnikowe, ale ponieważ nigdy nie ma żadnych negatywów, nie trzeba go maskować.

Zamiast dodawać 65 do tego wyniku, jak to robiliśmy wcześniej, wykładniki zmiennoprzecinkowe są reprezentowane jako liczba całkowita bez znaku 8 bitów od 0 do 255, gdzie wartość wykładnika 0 wynosi 127 (po prostu odejmij 127, aby uzyskać rzeczywistą „wykładnik” wartości wykładnika ). Ponieważ 127 - 65 wynosi 62, zamiast tego po prostu odejmujemy 62, aby zarówno przesunąć go z tego zakresu zmiennoprzecinkowego wykładnika, jak i do zakresu alfabetu ASCII w jednej operacji.

Dystrybucja

Nie jestem ekspertem od matematyki, więc nie mogę z całą pewnością powiedzieć dokładnej formuły dla tych rozkładów, ale mogę (i zrobiłem) przetestować każdą wartość w zakresie, [0, RAND_MAX)aby wykazać, że odległość między miejscem, w którym kończy się zakres jednej litery, a drugim zaczyna się, nigdy nie jest podobnie. (Uwaga: testy te zakładają losowe maksimum (2 ^ 32/2) - 1)

[Pierwszy program]

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

[Drugi program]

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 bajty

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

Mnoży znak przez jego wartość ascii, a następnie wybiera losowo jeden znak z otrzymanego ciągu.

Oto prawdopodobieństwa dla każdej wybranej litery w procentach:

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

Wypróbuj: https://repl.it/Cm0x

Galaretka , 5 bajtów

ØAxJX

(Równy wynik, ale inna metoda , niż istniejące rozwiązanie Jelly autorstwa Dennisa.)

Prawdopodobieństwo uzyskania każdej litery to indeks 1 w alfabecie podzielony przez 351 - 26 liczba trójkątna:

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

Ponieważ 1 + 2 + ... + 26 = 351, P (litera) = 1.

Realizacja:

Ø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

Przetestuj to na TryItOnline lub uzyskaj dystrybucję 100 000 przebiegów (kredyt do Dennisa)

q, 38 bajtów

Niezbyt krótki, ale ...

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

Dyskretną funkcją rozkładu skumulowanego jest sekwencja

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

A my po prostu próbkujemy z dystrybucji.

JavaScript (ES6), 45 bajtów

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

Osiąga nierównomierny rozkład poprzez podniesienie do kwadratu wartości losowej. Math.random()zwraca liczbę zmiennoprzecinkową zakresu, [0,1)więc wynik podniesienia do kwadratu zmierza w kierunku 0(lub a).

Test

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 bajtów

Wykorzystanie pozycji znaku w alfabecie jako prawdopodobieństwa

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;

Bez golfa

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 bajtów

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

rand generuje jednolitą wartość w (0,1]. Daje to 26 ^ rand inne prawdopodobieństwo zrównania liczb całkowitych od 1 do 26.

Starsza wersja, 45 bajtów

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

Ograniczona precyzja liczb całkowitych TI-Basic ogranicza rozkład normalny do generowania liczb w granicach µ ± 7,02σ (patrz randNorm(). Otrzymujemy więc wartość bezwzględną liczby losowej z µ 0 i σ 1, mnożąc ją przez cztery, aby zwiększyć wspomniany wcześniej praktyczny zakres do µ ± 28,08σ. Następnie doliczamy wartość dolną i dodajemy 1, ponieważ sub(jest indeksowana 1, co daje nam zakres od 1-29 z różnymi prawdopodobieństwami dla każdego z nich.

PHP, 92 84 bajtów

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

Tworzy ciąg wszystkich liter, powtarzając liczbę razy przez pętlę, którą jesteśmy, a następnie losowo wybiera literę z tego ciągu. W rezultacie litery później w alfabecie mają większe prawdopodobieństwo

Dzięki inserttusernamehere do golenia bajtów

prawdopodobieństwa wyniku (uporządkowane według%)

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 bajtów

Bardziej kompaktowy niż pierwszy, z nieco innymi prawdopodobieństwami: pierwsze ?mają 1/4 szansy wydrukowania A przy „pierwszej próbie”, 2/4 szansy na powrót do tego samego ?i 1/4 na przejście do Kolejny. Reszta ?każdego z nich ma 1/4 szansy wydrukowania litery pod nimi, 1/4 do ponownej próby, 1/4 przejścia do następnej litery, 1/4 przejścia do poprzedniej. Ponownie, prawdopodobieństwo wydrukowania A jest znacznie wyższe niż wydrukowanie Z.

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

Befunge, 186 bajtów

Oczywiście nie wygra z tym, ale myślę, że to jednak interesująca odpowiedź :)

vi >steruje kursorem odpowiednio w dół i w prawo. ?Operator wysyła kursor się w jednym z czterech kierunków losowy. Pierwszym ?jest „zablokowany” przez vi >w dwóch kierunkach, tak że ma tylko dwie drogi: albo pójść do wydrukowania A lub w dół do następnej ?. Tak więc od samego początku ?istnieje 50% szans na wydrukowanie A.

Następny ?ma 1/3 szansy na wydrukowanie B, 1/3 powrotu i 1/3 dalszego spadku. Itd itd.

Powinno być całkiem oczywiste, że wyższe litery mają znacznie większą szansę na wydrukowanie niż niższe, ale nie jestem do końca pewien, jakie są szanse każdej litery.

Będziemy wdzięczni za pomoc w dokładnej matematyce :)

Przynajmniej przy pierwszej próbie istnieje szansa 1/2 * 1/3 ^ 25, że kursor przesunie się w dół do litery Z. Nie jestem jednak pewien, jak szanse na przesuwanie kursora w górę i w dół wpływają na każdą literę.

,@ odciski i rezygnuje.

 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 bajtów

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

Tłumacz online

Duże litery.

Prawdopodobieństwo każdej litery jest indeksem 1 w alfabecie.

zsh, 63 bajty

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

działa, tworząc ten ciąg:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

czyli 65 razy A, 66 razy B, 67 razy C ...

a następnie wybiera losową postać

CJam, 11 bajtów

4.mrmqC*'A+

lub

676.mrmq'A+

Wypróbuj online!

To rozwiązanie jest podobne do pomysłu Luisa i tworzy nierównomierny rozkład, biorąc pierwiastek kwadratowy zmiennej losowej.

Partia, 116 bajtów

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

Działa poprzez wybranie większej lub mniejszej (zapominam która) dwóch zmiennych losowych.

Matlab, 22

Często zwraca wczesne litery, ale teoretycznie może je wszystkie dotknąć!

Bierze jedną podzieloną przez liczbę losową, ogranicza ją do 26 i zamienia na postać.

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

Oczywiście nie bardzo krótko, ale być może ta koncepcja może zainspirować inne odpowiedzi.

CJam, 10 bajtów

Podejście CJam # 3 ...

26mr)mr'A+

Wypróbuj online!

Spowoduje to utworzenie jednolicie losowej liczby xmiędzy 1 a 26, a następnie wykorzysta tę liczbę do utworzenia równomiernie losowej liczby między 0i do x-1której zostanie dodana A. To tendencyjność prowadzi do mniejszych postaci.

Labirynt , 19 bajtów

__v6%_65+.@
" )
"^2

Wypróbuj online!

Jest to pętla, która przy każdej iteracji albo a) zwiększa licznik rozpoczynający się od zera lub b) kończy się, oba z prawdopodobieństwem 50%. Na końcu pętli licznik jest pobierany modulo 26 i dodawany do 65, aby dać literę między Ai Z.

Daje to prawdopodobieństwo Anieco ponad 50%, Bnieco ponad 25% i tak dalej do Znieco ponad 1/2 ²⁶ . Teoretycznie istnieje możliwość takiego działania na zawsze, ale to zdarzenie ma zerowe prawdopodobieństwo zgodnie z wymaganiami wyzwania (w praktyce prawdopodobnie nie jest to możliwe, ponieważ PRNG zwróci oba możliwe wyniki w pewnym momencie w tym okresie).