每日#7高尔夫:一个明显随机的角色


47

关于系列

这是“每日随机高尔夫”系列的嘉宾条目。

首先,您可以像对待其他任何代码高尔夫挑战赛一样对待它,并回答它而不必担心系列赛。但是,在所有挑战中都有排行榜。您可以在第一篇文章中找到排行榜以及有关该系列的更多信息。

输入项

没有输入。

输出量

单个字母(不区分大小写),以及可选的尾随换行符。每个字母的选择概率必须为非零,并且所有26个概率必须是不同的。要消除所有歧义,请执行以下操作:Distinct表示不得存在两个彼此相等的概率。

计分

这是代码高尔夫。以字节为单位的最短代码获胜。

有效条目是一个完整的程序或函数,其终止的可能性为零。

字母

为避免混淆,要使用的特定字母是拉丁字母:

要么

ABCDEFGHIJKLMNOPQRSTUVWXYZ

要么

abcdefghijklmnopqrstuvwxyz

您可以选择输出大写或小写。或者,如果有帮助,您可以选择在不同的运行中输出不同的案例。给定字母的概率是在两种情况下(大写或小写)该字母出现的概率。

说明

由于从输出中根本看不出来,因此请对如何获得26种不同的概率作一个清晰的解释。

排行榜

(从这里开始

该系列的第一篇文章也产生了一个整体的排行榜。

为确保您的答案显示出来,请使用以下Markdown模板以标题开头每个答案:

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数,则可以通过打败旧分数保持标题。例如:

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

(目前未显示该语言,但是该代码段确实需要并对其进行解析,并且将来我可能会添加一个语言排行榜。)


您将如何测量26个不同的概率?通过运行26次程序?

1
@YOU通过解决方案进行了了解-有几种不同的方法都有很好的解释
trichoplax

如果它是一个函数,是否需要打印,还是可以返回字符值?
杰夫·里迪

@Geoff根据输入和输出的默认值,可以打印到STDOUT或返回字符。
trichoplax

@Geoff注意,它必须是一个字符,而不仅仅是代表它的数字值。例如,A而不是65
trichoplax

Answers:


13

Pyth,5岁

Os._G

在这里尝试

计算字母的前缀,因此:["a", "ab", "abc", ..., "abcdefghijklmnopqrstuvwxyz"]。然后拉平列表并从中均匀选择一个随机元素。这意味着既然a出现了26次,而b出现了25次,一直到z只有1次出现,每个字母都有不同的出现机会。总字符串包含351个字符。


1
我喜欢那个答案。非常聪明。
艾伦·费舍尔


19

05AB1E,6个字节

A.pJ.R

说明

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

现在,我们有以下字符串:

aababcabcdabcdeabcdefabcdefgabcdefghabcdefghiabcdefghijabcdefghijkabcdefghijklabcdefghijklmabcdefghijklmnabcdefghijklmnoabcdefghijklmnopabcdefghijklmnopqabcdefghijklmnopqrabcdefghijklmnopqrsabcdefghijklmnopqrstabcdefghijklmnopqrstuabcdefghijklmnopqrstuvabcdefghijklmnopqrstuvwabcdefghijklmnopqrstuvwxabcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxyz

之后,我们使用选择一个随机元素.R

机率

a > 7.4074074074074066%
b > 7.122507122507122%
c > 6.837606837606838%
d > 6.552706552706553%
e > 6.267806267806268%
f > 5.982905982905983%
g > 5.698005698005698%
h > 5.413105413105414%
i > 5.128205128205128%
j > 4.843304843304843%
k > 4.5584045584045585%
l > 4.273504273504274%
m > 3.988603988603989%
n > 3.7037037037037033%
o > 3.418803418803419%
p > 3.133903133903134%
q > 2.849002849002849%
r > 2.564102564102564%
s > 2.2792022792022792%
t > 1.9943019943019944%
u > 1.7094017094017095%
v > 1.4245014245014245%
w > 1.1396011396011396%
x > 0.8547008547008548%
y > 0.5698005698005698%
z > 0.2849002849002849%

在线尝试!


18

果冻,5 个字节

ØA»ẊX

在线尝试!

这个怎么运作

ØA«ẊX  Main link. No arguments.

ØA     Set argument and return value to the alphabet.
   Ẋ   Shuffle it.
  »    Yield the maximum of each letter in the sorted alphabet, and the
       corresponding character in the shuffled one.
    X  Pseudo-randomly select a letter of the resulting array.

背景

L 0,…,L 25以自然顺序表示字母,S 0,…,S 25L的随机选择排列统一表示。定义有限序列中号通过中号Ñ = MAX(L Ñ,S Ñ

n固定为0,…25并将k定义为索引,使L n = S k

以概率二十六分之一大号Ñ = S ñÑ= K,所以中号Ñ = L Ñ大号Ñ在occurrs一次中号

用概率26分之25大号Ñ ≠小号ÑN≠ķ。在这种情况下,将发生以下情况。

  • 概率为n / 25时S nL 0,…,L n-1之一,因此L n > S nM n = L n

  • 独立地,也以概率n / 25k0,…n-1之一,因此S k > L kM k = S k = L n

因此,出现的预期数量大号Ñ中号1/26 25/26 +·(N / 25 + N / 25)=(2N + 1)/ 26

最后,如果我们现在选择一个术语中号均匀地随机的,字母大号Ñ我们可以用概率选择(2N + 1)/ 26/26 =(2N + 1)/ 676

这产生了以下概率分布。

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

您可以通过调用该链接100,000次(花费几秒钟)来凭经验验证分布。


1
@RobertFraser的shuffle-and-yield步骤生成一个列表,其中A出现在任一列表中的任何地方,B出现在任一列表中的B以及另一个列表中除A之外的任何东西,... Z到Z的任何位置出现在两个列表中。因此结果的A大约是Z的52倍。
Sparr

1
@RobertFraser我添加了一个解释。
丹尼斯

2
@DennisJaheruddin是UTF-8。但是,Jelly使用了一个自定义代码页,该页将其理解的所有字符都编码为一个字节。标头中的字节链接指向它。
丹尼斯

2
我看到,当我阅读说明时,还不能立即清楚您也无法利用常规的UTF-8范围。因此,我是否正确假设通过更改解释器并将所有字符映射到单个UTF-8字符,您将拥有完全相同的代码(可读性/可写性稍差)?-如果是这样,请考虑扩展说明以提及char出于高尔夫目的应计入一个字节。
丹尼斯·贾赫鲁丁

2
@DennisJaheruddin如README(标题中的第一个链接)所述,解释器具有两种模式(果冻代码页和UTF-8),因此您可以将此程序保存在实际的5字节文件中。我可以将所有这些信息添加到我写的每个答案中,但是有数百个,因此我选择了链接。
丹尼斯

14

MATL,10字节

1Y2rU26*k)

在线尝试!

该代码在区间(0,1)(r)上生成一个统一的随机变量,并计算其平方(U)。这导致不均匀的,降低的概率密度。乘以26(26*)可确保结果在区间(0,26)上,而四舍五入(k)则可得出概率递减的值0,1,...,25。该值用作)大写字母(1Y2)的索引()。由于MATL使用基于1的模块化索引,因此0对应于Z,1对应于A,2对应于B等。

为了说明概率是不同的,这是由1000000个随机实现产生的离散直方图。该图是通过在Matlab中运行以下代码生成的:

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

enter image description here


1
真好!我能想到的最好的解决方案是16个字节
DJMcMayhem

1
@DJMcMayhem不错的方法!
路易斯·门多

也许,但是更长。:P
DJMcMayhem

另一个有趣的选择:matl.suever.net/…– Suever
2016年

实际上,您不需要k!注意到在尝试codegolf.stackexchange.com/a/89648/11159
Dennis Jaheruddin的

13

Java 7,62 57 56字节

5个字节,感谢Poke。

1个字节,感谢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);}

伊迪恩!

频率图(运行1e6,比例系数1/1000)

A: *
B: ****
C: *******
D: **********
E: *************
F: ****************
G: *******************
H: **********************
I: *************************
J: ***************************
K: ******************************
L: **********************************
M: ************************************
N: ***************************************
O: *******************************************
P: *********************************************
Q: ************************************************
R: ***************************************************
S: ******************************************************
T: *********************************************************
U: ************************************************************
V: ***************************************************************
W: ******************************************************************
X: *********************************************************************
Y: ************************************************************************
Z: ***************************************************************************

1
我认为您无需强制转换为int

@Poke谢谢,打高尔夫球。
Leaky Nun

您可以通过将676移到括号之外来保存字节吗?
trichoplax

@trichoplax是什么意思?
Leaky Nun

2
sqrt(x*y*y) = sqrt(x)*y
trichoplax

10

Perl,24个字节

@Martin Ender -4个
字节,@ Dom Hastings,-1个字节

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

需要-M5.010还是-E要跑:

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

运行以下代码将显示每个字母的出现:

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


工作原理:我猜代码很明确,但是仍然:它在0和之间选择一个随机数rand 26。因此,选择接近0(字母A)的数字的可能性要高得多。


这个解释对我来说很有意义:)
trichoplax

不错的解决方案!您可以使用裸列表和+来保存1个字节:say+(A..Z)[rand rand 26]
Dom Hastings

@DomHastings aarf,我很傻。我尝试了一下(A..Z)[...],但是没有用,所以我想我可以使用这样的匿名数组,但这只是因为say..谢谢!:)
达达

10

PHP,44 36 29 27字节

划掉44仍然是常规44;(

感谢在此插入用户名,Petah和Crypto提供的所有帮助

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

它选择一个介于0到675(= 26 2 -1)之间的随机数,取其平方根,然后对其取底(该chr函数将其参数转换为整数)。由于正方形之间的间隔不同,因此选择每个数字的概率是不同的。以概率(2n + 1)/ 676选择每n个。

在此数字上加65可得到一个从A到的随机字符Z

ideone的代码运行了1,000,000次


你可以打4个字节range(A,Z)
此处插入用户名,2016年

@insertusername此处:感谢您的提示,但是我完全不使用range而是只使用就能打出8个字节chr()
商业猫

3
更好。不幸的是,划掉的44仍然是常规44。:)
insertusername此处为

1
@insertusernamehere您太容易放弃了:-)<s>&nbsp;44&nbsp;</s>
MonkeyZeus

<?=chr(65+sqrt(rand(0,675)));
佩塔

8

R,40 27字节

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

这将从具有较高概率的1数字中获取26数字Z,而不是替换,并从大写字母列表中显示索引为该数字的字母LETTERS

sample函数的参数为:

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

是的,那是行不通的。可能是我最聪明的方法!
弗雷德里克

好吧,总会有衬里!一定要考虑一下...
弗雷德里克

1
固定较短-令人印象深刻:)
trichoplax

1
@trichoplax谢谢!顺便挑战一下!
弗雷德里克

1
@AlbertMasclans:的确可以,但是已经有人回答了,所以我不想“复制”!但是还是要谢谢!;)
Frédéric16年

8

> <>,14个字节

lx
;>dd+%'A'+o

> <>是一种环形2D语言,由于该语言唯一的随机性来源,因此不同的概率部分自然会发生。 在线尝试!

相关命令为:

[Row 1]
l          Push length of stack
x          Change the instruction pointer direction to one of up/down/left/right
           This gives a 50/50 chance of continuing on the first row (moving
           left/right) or going to the next row (moving up/down, wrapping if up)

[Row 2]
>          Change IP direction to right
dd+%       Take top of stack mod 26 (dd+ = 13+13 = 26)
'A'+       Add 65
o          Output as character
;          Halt

因此,输出概率为:

A:  1/2^1  + 1/2^27 + 1/2^53 + ... = 33554432 / 67108863 ~ 0.50000000745
B:  1/2^2  + 1/2^28 + 1/2^54 + ... = half of chance for A
C:  1/2^3  + 1/2^29 + 1/2^55 + ... = half of chance for B
...
Z:  1/2^26 + 1/2^52 + 1/2^78 + ... = half of chance for Y

7

Python 2,58 57字节

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

说明:这将在interval中生成一个随机浮点数[0, 676),取平方根,然后对其取底。然后,它加65(ascii值为“ A”),将其转换为char,然后打印。

这使从0到25的每个数字都有不同的概率。要了解原因,请这样考虑。取平方根和底数为0时,有多少个数字(忽略非整数)?只有一个数字(零)。这意味着零的概率为1/676。多少个数字会产生1?3 will,1、2和3。这意味着一个人的概率为3/676。可以使用4、5、6、7或8生成两个,使其概率为5,三个具有7的概率,依此类推,并且由于连续平方之间的差稳定地增加了2,因此每个数字递增时,这种模式都会继续至25(Z)。

多亏了修女,节省了1个字节!


chr(int(65+randint(676)**.5))
Leaky Nun

1
你可以做的chr(int(65+random()**.5*26))。代数相同,因为26 ==√676。而现在的操作顺序就在您身边
Wheat Wizard

3
@EamonOlive **2*26可以将另一个字节用于逆分布。
2013年

1
1/random()%26应该也可以。
xnor

1
@xnor有时会产生1/0%26
trichoplax

5

PowerShell v2 +,33 31字节

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

取一个范围从6590(即ASCII AZ),将其通过循环传递。每次迭代时,我们使用逗号运算符创建一个数组,该数组的元素乘以该数字。例如,这将达到65 65s,66 66s,67 67s等。该大数组通过管道传输到Get-Random(统一PRNG)选择一个元素。由于每种元素的数量不同,因此每个角色被拣选的机会略有不同。然后,我们将其封装在括号中并将其转换为char。剩下的就在管道上,输出是隐式的。

(感谢@LeakyNun甚至在发布之前打了几个字节。:D)


机率

(四舍五入,以便我可以演示ormat运算符的P选项-f

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

1
我没有看任何答案就开始了。尝试在gal输出([char[]]"uz$(gal|out-string)"-cmatch'[a-z]'|random)的基础上,先将50个字符,然后48个字符,转换为数字,然后先得到42个字符,再转换为31个字符,然后停在那里;看着排行榜,看看那会把我放到哪里。就在这儿。人物性格相同。抱歉,我可能无法战胜这一点。
TessellatingHeckler

5

CJam,21 17 12字节

感谢Martin Ender为我节省了5个字节!

新版本

'\,:,s_el-mR

这形成以下的图案的字符串数组AABABC,等。它将变平并选择一个随机字符。由于此字符串包含26个A,25个B,24个C等,因此每个字母都有不同的被选择概率。

在线尝试!

说明

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

旧版本

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

通过使每个字母出现多次等于其在字母表中的位置的字符串来获得不同的概率。

26,:)                 e# Push 1, 2, ... 26
     '[,'A,-          e# Push 'A', 'B', ... 'Z'
             .*       e# Vectorize: repeat each letter the corresponding number of times
               M*     e# Join with no separator
                 mr   e# Shuffle the string
                   0= e# Get the first character

5

R,23个字节

sample(LETTERS,1,,1:26)

只需从内置文件中“采样”一封信即可。的1:26是权重给每个字母一个不同的概率的向量。


1
1:26是每个字母的权重向量
user5957401

这使其成为一个有效的答案。值得进行解释说明,以便不熟悉R的人可以理解它的工作原理。
trichoplax

1
我打算去,然后我意识到我上面的那个人在他的代码中做了很多相同的事情,并给出了深入的解释器。
user5957401

最好添加一个解释-投票出现时,解决方案在页面上显示的顺序可能会有所不同,因此“上方”的投票可能不会在后面出现。
trichoplax

5

C,35个字节

该程序假定RAND_MAX为(2 ^ 32/2)-1,因为默认情况下它在gcc上。用该-lm标志编译以链接该sqrt函数。输出将以大写字母的形式写到标准输出,而不会在末尾加上换行符。

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

可选地,如果RAND_MAX为(2 ^ 16/2)-1,则可以使用较短的32字节版本:

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

只是为了好玩,我还制作了一个不使用该sqrt函数或不要求包含数学库的版本(该库必须具有RAND_MAX(2 ^ 32/2)-1),但是即使我认为是很酷:

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

说明

[第一程序]

对于使用的前两个sqrt,该函数仅将范围映射[0, RAND_MAX)[0, 25]直通除法,然后将65(ASCII A)添加到该值以在输出之前将其转换为ASCII字母。

[第二程序]

第二个程序有点复杂,因为它执行类似的策略,但是没有sqrt操作员。由于浮点的指数位是在分配整数后自动计算的,因此它们可以有效地用作获取数字以2为底的对数的粗略方法。

由于我们只希望范围RAND_MAX达到编码指数值25,因此(2 ^ 32/2-1)/(2 ^ 25)计算得出的结果只有64,在除法过程中rand用于映射它到这个新范围。我还向该值添加了1,因为0的浮点表示形式很奇怪,并且会破坏该算法。

接下来,将浮点数类型打孔为整数,以允许进行移位和其他此类操作。由于在IEEE 754浮点数中,指数位是30-23位,因此该数会右移23位,截取尾数并允许将原始指数值读取为整数。请注意,符号位也超出了指数位,但是由于从不存在任何负数,因此不必将其屏蔽掉。

而不是像以前那样向此结果添加65,浮点指数表示为从0到255的无符号8位整数,其中指数值0为127(只需减去127即可得到实际的“有符号”指数值)。由于127-65为62,因此我们只需简单地减去62即可将其移出该浮点指数范围并全部移入ASCII字母范围。

分配

我不是数学专家,所以我不能肯定地说出这些分布的确切公式,但是我可以(并且确实)测试范围内的每个值,[0, RAND_MAX)以表明一个字母的范围结束与另一个字母的开始之间的距离永远不会相同。(请注意,这些测试假设(2 ^ 32/2)-1)随机最大值)

[第一程序]

Letter - Starting Location
A - 0
B - 3179089
C - 12716356
D - 28611801
E - 50865424
F - 79477225
G - 114447204
H - 155775361
I - 203461696
J - 257506209
K - 317908900
L - 384669769
M - 457788816
N - 537266041
O - 623101444
P - 715295025
Q - 813846784
R - 918756721
S - 1030024836
T - 1147651129
U - 1271635600
V - 1401978249
W - 1538679076
X - 1681738081
Y - 1831155264
Z - 1986930625

[第二程序]

Letter - Starting Location
A - 0
B - 64
C - 192
D - 448
E - 960
F - 1984
G - 4032
H - 8128
I - 16320
J - 32704
K - 65472
L - 131008
M - 262080
N - 524224
O - 1048512
P - 2097088
Q - 4194240
R - 8388544
S - 16777152
T - 33554368
U - 67108800
V - 134217664
W - 268435392
X - 536870848
Y - 1073741760
Z - 2147483520

仅返回序号就比打印序号短吗?由于char是C中的整数类型,因此应该可以接受。
Mego

@Mego哦,是的,如果可以的话,我只是打高尔夫球的新手,所以我对可接受的输出不太熟悉。
Lemon Drop

4

Python 2,72个字节

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

将字符乘以其ascii值,然后从结果字符串中随机选择一个字符。

以下是每个字母的概率(以百分比表示):

A 3.23
B 3.28
C 3.33
D 3.37
E 3.42
F 3.47
G 3.52
H 3.57
I 3.62
J 3.67
K 3.72
L 3.77
M 3.82
N 3.87
O 3.92
P 3.97
Q 4.02
R 4.07
S 4.12
T 4.17
U 4.22
V 4.27
W 4.32
X 4.37
Y 4.42
Z 4.47

试试看:https : //repl.it/Cm0x


4

果冻,5 个字节

ØAxJX

(等于得分,但不同的方法,对现有的果冻溶液由Dennis)。

产生每个字母的概率是它在字母表中从1开始的索引除以351-第26个三角数:

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

由于1 + 2 + ... + 26 = 351,P(字母)= 1。

实现方式:

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

TryItOnline对其进行测试或获得10 万次运行分发(代码来源为Dennis)


您在哪里学到如此出色的果冻?我很难相信果冻会成为PPCG之外的常识。
Addison Crump

1
@Syxer我只是看了看维基,然后猛冲了一下-仍然不了解所有内容:)
Jonathan Allan

1
好吧。欢迎来到PPCG,进行投票。
艾迪生·克伦普

3

q,38个字节

不是特别短,但是...

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

离散累积分布函数是序列

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

我们只是从分布中抽样。


3

JavaScript(ES6),45个字节

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

通过对随机值求平方来实现非均匀分布。Math.random()返回范围的浮点数,[0,1)因此对它进行平方的结果趋向于0(或a)。

测试


42 B,(n=Math.random(),10+26*n+n|0).toString(36)
Ephellon Dantzler's

3

Oracle SQL 11.2,212字节

使用字母在字母中的位置作为概率

SELECT c FROM(SELECT dbms_random.value(0,351)v FROM DUAL),(SELECT c,e,LAG(e,1,0)OVER(ORDER BY c)s FROM(SELECT CHR(LEVEL+64)c,SUM(LEVEL)OVER(ORDER BY LEVEL)e FROM DUAL CONNECT BY LEVEL<27))WHERE v BETWEEN s AND e;

未打高尔夫球

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

3

TI-Basic,39个字节

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

rand 会在(0,1]中生成一个统一值。这使26兰特具有不同的概率,等于1到26之间的整数。

旧版本,45字节

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

TI-Basic整数的有限精度将正态分布限制为生成µ±7.02σ之内的数字(请参阅参考资料randNorm()。因此,我们得到一个具有µ 0和σ1的随机数的绝对值,再乘以4,将前面提到的实际范围增加到µ±28.08σ。然后,我们对值进行下限并加1,因为它sub(是1索引的,因此我们得到的范围是1-29,每个范围的概率不同。


1
@trichoplax这是我的错误,我从旧版本[0,29]中剩下30个。我现在修复了。
Timtech '16

间隔(0,1)应该为[0,1)。
kamoroso94 '16

@ kamoroso94您检查了吗?“注意:由于随机数生成算法的特殊性,可能生成的最小数字稍微大于0。实际上最大的数字实际上是1”-引用自 tibasicdev.wikidot.com/rand
Timtech '16

3

PHP,92 84字节

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

构建一个包含所有字母的字符串,在循环中重复执行多次,然后从该字符串中随机选择一个字母。结果,字母后面的字母更有可能出现

感谢insertusernamehere削减字节

结果概率(按百分比排序)

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%


1
更改为实际上遵守规则。我的错误
gabe3886'8

@insertusernamehere运行该命令时会得到未定义的变量通知,并且没有字母输出
gabe3886 '16

哦,对不起。我想我被带走了并搬走了$x=0,这显然是必要的。这是一个84字节的版本:运行代码时,您for($i=65,$x=0;$i<91;$a.=str_repeat(chr($i++),$x))$x++;echo substr($a,rand(0,$x),1);是否曾经设法获得一个比其大的值G?无论如何,notice打高尔夫球时您始终可以忽略。
插入用户名

1
我做到了,但是要花些时间才能长大。我运行了约100k次迭代来进行检查
gabe3886 '16

strlen$a是351,但你只能选择一个随机字符列全国第一$x(26)字符。您可以修复它,并通过将final $x更改350为+1字节来保留概率。这是一个77字节的版本,不仅可以解决问题,而且可以将各种可能性联系在一起:for($i=65;$i<91;$a.=str_repeat(chr($i),$i++));echo substr($a,rand(0,2014),1);
乔。

3

Befunge,168个 164字节

比第一个更紧凑,并且概率略有不同:第一个?1/4的机会在“首次尝试”上打印A,2/4的可能性返回到相同的值?,还有1/4的可能性来移动到下一个。其余的?s都有1/4的机会在其下打印字母,1/4再次尝试,1/4移至下一个字母,1/4移至上。同样,印刷A的概率是很多比打印Z.更高

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

Befunge,186个字节

显然不会赢,但是我仍然认为这是一个有趣的答案:)

v并将>光标分别向下和向右移动。在?操作者在四个方向随机一个发送光标离开。第一个?是由v>在两个方向,所以它只有两个路要走:无论是打印A,或到下一个?。因此,从第一个开始?,就有50%的机会打印A。

接下来?1/3机会打印B,中1/3的回去了, 1/3的去进一步回落。等等

很明显,较高的字母比较低的字母更有可能被印出,但是我不确定每个字母的机会是多少。

一些确切的数学帮助将不胜感激:)

至少有1/2 * 1/3 ^ 25的机会在第一次尝试中将光标一直向下移动到Z,但是我不确定光标上下移动的机会如何影响每个字母。

,@ 打印并退出。

 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">,@

2

J,20 18字节

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

在线口译

大写。

每个字母的概率是它在字母表中从1开始的索引。


2

zsh,63个字节

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

它通过创建以下字符串来工作:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ

又名A的65倍,B的66倍,C的67倍...

然后在其中选择一个随机字符


你为什么从65岁开始?
gcampbell '16

1
@gcampbell 65 A在ASCII中。您可以从1开始,但随后的内部循环将{65..$[#i]}延长1个字符
izabera

2

CJam,11个字节

4.mrmqC*'A+

要么

676.mrmq'A+

在线尝试!

该解决方案与Luis的想法相似,并通过取随机变量的平方根来创建非均匀分布。


2

批处理,116字节

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

通过选择两个随机变量中的较大或较小(我忘了哪个)来工作。


2

Matlab,22岁

通常会返回早期字母,但理论上可以触摸所有字母!

取一个由随机数表示的数字,将其限制为26,然后将其变成一个字符。

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

当然不是很短,但是也许这个概念可以激发其他答案。


是否rand返回[0,1)中的值?即,包括零但不包括一。如果这偶尔导致1/0,是否min(1/0,26)仍会返回26或错误?
trichoplax

据我所知rand返回的值是(0,1),所以应该没有问题
paul.oderso

1
@trichoplax尽管实际上您不会看到rand返回0,但min(1/0,26)实际上返回26。
丹尼斯Jaheruddin

在那种情况下,不错的解决方案:)
trichoplax

2

CJam,10个字节

CJam方法#3 ...

26mr)mr'A+

在线尝试!

这会x在1到26之间创建一个统一的随机数,然后使用它在之间创建一个统一的随机数,0并将x-1其添加到A。这会使结果偏向较小的字符。


2

迷宫,19字节

__v6%_65+.@
" )
"^2

在线尝试!

这是一个循环,在每次迭代时,a)递增从零开始的计数器或b)终止(均以50%的概率)。在循环结束时,计数器以26为模,并加到65以在AZ

这样给出的概率A略高于50%,B略高于25%,依此类推,甚至Z略高于1/2 26。从理论上讲,这种情况可能会永远持续下去,但此事件的概率为零(如挑战所要求)(实际上,这是不可能的,因为PRNG将在其期间的某个时刻返回两种可能的结果)。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.