Powerball - американська лотерея, яка нещодавно привернула увагу, оскільки нинішній джекпот (станом на 11 січня 2016 року) - це найбільший приз в історії лото , приблизно 1,5 мільярда доларів ( USD ).

Гравці Powerball вибирають 5 чітких чисел із 69 пронумерованих білих кульок, і 1 номер "Powerball" з 26 пронумерованих червоних куль. Вони виграють джекпот, якщо їх п’ять варіантів білих кульок відповідають тому, що було намальовано в будь-якому порядку, і якщо вони обрали правильний номер "Powerball".

Тож шанси виграти джекпот - це 1 у (69 choose 5)*(26 choose 1)або ((69*68*67*66*65)/(5*4*3*2*1))*26, що становить 1 на 292,201,338

Ніхто не виграв джекпот в останньому розіграші 9 січня 2016 року, але, можливо, хтось виграє наступний розіграш 13 січня 2016 року, 22:59 ET.

Виклик

Напишіть програму чи функцію, яка імітує малюнок Powerball, не беручи вводу, а виводячи 5 різних випадкових чисел від 1 до 69 включно, а потім одне випадкове число "Powerball" від 1 до 26 включно (що може бути повторенням одного з 5 початкові числа).

Номер "Powerball" завжди повинен бути останнім номером у виході, але в іншому випадку порядок перших 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)])))

Виграє найкоротший код у байтах.

^{Зауважте, що я не маю приналежності до Powerball і не дуже пропоную вам грати. Але якщо ви виграєте що-небудь із чисел, створених однією з програм тут, я впевнений, що ми хотіли б почути про це. : D}

Діалог 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

Перші п'ять чисел розділені пробілом, а не новим рядком. Це пов’язано з основою Октавиrandsample функцією яка поводиться інакше, ніж у Matlab (і була виправлена ​​в новій версії компілятора). У будь-якому разі, виклик дозволений і для нового рядка, і для пробілу.

Редагувати (4 квітня 2016 р.) : Спробуйте в Інтернеті!

Пояснення

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 трапляється вбудований метод вибірки, який вибирає випадкові значення з масиву без заміни. Завдяки QPaysTaxes за те, що вони мені не потрібні.

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

Він має схожість з відповіддю Меммінга , але він використовує пряме індексування, яке можливе лише в 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-Randomне було в v1 (значення Get-мається на увазі та -Maximumє позиційним). Вихід відокремлений новим рядком.

Безголівки:

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

Shell + coreutils, 31

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

МАТЛАБ, 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-індексоване), а потім відлуньте випадковий int від 1-26.

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

Спробуйте його онлайн тут .

Брахілог , 40 байт

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

Пояснення

Brachylog не має вбудований випадкові числа (поки ...) , тому ми повинні використовувати предикат SWI-Prolog для цього: random/1. Ми можемо ввести код 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, це працює, створюючи набір (який містить лише унікальні значення), рекурсивно додаючи randoms (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 буде інтерпретувати цілі числа як символи і, отже, виводить деякий рядок замість потрібних чисел powerball. Отже, ми повинні зменшити цілий масив до рядка.

Рубі, 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> замінено фактичним новим рядком)

EDIT: Уопс, не побачив попередньої відповіді Рубі. Я наткнувся sampleі прокрутився вниз, щоб відредагувати свою відповідь, але потім я побачив це… О добре. Моя підсумкова оцінка - 43 байти, але я продовжую займатися гольфом, щоб побачити, наскільки я вмію.

Математика, 64 байти

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

Досить просто.

Perl 5, 59 bytes

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

It's a subroutine; use it as:

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

PHP, 65 bytes

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

Thanks to the other PHP answer on this page. I wrote up a program on my own, and it turned out to be the exact same answer as the one written by Samsquanch, which drove me to take it a step further to save a few bytes.

If anyone can figure out a way to append one array to another in here that's less than the 5 bytes it takes me to join the powerball number on after, I would greatly appreciate it, cause it's driving me nuts! The best I could come up with would be after array_rand and before join, having a statement something like +[5=>rand()%25], but that's an extra byte over just concatenating it on 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

Run it through the command line. Sample:

C:\(filepath)>php powerball.php

Output:

 12 24 33 67 69 4

PARI/GP, 71 70 bytes

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

It generates a random permutation of [1..69], then takes the first 5.

Unfortunately this is an inefficient user of randomness, consuming an average of 87 bytes of entropy compared to the information-theoretic ideal of 3.5. This is mainly because the entire permutation is generated instead of just the first 5 members, and also because the perms are ordered (losing lg 5! =~ 7 bits). Further, random uses a rejection strategy rather than using arithmetic coding. (This is because PARI uses Brent's xorgen, which is fast enough that the overhead from more complicated strategies is rarely worthwhile.)

There are three 'obvious' changes which do not work under the current (2.8.0) version of gp. random and print could be stored in variables, and print could be called directly rather than via the anonymous -> function:

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

Together these would save 9 bytes. Unfortunately both functions are valid without arguments, and hence are evaluated immediately rather than stored, so these do not compute the desired output.

Intel x86 Machine code, 85 bytes

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

Well it does sometimes print the same numbers if so, just try again by pressing a key.

Compile with:

nasm file.asm -o file.bin

Make sure to align it to a floppy size (add zeros at the end) in order to mount it to a vm (it does not need any operating system).

Disassembly:

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 bytes

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];}

Not terribly happy with this solution as it feels like there should be more golfing opportunity. I'll look at it again tomorrow with fresh eyes. Try it here.

Swift, 165 bytes

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

Can quickly be run in an Xcode Playground.

EDIT: Current problem here is that it's theoretically possible for this to run forever in the while loop if arc4random_uniform somehow keeps pulling the same number. The odds of that happening, for any significant length of time, are probably better than the odds of winning the Powerball.

Perl 6,  32  31 bytes

# 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␤

Turning it into a function that returns a string, I can remove 4 bytes (put␠) while only adding 3 ({~ })

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

Usage:

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

If a function were allowed to return a list of the values, the following would also work.

( Otherwise it would be the same as above but within { } )

• function that returns a single flat list

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

• function that returns a list with the first 5 numbers in a sub list

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

• function that returns a list with the first 5 in a sub list, and the Powerball in another sub list

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

Seriously, 35 bytes

My first attempt at an answer in a golfing language.

Feels longer than it should have to be.
The repetition could likely be removed with W, but it seems to be broken in the online interpreter and I don't want to post untested code.

Too bad { doesn't work on lists.

Code:

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

Hex dump:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

Explanation:

: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

Online interpreter

Lua, 96 Bytes

A simple solution, using a table as a set by putting the value inside it as table[value]=truthy/falsyto be able to check if they are inside it or not.

I lose 5 bytes because I have to set the first value of my table, else I won't go inside the while(o[n])loop and will simply output n before using the random function. As Lua uses 1-based tables, I also have to force it to put its first value to the cell [0], otherwise I couldn't output a 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))

Ungolfed:

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 bytes

Golfed:

#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;}

Ungolfed:

#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;
}