A telitalálatot kétféleképpen üthetjük meg:

1. rövid időre űrhajónkkal fekete lyuk mellett parkolunk le, ezért a fellépő idődilatáció miatt a jövőbe érkezünk vissza, így tudomásunkra juthat a kisorsolt 5 db szám. Ezután egy féreglyukán át vissza kell csusszannunk a jelenbe, hogy gyorsan kitölthessük a telitalálatos lottószelvényt.

2. Egyetlen hét alatt spontán kitöltjük mind a 44 millió lottószelvényt.

Érdekesség: az USA egyik államában megtörtént: az ottani, speciális lottószabályok kijátszásával lehetőség nyílt arra, hogy nagyobb tétekben játszva megérje több lottószelvényt kitölteni, ezáltal nagyobb nyereséget besöpörni, mint a ráfordított összeg. Egy matematikus házaspár meg is látta a piaci rést és erre külön vállalkozást alapított. Elkövették azonban azt a hibát, hogy túl nagy zajjal végezték tevékenységüket és az állam egyetlenegy gyors törvénymódosítással lezárta a lottószabályok további kijátszását.

Az 1. lehetőség néhány 100 év múlva adott lesz, amely értelmetlenné fogja tenni az összes, lottószerű ostobaságot, ám addig a 2. lehetőség sem valósítható meg, mert a ráfordított idő problémáján felül azt is fontos tudnunk, hogy nem nyomtatnak ki ennyi lottószelvényt, illetve ha ezt egyszer mégis megtennék, komoly logisztikai akadályokba ütköznénk az összes lottószelvény felvásárlásakor.

Aki azonban mégis a 2. lehetőség mellett dönt, annak ajánlom szíves figyelmébe az alábbi rövid, futtatható Java-kódot, amelyik kilistázza az összes, tehát mind a 44 millió kombinációt.

Bár matematikailag nézve az itt alkalmazott kombinatorikai számítások különböznek a variációktól (A kínai mintacsalád ültetési rendje című fejezet), implementációik mégis kísértetiesen hasonlóak. Ez talán azt bizonyítja, hogy valójában felesleges külön matematikai fogalmakkal illetni őket (variáció és kombináció), bár igaz, hogy másképpen kell őket kiszámolni.

Mivel 90 elemű halmazból kell kiválasztanunk 5 elemet, úgy hogy az elemek ismétlődése nem megengedett (például nem lehet: 1 1 2 3 4), ezt 5 db egymásba ágyazott for ciklussal meg tudjuk tenni, amelyekben az iterálás (i j k l m) 1-től 90-ig tart. A számismétlődést egy nagyon hosszú feltételvizsgálattal tudjuk elkerülni, amely lényegében azt mondja ki, hogy egyetlen iterátor (i j k l m) sem lehet azonos a másikkal:

if (i!=j && i!=k && i!=l && i!=m && j!=k && j!=l && j!=m && k!=l && k!=m && l!=m)

Mivel a számítógép veszettül gyorsan listázza ki az eredményt, a kiírás csonkolódik a konzolon, azaz nem lehet látni minden kombinációt. Ezt úgy kísérelhetjük meg  elkerülni, hogy rövid időre (200 milliszekundum) késleltetjük a program futását (Thread.sleep(200)). Ezt a metódust kötelező try-catch blokkba tennünk, erről majd a későbbiekben részletesen szólunk (Kivételesen beszéljünk a kivételkezelésről című fejezetcsomag).

Szakértők részére!

Ők észre fogják venni és joggal tehetik szóvá, hogy a catch ág nincs lekezelve:

catch(InterruptedException ie){}

Tisztában vagyok vele, hogy "éles" projektben ilyet nem teszünk, ám ez csak egy olyan oktató példa, amelynek adott szintjén a kivételkezeléssel még nem is foglalkoztunk, következésképpen nincs értelme magyarázatok nélkül bármit is oda implementálni. Megjegyzem: komoly programozási szakkönyvek oktatási magyarázatok során ugyanígy tesznek. (Kérésre egy ilyen forráshivatkozást e-mailban elküldök.)

Aki megunta a listázást, az a konzolfülön megnyomható piros négyzettel tudja megállítani a program futását.

public class Main {
public static void main(String[] args) {
    for (int i = 1; i <= 90; i++){
        for (int j = 1; j <= 90; j++){
            for (int k = 1; k <= 90; k++){
                for (int l = 1; l <= 90; l++){
                    for (int m = 1; m <= 90; m++){
                    if (i!=j && i!=k && i!=l && i!=m && j!=k && j!=l && j!=m && k!=l && k!=m && l!=m){
                        try{
                            System.out.print(i + " " + j + " " + k + " " + l + " " + m + "\n");
                            Thread.sleep(200);
                            }catch(InterruptedException ie){}
                            }
                        }
                    }
                }
            }
        }
    }
}

Végeredmény (például):

1 2 3 4 5
1 2 3 4 6
1 2 3 4 7
1 2 3 4 8
1 2 3 4 9
1 2 3 4 10
1 2 3 4 11
1 2 3 4 12
1 2 3 4 13
1 2 3 4 14
1 2 3 4 15
1 2 3 4 16
1 2 3 4 17
1 2 3 4 18
1 2 3 4 19
1 2 3 4 20
1 2 3 4 21
1 2 3 4 22
1 2 3 4 23
1 2 3 4 24
1 2 3 4 25
1 2 3 4 26
1 2 3 4 27
1 2 3 4 28
1 2 3 4 29
1 2 3 4 30
1 2 3 4 31
1 2 3 4 32
1 2 3 4 33
1 2 3 4 34
1 2 3 4 35
1 2 3 4 36
1 2 3 4 37
1 2 3 4 38
1 2 3 4 39
1 2 3 4 40
1 2 3 4 41
1 2 3 4 42
1 2 3 4 43
1 2 3 4 44
1 2 3 4 45
1 2 3 4 46
1 2 3 4 47
1 2 3 4 48
1 2 3 4 49
1 2 3 4 50
1 2 3 4 51
1 2 3 4 52
1 2 3 4 53
1 2 3 4 54
1 2 3 4 55
1 2 3 4 56
1 2 3 4 57
1 2 3 4 58
1 2 3 4 59
1 2 3 4 60
1 2 3 4 61
1 2 3 4 62
1 2 3 4 63
1 2 3 4 64
1 2 3 4 65
1 2 3 4 66
1 2 3 4 67
1 2 3 4 68
1 2 3 4 69
1 2 3 4 70
1 2 3 4 71
1 2 3 4 72
1 2 3 4 73
1 2 3 4 74
1 2 3 4 75
1 2 3 4 76
1 2 3 4 77
1 2 3 4 78
1 2 3 4 79
1 2 3 4 80
1 2 3 4 81
1 2 3 4 82
1 2 3 4 83
1 2 3 4 84
1 2 3 4 85
1 2 3 4 86
1 2 3 4 87
1 2 3 4 88
1 2 3 4 89
1 2 3 4 90
1 2 3 5 4
1 2 3 5 6
1 2 3 5 7
1 2 3 5 8
1 2 3 5 9
1 2 3 5 10
1 2 3 5 11

stb.

Segédlet - a feltétel megfelelő beállítása:

i j k l m

i!=j && i!=k && i!=l && i!=m

j!=k && j!=l && j!=m

k!=l && k!=m

l!=m

i!=j && i!=k && i!=l && i!=m && j!=k && j!=l && j!=m && k!=l && k!=m && l!=m