Grouping similar adjacent values in a table

Help and Feedback Scripting Support
#1

This is something I can’t figure out.
Let’s say I have a table;

a = {0, 0, 0, 5, 5, 2, 2, 2, 0, 3, 3, 3, 3}

and I want to convert it to this;

b = {
    {0, 0, 0},
    {5, 5},
    {2, 2, 2}
    {0}
    {3, 3, 3, 3}
}

How would I go about doing this? Thank’s for your time.

1 Like
#2

What exactly are you trying to accomplish here? You could do this using a transition table that specifies the prevalence of different unique values. This is similar to a radix sort. The idea is to count the times that each unique value appears, store that value in a table, then reconstruct a new table with that information. There is most likely a better way to do this. What is it for?

2 Likes
#3

I don’t quite get what you mean.

#4

Why do you need to do this exactly? If you tell me what it is for I could probably help you find a better way to do it.

1 Like
#5

I have like a robot that raycasts 10 studs ahead and gets the first track that it hit’s, then it gets the angle between the previous track and the current track and stores it in a table, similar to table a (I copy a script I made and then paste it into the command bar). I want to group the similar angles so I can create a smooth bank on a curve, after I can get a new table like b I want to make the banking angle smooth, so if I get this table;

local b = {
    {0, 0, 0},
    {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
    {1, 1, 1, 1, 1},
    ...
}

and change it to

local b = {
    {0, 0, 0},
    {0.5, 1, 1.5, 2, 2, 2, 2, 2, 1.75, 1.5, 1.25},
    {1, 1, 1, 1, 1},
    ...
}

Here is an image of the tracks

image
image870×452 40.9 KB

#6

Another thing to mention, I am using archimedes 2.4 plugin by Scriptos and each track is 3 studs long

#7

Ok here you go:

-- First we construct a temporary storage
local temp = {} -- This will store the number of occurrences of each number in 'a'
for i = 1, #a do
   if not temp[i] then -- If this is the first time we find a number, add it into temp and set its occurrence to 1
      temp[a[i]] = 1
   else -- Otherwise, add 1 for each new occurence
      temp[a[i]] += 1
   end
end

-- Now we will construct 'b'
local b = {}
local x = 1
for n, v in pairs(temp) do
   b[x] = {} -- Create a table within 'b' for each unique 'n', which is a unique number in 'a'
   x += 1

   for i = 1, v do -- Run a loop to copy that number into the table the same amount of times it appears in 'a', as stored in 'temp'
      b[x][i] = n
   end
end
1 Like
#8

Could you explain each line please?

#9

I updated my answer with comments

1 Like
#10

Does it still work if the number is repeated twice?

#11

like {0, 0, 0, 1, 1, 1, 0, 0, 0}

#12

It will radix sort the numbers, so if the number appears twice in two different locations, then it will be combined.

1 Like
#13

If you don’t want the numbers to repeat use this alternative:

local b = {}
local last
local x = 0
for i = 1, #a do
   if a[i] == last then
     b[x][#b[x]+1] = a[i]
   else
      x += 1
      b[x] = {}

      b[x][1] = a[i]
      last = a[i]
   end
end
1 Like
#15

It’s not going to work as-is. Let me fix it

1 Like
#16

There’s an error on line 20 ‘attempt to index nil with number’

#17

Ok I rewrote it. See if this works. I haven’t tested it. (I edited my last code comment)

1 Like
#18

Also don’t you think there would be an easier way to do this by slicing the table and putting them as a nested table in b

#19

I didn’t realize at first that you needed it to work with repeat number groups. Originally it required a temp variable to store occurrences but now it doesn’t. This should be the most straightforward solution.

1 Like
#20

Slicing or your solution (I tested it and it works)

#21

My solution. I’m not sure what you mean by slicing.

1 Like