How to compare two tables for the same values?

I've been programming for a long time now, and one question that has plagued me is this. I've been able to find workarounds, but no longer.

I'm creating a terrain generator, and the idea behind it is this: Put nearby terrain parts into a table Put possible terrain locations into a table

If a nearby terrain part has the same location as a possible terrain location, remove it from the table.

Create terrain

Seems simple, right? Ideally one would assume this would work:

for _, nearGridTable in pairs(nearbyGrid) do
    for index, nearPositions in pairs(possibilities) do
        if nearGridTable == nearPositions then
        print("same")
        table.remove(possibilities, index)
        print("removed")
        end
    end
end

The issue I run into however is, my print's never run. That has lead me to believe that the nearGridTable is never equaling nearPositions.

On further analysis, there are duplicate values in both table, this for loop is just not getting them properly.

I've had a few ideas on how one might go about fixing it: Idea 1: Check the values before I put it into the table This wouldn't work, as it would be inefficient for my use case. Idea 2: use table.sort()

However, that doesn't sort my tables properly (I'm storing vector3 values). I could go about making my own sort function. I've never done this, and so essentially I come before everyone asking, what would you do to compare two tables?

Full code so you understand the context of what I'm working on:

-- Made by Conmmander --
-- terrainCore --
-- Last Edit: 9-2-2018, 2:55 PM --

-- Inititalization --

print("Intialization | "..script.Name)

-- Game Services --

local workspaceService = game:GetService("Workspace")
local playerService = game:GetService("Players")
local lightingService = game:GetService("Lighting")
local replicatedStorage = game:GetService("ReplicatedStorage")
local serverStorage = game:GetService("ServerStorage")
local starterGui = game:GetService("StarterGui")
local starterPack = game:GetService("StarterPack")
local chatService = game:GetService("Chat")

-- Game Folders --

local terrainStorage = serverStorage:FindFirstChild("terrainStorage")

local baseTerrain = terrainStorage:FindFirstChild("baseTerrain")
local buildingTerrain = terrainStorage:FindFirstChild("buildingTerrain")

-- Configuration --

local ignoreCordinates = {}
local baseLimit = 100
local yCord = .5
local mingenerationRange = 12
local maxgenerationRange = 15

-- Variables --

local bases = 0
local initialSetup = false

-- Functions --

function countTerrain()
    bases = 0
    for _, defaultPart in pairs(workspaceService:GetChildren()) do
        if defaultPart.Name == "defaultGrid" then
            bases = bases + 1
        end
    end
end

function generateTerrain(player)
    local nearbyGrid = {}
    local possibilities = {}
    if initialSetup == false then
        local position = CFrame.new(math.random(math.randomseed(1)), yCord, math.random(math.randomseed(1)))
        local clonedBase = baseTerrain.defaultGrid:Clone()
        clonedBase:SetPrimaryPartCFrame(position)
        clonedBase.Parent = workspaceService
        initialSetup = true
    end
    local debounce = false
    countTerrain()
    if bases < baseLimit then
    local Torso = player.Character.HumanoidRootPart
    local base = player.Character.RightFoot
    base.Touched:Connect(function(hitPart)
        wait(.1)
        if debounce == false then
        debounce = true
        if hitPart.Parent.Name == "defaultGrid" then
            if (hitPart.Parent.centerPart.Position-Torso.Position).Magnitude >= mingenerationRange and (hitPart.Parent.centerPart.Position-Torso.Position).Magnitude < maxgenerationRange then
                wait(.1)
                local debounce2 = false
                if debounce2 == false then
                debounce2 = true
                table.insert(possibilities, hitPart.Parent.centerPart.Position - Vector3.new(0, 0, 30))
                table.insert(possibilities, hitPart.Parent.centerPart.Position + Vector3.new(0, 0, 30))
                table.insert(possibilities, hitPart.Parent.centerPart.Position - Vector3.new(30, 0, 0))
                table.insert(possibilities, hitPart.Parent.centerPart.Position + Vector3.new(30, 0, 0))
                print("Insert")
                for _, leftPart in pairs(hitPart.Parent.left:GetTouchingParts()) do
                    print("Called")
                    if leftPart.Parent.Name == "defaultGrid" then
                        table.insert(nearbyGrid, leftPart.Parent.centerPart.Position)
                        print("Insertleft")
                    end
                end
                for _, rightPart in pairs(hitPart.Parent.right:GetTouchingParts()) do
                    print("Called")
                    if rightPart.Parent.Name == "defaultGrid" then
                        table.insert(nearbyGrid, rightPart.Parent.centerPart.Position)
                        print("Insertright")
                    end
                end
                for _, nearGridTable in pairs(nearbyGrid) do
                    for index, nearPositions in pairs(possibilities) do
                        if nearGridTable == nearPositions then
                            print("same")
                            table.remove(possibilities, index)
                            print("removed")
                        end
                    end
                end
                for _, position in pairs(possibilities) do
                    local clonedBase = baseTerrain.defaultGrid:Clone()
                    clonedBase:SetPrimaryPartCFrame(CFrame.new(position))
                    clonedBase.Parent = workspaceService
                end
                end
                debounce2 = false
            end
        end
        end
        wait(.2)
    debounce = false
    end)

    end
end

-- Code --

playerService.PlayerAdded:Connect(function(addedPlayer)
    addedPlayer.CharacterAdded:Connect(function(addedCharacter)
        generateTerrain(addedPlayer)
    end)
end)

-- Loop --

while true do
    wait(5)
    for _, players in pairs(playerService:GetPlayers()) do
        generateTerrain(players)
    end
end

EDIT:

Some nice person I spoke with yesterday sent me this as a method of sorting tables, but how would I use it? (I'm not very familiar with sorting tables).

local function unordered_tostring_equals(array_1, array_2)
    -- making count_diffs[unknown] return 0 instead of nil
    -- I usually I have have a function for this: count_diffs = DefaultedTable(0)
    local count_diffs = setmetatable({}, {__index = function()
            return 0
    end})

    -- adds 1's counts
    for _, v in ipairs(array_2) do
        local str = tostring(v)
        count_diffs[str] = count_diffs[str] + 1
    end

    -- subtracts 2's counts
    for _, v in ipairs(array_1) do
        local str = tostring(v)
        count_diffs[str] = count_diffs[str] - 1
    end

    -- if the same tostrings has a different count, it's a different table
    for _, count in pairs(count_diffs) do
        if count ~= 0 then
            return false
        end
    end

    return true
end