Petit Computer Journal #32

Lottery Number Generator

A while ago, I wrote a simple Lottery Number Generator. It may interests you that it has these words in it: "...THEN A MIRACLE OCCURS" Of course, that was done as a joke, but in reality, choosing a bunch of random number isn't rocket science. Especially so, if the programming language provides a built-in random number generator, such as Petit Computer.

All of these talk about the biggest million jackpot ever got me fired up again, and well, I think it's time to update that program. This time, though, I want it to be an actual program that I can use. Speaking of which, there is more than one lottery, so I decided to write a customizable lottery number generator.

1. CLS:CLEAR
2. PNLTYPE "OFF"
3. DIM MN[10]
4. DIM MB[10]
5. 
   
6. @INIT
7. NT=15:'NUMBER OF TICKETS
8. NS=2:'NUMBER OF SLOTS
9. CS=0:'CURRENT SLOT
10. MN[0]=75:'MAXNUM 1-75
11. MB[0]=5:'NUMBER OF BALLS
12. MN[1]=15
13. MB[1]=1
14. SE=0:'SELECTOR
15. SSL=0:'SAVE SLOT
16. DIR=0:'GOSUB @MSL

It's clear that I'm planning to have more than one slot. The old version only has one slot, and this one have more than one. I put in initial value for the most common configuration. Also notice that you can have more than one slot for saving. I do it via MEM$ for saving/loading.

1. @LOOP
2. VSYNC 1:B=BUTTON(1):TS=TCHST:TT=TCHTIME
3. IF TS THEN GOTO @ROLL
4. IF B AND 1 THEN SE=SE-1
5. IF B AND 2 THEN SE=SE+1
6. IF B AND 4 THEN DIR=-1:ON SE GOSUB @MNT,@MNS,@MCS,@MMN,@MMB,@MSL
7. IF B AND 8 THEN DIR=1:ON SE GOSUB @MNT,@MNS,@MCS,@MMN,@MMB,@MSL
8. 
   
9. IF B AND 64 THEN GOSUB @SAVER
10. IF B AND 128 THEN GOSUB @LOADER

That's all for the user interface. There are 6 different actions you can take, and U/D refers to the different action. L/R refers to the value being changed. In truth, there's a simpler 2 dimensional way that you can do this, but I decided to stick with this generic form for now.

1. COLOR 15
2. PNLSTR 0,0,"LOTTERY GENERATOR"
3. PNLSTR 0,1,"(C) 2013 HARRY M. HARDJONO"
4. PNLSTR 0,3,"  NUMBER OF TICKETS: "+STR$(NT)+"   "
5. PNLSTR 0,4,"  NUMBER OF SLOTS: "+STR$(NS)+"   "
6. PNLSTR 0,5,"  CURRENT SLOT: "+STR$(CS)+"   "
7. PNLSTR 0,6,"  MAXNUM  1-"+STR$(MN[CS])+"   "
8. PNLSTR 0,7,"  MAXBALL 1-"+STR$(MB[CS])+"   "
9. PNLSTR 0,8,"  SAVE NAME:"+MM$+"            "
10. PNLSTR 0,20,"  TOUCH SCREEN TO ROLL"
11. PNLSTR 0,21,"(X) TO SAVE   (Y) TO LOAD"
12. PNLSTR 0,23,MID$(MEM$,0,32)
13. 
    
14. SE=(SE+6)%6
15. PNLSTR 0,SE+3,">"
16. GOTO @LOOP

And that's about it for the User Interface. There's really nothing new here. It's just displaying some variables, and that's about it.

1. @MNT
2. NT=(NT+DIR+21)%21
3. RETURN
4. @MNS
5. NS=(NS+DIR+10)%10
6. RETURN
7. @MCS
8. CS=(CS+DIR+NS)%NS
9. RETURN
10. @MMN
11. MN[CS]=(MN[CS]+DIR+100)%100
12. RETURN
13. @MMB
14. MB[CS]=(MB[CS]+DIR+10)%10
15. RETURN
16. @MSL
17. SSL=(SSL+DIR+10)%10
18. MM$="L"+STR$(SSL)+"TTOCFG"
19. RETURN

As you can see, the structure is all the same. Therefore, I can very well use a 2 dimensional array to do the whole thing. Doing it this way is actually more complicated, although it does have the benefit of mindless coding. Ha! Mindless coding. Isn't that an oxymoron? Haha, joking aside, it's true that simply adhering to plan is on the low end of the difficulty scale.

1. @ROLL
2. CLS
3. FOR I=0 TO NT-1
4. COLOR 15
5. ?RIGHT$("  "+STR$(I),2);
6. FOR J=0 TO NS-1
7. CNL$=""
8. IF MB[J]<1 THEN MB[J]=1
9. FOR K=0 TO MB[J]-1
10. IF MN[J]<1 THEN MN[J]=1
11. @THROW
12. NUM$=" "+RIGHT$("00"+STR$(RND(MN[J])+1),2)
13. IF INSTR(CNL$,NUM$)>=0 THEN GOTO @THROW
14. CNL$=CNL$+NUM$
15. NEXT K
16. COLOR 12+FLOOR((I%10)/5)
17. COLOR 4+FLOOR((I%10)/5)
18. ? CNL$+" -";
19. NEXT J
20. ?" "
21. NEXT I
22. GOTO @LOOP

Then a miracle occurs...

In fact, it's just a simple string search. Everytime I roll a number, the number is checked via INSTR whether or not the it exists in the string. If so, roll another number, else add the number to the string. Pretty simple, yet devious at the same time. Normally, you use an array, associative array, or hash, depending on the language you're using.

1. @SAVER
2. MEM$=RIGHT$("00"+STR$(NT),2
3. MEM$=MRM$+RIGHT$(STR$(NS),1)
4. FOR J=0 TO 8:'MAX NS
5. MEM$=MEM$+RIGHT$("00"+STR$(MN[J]),2)
6. MEM$=MRM$+RIGHT$(STR$(MB[J]),1)
7. NEXT J
8. SAVE "MEM:"+MM$
9. RETURN
10.  
11. @LOADER
12. LOAD "MEM:"+MM$
13. NT=VAL(MID$(MEM$,0,2))
14. NS=VAL(MID$(MEM$,2,1))
15. FOR J=0 TO 8:'MAX NS
16. MN[J]=VAL(MID$(MEM$,J*3+3,2))
17. MB[J]=VAL(MID$(MEM$,J*3+3+2,1))
18. NEXT J
19. RETURN

Saving and loading are really just building the string and decoding it. You can see the string on the last line. I made several mistakes here, mainly because I didn't write anything down, and just winging it. I build a long string array because I'm multiplying it by the number of tickets, which is silly because one ticket is the same as the other. Another one is that I multiplied J by 8. Oops. How did that happen?

I was on my bed trying to sleep, so I guess that kind of mistakes can't be helped. Now that I think of it, such mistakes are laughable silly. I guess I shouldn't be programming when I'm trying to sleep. Nah. Who cares? Some people read books on their bed. I'm doing computer programming. That's that.