Powerball to amerykańska loteria, która niedawno zyskała na znaczeniu, ponieważ obecny jackpot (od 11 stycznia 2016 r.) Jest największą nagrodą lotto w historii , wynoszącą około 1,5 miliarda USD ( USD ).

Gracze Powerball wybierają 5 różnych liczb z 69 ponumerowanych białych kulek i 1 jedną liczbę „Powerball” z 26 ponumerowanych czerwonych kulek. Oni wygrać pulę, jeśli ich pięć białych wybory piłka dopasować co został sporządzony w dowolnej kolejności, a jeśli wybrali właściwą „Powerball” numer.

Tak więc szanse na wygraną wynoszą 1 (69 choose 5)*(26 choose 1)lub 3 ((69*68*67*66*65)/(5*4*3*2*1))*26, czyli 1 na 292,201,338

Nikt nie wygrał głównej wygranej w ostatnim losowaniu 9 stycznia 2016 r., Ale być może ktoś wygra następny losowanie 13 stycznia 2016 r., Godz. 22.59 ET.

Wyzwanie

Napisz program lub funkcję, która symuluje losowanie Powerball, nie biorąc udziału, ale wypisując 5 różnych liczb losowych od 1 do 69 włącznie, a następnie jedną losową liczbę „Powerball” od 1 do 26 włącznie (która może być powtórzeniem jednego z 5 numery początkowe).

Liczba „Powerball” powinna zawsze być ostatnią liczbą na wyjściu, ale w przeciwnym razie kolejność pierwszych 5 liczb nie ma znaczenia.

6 liczb powinno być wyprowadzanych w postaci dziesiętnej , oddzielonej spacją lub separatorem , z opcjonalnym pojedynczym znakiem nowej linii. Przecinki, nawiasy i inne znaki nie są dozwolone w danych wyjściowych.

Byłyby to prawidłowe dane wyjściowe (przy użyciu liczb z ostatniego rysunku ):

32 16 19 57 34 13

32
16
19
57
34
13

Wszystkie 292201338 możliwych wyników powinny być możliwe z jednakowym prawdopodobieństwem. Możesz użyć wbudowanych generatorów liczb pseudolosowych i założyć, że spełniają one ten standard.

Oto implementacja referencji bez golfisty, która działa w Pythonie 2 lub 3:

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

Najkrótszy kod w bajtach wygrywa.

^{Pamiętaj, że nie mam powiązań z Powerball i nie sugeruję, abyś grał. Ale jeśli wygrasz cokolwiek z liczb wygenerowanych przez jeden z programów tutaj, jestem pewien, że chcielibyśmy o tym usłyszeć. :RE}

Dyalog APL, 10 bajtów

(5?69),?26

Dwójkowym ?jest ⍺ różne liczb losowych w [1], ⍵ i monadycznego ?jest jeden numer losowy.

Wypróbuj tutaj .

CJam, 16 bajtów

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

Wypróbuj online.

MATL , 10 bajtów

69 5Zr26Yr

Korzysta z bieżącej wersji (9.2.0) języka / kompilatora.

Przykład

Z kompilatorem uruchomionym na Matlabie:

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

Z kompilatorem uruchomionym na Octave:

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

Pierwsze pięć liczb jest oddzielonych spacją, a nie znakiem nowej linii. Wynika to z tego, że podstawowa randsamplefunkcja Octave zachowuje się inaczej niż Matlab (i została poprawiona w nowej wersji kompilatora). W każdym razie zarówno wyzwanie nowej linii, jak i spacja są dozwolone.

Edytuj (4 kwietnia 2016 r.) : Wypróbuj online!

Wyjaśnienie

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

Zobacz odpowiednie funkcje Matlaba: randsamplei randi.

Ruby, 33 32

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

Ruby ma wbudowaną metodę, przykład, która wybiera losowe wartości z tablicy bez zamiany. Dzięki QPaysTaxes za zwrócenie uwagi, że nie potrzebuję parens.

R, 30 29 bajtów

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

sampleFunkcja wykonuje prostą losowego pobierania próbek z wejścia. Jeśli jako pierwszy argument podano jedną liczbę całkowitą, próbkowanie odbywa się od 1 do argumentu. Wielkość próby jest drugim argumentem. Używamy domyślnej opcji próbkowania bez zamiany.

Wypróbuj online

Python 3.5, 63 bajty

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

Jest to w zasadzie referencyjna implementacja golfa. Zauważ, że 3.5 jest konieczne do splatania w niekończącym się argumencie.

Oktawa, 35 32 bajtów

Hobby Calvina potwierdziło, że ans =korzystanie z funkcji było w porządku, więc:

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

Ma podobieństwo do odpowiedzi Memminga , ale wykorzystuje bezpośrednie indeksowanie, które jest możliwe tylko w Octave, i jest o 5 7 bajtów krótsze, więc pomyślałem, że i tak warto to opublikować.

randperm(69)tworzy listę z losową permutacją liczb 1-69. Możliwe jest bezpośrednie zaindeksowanie listy (niemożliwe w MATLAB), aby uzyskać tylko pierwsze 5 liczb w ten sposób (1;5). Po liście następuje randi(26)pojedynczy numer od 1 do 26.

Stary:

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

Wynikowa lista jest wyświetlana za pomocą disp.

PowerShell v2 +, 31 27 bajtów

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

Wymaga wersji 2 lub nowszej, ponieważ Get-Randomnie była obecna w wersji 1 ( Get-jest domyślna i -Maximumpozycyjna). Wyjście jest oddzielone znakiem nowej linii.

Nie golfowany:

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

Wiem. To nudne rozwiązanie.

PHP, 69 bajtów

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

Dość prosta odpowiedź. Wygeneruj 1-69 range, następnie użyj, array_randaby pobrać 5 losowych kluczy z tablicy, i wypisz echo $k+1wartości (indeksowane 0), a następnie powtórz losowe int z 1-26.

C #, 153 bajty 140 bajtów

Dzięki „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 bajty rozwiązanie:

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

Proste rozwiązanie za pomocą Linq i tasowanie za pomocą GUID.

Pyth - 13 14 13 bajtów

Możliwy duży golf, to był tylko FGITW.

jb>5.SS69hO26

Wypróbuj online tutaj .

Brachylog , 40 bajtów

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

Wyjaśnienie

Brachylog nie posiada wbudowany liczb losowych (jeszcze ...), więc musimy użyć predykatu SWI-Prolog na to: random/1. Możemy wprowadzić kod SWI-Prolog w Brachylog za pomocą cudzysłowów.

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 bajtów

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

Ponieważ nie możemy jednoznacznie próbkować losowych elementów w JavaScript, działa to poprzez utworzenie zestawu (który zawiera tylko unikalne wartości), rekurencyjne dodawanie losowych (1-69), dopóki nie będzie 5 unikalnych, dodawanie losowej liczby (1-26), następnie dołączając i zwracając to wszystko.

Eliksir , 83 bajtów

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

Po prostu IO.putswprowadzając tablicę liczb całkowitych, Elixir zinterpretuje liczby całkowite jako znaki, a zatem wyśle ​​niektóre ciągi zamiast pożądanych liczb kuli mocy. Musimy więc zredukować tablicę liczb całkowitych do ciągu.

Ruby, 47 43 39 bajtów

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

Wydaje mi się, że można bardziej grać w golfa, ale popracuję nad tym, gdy skończę, podziwiając, jak ładny jest ten kod, biorąc pod uwagę.

Działa prawie tak samo, jak wszystko inne: weź tablicę liczb od 1 do 69, potasuj je, zdobądź pierwsze pięć, wypisz je, a następnie wypisz losową liczbę od 1 do 26.

Przejrzałem kilka iteracji przed opublikowaniem tego:

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

(gdzie <newline>jest zastąpiony przez rzeczywistą nową linię)

EDYCJA: Ups, nie widziałem wcześniej istniejącej odpowiedzi Ruby. Zatoczyłem się samplei przewijałem w dół, aby edytować swoją odpowiedź, ale potem ją zobaczyłem ... No cóż. Mój końcowy wynik to 43 bajty, ale będę trochę grał w golfa, aby zobaczyć, jak dobrze sobie radzę.

Mathematica, 64 bajty

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

Całkiem proste.

Perl 5, 59 bajtów

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

To podprogram; użyj go jako:

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

PHP, 65 bajtów

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

Dzięki drugiej odpowiedzi PHP na tej stronie. Sam napisałem program i okazało się, że jest to dokładnie taka sama odpowiedź, jak ta napisana przez Samsquancha, co skłoniło mnie do pójścia o krok dalej i zaoszczędzenia kilku bajtów.

Jeśli ktokolwiek może wymyślić sposób, aby dołączyć tutaj jedną tablicę do drugiej, która jest mniejsza niż 5 bajtów, po których przyłączam się do numeru Powerball, byłbym bardzo wdzięczny, ponieważ doprowadza mnie to do szału! Najlepsze, co mogłem wymyślić, to po array_randi przed join, posiadanie czegoś podobnego +[5=>rand()%25], ale to dodatkowy bajt po prostu łącząc go później.

<?=                                                              // 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

Uruchom go z wiersza poleceń. Próba:

C:\(filepath)>php powerball.php

Wydajność:

 12 24 33 67 69 4

PARI / GP, 71 70 bajtów

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

Generuje losową permutację [1..69], a następnie przyjmuje pierwszą 5.

Niestety jest to nieefektywny użytkownik losowości, zużywający średnio 87 bajtów entropii w porównaniu z ideałem teoretycznym 3,5. Wynika to głównie z tego, że generowana jest cała permutacja zamiast tylko pierwszych 5 elementów, a także dlatego, że perms są uporządkowane (utrata lg 5! = ~ 7 bitów). Ponadto randomwykorzystuje strategię odrzucania zamiast kodowania arytmetycznego. (Jest tak, ponieważ PARI używa xorgena Brenta, który jest wystarczająco szybki, aby narzut z bardziej skomplikowanych strategii rzadko był opłacalny.)

Istnieją trzy „oczywiste” zmiany, które nie działają w obecnej wersji (2.8.0) gp. randomi printmogą być przechowywane w zmiennych, i printmogą być wywoływane bezpośrednio, a nie za pomocą ->funkcji anonimowej :

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

Razem zaoszczędzą 9 bajtów. Niestety obie funkcje są poprawne bez argumentów, a zatem są oceniane natychmiast, a nie przechowywane, więc nie obliczają one pożądanego wyniku.

Kod maszynowy Intel x86, 85 bajtów

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

Czasami drukuje te same liczby, jeśli tak, spróbuj ponownie, naciskając klawisz.

Połącz z:

nasm file.asm -o file.bin

Pamiętaj, aby wyrównać go do rozmiaru dyskietki (dodać zera na końcu), aby zamontować go na maszynie wirtualnej (nie wymaga on żadnego systemu operacyjnego).

Demontaż:

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 bajty

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

Niezbyt zadowolony z tego rozwiązania, ponieważ wydaje się, że powinno być więcej możliwości gry w golfa. Spojrzę na to jutro ze świeżymi oczami. Wypróbuj tutaj .

Szybki, 165 bajtów

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

Można szybko uruchomić na placu zabaw Xcode.

EDYCJA: Obecny problem polega na tym, że teoretycznie jest możliwe, aby działało to wiecznie w pętli while, jeśli arc4random_uniform nadal ciągnie tę samą liczbę. Szanse na to, przez dłuższy czas, są prawdopodobnie lepsze niż szanse wygrania Powerball.

Perl 6 ,  32   31 bajtów

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

Przekształcając go w funkcję zwracającą ciąg, mogę usunąć 4 bajty ( put␠), dodając tylko 3 ( {~ })

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

Stosowanie:

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

Gdyby funkcja mogła zwrócić listę wartości, działałyby również następujące.

(W przeciwnym razie byłoby to to samo co powyżej, ale w środku { })

• funkcja, która zwraca pojedynczą płaską listę

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

• funkcja, która zwraca listę z 5 pierwszymi liczbami na liście podrzędnej

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

• funkcja, która zwraca listę pierwszych 5 na liście podrzędnej, a Powerball na innej liście podrzędnej

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

Poważnie, 35 bajtów

Moja pierwsza próba odpowiedzi w języku golfowym.

Wydaje się dłuższy niż powinien.
Powtórzenie można prawdopodobnie usunąć za pomocą W , ale wydaje się, że jest zepsute w internetowym tłumaczu i nie chcę publikować nieprzetestowanego kodu.

Szkoda { nie działa na listach.

Kod:

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

Zrzut szesnastkowy:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

Wyjaśnienie:

: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

Tłumacz online

Lua, 96 bajtów

Proste rozwiązanie, wykorzystujące tabelę jako zestaw, umieszczając w niej wartość, table[value]=truthy/falsyaby móc sprawdzić, czy są w niej, czy nie.

Tracę 5 bajtów, ponieważ muszę ustawić pierwszą wartość mojej tabeli, inaczej nie wejdę do while(o[n])pętli i po prostu wyprowadzę dane nprzed użyciem funkcji losowej. Ponieważ Lua używa tabel opartych na 1, muszę również zmusić ją do umieszczenia pierwszej wartości w komórce [0], w przeciwnym razie nie byłbym w stanie wygenerować wartości 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))

Nie golfowany:

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 bajty

Gra w golfa:

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

Nie golfowany:

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