Powerball è una lotteria americana che ha recentemente attirato l'attenzione perché l'attuale jackpot (dall'11 gennaio 2016) è il più grande premio del lotto della storia , a circa $ 1,5 miliardi ( USD ).

I giocatori di Powerball scelgono 5 numeri distinti da 69 palle bianche numerate e 1 numero "Powerball" da 26 palle rosse numerate. Essi vincono il jackpot se i loro cinque scelte palla bianca corrispondono elaborato in qualsiasi ordine, e se hanno scelto il numero corretto "Powerball".

Quindi le possibilità di vincere il jackpot sono 1 su (69 choose 5)*(26 choose 1)o ((69*68*67*66*65)/(5*4*3*2*1))*26, che è 1 su 292.201.338

Nessuno ha vinto il jackpot nel sorteggio più recente del 9 gennaio 2016, ma forse qualcuno vincerà il sorteggio successivo il 13 gennaio 2016, 22:59 ET.

Sfida

Scrivi un programma o una funzione che simuli un disegno di Powerball, senza ricevere input ma producendo 5 numeri casuali distinti da 1 a 69 inclusi, quindi un numero "Powerball" casuale da 1 a 26 inclusi (che potrebbe essere una ripetizione di uno dei 5 numeri iniziali).

Il numero "Powerball" dovrebbe sempre essere l'ultimo numero nell'output, ma in caso contrario l'ordine dei primi 5 numeri non ha importanza.

I 6 numeri devono essere emessi in decimali , separati da spazio o separati da una nuova riga, con una nuova riga finale singola facoltativa. Le virgole, le parentesi e altri caratteri non sono consentiti nell'output.

Quindi questi sarebbero output validi (usando i numeri dell'ultimo disegno ):

32 16 19 57 34 13

32
16
19
57
34
13

Tutti i 292201338 risultati possibili dovrebbero essere possibili con probabilità uniforme. È possibile utilizzare generatori di numeri pseudo-casuali incorporati e supporre che soddisfino questo standard.

Ecco un'implementazione di riferimento non golfata che funziona in Python 2 o 3:

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

Vince il codice più breve in byte.

^{Nota che non ho alcuna affiliazione con Powerball e non suggerisco davvero di giocare. Ma se vinci qualcosa dai numeri generati da uno dei programmi qui, sono sicuro che ci piacerebbe saperlo. : D}

Dyalog APL, 10 byte

(5?69),?26

Diadico ?è ⍺ numeri casuali distinte in [1, ⍵], e monadico ?è un singolo numero casuale.

Provalo qui .

CJam, 16 byte

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

Provalo online.

MATL , 10 byte

69 5Zr26Yr

Utilizza la versione corrente (9.2.0) della lingua / compilatore.

Esempio

Con il compilatore eseguito su Matlab:

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

Con il compilatore eseguito su Octave:

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

I primi cinque numeri sono separati da spazio, non da newline. Ciò è dovuto al fatto che la randsamplefunzione sottostante di Octave si comporta in modo diverso da quella di Matlab (ed è stata corretta in una nuova versione del compilatore). Comunque, newline e spazio sono entrambi consentiti dalla sfida.

Modifica (4 aprile 2016) : provalo online!

Spiegazione

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

Vedi le funzioni Matlab rilevanti: randsamplee randi.

Ruby, 33 32

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

Ruby sembra avere un metodo integrato, campione, che seleziona valori casuali da un array senza sostituzione. Grazie a QPaysTaxes per aver sottolineato che non ho bisogno dei genitori.

R, 30 29 byte

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

La samplefunzione esegue un semplice campionamento casuale dall'ingresso. Se viene fornito un singolo numero intero come primo argomento, il campionamento viene eseguito da 1 all'argomento. La dimensione del campione è il secondo argomento. Stiamo impiegando l'opzione predefinita di campionamento senza sostituzione.

Provalo online

Python 3.5, 63 byte

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

Fondamentalmente è l'implementazione di riferimento golfizzata. Si noti che 3.5 è necessario splat in un argomento non ultimo.

Ottava, 35 32 byte

Calvin's Hobbies ha confermato che ans =andava bene quando si utilizza una funzione, quindi:

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

Ha somiglianze con la risposta di Memming , ma usa l'indicizzazione diretta che è possibile solo in Octave, ed è più corta di 5 7 byte, quindi ho pensato che valesse la pena pubblicare comunque.

randperm(69)crea un elenco con una permutazione casuale dei numeri 1-69. È possibile indicizzare direttamente l'elenco (non possibile in MATLAB) per ottenere solo i primi 5 numeri come questo (1;5). L'elenco è seguito dal randi(26)quale restituisce un singolo numero compreso tra 1 e 26.

Vecchio:

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

L'elenco risultante viene visualizzato utilizzando disp.

PowerShell v2 +, 31 27 byte

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

Richiede la versione 2 o più recente, poiché Get-Randomnon era presente in v1 ( Get-è implicito ed -Maximumè posizionale). L'output è separato da una nuova riga.

Ungolfed:

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

Lo so. È la soluzione noiosa.

PHP, 69 byte

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

Risposta piuttosto diretta. Genera un 1-69 range, quindi usa array_randper prendere 5 chiavi casuali dall'array e riecheggia il $k+1valore (0-indicizzato), quindi fai eco a un int casuale da 1-26.

C #, 153 byte 140 byte

Grazie a "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 byte di soluzione:

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

Soluzione semplice con Linq e shuffle con GUID.

Pyth - 13 14 13 byte

Grande golf possibile, questo era solo un FGITW.

jb>5.SS69hO26

Provalo online qui .

Brachylog , 40 byte

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

Spiegazione

Brachylog non ha un built-in per i numeri casuali (ancora ...) quindi dobbiamo usare un predicato SWI-Prolog per questo: random/1. Possiamo inserire il codice SWI-Prolog in Brachylog usando i backquotes.

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 byte

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

Dal momento che non possiamo campionare in modo univoco i randoms in JavaScript, questo funziona creando un Set (che contiene solo valori univoci), aggiungendo ricorsivamente i randoms (1-69) fino a quando non ci sono 5 unici, aggiungendo un numero casuale (1-26), quindi unirsi e restituire tutto.

Elisir , 83 byte

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

Quando si IO.putsinserisce una matrice di numeri interi, Elisir interpreterà i numeri interi come caratteri e quindi produrrà una stringa invece dei numeri di powerball desiderati. Quindi, dobbiamo ridurre l'array intero in una stringa.

Rubino, 47 43 39 byte

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

Penso che si possa giocare di più, ma ci lavorerò una volta che avrò ammirato quanto sia bello questo codice, considerando.

Funziona praticamente allo stesso modo di tutto il resto: prendi un array dei numeri da 1 a 69, mescolali, ottieni i primi cinque, emetti quelli, quindi emetti un numero casuale compreso tra 1 e 26.

Ho passato alcune iterazioni prima di pubblicare questo:

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

(dove <newline> viene sostituito con una nuova riga effettiva)

EDIT: Whoops, non ho visto la risposta preesistente Ruby. Mi sono imbattuto samplee stavo scorrendo verso il basso per modificare la mia risposta, ma poi l'ho vista ... Oh bene. Il mio punteggio finale è di 43 byte, ma continuerò a giocare a golf un po 'per vedere quanto posso fare.

Mathematica, 64 byte

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

Abbastanza semplice.

Perl 5, 59 byte

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

È una subroutine; usalo come:

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

PHP, 65 byte

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

Grazie all'altra risposta PHP in questa pagina. Ho scritto un programma da solo, e si è rivelata la stessa identica risposta di quella scritta da Samsquanch, che mi ha spinto a fare un passo avanti per salvare qualche byte.

Se qualcuno riesce a capire un modo per aggiungere un array a un altro qui che è inferiore ai 5 byte che mi ci vuole per unire il numero di powerball dopo, lo apprezzerei molto, perché mi sta facendo impazzire! Il meglio che potrei inventare sarebbe dopo array_rande prima join, avere una frase simile +[5=>rand()%25], ma è un byte in più rispetto al concatenarlo dopo.

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

Eseguilo attraverso la riga di comando. Campione:

C:\(filepath)>php powerball.php

Produzione:

 12 24 33 67 69 4

PARI / GP, 71 70 byte

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

Genera una permutazione casuale di [1..69], quindi prende i primi 5.

Sfortunatamente si tratta di un utente inefficiente della casualità, che consuma in media 87 byte di entropia rispetto all'ideale teorico dell'informazione di 3.5. Questo principalmente perché viene generata l'intera permutazione anziché solo i primi 5 membri, e anche perché i permanenti sono ordinati (perdendo lg 5! = ~ 7 bit). Ulteriore,random utilizza una strategia di rifiuto anziché utilizzare la codifica aritmetica. (Questo perché PARI utilizza lo xorgen di Brent, che è abbastanza veloce da rendere raramente utile il sovraccarico derivante da strategie più complicate.)

Ci sono tre modifiche "ovvie" che non funzionano con l'attuale versione (2.8.0) di gp. randome printpotrebbe essere memorizzato in variabili e printpotrebbe essere chiamato direttamente anziché tramite la ->funzione anonima :

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

Insieme, questi risparmierebbero 9 byte. Sfortunatamente entrambe le funzioni sono valide senza argomenti e quindi vengono valutate immediatamente anziché memorizzate, quindi non calcolano l'output desiderato.

Codice macchina Intel x86, 85 byte

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

Beh, a volte stampa gli stessi numeri in tal caso, basta riprovare premendo un tasto.

Compilare con:

nasm file.asm -o file.bin

Assicurati di allinearlo a una dimensione floppy (aggiungi zeri alla fine) per montarlo su un VM (non ha bisogno di alcun sistema operativo).

Smontaggio:

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 byte

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

Non molto soddisfatto di questa soluzione in quanto sembra che ci dovrebbero essere più opportunità di golf. Lo guarderò di nuovo domani con occhi nuovi. Provalo qui .

Rapido, 165 byte

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

Può essere eseguito rapidamente in un parco giochi Xcode.

EDIT: Il problema attuale qui è che teoricamente è possibile che ciò avvenga per sempre nel ciclo while se arc4random_uniform in qualche modo continua a ottenere lo stesso numero. Le probabilità che ciò accada, per un periodo di tempo significativo, sono probabilmente migliori delle probabilità di vincere il Powerball.

Perl 6 ,  32   31 byte

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

Trasformandolo in una funzione che restituisce una stringa, posso rimuovere 4 byte ( put␠) aggiungendo solo 3 ( {~ })

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

Uso:

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

Se una funzione fosse autorizzata a restituire un elenco di valori, funzionerebbe anche quanto segue.

(Altrimenti sarebbe lo stesso di sopra ma all'interno { })

• funzione che restituisce un unico elenco piatto

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

• funzione che restituisce un elenco con i primi 5 numeri in un elenco secondario

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

• funzione che restituisce un elenco con i primi 5 in un elenco secondario e il Powerball in un altro elenco secondario

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

Scherzi a parte, 35 byte

Il mio primo tentativo di risposta in una lingua da golf.

Sembra più lungo di quanto dovrebbe essere.
La ripetizione potrebbe essere probabilmente rimossa con W , ma sembra essere rotta nell'interprete online e non voglio pubblicare codice non testato.

Peccato { non funziona sugli elenchi.

Codice:

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

Discarica esadecimale:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

Spiegazione:

: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

Interprete online

Lua, 96 byte

Una soluzione semplice, utilizzando una tabella come set inserendo il valore al suo interno in modo table[value]=truthy/falsyda poter verificare se sono al suo interno o meno.

Perdo 5 byte perché devo impostare il primo valore della mia tabella, altrimenti non andrò all'interno di while(o[n]) ciclo e semplicemente uscirò nprima di usare la funzione casuale. Dato che Lua usa tabelle basate su 1, devo anche forzarlo a mettere il suo primo valore nella cella [0], altrimenti non potrei produrre 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 byte

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