A Powerball é uma loteria americana que ganhou atenção recentemente porque o jackpot atual (em 11 de janeiro de 2016) é o maior prêmio de loteria da história , com cerca de US $ 1,5 bilhão ( USD ).

Jogadores de Powerball escolhem 5 números distintos entre 69 bolas brancas numeradas e 1 número "Powerball" de 26 bolas vermelhas numeradas. Eles ganham o jackpot se suas cinco escolhas de bola branca corresponderem ao que foi sorteado em qualquer ordem e se escolherem o número correto de "Powerball".

Portanto, as chances de ganhar o jackpot são de 1 em (69 choose 5)*(26 choose 1)ou ((69*68*67*66*65)/(5*4*3*2*1))*26, que é 1 em 292,201.338

Ninguém ganhou o jackpot no sorteio mais recente em 9 de janeiro de 2016, mas talvez alguém ganhe o próximo sorteio em 13 de janeiro de 2016, às 22:59 ET.

Desafio

Escreva um programa ou função que simule um desenho da Powerball, sem nenhuma entrada, mas produzindo 5 números aleatórios distintos de 1 a 69 inclusive, e depois um número aleatório de "Powerball" de 1 a 26 inclusive (que pode ser uma repetição de um dos 5 números iniciais).

O número "Powerball" deve sempre ser o último número na saída, mas, caso contrário, a ordem dos 5 primeiros números não importa.

Os 6 números devem ser impressos em decimal , separados por espaço ou por nova linha, com uma nova linha à direita opcional. Vírgulas, colchetes e outros caracteres não são permitidos na saída.

Portanto, essas seriam saídas válidas (usando os números do último desenho ):

32 16 19 57 34 13

32
16
19
57
34
13

Todos os 292201338 possíveis resultados devem ser possíveis com probabilidade uniforme. Você pode usar geradores de números pseudo-aleatórios incorporados e assumir que eles atendem a esse padrão.

Aqui está uma implementação de referência não destruída que funciona no Python 2 ou 3:

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

O código mais curto em bytes vence.

^{Note que eu não tenho afiliação com a Powerball e realmente não sugiro que você jogue. Mas se você ganhar alguma coisa com números gerados por um dos programas aqui, tenho certeza de que gostaríamos de ouvir sobre isso. : D}

Dyalog APL, 10 bytes

(5?69),?26

Diádico ?é ⍺ números aleatórios distintas em [1, ⍵], e monadic ?é um único número aleatório.

Experimente aqui .

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

Experimente online.

MATL , 10 bytes

69 5Zr26Yr

Usa a versão atual (9.2.0) do idioma / compilador.

Exemplo

Com o compilador executado no Matlab:

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

Com o compilador executado no Octave:

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

Os cinco primeiros números são separados por espaço, não por nova linha. Isso ocorre porque a randsamplefunção subjacente do Octave se comporta de maneira diferente da do Matlab (e foi corrigida em uma nova versão do compilador). De qualquer forma, nova linha e espaço são permitidos pelo desafio.

Editar (4 de abril de 2016) : Experimente online!

Explicação

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

Veja as funções relevantes do Matlab: randsamplee randi.

Ruby, 33 32

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

Por acaso, Ruby possui um método interno, amostra, que seleciona valores aleatórios de uma matriz sem substituição. Agradecemos a QPaysTaxes por apontar que não preciso dos parâmetros.

R, 30 29 bytes

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

A samplefunção executa amostragem aleatória simples a partir da entrada. Se um único inteiro é dado como o primeiro argumento, a amostragem é feita de 1 ao argumento. O tamanho da amostra é o segundo argumento. Estamos empregando a opção padrão de amostragem sem substituição.

Experimente online

Python 3.5, 63 bytes

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

É basicamente a implementação de referência jogada. Observe que 3.5 é necessário para dividir em um argumento não-último.

Oitava, 35 32 bytes

O Calvin's Hobbies confirmou que ans =estava tudo bem ao usar uma função, então:

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

Tem semelhanças com a resposta de Memming , mas usa indexação direta que só é possível no Octave e é 5 7 bytes mais curta, então achei que valia a pena postar de qualquer maneira.

randperm(69)cria uma lista com uma permutação aleatória dos números 1-69. É possível indexar diretamente a lista (não é possível no MATLAB) para obter apenas os 5 primeiros números como este (1;5). A lista é seguida pelo randi(26)que retorna um número único entre 1 e 26.

Velho:

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

A lista resultante é exibida usando disp.

PowerShell v2 +, 31 27 bytes

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

Requer a versão 2 ou mais recente, como Get-Random não estava presente na v1 ( Get-está implícita e -Maximumé posicional). A saída é separada por nova linha.

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

Eu sei. É a solução chata.

PHP, 69 bytes

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

Resposta bastante direta. Gere um 1-69 range, use array_randpara pegar 5 chaves aleatórias da matriz e ecoar o $k+1valor (indexado 0) e, em seguida, ecoar um int aleatório de 1-26.

C #, 153 bytes 140 bytes

Graças 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)))

Solução 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))

Solução simples usando Linq e embaralhamento usando GUID.

Pitão - 13 14 13 bytes

Major golfe possível, este era apenas um FGITW.

jb>5.SS69hO26

Experimente online aqui .

Braquilog , 40 bytes

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

Explicação

Não Brachylog não tem um built-in para números aleatórios (ainda ...) por isso temos de usar um predicado SWI-Prolog para que: random/1. Podemos inserir o código SWI-Prolog no Brachylog usando aspas.

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 não podemos amostrar aleatoriamente randoms em JavaScript, isso funciona criando um conjunto (que contém apenas valores únicos), adicionando recursivamente randoms (1-69) até que existam 5 únicos, acrescentando um número aleatório (1-26), depois juntar e devolver tudo.

Elixir , 83 bytes

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

Ao apenas IO.putsinserir uma matriz de números inteiros, o Elixir interpretará os números inteiros como caracteres e, portanto, emitirá alguma sequência em vez dos números desejados de powerball. Portanto, temos que reduzir a matriz inteira para uma string.

Ruby, 47 43 39 bytes

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

Eu acho que pode ser mais jogado, mas vou trabalhar nisso quando terminar de admirar o quão bonito esse código parece, considerando.

Funciona da mesma maneira que todo o resto: pegue uma matriz dos números de 1 a 69, embaralhe-os, obtenha os cinco primeiros, produza-os e depois produza um número aleatório entre 1 e 26.

Passei por algumas iterações antes de postar isso:

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

(Onde <newline> é substituído por uma nova linha real)

EDIT: Opa, não vi a resposta Ruby preexistente. Eu tropecei samplee estava rolando para baixo para editar minha resposta, mas então eu vi ... Oh, bem. Minha pontuação final é de 43 bytes, mas continuarei jogando um pouco para ver como posso me sair bem.

Mathematica, 64 bytes

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

Bem simples.

Perl 5, 59 bytes

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

É uma sub-rotina; use-o como:

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

PHP, 65 bytes

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

Graças à outra resposta PHP nesta página. Eu escrevi um programa por conta própria e acabou sendo exatamente a mesma resposta que foi escrita por Samsquanch, o que me levou a dar um passo adiante para economizar alguns bytes.

Se alguém puder descobrir uma maneira de acrescentar uma matriz a outra aqui, que seja menor que os 5 bytes necessários para associar o número da powerball depois, eu agradeceria muito, porque está me deixando louco! O melhor que eu poderia fazer seria depois array_rande antes join, com uma declaração parecida +[5=>rand()%25], mas esse é um byte extra, além de concatená-la depois.

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

Execute-o através da linha de comando. Amostra:

C:\(filepath)>php powerball.php

Saída:

 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)

Ele gera uma permutação aleatória de [1..69] e depois pega os 5 primeiros.

Infelizmente, este é um usuário ineficiente da aleatoriedade, consumindo uma média de 87 bytes de entropia em comparação com o ideal teórico da informação de 3,5. Isso ocorre principalmente porque toda a permutação é gerada, em vez de apenas os 5 primeiros membros, e também porque as permissões são ordenadas (perdendo lg 5! = ~ 7 bits). Mais distante,random usa uma estratégia de rejeição em vez de usar codificação aritmética. (Isso ocorre porque o PARI usa o xorgen de Brent, que é rápido o suficiente para que as despesas de estratégias mais complicadas raramente valham a pena.)

Existem três mudanças 'óbvias' que não funcionam na versão atual (2.8.0) do gp. randome printpode ser armazenado em variáveis ​​e printpode ser chamado diretamente, e não através da ->função anônima :

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

Juntos, eles economizariam 9 bytes. Infelizmente, ambas as funções são válidas sem argumentos e, portanto, são avaliadas imediatamente e não armazenadas, portanto, elas não calculam a saída desejada.

Código da máquina Intel x86, 85 bytes

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

Bem, às vezes imprime os mesmos números, se sim, tente novamente pressionando uma tecla.

Ajuntar com:

nasm file.asm -o file.bin

Alinhe-o com um tamanho de disquete (adicione zeros no final) para montá-lo em uma vm (ele não precisa de nenhum sistema operacional).

Desmontagem:

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

Não está muito satisfeito com esta solução, pois parece que deveria haver mais oportunidades de golfe. Amanhã voltarei a vê-lo com novos olhos. Experimente aqui .

Rápido, 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)}

Pode ser executado rapidamente em um Xcode Playground.

EDIT: O problema atual aqui é que, teoricamente, é possível que isso funcione para sempre no loop while, se arc4random_uniform de alguma forma continuar puxando o mesmo número. As chances de que isso aconteça, por um período significativo de tempo, são provavelmente melhores do que as chances de ganhar a 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␤

Transformando-o em uma função que retorna uma string, eu posso remover 4 bytes (put␠ ) enquanto adiciono apenas 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 uma função tivesse permissão para retornar uma lista dos valores, o seguinte também funcionaria.

(Caso contrário, seria o mesmo que acima, mas dentro { })

• função que retorna uma única lista plana

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

• função que retorna uma lista com os 5 primeiros números em uma sub-lista

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

• função que retorna uma lista com os 5 primeiros em uma sub-lista e a Powerball em outra sub-lista

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

Sério, 35 bytes

Minha primeira tentativa de resposta em um idioma de golfe.

Parece mais do que deveria ser.
A repetição provavelmente pode ser removida com W , mas parece estar quebrada no intérprete on-line e não quero postar código não testado.

Que pena { não funciona em listas.

Código:

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

Despejo hexagonal:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

Explicação:

: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

Intérprete online

Lua, 96 bytes

Uma solução simples, usando uma tabela como um conjunto, colocando o valor dentro dela table[value]=truthy/falsypara poder verificar se ela está dentro ou não.

Perco 5 bytes porque tenho que definir o primeiro valor da minha tabela; caso contrário, não entrarei no while(o[n])loop e simplesmente sairei nantes de usar a função aleatória. Como Lua usa tabelas baseadas em 1, também tenho que forçá-lo a colocar seu primeiro valor na célula [0], caso contrário, não poderia gerar 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

Golfe:

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