Seriler Hakkında

Bu Günün Rastgele Golf serisinin konuk girişidir.

Öncelikle, buna diğer herhangi bir kod golf mücadelesi gibi davranabilir ve seri hakkında endişelenmeden cevap verebilirsiniz. Ancak, tüm zorluklarda bir lider tablosu var. Afiş ilk yazı dizisinde dizileri hakkında daha fazla bilgi ile birlikte bulabilirsiniz .

Giriş

Giriş alınmadı.

Çıktı

İsteğe bağlı bir izleyen yeni satır ile alfabenin tek bir harf (durum ilgisiz). Her harf, sıfır olasılıkla seçilme olasılığına sahip olmalı ve 26 olasılık da farklı olmalıdır . Tüm belirsizliği ortadan kaldırmak için: Belirgin, birbirine eşit iki olasılık olmaması gerektiği anlamına gelir.

puanlama

Bu kod golfü. Bayt cinsinden en kısa kod kazanır.

Geçerli bir giriş, sıfırlanmama ihtimali sıfır olan tam bir program veya fonksiyondur .

Alfabe

Karışıklığı önlemek için kullanılacak özel alfabe Latin alfabesidir:

ya

ABCDEFGHIJKLMNOPQRSTUVWXYZ

veya

abcdefghijklmnopqrstuvwxyz

Büyük harf veya küçük harf çıkarmayı seçebilirsiniz. Alternatif olarak, eğer yardımcı olursa farklı denemelerde farklı vakalar çıkarmayı seçebilirsiniz. Belirli bir harf için olasılık, her iki durumda da (üst ya da alt) görünen o harfin olasılığıdır.

açıklama

Çıktıdan açıkça anlaşılmayacağından , lütfen 26 farklı olasılığı nasıl elde ettiğinize dair net bir açıklama ekleyin.

Liderler Sıralaması

( buradan )

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>

Serinin ilk gönderisi aynı zamanda genel bir lider tablosu oluşturur.

Yanıtlarınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak her bir başlığa başlıkla başlayın:

## Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

(Dil şu anda gösterilmiyor, ancak snippet bunu gerektiriyor ve ayrıştırıyor ve gelecekte bir dilin lider tahtası ekleyebilirim.)

Pyth, 5

Os._G

Burada dene

Böylece, alfabenin önekleri hesaplar: ["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]. Sonra listeyi düzleştirir ve tek biçimli olarak rastgele bir öğe seçer. Bu, a26 kez bgöründüğü için, 25 kez göründüğü halde z, sadece 1 görünüme kadar, her harfin farklı görünme şansı olduğu anlamına gelir. Toplam dize 351 karakterden oluşur.

MATL, 6 Karakter

1Y2Xr)

Açıklama:

XrNormal dağılmış rasgele bir sayı alın )Endekslemek için bunu kullanın ... 1Y2Alfabe

Dağılım 0 civarında simetriktir ve sayının char'a çevrilmesi 0.5 civarında simetriktir. Gibi olasılıklar belirgin olmalıdır.

05AB1E , 6 bayt

kod

A.pJ.R

açıklama

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

Şimdi şu dizgeye sahibiz:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

Ondan sonra kullanarak rastgele bir eleman seçiyoruz .R.

Olasılıklar

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%

Çevrimiçi deneyin! .

Jöle , 5 bayt

ØA»ẊX

Çevrimiçi deneyin!

Nasıl çalışır

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

Arka fon

Let L ₀ , ..., L ₂₅ O anlamına gelir doğal sırayla alfabenin harfleri ve S ₀ , ..., S ₂₅ eşit bir biçimde rastgele seçilen permütasyon L . Sonlu dizisi tanımlama M tarafından M _n- maks (L = _N , S _{, n} ) .

Düzeltme , n de , 0, ... 25 ve tanımlamak k endeksi bu şekilde gösterilen L _{, n} = S _k .

Olasılık ile 1/26 , L _{, n} = S _{, n} ve n = k , yani M _{, n} = L _{, n} ve L _{, n} occurrs kez M .

Olasılık ile 25/26 , L _{, n} ≠ S _{, n} ve n ≠ k . Bu durumda, aşağıdakiler olur.

• Olasılık ile N / 25 , S _{, n} biri L ₀ , ..., L _{, n - 1} , yani L _{, n} > S _{, n} ve M _{, n} = L _{, n} .

• Bağımsız olarak, aynı zamanda olasılıkla N / 25 , k biri 0, ... n - 1 , yani S _k > L _K ve M _k = S _k = L _{, n} .

Bu nedenle, ortaya çıkma beklenen sayısı L _n, içinde M ise 1/26 + 25/26 · (n / 25 + n / 25) = (2n + 1) / 26 .

Şimdi bir terim seçmek Son olarak, m ve M eşit rastgele, mektup L _n, biz olasılık ile seçilebilir (2n + 1) / 26/26 = (2n + 1) / 676 .

Bu, aşağıdaki olasılık dağılımını verir.

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

Bağlantıyı 100.000 kez arayarak (birkaç saniye sürer) dağılımı ampirik olarak doğrulayabilirsiniz .

MATL , 10 bayt

1Y2rU26*k)

Çevrimiçi deneyin!

Kod, (0,1) ( r) aralığında tek biçimli bir rasgele değişken oluşturur ve karesini ( U) hesaplar . Bu, düzgün olmayan, azalan bir olasılık yoğunluğuyla sonuçlanır. 26 ( 26*) ile çarpmak sonucun aralıkta (0,26) olmasını sağlar ve aşağı yuvarlama ( k), azalan olasılıklarla 0,1, ..., 25 değerlerini üretir. Değer, )büyük harfli alfabe ( 1Y2) içine bir indeks ( ) olarak kullanılır . MATL, 1 tabanlı modüler indeksleme kullandığından, 0, Z, 1 ila A, 2 ila B vs.'ye karşılık gelir.

Olasılıkların farklı olduğunu gösteren bir örnek olarak, işte 1000000 rastgele gerçekleşmeden kaynaklanan ayrı bir histogram. Grafik, Matlab'da şu şekilde çalıştırılarak üretilir:

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

Java 7, 62 57 56 bayt

Poke sayesinde 5 bayt.

Trichoplax sayesinde 1 bayt.

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!

Frekans diyagramı (1e6 çalışır, ölçekleme faktörü 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 bayt

@Martin Ender -1 bayt sayesinde -4 bayt
@Dom Hastings sayesinde

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

İhtiyaç duyması -M5.010veya -Eçalıştırılması:

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

Aşağıdaki kodun çalıştırılması her harfin oluşumunu gösterecektir:

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

Nasıl çalışır : Kodun oldukça açık olduğunu düşünüyorum, ancak yine de: 0ve arasında rastgele bir sayı seçer rand 26. Bu yüzden, 0( Aharflere) yakın rakamların seçilmesi ihtimali çok daha yüksek bir ihtimaldir .

PHP, 44 36 29 27 bayt

^{44'ü geçti, hala 44'dür;}

Tüm yardım için insertusernamehere, Petah ve Crypto'ya teşekkürler

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

0 ile 675 arasında rasgele bir sayı seçer (= 26 ² -1), karekökünü alır ve onu chrdöşer ( işlev argümanını bir tamsayıya dönüştürür). Kareler aralarında farklı aralıklar bulunduğundan, seçilen her sayının olasılığı belirgindir. Her n olasılıkla (2n + 1) / 676 seçildi.

Bu sayıya 65 eklemek, Aile arasında rastgele bir karakter verir Z.

1.000.000 kez çalışan kodun ideonu

R, 40 27 bayt

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

Bu alacak 1numarayı 26doğru olasılığını büyüyen üretilen sayılar Zdeğiştirmeden, ve bir mektubu büyük harf listesinden, bu numarayı olduğu dizini görüntülemek LETTERS.

sampleİşlevin argümanları :

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

> <> , 14 bayt

lx
;>dd+%'A'+o

> <> toroidal 2B bir dildir ve farklı olasılıklar bölümü doğal olarak dilin tek rastgele kaynak olması nedeniyle gerçekleşir. Çevrimiçi deneyin!

İlgili komutlar:

[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

Böylece çıktı olasılıkları:

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 bayt

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

Açıklama: Bu aralıkta rasgele bir kayan nokta sayısı oluşturur [0, 676), karekökü alır ve sonra onu döşer. Sonra 65 ekler ("A" nın ascii değeri), onu bir karaktere dönüştürür ve yazdırır.

Bu, 0'dan 25'e kadar her sayıya ayrı bir olasılık verir. Nedenini anlamak için böyle düşünün. Karekök ve taban aldığınızda, tam sayı olmayanları yok sayarak kaç sayı 0 verir? Sadece bir numara (sıfır) olacaktır. Bu, sıfır olasılığının olduğu anlamına gelir 1/676. Kaç tane sayı üretecek 1? 3, 1, 2 ve 3 olacaktır. Bu, birinin olasılığı olduğu anlamına gelir 3/676. 4, 5, 6, 7 veya 8 ile iki tane üretilebilir, olasılık 5, üçün olasılık 7, vb. Vardır ve ardışık kareler arasındaki fark iki kat artarsa, bu desen her sayı için devam eder. ila 25 (Z).

Sızdıran rahibe sayesinde 1 bayt kurtarıldı!

PowerShell v2 +, 33 31 bayt

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

Bir dizi alır 65için 90(diğer bir deyişle, ASCII Aiçin Z), bir halka ya da boru o. Her yinelemede, virgül işlecini kullanarak bu sayının çarpı o öğeden oluşan bir dizi oluştururuz. Örneğin, bu 65 65s, 66 66s, 67 67s, vb. Yapacak. Bu büyük dizinin boruya bağlanması Get-Random(üniform olarak PRNG) bir eleman seçecek. Her elemanın farklı miktarları olduğundan, her karakterin seçilme yüzdesi biraz farklıdır. Daha sonra onu parens içinde enkapsüle edip a olarak atarız char. Bu, boru hattında bırakılan ve çıktının kapalı olduğu.

( Yayınlanmadan önce bile birkaç byte golf attığı için @LeakyNun'a teşekkürler .: D)

Olasılıklar

(hafif yuvarlama Psayesinde -format operatörünün seçeneğini gösterebilirim)

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 bayt

Beni 5 bayt kurtardığı için Martin Ender'e teşekkürler!

Yeni sürüm

'\,:,s_el-mR

Bu modele uyan bir dize dizisi oluşturur A, AB, ABC, vb. Onu düzleştirir ve rastgele bir karakter seçer. Bu dize 26 A, 25 B, 24 C, vb. İçerdiğinden, her harfin seçilme olasılığı vardır.

Çevrimiçi deneyin!

açıklama

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

Eski versiyon

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

Her harfin alfabedeki konumuna eşit sayıda göründüğü bir dize yaparak belirgin olasılıklar elde eder.

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 bayt

sample(LETTERS,1,,1:26)

Sadece bir yerleşikten gelen bir mektubu 'örnekler'. 1:26Her mektubu farklı bir olasılık veren ağırlıkları vektörüdür.

C, 35 bayt

Bu program, varsayılan RAND_MAXolarak gcc'de olduğu gibi (2 ^ 32/2) - 1 olduğunu varsaymaktadır . İşlevi -lmbağlamak için bayrakla derleyin sqrt. Çıktı yeni satırları takip etmeden stdout'a büyük harflerle yazılır.

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

İsteğe bağlı RAND_MAXolarak (2 ^ 16/2) - 1 ise, daha kısa bir 32 byte versiyon kullanılabilir:

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

Yalnızca eğlence için, sqrtişlevi kullanmayan veya dahil edilen matematik kütüphanesini gerektiren bir sürüm de yaptım (bunun RAND_MAXda (2 ^ 32/2) - 1 olması gerekir), ancak sandığımdan daha uzun sürdü oldukça havalı:

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

açıklama

[İlk Program]

Kullanılan ilk iki için sqrt, fonksiyon sadece aralığı haritalar [0, RAND_MAX)için [0, 25]bölünme yoluyla ve daha sonra 65 (ASCII ekler Açıktısı önce ASCII alfabeye vardiya değere).

[İkinci Program]

İkinci program, benzer bir stratejiye göre biraz daha karmaşık, ancak sqrtoperatör olmadan daha karmaşık . Kayan bir noktanın üs bitleri bir tamsayı atandığında otomatik olarak hesaplandığından, bir sayının temel 2 logaritmasını elde etmek için etkili bir şekilde kullanılabilirler.

Yalnızca RAND_MAX25 kodlanmış bir üs değerine ulaşmak için aralık istediğimiz için , hesaplama (2 ^ 32/2 - 1) / (2 ^ 25) bize randharitalama sırasında kullanılan 64 kadarı verir . bu yeni seriye. Ayrıca, 0'ın kayan nokta gösterimi oldukça tuhaf ve bu algoritmayı bozacağı için değere 1 ekledim.

Daha sonra, şamandıra uç kaydırma ve diğer benzeri işlemlere izin vermek için bir tamsayıya yazılır. IEEE 754 kayan nokta sayılarında üs bitleri 30-23 bit olduğundan, sayı daha sonra 23 bit kaydırılır, mantisleri kesilir ve ham üs değerinin bir tamsayı olarak okunmasına izin verilir. Tabela bitinin üs bitlerinin dışında olduğunu unutmayın, ancak hiçbir zaman negatif olmadığından maskelenmesi gerekmez.

Daha önce yaptığımız gibi bu sonuca 65 eklemek yerine, kayan nokta üsleri 0 ile 255 arasında işaretsiz bir 8 bit tam sayı olarak gösterilir, burada 0 üs değeri 127 (gerçek "imzalı" üs değerini almak için 127'yi çıkarın) ). 127 - 65, 62 olduğundan, bunun yerine 62'yi hem bu kayan nokta üssünün dışına çıkarmak hem de ASCII alfabe aralığına kaydırmak için çıkarırız.

dağıtım

Ben matematik uzmanı değilim, bu yüzden bu dağılımların kesin formülünü kesin olarak söyleyemem, ancak [0, RAND_MAX)bir harfin menzilinin diğerinin başladığı yer arasındaki mesafenin asla bitmediğini göstermek için aralıktaki her değeri test edebilir (ve yaptım) . aynı. (Bu testlerin (2 ^ 32/2) - 1) rasgele maksimum olduğunu varsaydığını unutmayın)

[İlk 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

[İkinci 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 bayt

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

Karakteri ascii değerine göre çarpar, ardından elde edilen dizgeden rastgele bir karakter alır.

Seçili olan her harf için olasılıklar, yüzde olarak:

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

Deneyin: https://repl.it/Cm0x

Jöle , 5 bayt

ØAxJX

(Eşit puan, ancak farklı bir yöntem , Dennis tarafından mevcut bir Jelly çözümüne .)

Her mektubu verme olasılığı, alfabedeki 351 - 26 üçgen sayısının 1'e göre indekslenmesidir:

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

1 + 2 + ... + 26 = 351’den beri, P (harf) = 1.

Uygulama:

ØAxJX    - no input taken
ØA       - yield the alphabet: 'ABC...Z'
   J     - yield [1,...,len(Left)]: [1,2,3,...26]
  x      - Left times Right: 'abbccc...zzzzzzzzzzzzzzzzzzzzzzzzzz'
    X    - choose random element from Left

TryItOnline'da test edin ya da 100.000 koşunun dağıtımını elde edin (Dennis'e kod kredisi)

q, 38 bayt

Özellikle kısa değil ama ...

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

Ayrık kümülatif dağılım fonksiyonu sekanstır.

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

Ve biz sadece dağıtımdan örnek alıyoruz.

JavaScript (ES6), 45 bayt

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

Rasgele değeri karıştırarak düzgün olmayan bir dağılım elde eder. Math.random()aralığın bir yüzgecini döndürür, [0,1)böylece karenin sonucu doğru 0(veya a) olur.

Ölçek

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 bayt

Alfabedeki karakter pozisyonunu olasılık olarak kullanmak

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;

Un-golfed

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 bayt

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

rand (0,1) 'de tek biçimli bir değer üretir, bu 26 ^ rand'a 1 - 26 arasında tamsayıları eşitlemek için farklı bir olasılık verir.

Eski sürüm, 45 bayt

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

TI-Basic tam sayılarının sınırlı kesinliği, ± ± 7,02σ içinde sayı üretme normal dağılımlarını sınırlar (bkz. randNorm(). Bu yüzden, daha önce belirtilen pratik aralığı µ ± 28.08σ'ya yükseltmek için 00 ve σ 1 ile rastgele bir sayının mutlak değerini elde ederiz. Sonra, değeri katlayıp 1 ekleriz, çünkü sub(1 indekslidir, bize her biri farklı olasılıklarla 1-29 arasında bir aralık verir.

PHP, 92 84 bayt

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

Tüm harflerden oluşan bir dize oluşturur, bulunduğumuz döngü boyunca kaç kez tekrarlanır ve sonra bu dizgeden gelen bir harfi rastgele alır. Sonuçta alfabedeki harflerin sonuç olarak daha yüksek olasılıkları vardır.

Bayt tıraş için insertusernamehere teşekkürler

sonuç olasılıkları (% ile sıralanır)

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 bayt

Biraz farklı olasılıklar ile, birincisinden daha fazla kompakt: İlk ?bir var 1/4 "ilk denemede" konulu bir A baskı şansı, 2/4 şans aynı geri gelmek ?ve 1/4 geçmek için Sonraki. Geri kalanların ?her birinin altında 1/4 harf, 1/4 tekrar denemek için bir sonraki mektuba 1/4 , bir sonraki harekette 1/4 hareket etmek için 1/4 şansı var . Yine, bir A basma olasılığı bir Z basmaktan çok daha yüksektir.

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

Befunge, 186 bayt

Açıkçası bu kazanmayacağım, ama yine de ilginç bir cevap olduğunu düşünüyorum :)

vve >imleci sırasıyla aşağı ve sağa yönlendirir. ?Operatör rastgele dört yönde bir kapalı imleci gönderir. Birincisi ve iki yöne ?"bloke edilir" , bu yüzden sadece iki yolu vardır: Ya A'yı ya da aşağıdakini yazdırmak için . Yani sadece ilkinden itibaren % 50 oranında A yazdırma şansı var.v>??

Bir sonraki ?bir sahiptir 1/3 B, baskı şansı 1/3 geri gitmeyi ve 1/3 ayrıca aşağı gidiyor. Vs vs.

Yüksek harflerin, alt harflerden daha fazla basılma şansı olduğu açık olmalıdır, ancak her bir mektubun şansının ne olduğundan tam olarak emin değilim.

Kesin matematik ile ilgili bazı yardımlar takdir edilecektir :)

En azından 1/2 * 1/3 ^ 25 ilk denemede imlecin Z yönünde aşağıya doğru hareket etme şansı var, ancak imlecin yukarı ve aşağı hareket etme şansının her harfi nasıl etkilediğinden emin değilim.

,@ yazdırır ve çıkar.

 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 bayt

(? {~ @ #) U: 64 + # ~ 1 + I.26
(? {~ @ #) U: 64 + # ~ I.27

Çevrimiçi tercüman

Büyük harf.

Her harfin olasılığı, alfabedeki 1 tabanlı dizinidir.

zsh, 63 bayt

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

Bu dize oluşturarak çalışır:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

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

ve sonra içinde rastgele bir karakter seçer.

CJam, 11 bayt

4.mrmqC*'A+

veya

676.mrmq'A+

Çevrimiçi deneyin!

Bu çözüm Luis'in fikrine benzer ve rastgele değişkenin karekökünü alarak düzgün olmayan bir dağılım oluşturur.

Toplu iş, 116 bayt

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

İki rastgele değişkenden daha büyük veya daha küçük (hangisini unuttuğumu) seçerek çalışır.

Matlab, 22

Sık sık erken harfleri döndürür, ancak teorik olarak hepsine dokunabilir!

Rastgele bir sayı ile ayrılmış bir tane alır, bunu 26 ile sınırlar ve onu bir karaktere dönüştürür.

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

Elbette çok kısa değil, ama belki de konsept diğer cevaplara ilham verebilir.

CJam, 10 bayt

CJam yaklaşıyor # 3 ...

26mr)mr'A+

Çevrimiçi deneyin!

Bu, x1 ile 26 arasında eşit olarak rastgele bir sayı oluşturur ve daha sonra arasında eklenmiş 0ve arasında eşit olarak rasgele bir sayı oluşturmak için bunu kullanır . Bu önyargılar daha küçük karakterlere yol açar.x-1A

Labirent , 19 bayt

__v6%_65+.@
" )
"^2

Çevrimiçi deneyin!

Bu, her yinelemede ya a) sıfırdan başlayan bir sayacı artıran veya b) her ikisi de% 50 olasılıkla sonlanan bir döngüdür. Döngü sonunda, bir sayaç modülo 26 alınır ve ilave 65 arasında bir harf elde edilir Ave Z.

Bu, A% 50'nin biraz üzerinde, Bsadece% 25'in biraz üzerinde ve bu Zoranın 1/2 ²⁶ üzerinde bir miktarına kadar bir olasılık veriyor . Teorik olarak, bunun sonsuza dek sürmesi olasılığı var, ancak bu olay, meydan okuma için gerekli sıfır olasılığına sahiptir (pratikte zaten mümkün değildir çünkü PRNG, her iki olası sonucu da belirli bir noktada geri döndürecektir).