Powerball es una lotería estadounidense que recientemente ha llamado la atención porque el premio mayor actual (a partir del 11 de enero de 2016) es el mayor premio de lotería de la historia , con alrededor de $ 1.5 mil millones ( USD ).

Los jugadores de Powerball eligen 5 números distintos de 69 bolas blancas numeradas y 1 número de "Powerball" de 26 bolas rojas numeradas. Ellos ganan el premio mayor si sus cinco opciones de bolas blancas se ajustan a lo que hemos dibujado en cualquier orden, y si eligieron el número correcto "Powerball".

Entonces, las posibilidades de ganar el premio mayor son 1 en (69 choose 5)*(26 choose 1)o ((69*68*67*66*65)/(5*4*3*2*1))*26, que es 1 en 292,201,338

Nadie ganó el premio mayor en el sorteo más reciente el 9 de enero de 2016, pero quizás alguien gane el próximo sorteo el 13 de enero de 2016 a las 10:59 p.m. ET.

Reto

Escriba un programa o función que simule un dibujo de Powerball, sin ingresar nada pero emitiendo 5 números aleatorios distintos del 1 al 69 inclusive, y luego un número aleatorio "Powerball" del 1 al 26 inclusive (que podría ser una repetición de uno de los 5 números iniciales).

El número "Powerball" siempre debe ser el último número en la salida, pero de lo contrario, el orden de los primeros 5 números no importa.

Los 6 números deben salir en decimal , separados por espacios o separados por nueva línea, con una nueva línea final opcional. Las comas, corchetes y otros caracteres no están permitidos en la salida.

Entonces, estos serían resultados válidos (usando los números del último dibujo ):

32 16 19 57 34 13

32
16
19
57
34
13

Todos los resultados posibles 292201338 deberían ser posibles con probabilidad uniforme. Puede usar generadores de números pseudoaleatorios integrados y asumir que cumplen con este estándar.

Aquí hay una implementación de referencia no protegida que funciona en Python 2 o 3:

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

El código más corto en bytes gana.

^{Tenga en cuenta que no estoy afiliado a Powerball y realmente no le sugiero que juegue. Pero si gana algo de los números generados por uno de los programas aquí, estoy seguro de que nos encantaría saberlo. :RE}

Dyalog APL, 10 bytes

(5?69),?26

Dyadic ?es ⍺ números aleatorios distintos en [1, ⍵], y monádico ?es un solo número aleatorio.

Probarlo aquí .

CJam, 16 bytes

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

Pruébalo en línea.

MATL , 10 bytes

69 5Zr26Yr

Utiliza la versión actual (9.2.0) del lenguaje / compilador.

Ejemplo

Con el compilador ejecutado en Matlab:

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

Con el compilador ejecutado en Octave:

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

Los primeros cinco números están separados por espacio, no por nueva línea. Esto se debe a que la randsamplefunción subyacente de Octave se comporta de manera diferente a la de Matlab (y se ha corregido en una nueva versión del compilador). De todos modos, la nueva línea y el espacio están permitidos por el desafío.

Editar (4 de abril de 2016) : ¡ Pruébelo en línea!

Explicación

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

Ver funciones relevantes de Matlab: randsampley randi.

Rubí, 33 32

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

Ruby tiene un método incorporado, muestra, que selecciona valores aleatorios de una matriz sin reemplazo. Gracias a QPaysTaxes por señalar que no necesito a los padres.

R, 30 29 bytes

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

La samplefunción realiza un muestreo aleatorio simple desde la entrada. Si se da un solo entero como primer argumento, el muestreo se realiza desde 1 hasta el argumento. El tamaño de la muestra es el segundo argumento. Estamos empleando la opción predeterminada de muestreo sin reemplazo.

Pruébalo en línea

Python 3.5, 63 bytes

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

Básicamente es la implementación de referencia de golf. Tenga en cuenta que 3.5 es necesario para salpicar en un último argumento.

Octava, 35 32 bytes

Calvin's Hobbies confirmó que ans =estaba bien cuando usaba una función, así que:

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

Tiene similitudes con la respuesta de Memming , pero usa una indexación directa que solo es posible en Octave, y es 5 7 bytes más corta, así que pensé que valía la pena publicarla de todos modos.

randperm(69)crea una lista con una permutación aleatoria de los números 1-69. Es posible indexar directamente la lista (no es posible en MATLAB) para obtener solo los primeros 5 números como este (1;5). La lista es seguida por la randi(26)cual devuelve un solo número entre 1 y 26.

Antiguo:

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

La lista resultante se muestra usando disp.

PowerShell v2 +, 31 27 bytes

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

Requiere la versión 2 o posterior, ya que Get-Randomno estaba presente en v1 ( Get-está implícito y -Maximumes posicional). La salida está separada por una nueva línea.

Sin golf:

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 sé. Es la solución aburrida.

PHP, 69 bytes

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

Respuesta bastante directa. Genere un 1-69 range, luego úselo array_randpara tomar 5 claves aleatorias de la matriz y haga eco del $k+1valor (indexado en 0), luego repita un int aleatorio de 1-26.

C #, 153 bytes 140 bytes

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

Solución de 153 bytes:

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

Solución simple usando Linq y barajando usando GUID.

Pyth - 13 14 13 bytes

Gran golf posible, esto fue solo un FGITW.

jb>5.SS69hO26

Pruébelo en línea aquí .

Brachylog , 40 bytes

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

Explicación

Brachylog no tiene un built-in de números aleatorios (todavía ...) así que tenemos que utilizar un predicado SWI-Prolog para que: random/1. Podemos ingresar el código SWI-Prolog en Brachylog usando comillas inversas.

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 bytes

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

Como no podemos muestrear de forma exclusiva los randoms en JavaScript, esto funciona creando un Set (que solo contiene valores únicos), agregando recursivamente randoms (1-69) hasta que haya 5 únicos, agregando un número aleatorio (1-26), luego uniéndose y devolviéndolo todo.

Elixir , 83 bytes

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

Cuando solo IO.putsutiliza una matriz de enteros, Elixir interpretará los enteros como caracteres y, por lo tanto, generará una cadena en lugar de los números deseados de Powerball. Entonces, tenemos que reducir la matriz entera a una cadena.

Ruby, 47 43 39 bytes

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

Creo que se puede jugar más al golf, pero trabajaré en eso una vez que termine de admirar lo bonito que se ve este código, teniendo en cuenta.

Funciona casi de la misma manera que todo lo demás: tome una matriz de los números del 1 al 69, baraje, obtenga los primeros cinco, genere esos y luego genere un número aleatorio entre 1 y 26.

Pasé por algunas iteraciones antes de publicar esto:

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

(dónde <newline> se reemplaza con una nueva línea real)

EDITAR: Vaya, no vi la respuesta preexistente de Ruby. Tropecé sampley me estaba desplazando hacia abajo para editar mi respuesta, pero luego lo vi ... Oh, bueno. Mi puntaje final es de 43 bytes, pero seguiré jugando al golf un poco para ver qué tan bien puedo hacerlo.

Mathematica, 64 bytes

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

Bastante sencillo.

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