Get disjoint elements from two tables - loops

Question

I am trying to get disjoint elements from two tables. My tables currently are defined as:
local t1={elem5=true, elem2=true, ...}
local t2={elem2=true, elem5=true, ...}
However it would not be much of a problem to change the structure to:
local t1={elem5, elem2, ...}
local t2={elem2, elem5, ...}
How could I get disjoint elements from both tables efficienlty? Also I need to know which table the elements where originally part of.
What first came to mind was to loop over both tables:
local fromt1={}
for k, v in pairs(t1) do
if not t2[k] then
fromt1[#fromt1+1]=v
end
end
local fromt2={}
for k, v in pairs(t2) do
if not t1[k] then
fromt2[#fromt2+1]=v
end
end
But these are two loops, so I looked some more and found a function for iterating two tables in one loop (link):
function pairs2(t, ...)
local i, a, k, v = 1, {...}
return
function()
repeat
k, v = next(t, k)
if k == nil then
i, t = i + 1, a[i]
end
until k ~= nil or not t
return k, v
end
end
local fromt1, fromt2={}, {}
for k, v in pairs2(t1, t2) do
if not t2[k] then
fromt1[#fromt1+1]=v
end
if not t1[k] then
fromt2[#fromt2+1]=v
end
end
Any more efficient/cleaner way to get disjoint elements from two tables in Lua?

Answer 1

There's nothing wrong with the first aproach.
1) You have to iterate over both tables one way or another; whether you do it in two loops or one is irrelevant.
2) You need at least two additional tables for the two result sets.
The one optimization you could do:
the # operator on tables is somewhat expensive, so you can sometimes improve perofmance by keeping a number variable and increasing it manually with each insertion. But please don't just implement this because I told you. Benchmark your code and only use this optimization if you find that your code actually runs faster.
EDIT: I just noticed that I kida skipped one possible implementation because I assumed you don't want to change either of the original tables. If however, one of the two is a throwaway table and you don't mind it changing, consider this:
local function remove_first_from_second(first, second)
for key in pairs(first) do
second[key] = nil
end
return second
end
Running this both ways won't work:
remove_first_from_second(fromt1, fromt2) -- Removes shared keys from fromt2
remove_first_from_second(fromt2, fromt1) -- Removes nothing from fromt1
Because at the time you call it the second time, fromt2 already contains only the keys that fromt1 doesn't have.
However, since this problem only affects the second call, you can get away with just one in-between table (assuming both original tables can be mutated)