Powerball ist eine amerikanische Lotterie, die in letzter Zeit auf sich aufmerksam gemacht hat, da der aktuelle Jackpot (Stand: 11. Januar 2016) mit rund 1,5 Mrd. USD der größte Lottopreis in der Geschichte ist .

Powerball-Spieler wählen aus 69 nummerierten weißen Bällen 5 verschiedene Zahlen und aus 26 nummerierten roten Bällen eine "Powerball" -Nummer. Sie gewinnen den Jackpot, wenn ihre fünf weißen Ballwahlen mit der gezogenen Reihenfolge übereinstimmen und wenn sie die richtige "Powerball" -Nummer gewählt haben.

Also die Chancen, den Jackpot zu gewinnen sind 1 in (69 choose 5)*(26 choose 1)oder ((69*68*67*66*65)/(5*4*3*2*1))*26, das ist 1 in 292.201.338

Niemand hat den Jackpot in der letzten Ziehung am 9. Januar 2016 gewonnen, aber vielleicht gewinnt jemand die nächste Ziehung am 13. Januar 2016, 22:59 Uhr ET.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Powerball - Zeichnung simuliert, indem Sie 5 verschiedene Zufallszahlen von 1 bis einschließlich 69 und dann eine zufällige "Powerball" - Zahl von 1 bis einschließlich 26 eingeben (was eine Wiederholung einer der 5 sein könnte) Anfangszahlen).

Die "Powerball" -Nummer sollte immer die letzte Nummer in der Ausgabe sein, ansonsten spielt die Reihenfolge der ersten 5 Nummern keine Rolle.

Die 6 Zahlen sollten in Dezimalzahlen ausgegeben werden , entweder durch Leerzeichen oder durch Zeilenumbrüche getrennt, und optional durch eine einzelne nachgestellte Zeile. Kommas, Klammern und andere Zeichen sind in der Ausgabe nicht zulässig.

Das wären also gültige Ausgaben (unter Verwendung der Zahlen aus der letzten Zeichnung ):

32 16 19 57 34 13

32
16
19
57
34
13

Alle 292201338 möglichen Ergebnisse sollten mit einheitlicher Wahrscheinlichkeit möglich sein. Sie können integrierte Pseudozufallszahlengeneratoren verwenden und davon ausgehen, dass diese diesen Standard erfüllen.

Hier ist eine unbenutzte Referenzimplementierung, die in Python 2 oder 3 funktioniert:

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

Der kürzeste Code in Bytes gewinnt.

^{Beachten Sie, dass ich keine Beziehung zu Powerball habe und nicht wirklich vorschlage, dass Sie spielen. Aber wenn Sie irgendetwas aus Zahlen gewinnen, die von einem der Programme hier generiert wurden, würden wir sicher gerne davon hören. : D}

Dyalog APL, 10 Bytes

(5?69),?26

Dyadisch ?ist ⍺ verschiedene Zufallszahlen in [1, ⍵] und monadisch ?ist eine einzelne Zufallszahl.

Probieren Sie es hier aus .

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

Probieren Sie es online aus.

MATL , 10 Bytes

69 5Zr26Yr

Verwendet die aktuelle Version (9.2.0) der Sprache / des Compilers.

Beispiel

Mit auf Matlab laufendem Compiler:

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

Mit auf Octave laufendem Compiler:

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

Die ersten fünf Zahlen werden durch ein Leerzeichen und nicht durch ein Zeilenumbruch getrennt. Dies liegt daran, dass sich die zugrunde liegende randsampleFunktion von Octave anders verhält als die von Matlab (und in einer neuen Version des Compilers korrigiert wurde). Wie auch immer, Newline und Space sind beide durch die Herausforderung erlaubt.

Bearbeiten (4. April 2016) : Probieren Sie es online!

Erläuterung

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

Siehe relevante Matlab-Funktionen: randsampleund randi.

Ruby, 33 32

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

Ruby hat zufällig eine eingebaute Methode, sample, die zufällige Werte aus einem Array auswählt, ohne sie zu ersetzen. Vielen Dank an QPaysTaxes für den Hinweis, dass ich die Eltern nicht brauche.

R 30 29 Bytes

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

Die sampleFunktion führt einfache Zufallsstichproben aus der Eingabe durch. Wenn als erstes Argument eine einzelne Ganzzahl angegeben wird, erfolgt die Stichprobenerfassung von 1 bis zum Argument. Die Stichprobengröße ist das zweite Argument. Wir verwenden die Standardoption der ersatzlosen Probenahme.

Probieren Sie es online aus

Python 3.5, 63 Bytes

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

Es ist im Grunde die Referenzimplementierung Golf. Beachten Sie, dass 3.5 erforderlich ist, um ein nicht letztes Argument einzugeben.

Oktave, 35 32 Bytes

Calvins Hobbys bestätigten, dass die ans =Verwendung einer Funktion in Ordnung war.

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

Es hat Ähnlichkeiten mit der Antwort von Memming , verwendet jedoch eine direkte Indizierung, die nur in Octave möglich ist, und ist 5 bis 7 Bytes kürzer.

randperm(69)Erstellt eine Liste mit einer zufälligen Permutation der Zahlen 1-69. Es ist möglich, die Liste direkt zu indizieren (in MATLAB nicht möglich), um nur die ersten 5 Zahlen wie diese zu erhalten (1;5). Nach der Liste wird randi(26)eine einzelne Zahl zwischen 1 und 26 zurückgegeben.

Alt:

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

Die resultierende Liste wird mit angezeigt disp.

PowerShell v2 +, 31 27 Bytes

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

Benötigt Version 2 oder neuer, da Get-Randomin Version 1 nicht vorhanden ( Get-impliziert und -Maximumpositionsbezogen). Die Ausgabe erfolgt in Zeilenumbrüchen.

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

Ich kenne. Es ist die langweilige Lösung.

PHP, 69 Bytes

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

Ziemlich direkte Antwort. Generieren Sie eine 1-69 range, array_randgreifen Sie mit 5 zufälligen Schlüsseln aus dem Array zu, geben Sie den $k+1Wert (0-indiziert) aus und geben Sie dann eine zufällige Ganzzahl von 1-26 aus.

C #, 153 Bytes 140 Bytes

Dank an "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-Lösung:

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

Einfache Lösung mit Linq und Mischen mit GUID.

Pyth - 13 14 13 Bytes

Großartiges Golfen möglich, dies war nur eine FGITW.

jb>5.SS69hO26

Probieren Sie es hier online aus .

Brachylog , 40 Bytes

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

Erläuterung

Brachylog hat kein eingebaut für Zufallszahl (noch ...) , so dass wir ein SWI-Prolog - Prädikat für das verwenden müssen: random/1. Wir können SWI-Prolog-Code in Brachylog mit Anführungszeichen eingeben.

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` `

Da wir in JavaScript keine eindeutigen Stichproben für Zufälle erstellen können, erstellen wir ein Set (das nur eindeutige Werte enthält) und fügen rekursiv Zufälle (1-69) hinzu, bis es 5 eindeutige Werte gibt, und fügen eine Zufallszahl (1-26) hinzu. dann verbinden und alles zurückgeben.

Elixier , 83 Bytes

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

Wenn IO.putsElixir nur ein Array von Ganzzahlen eingibt, interpretiert es die Ganzzahlen als Zeichen und gibt daher anstelle der gewünschten Powerball-Zahlen einen String aus. Also müssen wir das Integer-Array auf einen String reduzieren.

Ruby, 47 43 39 Bytes

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

Ich denke, es kann mehr Golf gespielt werden, aber ich werde daran arbeiten, wenn ich fertig bin und bewundere, wie hübsch dieser Code aussieht, wenn man bedenkt.

Es funktioniert so ziemlich genauso wie alles andere: Nimm ein Array der Zahlen 1 bis 69, mische sie, hole die ersten fünf, gib diese aus und gib dann eine Zufallszahl zwischen 1 und 26 aus.

Ich habe einige Iterationen durchlaufen, bevor ich dies gepostet habe:

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

(woher <newline> wird durch eine aktuelle Newline ersetzt)

EDIT: Whoops, habe die bereits existierende Ruby-Antwort nicht gesehen. Ich stolperte weiter sampleund scrollte nach unten, um meine Antwort zu bearbeiten, aber dann sah ich es ... Na ja. Mein Endergebnis ist 43 Bytes, aber ich werde weiter ein bisschen Golf spielen, um zu sehen, wie gut ich es kann.

Mathematica, 64 Bytes

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

Ziemlich einfach.

Perl 5, 59 Bytes

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

Es ist eine Unterroutine; benutze es als:

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

PHP, 65 Bytes

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

Danke an die andere PHP Antwort auf dieser Seite. Ich habe selbst ein Programm geschrieben, und es stellte sich heraus, dass es genau die gleiche Antwort war wie die von Samsquanch, was mich dazu veranlasste, noch einen Schritt weiter zu gehen, um ein paar Bytes zu sparen.

Wenn irgendjemand hier eine Möglichkeit finden kann, ein Array an ein anderes anzuhängen, die weniger als die 5 Bytes beträgt, die ich brauche, um mich der Powerball-Nummer anzuschließen, wäre ich sehr dankbar, denn das macht mich verrückt! Das Beste, was ich mir einfallen lassen könnte, wäre nach array_randund vor joineine Aussage zu haben +[5=>rand()%25], aber das ist ein zusätzliches Byte, wenn ich sie nur nach und nach verkette.

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

Führen Sie es über die Befehlszeile aus. Probe:

C:\(filepath)>php powerball.php

Ausgabe:

 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)

Es erzeugt eine zufällige Permutation von [1..69] und nimmt dann die ersten 5.

Leider ist dies ein ineffizienter Zufallsnutzer, der im Vergleich zum informationstheoretischen Ideal von 3,5 durchschnittlich 87 Byte Entropie verbraucht. Dies liegt hauptsächlich daran, dass die gesamte Permutation anstelle der ersten 5 Elemente generiert wird und auch daran, dass die Perms geordnet sind (Verlust von lg 5! = ~ 7 Bits). Ferner randomverwendet eine Ablehnung Strategie anstatt arithmetische Codierung. (Dies liegt daran, dass PARI Brents xorgen verwendet, was schnell genug ist, so dass sich der Aufwand für kompliziertere Strategien selten lohnt.)

Es gibt drei 'offensichtliche' Änderungen, die unter der aktuellen (2.8.0) Version von gp nicht funktionieren. randomund printkönnen in Variablen gespeichert und printdirekt und nicht über die anonyme ->Funktion aufgerufen werden :

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

Zusammen würden dies 9 Bytes einsparen. Leider sind beide Funktionen ohne Argumente gültig und werden daher sofort ausgewertet und nicht gespeichert, sodass diese nicht die gewünschte Ausgabe berechnen.

Intel x86-Maschinencode, 85 Byte

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

Nun, manchmal werden die gleichen Zahlen gedruckt. Versuchen Sie es einfach noch einmal, indem Sie eine Taste drücken.

Kompilieren mit:

nasm file.asm -o file.bin

Stellen Sie sicher, dass Sie eine Diskettengröße festlegen (fügen Sie am Ende Nullen hinzu), um sie auf einem virtuellen Computer zu mounten (es wird kein Betriebssystem benötigt).

Demontage:

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

Ich bin nicht sonderlich zufrieden mit dieser Lösung, da ich der Meinung bin, dass es mehr Möglichkeiten zum Golfen geben sollte. Ich werde es morgen noch einmal mit neuen Augen betrachten. Probieren Sie es hier aus .

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

Kann schnell in einem Xcode-Spielplatz ausgeführt werden.

BEARBEITEN: Das aktuelle Problem hier ist, dass es theoretisch möglich ist, dass dies für immer in der while-Schleife abläuft, wenn arc4random_uniform irgendwie die gleiche Zahl zieht. Die Wahrscheinlichkeit, dass dies für einen längeren Zeitraum geschieht, ist wahrscheinlich höher als die Wahrscheinlichkeit, den Powerball zu gewinnen.

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␤

Wenn ich daraus eine Funktion mache, die eine Zeichenfolge zurückgibt, kann ich 4 Bytes ( put␠) entfernen und nur 3 ( {~ }) hinzufügen.

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

Verwendung:

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

Wenn eine Funktion eine Liste der Werte zurückgeben könnte, würde auch Folgendes funktionieren.

(Sonst wäre es dasselbe wie oben, aber innerhalb { })

• Funktion, die eine einzelne flache Liste zurückgibt

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

• Funktion, die eine Liste mit den ersten 5 Ziffern einer Unterliste zurückgibt

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

• Funktion, die eine Liste mit den ersten 5 in einer Unterliste und den Powerball in einer anderen Unterliste zurückgibt

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

Im Ernst, 35 Bytes

Mein erster Versuch, eine Antwort in einer Golfsprache zu finden.

Fühlt sich länger an, als es sein sollte.
Die Wiederholung könnte wahrscheinlich mit W entfernt werden , scheint aber im Online-Interpreter fehlerhaft zu sein und ich möchte keinen ungetesteten Code veröffentlichen.

Schade, dass { nicht auf Listen funktioniert.

Code:

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

Hex-Dump:

3a37303a317869204a7b2e204a7b2e204a7b2e204a7b2e204a7b2e3a32363a4a752e7f

Erläuterung:

: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-Dolmetscher

Lua, 96 Bytes

Eine einfache Lösung, bei der eine Tabelle als Menge verwendet wird, indem der Wert als in sie eingefügt wird table[value]=truthy/falsy , um zu überprüfen, ob sie sich in der oder nicht.

Ich verliere 5 Bytes, weil ich den ersten Wert meiner Tabelle setzen muss, sonst gehe ich nicht in die while(o[n])Schleife und gebe einfach aus, nbevor ich die Zufallsfunktion benutze. Da Lua 1-basierte Tabellen verwendet, muss ich auch erzwingen, dass der erste Wert in die Zelle geschrieben wird [0], da ich sonst a nicht ausgeben kann 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

Golf gespielt:

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