Sobre la serie

Esta es una entrada invitada para la serie Random Golf of the Day.

En primer lugar, puede tratar esto como cualquier otro desafío de golf de código y responderlo sin preocuparse por la serie. Sin embargo, hay una tabla de clasificación en todos los desafíos. Puede encontrar la tabla de clasificación junto con más información sobre la serie en la primera publicación .

Entrada

No se toma ninguna entrada.

Salida

Una sola letra del alfabeto (caso irrelevante), con una nueva línea final opcional. Cada letra debe tener una probabilidad distinta de cero de ser elegida, y las 26 probabilidades deben ser distintas . Para eliminar toda ambigüedad: Distinto significa que no debe haber dos probabilidades que sean iguales entre sí.

Puntuación

Este es el código de golf. El código más corto en bytes gana.

Una entrada válida es un programa o función completa que tiene una probabilidad cero de no terminar.

Alfabeto

Para evitar confusiones, el alfabeto particular que se utilizará es el alfabeto latino:

Ya sea

ABCDEFGHIJKLMNOPQRSTUVWXYZ

o

abcdefghijklmnopqrstuvwxyz

Puede optar por generar mayúsculas o minúsculas. Alternativamente, puede optar por generar diferentes casos en diferentes ejecuciones si eso ayuda. La probabilidad de una letra dada es la probabilidad de que esa letra aparezca en cualquier caso (superior o inferior).

Explicación

Como no será del todo obvio por el resultado, incluya una explicación clara de cómo logró las 26 probabilidades distintas.

Tabla de clasificación

(desde aquí )

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>

La primera publicación de la serie también genera una tabla de clasificación general.

Para asegurarse de que sus respuestas aparezcan, comience cada respuesta con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

(El idioma no se muestra actualmente, pero el fragmento sí lo requiere y analiza, y puedo agregar una tabla de clasificación por idioma en el futuro).

Pyth, 5

Os._G

Pruébalo aquí

Calcula los prefijos del alfabeto, así: ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Luego aplana la lista y selecciona un elemento aleatorio de manera uniforme. Esto significa que, dado que aaparece 26 veces, mientras que baparece 25 veces, hasta el final zcon solo 1 aparición, cada letra tiene una posibilidad diferente de aparecer. La cadena total tiene 351 caracteres.

MATL, 6 Personajes

1Y2Xr)

Explicación:

XrTome un número aleatorio normalmente distribuido )Use esto para indexar en ... 1Y2El alfabeto

La distribución es simétrica alrededor de 0, y la traducción del número a char es simétrica alrededor de 0.5. Como tal, las probabilidades deben ser distintas.

05AB1E , 6 bytes

Código

A.pJ.R

Explicación

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

Ahora tenemos la siguiente cadena:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Después de eso, elegimos un elemento aleatorio usando .R.

Las probabilidades

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%

Pruébalo en línea! .

Jalea , 5 bytes

ØA»ẊX

Pruébalo en línea!

Cómo funciona

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

Antecedentes

Let L ₀ , ..., L ₂₅ denota las letras del alfabeto en su orden natural, y S ₀ , ..., s ₂₅ una permutación aleatoria seleccionada de manera uniforme a de L . Defina la secuencia finita M por M _n = max (L _n , S _n ) .

Arregle n en 0,… 25 y defina k como el índice tal que L _n = S _k .

Con probabilidad 1/26 , L _n = S _n y n = k , por lo que M _n = L _n y L _n occurrs una vez en M .

Con probabilidad 25/26 , L _n ≠ S _n y n ≠ k . En este caso, sucede lo siguiente.

• Con probabilidad n / 25 , S _n es uno de L ₀ , ..., L _{n - 1} , entonces L _n > S _n y M _n = L _n .

• Independientemente, también con probabilidad n / 25 , k es uno de 0, ... n - 1 , entonces S _k > L _k y M _k = S _k = L _n .

Por lo tanto, el número esperado de ocurrencias de L _n en M es 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 .

Finalmente, si ahora seleccionamos un término m de M de manera uniforme al azar, la letra L _n se elegirá con probabilidad (2n + 1) / 26/26 = (2n + 1) / 676 .

Esto produce la siguiente distribución de probabilidades.

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

Puede verificar empíricamente la distribución llamando al enlace 100,000 veces (toma unos segundos).

MATL , 10 bytes

1Y2rU26*k)

Pruébalo en línea!

El código genera una variable aleatoria uniforme en el intervalo (0,1) ( r) y calcula su cuadrado ( U). Esto da como resultado una densidad de probabilidad decreciente no uniforme. Multiplicar por 26 ( 26*) asegura que el resultado esté en el intervalo (0,26), y el redondeo hacia abajo ( k) produce los valores 0,1, ..., 25 con probabilidades decrecientes. El valor se usa como un índice ( )) en el alfabeto en mayúsculas ( 1Y2). Dado que MATL usa indexación modular basada en 1, 0 corresponde a Z, 1 a A, 2 a B, etc.

Como ilustración de que las probabilidades son distintas, aquí hay un histograma discreto resultante de 1000000 realizaciones aleatorias. El gráfico se produce al ejecutar esto en Matlab:

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

Java 7, 62 57 56 bytes

5 bytes gracias a Poke.

1 byte gracias a 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 it!

Diagrama de frecuencia (1e6 carreras, factor de escala 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 gracias a @Martin Ender
-1 byte gracias a @Dom Hastings

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

Necesita -M5.010o -Ecorrer:

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

Ejecutar el siguiente código mostrará la aparición de cada letra:

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ómo funciona : supongo que el código es bastante explícito, pero aún así: elige un número aleatorio entre 0y rand 26. Por lo tanto, hay una probabilidad mucho mayor de que se elijan números cercanos a 0(letra A).

PHP, 44 36 29 27 bytes

^{Tachado 44 sigue siendo regular 44; (}

Gracias a insertusernamehere, Petah y Crypto por toda la ayuda

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

Elige un número aleatorio entre 0 y 675 (= 26 ² -1), toma su raíz cuadrada y la coloca (la chrfunción convierte su argumento en un entero). Dado que los cuadrados tienen diferentes intervalos entre ellos, la probabilidad de que cada número sea elegido es distinta. Cada n se elige con probabilidad (2n + 1) / 676.

Agregar 65 a este número le da un carácter aleatorio de Aa Z.

Ideona del código corriendo 1,000,000 veces

R, 40 27 bytes

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

Esto tomará el 1número de los 26números generados con una probabilidad creciente hacia Z, sin reemplazar, y mostrará una letra cuyo índice es este número, de la lista de letras mayúsculas LETTERS.

Los argumentos de la samplefunción son:

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

> <> es un lenguaje 2D toroidal, y la parte de las probabilidades distintas ocurre naturalmente debido a la única fuente de aleatoriedad del lenguaje. Pruébalo en línea!

Los comandos relevantes son:

[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

Por lo tanto, las probabilidades de salida son:

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

Pitón 2, 58 57 bytes

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

Explicación: esto genera un número aleatorio de coma flotante en el intervalo [0, 676), toma la raíz cuadrada y luego la coloca en el piso. Luego agrega 65 (el valor ascii de "A"), lo convierte en un carácter y lo imprime.

Esto le da a cada número del 0 al 25 una probabilidad distinta. Para entender por qué, piénsalo así. ¿Cuántos números, ignorando los no enteros, cuando tomas la raíz cuadrada y el piso dan 0? Solo un número será (cero). Esto significa que cero tiene una probabilidad de1/676 . ¿Cuántos números producirán 1? 3 will, 1, 2 y 3. Esto significa que uno tiene una probabilidad de 3/676. Se puede producir un dos con un 4, 5, 6, 7 u 8, lo que le da una probabilidad de 5, un tres tiene una probabilidad de 7, etc. a 25 (Z).

¡1 byte guardado gracias a la monja con fugas!

PowerShell v2 +, 33 31 bytes

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

Toma un rango de 65a 90(es decir, ASCII Aa Z), lo canaliza a través de un bucle. En cada iteración, utilizamos el operador de coma para crear una matriz de ese elemento multiplicado por ese número. Por ejemplo, esto generará 65 65s, 66 66s, 67 67s, etc. Esa gran matriz se canaliza a la Get-Randomque (uniformemente PRNG) seleccionará un elemento. Dado que hay diferentes cantidades de cada elemento, cada personaje tiene un porcentaje ligeramente diferente de ser elegido. Luego encapsulamos eso en parens y lo lanzamos como a char. Eso queda en la tubería y la salida es implícita.

(Gracias a @LeakyNun por jugar unos pocos bytes incluso antes de que se publicara.: D)

Las probabilidades

(leve redondeo para poder demostrar la Popción del -foperador 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 bytes

¡Gracias a Martin Ender por salvarme 5 bytes!

Nueva versión

'\,:,s_el-mR

Esto forma una matriz de cadenas siguiendo el patrón A, AB, ABC, y así sucesivamente. Lo aplana y elige un personaje aleatorio. Como esta cadena contiene 26 A, 25 B, 24 C, etc., cada letra tiene una probabilidad distinta de ser elegida.

Pruébalo en línea!

Explicación

'\,          e# Push the range of all characters up to 'Z'
   :,        e# For each one, take the range of all characters up to it
     s       e# Convert the array of ranges to one string
      _el-   e# Subtract the lower case version of the string from itself
             e# This leaves only capital letters in the string
          mR e# Take a random character from it

Versión antigua

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

Obtiene probabilidades distintas al hacer una cadena en la que cada letra aparece varias veces igual a su posición en el alfabeto.

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)

Simplemente 'muestra' una carta de un builtin incorporado. El 1:26es un vector de pesos que le da a cada letra una probabilidad diferente.

C, 35 bytes

Este programa asume que RAND_MAXes (2 ^ 32/2) - 1 ya que está en gcc por defecto. Compile con la -lmbandera para vincular la sqrtfunción. La salida se escribe en stdout como letras mayúsculas sin líneas nuevas.

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

Opcionalmente, si RAND_MAXes (2 ^ 16/2) - 1, se puede usar una versión más corta de 32 bytes:

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

Solo por diversión, también hice una versión que no usa la sqrtfunción o requiere la biblioteca matemática incluida (esta debe tener RAND_MAXcomo (2 ^ 32/2) - 1), pero terminó siendo más larga aunque pensé que era muy genial:

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

Explicación

[Primer programa]

Para los dos primeros que usan sqrt, la función simplemente asigna el rango [0, RAND_MAX)a [0, 25]través de la división, y luego agrega 65 (ASCII A) al valor para cambiarlo al alfabeto ASCII antes de generarlo.

[Segundo programa]

El segundo programa es un poco más complejo ya que hace una estrategia similar, pero sin el sqrtoperador. Dado que los bits de exponente de un punto flotante se calculan automáticamente al asignar un número entero, pueden usarse efectivamente como una forma cruda de obtener el logaritmo de base 2 de un número.

Como solo queremos que el rango RAND_MAXalcance un valor de exponente codificado de 25, el cálculo (2 ^ 32/2 - 1) / (2 ^ 25) nos da aproximadamente 64, que se usa durante la división de randpara mapearlo a esta nueva gama. También agregué 1 al valor ya que la representación de coma flotante de 0 es bastante extraña y rompería este algoritmo.

A continuación, el flotante se escribe en un entero para permitir el desplazamiento de bits y otras operaciones similares. Dado que en los números de coma flotante IEEE 754 los bits de exponente son bits 30-23, el número se desplaza 23 bits a la derecha, cortando la mantisa y permitiendo que el valor de exponente bruto se lea como un entero. Tenga en cuenta que el bit de signo también está más allá de los bits de exponente, pero como nunca hay negativos, no es necesario enmascararlo.

Sin embargo, en lugar de sumar 65 a este resultado como lo hicimos antes, los exponentes de coma flotante se representan como un entero de 8 bits sin signo de 0 a 255, donde el valor de exponente de 0 es 127 (simplemente reste 127 para obtener el valor de exponente "firmado" real ) Dado que 127 - 65 es 62, simplemente restamos 62 para desplazarlo fuera de este rango de exponente de coma flotante al rango de alfabeto ASCII, todo en una sola operación.

Distribución

No soy un experto en matemáticas, así que no puedo decir con certeza la fórmula exacta para estas distribuciones, pero puedo (y probé) probar cada valor en el rango [0, RAND_MAX)para mostrar que la distancia entre el final del rango de una letra y la otra comienza nunca es la mismo. (Tenga en cuenta que estas pruebas suponen el (2 ^ 32/2) - 1) máximo aleatorio)

[Primer programa]

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

[Segundo programa]

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

Multiplica el carácter por su valor ascii, luego elige un carácter al azar de la cadena resultante.

Aquí están las probabilidades para cada letra seleccionada, en porcentajes:

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

Pruébalo: https://repl.it/Cm0x

Jalea , 5 bytes

ØAxJX

(Puntuación igual, pero un método diferente , a una solución Jelly existente de Dennis).

La probabilidad de obtener cada letra es su índice basado en 1 en el alfabeto dividido por 351, el 26 ° número triangular:

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

Como 1 + 2 + ... + 26 = 351, P (letra) = 1.

Implementació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

Pruébelo en TryItOnline u obtenga la distribución de 100K carreras (código de crédito para Dennis)

q, 38 bytes

No particularmente corto pero ...

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

La función de distribución acumulativa discreta es la secuencia

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

Y simplemente tomamos muestras de la distribución.

JavaScript (ES6), 45 bytes

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

Logra una distribución no uniforme al cuadrar el valor aleatorio. Math.random()devuelve un flotador del rango, [0,1)por lo que el resultado de cuadrar esto tiende hacia 0(o a).

Prueba

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 bytes

Usar la posición del personaje en el alfabeto como probabilidad

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;

Sin golf

SELECT c FROM
  (SELECT dbms_random.value(0,351)v FROM DUAL), -- random value
  (
    SELECT c,e,LAG(e,1,0)OVER(ORDER BY c)s -- Mapping each character to its interval 
    FROM   (
             -- Each char has it's position in the alphabet as probability
             SELECT CHR(LEVEL+64)c,SUM(LEVEL)OVER(ORDER BY LEVEL)e 
             FROM   DUAL 
             CONNECT BY LEVEL<27
           )  
  )
WHERE v BETWEEN s AND e -- match the random value to an interval

TI-Basic, 39 bytes

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

rand genera un valor uniforme en (0,1]. Esto le da a 26 ^ rand una probabilidad diferente de igualar los enteros de 1 a 26.

Versión anterior, 45 bytes.

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

La precisión limitada de los enteros TI-Basic limita las distribuciones normales para generar números dentro de µ ± 7.02σ (ver randNorm(). Entonces obtenemos el valor absoluto de un número aleatorio con µ 0 y σ 1, multiplicando por cuatro para aumentar el rango práctico mencionado anteriormente a µ ± 28.08σ. Luego, colocamos el valor en el piso y sumamos 1, ya que sub(está indexado en 1, lo que nos da un rango de 1-29 con diferentes probabilidades de cada uno.

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

Construye una cadena de todas las letras, repite el número de veces a través del bucle que estamos y luego elige una letra de esa cadena al azar. Las letras más adelante en el alfabeto tienen una mayor probabilidad como resultado

Gracias a insertusernamehere por eliminar bytes

probabilidades de resultado (ordenadas por%)

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

Más compacto que el primero, con probabilidades un poco diferentes: los primeros ?tienen una probabilidad de 1/4 de imprimir una A en el "primer intento", 2/4 de posibilidad de volver a la misma ?y 1/4 de moverse al próximo. El resto de los ?s tienen 1/4 de posibilidades de imprimir la letra debajo de ellos, 1/4 para volver a intentarlo, 1/4 moviéndose a la siguiente letra, 1/4 moviéndose a la anterior. Nuevamente, la probabilidad de imprimir una A es mucho mayor que imprimir una Z.

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

Befunge, 186 bytes

Obviamente no voy a ganar con esto, pero creo que es una respuesta interesante :)

vy >dirige el cursor respectivamente hacia abajo y hacia la derecha. El ?operador envía el cursor en una de las cuatro direcciones al azar. El primero ?está "bloqueado" por vy> en dos direcciones, por lo que solo tiene dos vías: imprimir la A o bajar a la siguiente ?. Entonces, desde el primero ?solo hay un 50% de posibilidades de imprimir una A.

El siguiente ?tiene una probabilidad de 1/3 de imprimir una B, 1/3 de volver a subir y 1/3 de bajar más. Etcétera etcétera.

Debería ser bastante obvio que las letras más altas tienen muchas más posibilidades de ser impresas que las letras más bajas, pero no estoy exactamente seguro de cuáles son las posibilidades de cada letra.

Se agradecería un poco de ayuda con las matemáticas exactas :)

Al menos hay un 1/2 * 1/3 ^ 25 probabilidad de que el cursor se mueva hasta la Z en el primer intento, pero no estoy seguro de cómo las posibilidades de que el cursor se mueva hacia arriba y hacia abajo afecte a cada letra.

,@ imprime y termina.

 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 bytes

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

Intérprete en línea

Mayúscula

La probabilidad de cada letra es su índice basado en 1 en el alfabeto.

zsh, 63 bytes

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

funciona creando esta cadena:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

también conocido como 65 veces A, 66 veces B, 67 veces C ...

y luego elige un personaje aleatorio

CJam, 11 bytes

4.mrmqC*'A+

o

676.mrmq'A+

Pruébalo en línea!

Esta solución es similar a la idea de Luis y crea una distribución no uniforme tomando la raíz cuadrada de la variable aleatoria.

Lote, 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%%

Funciona eligiendo la más grande o más pequeña (no recuerdo cuál) de dos variables aleatorias.

Matlab, 22

A menudo devolverá letras tempranas, ¡pero teóricamente puede tocarlas todas!

Toma uno dividido por un número aleatorio, lo limita a 26 y lo convierte en un personaje.

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

No muy corto, por supuesto, pero quizás el concepto pueda inspirar otras respuestas.

CJam, 10 bytes

Enfoque CJam # 3 ...

26mr)mr'A+

Pruébalo en línea!

Esto crea un número aleatorio uniforme xentre 1 y 26 y luego lo usa para crear un número aleatorio uniforme entre 0y al x-1cual se agrega A. Este sesgo da como resultado caracteres más pequeños.

Laberinto , 19 bytes

__v6%_65+.@
" )
"^2

Pruébalo en línea!

Este es un ciclo que, en cada iteración, a) incrementa un contador que comienza en cero o b) termina, ambos con una probabilidad del 50%. Al final del ciclo, el contador se toma el módulo 26 y se agrega a 65 para dar una letra entre Ay Z.

Esto da una probabilidad de Aun poco más del 50%, Bun poco más del 25% y así sucesivamente hasta Zun poco más del 1/2 ²⁶ . En teoría, existe la posibilidad de que esto se ejecute para siempre, pero este evento tiene una probabilidad cero según lo requerido por el desafío (en la práctica eso probablemente no sea posible de todos modos porque el PRNG devolverá ambos resultados posibles en algún momento durante su período).