强力球是最近引起美国关注的彩票，因为当前的累积奖金（截至2016年1月11日）是历史上最大的乐透奖金，约为15亿美元。

强力球运动员从69个编号的白球中选择5个不同的数字，并从26个编号的红球中选择1个“强力球”数字。如果他们的五个白球选择与按任何顺序绘制的内容相匹配，并且选择了正确的“强力球”号码，他们将赢得大奖。

因此，赢得大奖的机会是1 (69 choose 5)*(26 choose 1)或((69*68*67*66*65)/(5*4*3*2*1))*26，即292,201,338中的1

没有人在2016年1月9日的最新抽奖中赢得大奖，但是也许有人会在美国东部时间2016年1月13日晚上10:59赢得下一张抽奖。

挑战

编写一个模拟强力球绘图的程序或函数，不输入任何内容，而是输出1至69之间的5个不同的随机数，然后输出1至26之间的1个随机的“ Powerball”数字（可以重复5个之一）初始数字）。

“强力球”数字应始终是输出中的最后一个数字，但其他前5个数字的顺序无关紧要。

这6个数字应以十进制输出，以空格分隔或换行符分隔，并带有一个可选的尾随换行符。输出中不允许使用逗号，方括号和其他字符。

因此，这些将是有效的输出（使用最后一张图中的数字）：

32 16 19 57 34 13

32
16
19
57
34
13

所有292201338可能的结果都应该具有统一的可能性。您可以使用内置的伪随机数生成器，并假定它们符合此标准。

这是可在Python 2或3中使用的简单参考实现：

import random
print(' '.join(map(str, random.sample(range(1,70), 5) + [random.randint(1, 26)])))

以字节为单位的最短代码获胜。

^{请注意，我与强力球没有任何隶属关系，也不是真的建议您参加比赛。但是，如果您从这里的一个程序生成的数字中赢得任何收益，那么我相信我们很乐意听到这一消息。：D}

Dyalog APL，10个字节

(5?69),?26

二元?是在[1，⍵]⍺不同的随机数，和一元?是一个单一的随机数。

在这里尝试。

CJam，16个字节

69,mr5<26mr+:)S*

69,   range(69)
mr    shuffle the generated array
5<    first 5 elements
26mr  random number 0..25
+     concat to array
:)    increment each array element
S*    join with spaces

在线尝试。

MATL，10字节

69 5Zr26Yr

使用语言/编译器的当前版本（9.2.0）。

例

使用在Matlab上运行的编译器：

>> matl
 > 69 5Zr26Yr
 > 
66
59
64
56
29
12

使用在Octave上运行的编译器：

>> matl
 > 69 5Zr26Yr
 >
2 69 41 44 23
22

前五个数字用空格隔开，而不用换行符隔开。这是由于Octave的基础randsample功能与Matlab的功能有所不同（并且在新版本的编译器中已得到纠正）。无论如何，挑战都允许换行和空格。

编辑（2016年4月4日）：在线试用！

说明

69 5Zr    % randsample(69,5), without replacement by default. Gives a 5x1 column vector
26Yr      % randi(26). Gives single number
          % implicit display

参见相关的Matlab函数：randsample和randi。

红宝石，33 32

p *[*1..69].sample(5),rand(26)+1

Ruby碰巧有一个内置方法sample，该方法从数组中选择随机值而无需替换。感谢QPaysTaxes指出我不需要parens。

R，30 29字节

cat((s=sample)(69,5),s(26,1))

该sample函数从输入中执行简单的随机采样。如果给定单个整数作为第一个参数，则从1到参数进行采样。样本数量是第二个参数。我们采用的是默认抽样方式，无需替换。

在线尝试

Python 3.5，63个字节

from random import*
print(*sample(range(1,70),5),randint(1,26))

它基本上是参考实现。请注意，需要3.5才可以使用非最后一个参数。

八度，35 32字节

卡尔文的兴趣爱好确认ans =使用功能时可以，因此：

@()[randperm(69)(1:5),randi(26)]

它与Memming的答案相似，但是它使用仅在Octave中才可以使用的直接索引，它的长度短了5 7个字节，因此我认为还是值得发布的。

randperm(69)创建一个随机排列的数字为1-69的列表。可以直接为列表建立索引（在MATLAB中是不可能的），这样只能获取前5个数字(1;5)。该列表后跟randi(26)一个返回1到26之间的单个数字。

旧：

disp([randperm(69)(1:5),randi(26)])

使用显示结果列表disp。

PowerShell v2 +，31个 27字节

1..69|Random -c 5;Random 27

需要版本2或更高版本，如Get-Randomv1中所没有（这Get-是隐含的，并且-Maximum是固定的）。输出以换行符分隔。

取消高尔夫：

Get-Random -InputObject (1..69) -Count 5
Get-Random -Maximum 27

Shell + coreutils，31岁

shuf -i1-69 -n5
shuf -i1-26 -n1

MATLAB，40

x=randperm(69);disp([x(1:5) randi(26)])

我知道。这是无聊的解决方案。

PHP，69字节

<?foreach(array_rand(range(1,69),5)as$k)echo$k+1," ";echo rand(1,26);

很简单的答案。生成1-69 range，然后用于array_rand从数组中获取5个随机键，然后回显$k+1值（0索引），然后从1-26回显随机int。

C＃，153个字节 140个字节

感谢“ McKay”：

string.Join(" ",Enumerable.Range(1,69).OrderBy(e=>Guid.NewGuid()).Take(5).Concat(Enumerable.Range(1,26).OrderBy(e=>Guid.NewGuid()).Take(1)))

153字节解决方案：

string.Join(" ",Enumerable.Range(1,69).OrderBy(e=>Guid.NewGuid()).Take(5))+" "+string.Join(" ",Enumerable.Range(1,26).OrderBy(e=>Guid.NewGuid()).Take(1))

使用Linq的简单解决方案和使用GUID的改组。

Pyth- 13 14 13字节

可能会打高尔夫球，这只是FGITW。

jb>5.SS69hO26

在这里在线尝试。

Brachylog，40个字节

1:5e,68{I`random(I)+1=Z`Z=w,"
"w}\;25:1&

说明

Brachylog还没有内置随机数（但...），因此我们必须使用SWI-Prolog谓词：random/1。我们可以使用反引号在Brachylog中输入SWI-Prolog代码。

1:5e,                             \  § Enumerate from 1 to 5 using \ (backtrack), which
                                     § evaluates to false and thus constructs a loop

     68{                         }   § Declare sub-predicate 1 and call it with 68 as input

        I`random(I)+1=Z`             § Z is the arithmetic expression 'random(I) + 1' where
                                     § I is the input of the sub-predicate

                        Z=w,         § Evaluate Z and write it
                            "\n"w    § Write a new line

;                                    § Else (we will reach this after the 5th iteration of
                                     § the enumeration, since \ is always false)

25:1&                                § Call the sub-predicate 1 with 25 as input

JavaScript（ES6），106 86 84字节

F=(s=new Set,r=Math.random)=>s.size<5?F(s.add(r()*69+1|0)):[...s,r()*26|0+1].join` `

由于我们无法在JavaScript中唯一地抽样随机数，因此可以通过创建一个Set（仅包含唯一值），递归地添加随机数（1-69）直到有5个唯一的随机数，附加随机数（1-26）来工作。然后加入并全部归还。

长生不老药，83字节

Enum.reduce Enum.take_random(1..69,5)++[Enum.random(1..26)],fn(x,a)->"#{a} #{x}"end

当仅IO.puts整数数组时，Elixir会将整数解释为字符，因此输出一些字符串而不是所需的强力球编号。因此，我们必须将整数数组缩减为一个字符串。

Ruby，47 43 39字节

puts *(1..69).to_a.sample(5),rand(26)+1

我认为它可以发挥更多的作用，但是考虑到这些代码看起来很漂亮，我将继续研究。

它的工作原理与其他所有方法几乎相同：将数字1到69组成一个数组，对其进行随机排序，得到前五个数字，输出这些数字，然后输出1到26之间的一个随机数。

发布此代码之前，我经历了几次迭代：

puts (1..69).to_a.shuffle.first(5).join(' ')+" #{rand(26)+1}"  #61
puts (1..69).to_a.shuffle[0..5].join(' ')+" #{rand(26)+1}"     #58
puts (1..69).to_a.shuffle[0..5].join('<newline>'),rand(26)+1   #52
puts *('1'..'69').to_a.shuffle[0..5],rand(26)+1                #47
puts *('1'..'69').to_a.sample(5),rand(26)+1                    #43

（在此处<newline>替换为实际的换行符）

编辑：糟糕，没有看到先前存在的Ruby答案。我偶然发现sample并向下滚动以编辑我的答案，但是后来我看到了...哦，很好。我的最终成绩是43个字节，但我会继续打高尔夫球以了解自己的表现。

Mathematica，64个字节

StringRiffle@Append[Range@69~RandomSample~5,RandomInteger@25+1]&

非常简单。

Perl 5，59位元组

{say for(sort{-1+2*int rand 2}1..69)[0..5];say$==1+rand 25}

这是一个子例程；用作：

perl -M5.010 -e'sub f{...}f'

PHP，65字节

<?=join(' ',array_rand(array_flip(range(1,69)),5))." ".rand()%26;

感谢此页面上的其他PHP答案。我自己编写了一个程序，结果与Samsquanch编写的答案完全相同，这驱使我更进一步以节省一些字节。

如果有人能找到一种在此处将一个数组追加到另一个数组的方法，该方法少于5个字节，之后我要加入强力球编号，我将不胜感激，因为它使我发疯！我能想到的最好的方法是在after array_rand和before之前join，有类似的语句+[5=>rand()%25]，但这比在after上串联起来要多一个字节。

<?=                                                              // This represents an inline 'echo' statement
                                  range(1,69)                    // Get an array of all numbers from 1 to 69 inclusive
                       array_flip(           )                   // Swap the keys and values.
            array_rand(                       ,5)                // Get a random subset of five keys.
   join(' ',                                     ).rand()%26     // Concatenate the array with spaces, along with the powerball number

通过命令行运行它。样品：

C:\(filepath)>php powerball.php

输出：

 12 24 33 67 69 4

PARI / GP，71 70字节

apply(n->print(n),numtoperm(69,random(69!))[1..5]);print(random(26)+1)

它生成[1..69]的随机排列，然后取前5个。

不幸的是，这是效率低下的随机性用户，与3.5的信息理论理想值相比，平均要消耗87字节的熵。这主要是因为生成了整个置换而不是仅生成了前5个成员，而且还因为置换是有序的（丢失lg 5！=〜7位）。此外，random使用拒绝策略而不是使用算术编码。（这是因为PARI使用Brent的xorgen，这种速度足够快，以至于更复杂的策略产生的开销很少值得。）

在当前（2.8.0）版本的gp下，有3个“明显”更改不起作用。random并且print可以存储在变量中，并且print可以直接调用而不是通过匿名->函数调用：

r=random;apply(p=print,numtoperm(69,r(69!))[1..5]);p(r(26)+1)

这些一起可以节省9个字节。不幸的是，这两个函数在没有参数的情况下都是有效的，因此会立即求值而不是存储，因此它们无法计算所需的输出。

英特尔x86机器代码，85字节

¿I ±‰ø1Ò»E ÷óB‰Ðè+ ‰þÑç÷ƒÇþÉ„Éuâ‰ø1Ò» ÷óB‰Ðè
 0ä͸ ͱëÆÔ
00†Äˆã´ÍˆØÍ° ÍÃ

好吧，有时确实会打印相同的数字，只需按一个键再试一次。

编译：

nasm file.asm -o file.bin

确保将其调整为软盘大小（末尾添加零），以便将其安装到vm（不需要任何操作系统）。

拆卸：

BITS 16
ORG 0x7c00

mov di,73 ;starting seed
mov cl,5 ;we need five numbers

loop:

mov ax,di

xor dx,dx
mov bx,69
div bx
inc dx
mov ax,dx

call print_rnd_number

mov si,di
shl di,1
add di,si
add di,7

dec cl

test cl,cl
jne loop

mov ax,di

xor dx,dx
mov bx,26
div bx
inc dx
mov ax,dx

call print_rnd_number

xor ah,ah
int 0x16
mov ax,0x0002
int 0x10
mov cl,5
jmp loop

print_rnd_number:
aam
add ax,0x3030
xchg al,ah
mov bl,ah
mov ah,0x0E
int 0x10
mov al,bl
int 0x10
mov al,' '
int 0x10
ret

C，142字节

i,x[6],n;main(j){for(srand(time(0));i<6;n-i?0:printf("%d ",x[i]),i++)for(x[n=j=i]=(69-i/5*43)*(rand()/2147483647.)+1;i<6&&j--;)i-=x[i]==x[j];}

对这种解决方案并不十分满意，因为感觉应该有更多的高尔夫机会。明天我再换个角度看看。在这里尝试。

斯威夫特，165字节

import UIKit;var a=[Int]();for i in 0...5{func z()->Int{return Int(arc4random_uniform(i<5 ?68:25)+1)};var n=z();while i<5&&a.contains(n){n=z()};a.append(n);print(n)}

可以在Xcode Playground中快速运行。

编辑：这里的当前问题是，如果arc4random_uniform以某种方式保持拉相同的值，则理论上可以在while循环中永久运行。在任何相当长的时间内，发生这种情况的几率都可能比赢得强力球的几率更好。

Perl 6的， 32   31个字节

# space is necessary so that the parens denote a list
# rather than being part of the call to `put`
put (pick(5,1..69),(1..26).pick) # 32 bytes
# 25 35 57 67 62 24␤

将其变成返回字符串的函数，我可以删除4个字节（put␠），而仅添加3个（{~ }）

{~(pick(5,1..69),(1..26).pick)} # 31 bytes

用法：

say {...}().perl; # use .perl to prove it returns a string
# "25 35 57 67 62 24"

如果允许一个函数返回值列表，那么下面的方法也可以工作。

（否则与上面相同，但在 { }）

• 返回单个平面列表的函数

  {|pick(5,1..69),(1..26).pick} # 29 bytes
  # (25,35,57,67,62,24)

• 返回子列表中前5个数字的列表的函数

  {pick(5,1..69),(1..26).pick} # 28 bytes
  # ((25,35,57,67,62),24)

• 该函数返回一个列表，其中子列表的前5个，而Powerball在另一个子列表中

  {pick(5,1..69),pick 1,1..26} # 28 bytes
  # ((25,35,57,67,62),(24,))

认真地，35个字节

我第一次尝试用高尔夫球语言回答。

感觉比应有的更长。
重复可能用W删除，但是它似乎在在线解释器中被破坏了，我不想发布未经测试的代码。

太糟糕{不适用于列表。

码：

:70:1xi J{. J{. J{. J{. J{.:26:Ju.

十六进制转储：

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

说明：

:70:1x                       # Push a list of the numbers 1-69
i                            # Explode list
 J{.                         # rotate stack random(len(stack)) times and pop/print
 J{. J{. J{. J{.             # same thing 4 more times
:26:Ju.                      # print random number in 1-26
                             # (7F) unprintable, terminate without explicit printing

在线口译

Lua，96个字节

一个简单的解决方案，通过将表放入值中来使用表作为集合，table[value]=truthy/falsy以便能够检查表是否在表中。

我丢失了5个字节，因为我必须设置表的第一个值，否则我将不会进入while(o[n])循环内部，只会n在使用random函数之前简单地输出。由于Lua使用基于1的表，因此我还必须强制其将其第一个值放入单元格中[0]，否则我将无法输出1。

m,n,o=math.random,0,{[0]=0}for i=1,5 do while(o[n])do n=m(69)end o[n]=0 print(n)end print(m(26))

取消高尔夫：

m,n,o=math.random,0,{[0]=0}
for i=1,5
do
  while(o[n])
  do
    n=m(69)
  end
  o[n]=0
  print(n)
end
print(m(26))

C ++，252个字节

打高尔夫球：

#include<iostream>
#include <random>

int main(){std::random_device rd;std::mt19937 gen(rd());std::uniform_int_distribution<> dis(1,69);for(int c=0;c<=5;c++){std::cout<<dis(gen)<<" ";}int x=dis(gen);while(x>26||x<1){x=dis(gen);}std::cout<<x;return 0;}

取消高尔夫：

#include<iostream>
#include <random>

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 69);
    for(int c = 0; c <= 5; c++){
        std::cout<<dis(gen)<<" ";
    }
    int x = dis(gen);
    while (x > 26 || x < 1){
        x = dis(gen);
    }
    std::cout<<x;
    return 0;
}