Über die Serie

Dies ist ein Gastbeitrag für die Random Golf of the Day-Serie.

Zunächst einmal können Sie dies wie jede andere Code-Golf-Herausforderung behandeln und beantworten, ohne sich Gedanken über die Serie zu machen. Es gibt jedoch eine Rangliste für alle Herausforderungen. Sie finden die Rangliste zusammen mit einigen weiteren Informationen über die Serie im ersten Beitrag .

Eingang

Es werden keine Eingaben gemacht.

Ausgabe

Ein einzelner Buchstabe des Alphabets (Groß- / Kleinschreibung ist irrelevant) mit optionalem abschließendem Zeilenumbruch. Jeder Buchstabe muss mit einer Wahrscheinlichkeit ungleich Null ausgewählt werden, und alle 26 Wahrscheinlichkeiten müssen unterschiedlich sein . Um alle Mehrdeutigkeiten zu beseitigen: Unterscheiden bedeutet, dass es nicht zwei Wahrscheinlichkeiten geben darf, die einander gleich sind.

Wertung

Das ist Code Golf. Kürzester Code in Bytes gewinnt.

Ein gültiger Eintrag ist ein vollständiges Programm oder eine vollständige Funktion mit einer Wahrscheinlichkeit von Null, dass sie nicht beendet wird.

Alphabet

Um Verwechslungen zu vermeiden, ist das verwendete Alphabet das lateinische Alphabet:

Entweder

ABCDEFGHIJKLMNOPQRSTUVWXYZ

oder

abcdefghijklmnopqrstuvwxyz

Sie können zwischen Groß- und Kleinschreibung wählen. Alternativ können Sie verschiedene Fälle in verschiedenen Läufen ausgeben, wenn dies hilfreich ist. Die Wahrscheinlichkeit für einen bestimmten Buchstaben ist die Wahrscheinlichkeit, dass dieser Buchstabe in beiden Fällen (oben oder unten) erscheint.

Erläuterung

Bitte erläutern Sie anhand der Ausgabe genau, wie Sie die 26 verschiedenen Wahrscheinlichkeiten erreicht haben.

Bestenliste

(von hier )

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>

Der erste Beitrag der Serie generiert auch eine allgemeine Rangliste.

Um sicherzustellen, dass Ihre Antworten angezeigt werden, beginnen Sie jede Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

(Die Sprache wird derzeit nicht angezeigt, das Snippet erfordert sie jedoch und analysiert sie. Ich füge möglicherweise in Zukunft eine Bestenliste nach Sprachen hinzu.)

Pyth, 5

Os._G

Probieren Sie es hier aus

Berechnet die Präfixe des Alphabets ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Dann wird die Liste geglättet und ein zufälliges Element einheitlich ausgewählt. Dies bedeutet, dass seit dem a26-fachen und dem b25-fachen zAuftreten jedes Buchstabens eine andere Chance hat, auftauchen zu können. Die Gesamtzeichenfolge hat 351 Zeichen.

MATL, 6 Zeichen

1Y2Xr)

Erläuterung:

XrNehmen Sie eine normalverteilte Zufallszahl. )Verwenden Sie diese, um ... 1Y2das Alphabet zu indizieren

Die Verteilung ist symmetrisch um 0 und die Übersetzung von Zahl zu Zeichen ist symmetrisch um 0,5. Daher sollten die Wahrscheinlichkeiten unterschiedlich sein.

05AB1E , 6 Bytes

Code

A.pJ.R

Erläuterung

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

Wir haben jetzt die folgende Zeichenfolge:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Danach wählen wir ein Zufallselement verwenden .R.

Die Wahrscheinlichkeiten

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%

Probieren Sie es online! .

Gelee , 5 Bytes

ØA»ẊX

Probieren Sie es online!

Wie es funktioniert

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

Hintergrund

Let L ₀ , ..., L ₂₅ die Buchstaben des Alphabets Bezeichnet in ihrer natürlichen Reihenfolge, und S ₀ , ..., S ₂₅ eine gleichmäßig zufällig ausgewählt Permutation von L . Definieren Sie die endliche Folge M durch M _n = max (L _n , S _n ) .

Fixiere n in 0,… 25 und definiere k als Index, so dass L _n = S _{k ist} .

Mit der Wahrscheinlichkeit 1/26 , L _n = S _n und n = k , so M _n = L _n und L _n occurrs einmal in M .

Mit der Wahrscheinlichkeit 25/26 sind L _n ≤ S _n und n ≤ k . In diesem Fall geschieht Folgendes.

• Mit der Wahrscheinlichkeit n / 25 ist S _n einer von L ₀ ,…, L _{n - 1} , so dass L _n > S _n und M _n = L _n .

• Unabhängig davon wird auch mit einer Wahrscheinlichkeit von n / 25 , k ist ein von 0, ... N - 1 , also S _k > L _k und M _k = S _k = L _n .

Somit kann die erwartete Anzahl der Vorkommen von L _n in M ist 1/26 + 25/26 · (n / 25 + N / 25) = (2n + 1) / 26 .

Wenn wir nun einen Term m von M gleichmäßig zufällig auswählen , wird der Buchstabe L _n mit der Wahrscheinlichkeit (2n + 1) / 26/26 = (2n + 1) / 676 ausgewählt .

Dies ergibt die folgende Wahrscheinlichkeitsverteilung.

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

Sie können die Verteilung empirisch überprüfen, indem Sie den Link 100.000 Mal aufrufen (dies dauert einige Sekunden).

MATL , 10 Bytes

1Y2rU26*k)

Probieren Sie es online!

Der Code generiert eine einheitliche Zufallsvariable für das Intervall (0,1) ( r) und berechnet sein Quadrat ( U). Dies führt zu einer ungleichmäßigen, abnehmenden Wahrscheinlichkeitsdichte. Das Multiplizieren mit 26 ( 26*) stellt sicher, dass das Ergebnis im Intervall (0,26) liegt, und das Abrunden ( k) ergibt die Werte 0,1, ..., 25 mit abnehmender Wahrscheinlichkeit. Der Wert wird als Index ( )) für das Großbuchstaben ( 1Y2) verwendet. Da MATL 1-basierte modulare Indizierung verwendet, entspricht 0 Z, 1 bis A, 2 bis B usw.

Zur Veranschaulichung, dass die Wahrscheinlichkeiten unterschiedlich sind, ist hier ein diskretes Histogramm, das aus 1000000 zufälligen Realisierungen resultiert. Das Diagramm wird erstellt, indem Folgendes in Matlab ausgeführt wird:

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

Java 7, 62 57 56 Bytes

5 Bytes dank Poke.

1 Byte dank 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 es!

Frequenzdiagramm (1e6 läuft, Skalierungsfaktor 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 Bytes

-4 Bytes dank @Martin Ender
-1 Bytes dank @Dom Hastings

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

Notwendig -M5.010oder -Ezu laufen:

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

Wenn Sie den folgenden Code ausführen, wird das Vorkommen jedes Buchstabens angezeigt:

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

Wie es funktioniert : Ich denke, der Code ist ziemlich explizit, aber dennoch: Er wählt eine Zufallszahl zwischen 0und rand 26. Daher ist die Wahrscheinlichkeit, dass Zahlen in der Nähe von 0(Buchstaben A) ausgewählt werden, sehr viel höher .

PHP, 44 36 29 27 Bytes

^{Durchgestrichen 44 ist immer noch regulär 44; (}

Vielen Dank an insertusernamehere, Petah und Crypto für die Hilfe

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

Es wählt eine Zufallszahl zwischen 0 und 675 (= 26 ² -1), verwendet die Quadratwurzel und fasst sie zusammen (die chrFunktion wandelt ihr Argument in eine Ganzzahl um). Da die Quadrate unterschiedliche Intervalle haben, ist die Wahrscheinlichkeit, dass eine Zahl ausgewählt wird, unterschiedlich. Jedes n wird mit Wahrscheinlichkeit (2n + 1) / 676 gewählt.

Wenn Sie dieser Zahl 65 hinzufügen, erhalten Sie ein zufälliges Zeichen von Abis Z.

Ideone des Codes läuft 1.000.000 mal

R, 40 27 Bytes

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

Dies nimmt die 1Zahl von 26Zahlen, die mit zunehmender Wahrscheinlichkeit erzeugt wurden Z, ohne sie zu ersetzen, und zeigt einen Buchstaben aus der Liste der Großbuchstaben an, dessen Index diese Zahl ist LETTERS.

Die Argumente der sampleFunktion sind:

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

> <> , 14 Bytes

lx
;>dd+%'A'+o

> <> ist eine toroidale 2D-Sprache, und der Teil mit den unterschiedlichen Wahrscheinlichkeiten geschieht auf natürliche Weise aufgrund der einzigen Zufallsquelle der Sprache. Probieren Sie es online!

Die relevanten Befehle sind:

[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

Somit sind die Ausgabewahrscheinlichkeiten:

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 Bytes

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

Erläuterung: Dadurch wird eine zufällige Gleitkommazahl im Intervall generiert [0, 676), die Quadratwurzel wird gezogen und anschließend auf den Boden gelegt. Dann addiert es 65 (den ASCII-Wert von "A"), konvertiert ihn in ein Zeichen und druckt ihn aus.

Dies gibt jeder Zahl von 0 bis 25 eine unterschiedliche Wahrscheinlichkeit. Um zu verstehen warum, denken Sie so darüber nach. Wie viele Zahlen, die Nicht-Ganzzahlen ignorieren, wenn Sie die Quadratwurzel nehmen und den Boden mit 0 angeben? Nur eine Zahl wird (Null). Dies bedeutet, dass Null eine Wahrscheinlichkeit von hat 1/676. Wie viele Zahlen ergeben 1? 3 wird, 1, 2 und 3. Dies bedeutet, man hat eine Wahrscheinlichkeit von 3/676. Eine Zwei kann mit einer 4, 5, 6, 7 oder 8 erzeugt werden, was eine Wahrscheinlichkeit von 5 ergibt, eine Drei eine Wahrscheinlichkeit von 7 usw., und da die Differenz zwischen aufeinanderfolgenden Quadraten stetig um zwei zunimmt, setzt sich dieses Muster für jede aufsteigende Zahl fort bis 25 (Z).

1 Byte gespart dank undichter Nonne!

PowerShell v2 +, 33 bis 31 Byte

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

Nimmt einen Bereich von 65bis 90(dh ASCII Anach Z) und leitet ihn durch eine Schleife. Bei jeder Iteration verwenden wir den Komma-Operator, um ein Array dieses Elements multipliziert mit dieser Zahl zu erstellen. Dies ergibt zum Beispiel 65 65s, 66 66s, 67 67s usw. Das große Array, zu Get-Randomdem geleitet wird, wählt (einheitlich PRNG) ein Element aus. Da es für jedes Element unterschiedliche Mengen gibt, hat jeder Charakter eine leicht unterschiedliche prozentuale Chance, ausgewählt zu werden. Wir kapseln das dann in parens und gießen es als char. Das bleibt in der Pipeline und die Ausgabe ist implizit.

(Danke an @LeakyNun für das Golfen ein paar Bytes, noch bevor es gepostet wurde.: D)

Die Wahrscheinlichkeiten

(leichte Rundung, damit ich die POption des -fOrmat-Operators demonstrieren kann )

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 Bytes

Vielen Dank an Martin Ender, der mir 5 Bytes gespart hat!

Neue Version

'\,:,s_el-mR

Dies bildet einen Array von Strings nach dem Muster A, AB, ABC, und so weiter. Es flacht es ab und wählt einen zufälligen Charakter. Da diese Zeichenfolge 26 A-, 25 B-, 24 C-Zeichen usw. enthält, hat jeder Buchstabe eine unterschiedliche Wahrscheinlichkeit, ausgewählt zu werden.

Probieren Sie es online!

Erläuterung

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

Alte Version

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

Ruft unterschiedliche Wahrscheinlichkeiten ab, indem eine Zeichenfolge erstellt wird, in der jeder Buchstabe so oft vorkommt, wie er im Alphabet enthalten ist.

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 Bytes

sample(LETTERS,1,,1:26)

Probieren Sie einfach einen Brief von einem eingebauten Gerät aus. Dies 1:26ist ein Vektor von Gewichten, die jedem Buchstaben eine andere Wahrscheinlichkeit geben.

C 35 Bytes

Dieses Programm geht von RAND_MAX(2 ^ 32/2) - 1 aus, da es standardmäßig auf gcc läuft. Kompilieren Sie mit dem -lmFlag, um die sqrtFunktion zu verknüpfen . Die Ausgabe wird als Großbuchstaben ohne Zeilenumbruch auf stdout geschrieben.

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

Wenn RAND_MAX(2 ^ 16/2) - 1 ist, kann optional eine kürzere 32-Byte-Version verwendet werden:

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

Aus Spaß habe ich auch eine Version erstellt, die die sqrtFunktion nicht verwendet oder die enthaltene Mathematikbibliothek nicht benötigt (diese muss RAND_MAXals (2 ^ 32/2) - 1 vorliegen ), aber sie ist länger geworden, obwohl ich dachte, dass dies der Fall ist ziemlich cool:

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

Erläuterung

[Erstes Programm]

Bei den ersten beiden Anwendungen sqrtordnet die Funktion den Bereich einfach [0, RAND_MAX)einer [0, 25]durchgehenden Division zu und addiert dann 65 (ASCII A) zu dem Wert, um ihn vor der Ausgabe in das ASCII-Alphabet zu verschieben.

[Zweites Programm]

Das zweite Programm ist etwas komplexer, da es eine ähnliche Strategie ausführt, jedoch ohne den sqrtBediener. Da die Exponentenbits eines Gleitkommas beim Zuweisen einer Ganzzahl automatisch berechnet werden, können sie effektiv als grobe Methode verwendet werden, um den Logarithmus der Basis 2 einer Zahl zu erhalten.

Da wir nur wollen, dass der Bereich bis zu RAND_MAXeinem codierten Exponentenwert von 25 reicht, ergibt die Berechnung (2 ^ 32/2 - 1) / (2 ^ 25) nur ungefähr 64, die während der Division von verwendet wird rand, um ihn abzubilden zu diesem neuen Bereich. Ich habe auch 1 zum Wert hinzugefügt, da die Gleitkommadarstellung von 0 ziemlich seltsam ist und diesen Algorithmus zerstören würde.

Als nächstes wird der Gleitkommawert auf eine Ganzzahl typisiert, um Bitverschiebung und andere derartige Operationen zu ermöglichen. Da in IEEE 754-Gleitkommazahlen die Exponentenbits die Bits 30 bis 23 sind, wird die Zahl um 23 Bits nach rechts verschoben, wodurch die Mantisse abgeschnitten wird und der rohe Exponentenwert als Ganzzahl gelesen werden kann. Beachten Sie, dass das Vorzeichenbit auch jenseits der Exponentenbits liegt, aber da es nie irgendwelche Negative gibt, muss es nicht ausgeblendet werden.

Anstatt wie zuvor 65 zu diesem Ergebnis zu addieren, werden Gleitkomma-Exponenten als vorzeichenlose 8-Bit-Ganzzahlen von 0 bis 255 dargestellt, wobei der Exponentenwert 127 ist ). Da 127 - 65 62 ist, subtrahieren wir stattdessen einfach 62, um es sowohl aus diesem Gleitkomma-Exponentenbereich als auch in den ASCII-Alphabet-Bereich zu verschieben, und das alles in einer Operation.

Verteilung

Ich bin kein Mathe-Experte, daher kann ich die genaue Formel für diese Verteilungen nicht genau sagen, aber ich kann (und habe) jeden Wert im Bereich testen, um [0, RAND_MAX)zu zeigen, dass der Abstand zwischen dem Ende des Bereichs eines Buchstabens und dem Beginn des anderen niemals der gleiche ist gleich. (Beachten Sie, dass diese Tests das (2 ^ 32/2) - 1) Zufallsmaximum annehmen.)

[Erstes Programm]

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

[Zweites Programm]

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 Bytes

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

Multipliziert das Zeichen mit seinem ASCII-Wert und wählt dann zufällig ein Zeichen aus der resultierenden Zeichenfolge aus.

Hier sind die Wahrscheinlichkeiten für jeden ausgewählten Buchstaben in Prozent:

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

Probieren Sie es aus: https://repl.it/Cm0x

Gelee , 5 Bytes

ØAxJX

(Gleiche Punktzahl, aber eine andere Methode als bei einer vorhandenen Jelly-Lösung von Dennis.)

Die Wahrscheinlichkeit, einen Buchstaben zu erhalten, ist der auf 1 basierende Index im Alphabet geteilt durch 351 - die 26. dreieckige Zahl:

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

Da 1 + 2 + ... + 26 = 351 ist, ist P (Buchstabe) = 1.

Implementierung:

Ø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

Testen Sie es auf TryItOnline oder erhalten Sie die Verteilung von 100K-Läufen (Code-Gutschrift an Dennis)

q, 38 Bytes

Nicht besonders kurz, aber ...

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

Die diskrete kumulative Verteilungsfunktion ist die Sequenz

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

Und wir probieren nur aus der Distribution.

JavaScript (ES6), 45 Byte

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

Erzielt eine ungleichmäßige Verteilung durch Quadrieren des Zufallswerts. Math.random()Gibt einen Gleitkommawert des Bereichs zurück, [0,1)sodass das Ergebnis der Quadratur in Richtung 0(oder a) tendiert .

Prüfung

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

Zeichenposition im Alphabet als Wahrscheinlichkeit verwenden

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;

Nicht golfen

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 Bytes

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

rand erzeugt einen einheitlichen Wert in (0,1]. Dies gibt 26 ^ rand eine andere Wahrscheinlichkeit, um die ganzen Zahlen von 1 bis 26 zu gleichen.

Ältere Version, 45 Bytes

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

Die eingeschränkte Genauigkeit der TI-Basic-Ganzzahlen beschränkt die Normalverteilungen auf die Erzeugung von Zahlen innerhalb von µ ± 7,02σ (siehe randNorm(). Wir erhalten also den absoluten Wert einer Zufallszahl mit µ 0 und σ 1, multipliziert mit vier, um den oben erwähnten praktischen Bereich auf µ ± 28,08σ zu erhöhen. Dann untermauern wir den Wert und addieren 1, da sub(1-indiziert, was uns einen Bereich von 1 bis 29 mit jeweils unterschiedlichen Wahrscheinlichkeiten gibt.

PHP, 92 84 Bytes

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

Erstellt eine Zeichenfolge aus allen Buchstaben, wiederholt die Schleife so oft, wie wir es sind, und wählt dann zufällig einen Buchstaben aus dieser Zeichenfolge aus. Buchstaben später im Alphabet haben daher eine höhere Wahrscheinlichkeit

Danke an insertusernamehere für das Abschneiden von Bytes

Ergebniswahrscheinlichkeiten (geordnet nach%)

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 Bytes

Kompakt Mehr als die erste, mit ein wenig unterschiedlichen Wahrscheinlichkeiten: Die erste ?einen haben 1/4 ein A von Druck auf „ersten Versuch“ Chance, 2/4 Chance auf das gleiche wieder zu kommen ?, und ein Viertel bis die bewegen Nächster. Die restlichen ?s haben jeweils eine 1/4 Chance, den darunter liegenden Buchstaben zu drucken, 1/4 , um es erneut zu versuchen, 1/4 , um zum nächsten Buchstaben zu gelangen, 1/4 , um zum vorherigen zu gelangen. Auch hier ist die Wahrscheinlichkeit, ein A zu drucken, viel höher als die eines Z.

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

Befunge, 186 Bytes

Natürlich wird ich damit nicht gewinnen, aber ich denke, es ist trotzdem eine interessante Antwort :)

vund >lenkt den Cursor jeweils nach unten und rechts. Der ?Bediener schickt den Cursor nach dem Zufallsprinzip in eine von vier Richtungen. Die erste ?ist durch vund >in zwei Richtungen "blockiert" , so dass nur zwei Möglichkeiten bestehen: Entweder um das A auszudrucken, oder bis zur nächsten ?. Ab dem ersten Mal ?besteht also eine 50% ige Chance, ein A zu drucken.

Die nächste ?hat eine 1/3- Chance, ein B zu drucken, 1 /3- Chance , wieder nach oben und 1 / 3- Chance , weiter nach unten zu gehen. Usw.

Es sollte ziemlich offensichtlich sein, dass die höheren Buchstaben eine viel größere Chance haben, gedruckt zu werden als die niedrigeren, aber ich bin nicht genau sicher, wie die Chancen jedes Buchstabens sind.

Etwas Hilfe bei der genauen Berechnung wäre dankbar :)

Zumindest besteht eine Chance von 1/2 * 1/3 ^ 25, dass sich der Cursor beim ersten Versuch bis zum Z nach unten bewegt, aber ich bin mir nicht sicher, wie sich die Wahrscheinlichkeit, dass sich der Cursor nach oben und unten bewegt, auf jeden Buchstaben auswirkt.

,@ druckt und beendet.

 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 bis 18 Bytes

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

Online-Dolmetscher

Großbuchstaben.

Die Wahrscheinlichkeit jedes Buchstabens ist sein 1-basierter Index im Alphabet.

zsh, 63 Bytes

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

Es funktioniert, indem Sie diese Zeichenfolge erstellen:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

aka 65 mal A, 66 mal B, 67 mal C ...

und dann wählt es ein zufälliges Zeichen darin

CJam, 11 Bytes

4.mrmqC*'A+

oder

676.mrmq'A+

Probieren Sie es online!

Diese Lösung ähnelt Luis 'Idee und erzeugt eine ungleichmäßige Verteilung, indem die Quadratwurzel der Zufallsvariablen verwendet wird.

Batch, 116 Bytes

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

Arbeitet durch Auswählen der größeren oder kleineren (ich vergesse welche) von zwei Zufallsvariablen.

Matlab, 22

Gibt oft frühe Briefe zurück, kann sie aber theoretisch alle berühren!

Nimmt eine durch eine Zufallszahl geteilte Zahl, begrenzt diese auf 26 und wandelt sie in eine Figur um.

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

Natürlich nicht sehr kurz, aber vielleicht kann das Konzept andere Antworten inspirieren.

CJam, 10 Bytes

CJam Ansatz # 3 ...

26mr)mr'A+

Probieren Sie es online!

Dies erzeugt eine einheitliche Zufallszahl xzwischen 1 und 26 und verwendet diese dann, um eine einheitliche Zufallszahl zwischen 0und zu erzeugen, x-1die addiert wird A. Dies führt zu einer Tendenz zu kleineren Zeichen.

Labyrinth , 19 Bytes

__v6%_65+.@
" )
"^2

Probieren Sie es online!

Dies ist eine Schleife, die bei jeder Iteration entweder a) einen Zähler erhöht, der bei Null beginnt, oder b) mit einer Wahrscheinlichkeit von 50% beendet. Am Ende der Schleife wird der Zähler modulo 26 genommen und zu 65 addiert, um einen Buchstaben zwischen Aund zu ergeben Z.

Dies ergibt eine Wahrscheinlichkeit für Aetwas mehr als 50%, Betwas mehr als 25% usw. bis Zetwas mehr als 1/2 ²⁶ . Theoretisch besteht die Möglichkeit, dass dies für immer abläuft, aber dieses Ereignis hat die von der Herausforderung geforderte Wahrscheinlichkeit Null (in der Praxis ist dies wahrscheinlich ohnehin nicht möglich, da der PRNG zu einem bestimmten Zeitpunkt im Laufe seines Zeitraums beide möglichen Ergebnisse zurückgibt).