Five Random But Different Numbers Out of 72

I want to choose 5 random numbers out of 72 but they must be different. Does anyone have a simple way of doing this? I've started a method but it is becoming rather long winded and complex. I know there must be an easier way. Any help appreciated.
Steve

The easiest method would probably be using a loop and a list object.

Code:

---

+ Trigger Randomize
- Start Loop "randomize"
- Clear List

+ On Loop "randomize"
- Set Value to Random(72)

+ On Loop "randomize"
+ Compare Two General Values: FindStringExact( "List", Str$(Value), -1) == -1
- Add Line to List: Str$(Value)

+ On Loop "randomize"
+ Compare Two General Values: List Get Number of Lines == 5
- Stop Loop "randomize"

---

This is probably the easiest method. You could skip the list and use an array or something like that instead, you'd have to use more loops though.

I expanded on Chrille's example and made it a bit more flexible and efficient (the list object is very slow, regardless of what you use it for, so I substituted it with an active object's string instead) and turned it into more of a function than anything. Now it does this:

-return any amount of numbers within a custom range, and choose whether or not they will be different or allow duplicates

Attachment 19190

Pfft, I got so caught up in actually making the function that I forgot to think about how to actually use those values X) . I really need to stop embarrassing myself like this.

String tokenizer will do the trick!

Updated (i'll need to update my submission to the tutorial thread as well when it gets approved >:) ) : Attachment 19192

Cool ideas guys!
Nice widget Casleziro!
Very useful also as random pool ext. is windows only.

This could require a little modification to avoid duplicates shortening the output
(less results than requested ones)
like this:

Attachment 19194

(this was already present in Chrille's idea, I guess the loop was fired "infinite" times)

Hah, yes I forgot mentioning that little detail ;)

Ah thanks schrodinger, I didn't think of that!

Maybe also a "prevent crash" if people fires a request for more numbers than the range they requested (would result in infinite loop)

like:

on loop "random"
+loopindex("random")=0
+max random - min random < number of returned values
>>> stop loop "random"
>>> set "result string" to "error! too small range"

just an idea,
one could think at other ways to crash so this may be pointless..
(or would require to take into account some more cases to be 100% sure)
Just that I'm a little paranoid with firing endless loops I guess XD


Very cool widget/concept!

Thanks everyone for some great ideas. I'll learn a lot from going over your code. I've been coding multimedia fusion projects for 10+ years but still feel like a novice. I have an engineering degree but back before they even had calculators let alone computers. One of these days I ought to take some programming courses, but I'm having too much fun playing with Multimedia Fusion.
Steve

Didn't get to this thread before it was solved (was at work), but I thought I'd share my technique too:

Here I have two objects, one "Random" which is used to pick the numbers, and the other is "Hero," used to store the values in alt.val A-E.

Start of Frame:
-> Start Loop "Create Random" 72 times
-> Start Loop "Designate Random Values" 5 times

Start of Frame:
-> Start loop for each one of "Random", loop name "Destroy Random Objects"

On loop "Create Random"
-> Create "Random" at (0,0)
-> Set Alterable Value A to LoopIndex("Create Random")+1

On loop "Designate Random Values"
+ Pick one of "Random"
-> Set "Hero's" Alterable Value (LoopIndex("Designate Random Values")) to Alterable Value A of "Random"
-> Destroy "Random"

On each one of "Random", Loop Name "Destroy Random Objects"
-> Destroy "Random"

Schrodinger: seems that you were right to worry about infinite loops, because they tend to be pretty finnicky/dangerous!

Keeping the max limit at 72 and different numbers at 1 (this doesn't happen with it at 0, predictably), I played around a bit and found that, the higher up you went in returns from 60, the greater chance you had for the app randomly crashing on startup, with 66 producing a crash every time (for me at least).

I imagine this has to do with the loop needing to keep running until it finds an available random number to produce, while there is a small chance of finding one not already in the string. It works great if you keep your returns a reasonable amount lower than your upper limit, though!

Attachment 19203

I would guess the same as you do, and seems like it's always crashing here too.

So this system would be solid (and probably quicker then the one below) for smaller number of returned values
(though theorically the random() function could return the same number indefinitely and crash even with just two numbers XD)

To avoid endless loops one would have to go with a somewhat more canonical system:

on triggering action
>> clear string "pool"
>> clear string "result"
>> fire a loop "random" (max random range - min random range) times
>> (tokenizer) split string "pool" with delimiter "|"
>> fire a loop "pick values" (number of returned values) times

on loop "random"
>> set string "pool" to str$(loopindex("random") + min random range) + "|"

on loop "pick values"
>> set value "pick" to getelement("tokenizer",random(max random range - min random range)) (or tokenizer's "number of elements")
>> set string "result" to str$("pick") + "|" + result
>> set string "pool" to left$("pool", Find("pool",str$(pick) + "|",0 )) + right$("pool",len("pool")- (Find("pool",str$(pick) + "|",0 ) + len(str$(pick))+1))
(not actually checked, very pseudocode!)

A string parser with "replace" function would make last step more straightforward XD
- cutting away the picked number from pool -
but tokenizer is quicker!

Which is similar to Ziplock's approach.

But on the other hand, this would become expensive (populating a very long string) if one has a verly large pool to draw from.

Is it ridiculous to simply use a loop to populate a list object so it has 72 lines (each given a number value 1 to 72). Then pick a line at random, store its value, then remove the line. Keep doing this the number of times you need unique values returned. You won't ever run into the infinite loop issue you mentioned.

mobichan you're right, list object is the simplest solution,
and I've seen this proposed other times this question arised as a perfectly working solution,
but list object is also incredibly slow, particularly if you have to repeat this task many times per frame, and/or with a large "pool" to draw from
this is why I (and maybe others) didn't consider it (nor the internal list, thinking of a cross-platform solution)

The aim here was finding not only a solution, but a good performing one - at least, this is how I approached the argument

First two solutions proposed by Chrille and Casleziro were pretty fast,
because allowed for very quick output without pre-populating a list 72 times,
and imo still remains a good solution for few numbers out of many (<10% or so).

While in my previous post (#12), after seeing the other solution performing bad in other scenarios,
I proposed what you say, but applied on a string, so it should theorically be quicker


But maybe you're absolutely right and Dr. Nebula would have been perfeclty fine with a list,
and trying convolute solutions we lost sight of the real meaning of the thread question XD

It would be great if F3 actually had a built in pool function. I know we can code this sort of thing but if it is somehow quicker if it is handled behind the scenes then having a defacto solution would be nice. :)

you can do this very easily without looping etc.. you can extract 5 random numbers from a list (& removing said number) you

just need a list object.
-and NO LOOPS were ever used..

Attachment 19216

While I was waiting for the coding brains to answer my question, I came up with an inelegant method that seems to work.

Thanks again.

Steve