How to randomly list objects of an array?
To put it simple, I want to go through every single object in an array in a way that is random every time.
I've found out that by using this method:
1 | local array = something:GetChildren() |
2 |
3 | for i=1, #array do |
4 | array[i] --do something |
5 | end |
it would go through every single object of the array by their time of creation which would be the same every time the code is run. So, I'm asking you what would be the easiest way to make it happen randomly.
So far I've thought of
1 | local i = math.random(1,#array) |
but it would be too messy, because you would have to keep track of objects that' already have gone through.
Thankyou in advance!
0
4 answers
There are evidently many solutions to this problem, but I'll just share the first (and in my opinion, the simplest) that comes to mind.
Solution
You most likely don't want to change the state of the array whilst listing random indices, so you probably want some sort of buffer to temporarily represent the array. Then, a new table to store the new random configuration of the array.
01 | local function randomSortArray(array) |
02 | -- A buffer that is a direct clone of the array for temporary use |
03 | local buffer = {} |
04 | for i = 1, #array do |
05 | buffer[i] = array[i] |
06 | end |
07 |
08 | -- The new array that represents a random configuration of the buffer array |
09 | local newArray = {} |
10 | while (#buffer > 0) do |
11 | -- Remove the randomly chosen index from the buffer to ensure original values each iteration |
12 | newArray[#newArray+1] = table.remove(buffer, math.random(#buffer)) |
13 | end |
14 |
15 | -- Teturn the random configuration |
16 | return newArray |
17 | end |
Here's a Walkthrough
Create a clone of the original array (a buffer)
buffer = {}
Copy all elements from array into the buffer
for i = 1, #array do buffer[i] = array[i]; end
Create a new empty table to store the random order of the array
newArray = {}
Traverse the buffer, choose a random index, and insert that into the new array
newArray[#newArray+1] = table.remove(buffer, math.random(#buffer))
Return the new array
Notice that, while inserting the next random index to the new array, we're also removing it from the buffer. This is so that we update the probability according to the size of the array, while retaining it's array structure. I hope this helped. If you have any questions, just leave a comment and I'll get to it.
0
0
0
0
I would use a temporary permutation array:
01 | local function RandomPermutation(n) |
02 | -- Initialize the permutation as the array 1...n: |
03 | local perm = {} |
04 | for i = 1, n do |
05 | perm[i] = i |
06 | end |
07 |
08 | -- A Fisher-Yates shuffle: |
09 | for i = 1, n-1 do |
10 | local j = math.random(i, n) |
11 | perm[i], perm[j] = perm[j], perm[i] |
12 | end |
13 |
14 | return perm |
15 | end |
You might possibly also do a random shuffle directly reordering the array you want to loop over, instead.
0
0
0
0
0
I copied this from the dev forum, but I think you could go:
01 | local array = {"I", "am", "kazeks123", "Me", "is", "cool"} |
02 | local function Shuffle(t) |
03 | for i = #t, 2, -1 do |
04 | local j = Random.new():NextInteger(1, i) |
05 | t[j], t[i] = t[i], t[j] |
06 | end |
07 | end |
08 | Shuffle(array) |
09 | for i, v in pairs(array) do |
10 | print(v) |
11 | end |
(if you want to keep the original table maybe make the shuffled table a duplicate of it)
Hope this helps
Don't re-invent the wheel -- shuffling a list is a common problem. It's a little surprising Lua doesn't have an in-built solution. Then again, there are many things Lua doesn't have because it's not a very good language.
From here: https://gist.github.com/Uradamus/10323382
1 | function shuffle(tbl) |
2 | for i = #tbl, 2, -1 do |
3 | local j = math.random(i) |
4 | tbl[i], tbl[j] = tbl[j], tbl[i] |
5 | end |
6 | return tbl |
7 | end |
This should shuffle a table in-place. Copy the table before passing it if you need to retain order.
1 | function copyTable(tbl) |
2 | newTable = {} |
3 | for i, v in pairs(tbl) do |
4 | newTable[i] = v |
5 | end |
6 | return newTable |
7 | end |
edit 1
smh "don't re-invent the wheel" then does that
1 | function shuffleButNotInPlace(oldTable) |
2 | tbl = {unpack(oldTable)} |
3 | for i = #tbl, 2, -1 do |
4 | local j = math.random(i) |
5 | tbl[i], tbl[j] = tbl[j], tbl[i] |
6 | end |
7 | return tbl |
8 | end |
1
0
0