Porównywanie dwóch tabel indeksów według wartości indeksu w lua

Question

Próbuję porównać dwie tabele o równej długości z funkcją, ponieważ nie znam innego sposobu, aby to zrobić. Jednak z następującą funkcją, nie rejestruje się i nie mam pojęcia dlaczego. Mam nadzieję, że ktoś może zapewnić wgląd w ten problem lub ma lepszy sposób na porównanie obu tabel.

Tabele są wypełniane za pomocą następującego kodu:

str = "parameters determined by program (all digits)" 
tableone = {} 
for word in str:gmatch("%d") do table.insert(tableone,word) end 

To identyczna dla obu tabel, z wyjątkiem, oczywiście, poszczególnych nazw tabel. Tabele są wypełniane poprawnie i wyświetlane poprawnie po ich wydrukowaniu. Oto dwie tabele dla tego pytania:

tableone = {} 
tabletwo = {} 
for i=1,4 do table.insert(tableone, i) end 
for i=1,4 do table.insert(tabletwo, i) end 

Oczywiście te dwie tabele będą sobie równe. Funkcja pisałem porównać tabele indeksu jest następująca:

function comparetables(t1, t2) 
matchct = 0 
for i=1,#t1 do 
    if t1[i] == t2[i] then 
    matchct = matchct + 1 
    end 
if matchct == #t1 then 
return true 
end 
end 

Próbowałem robić

print(comparetables(tableone,tabletwo)) 

aby zobaczyć, czy to będzie drukować „prawdziwe”, ale bez powodzenia. Dla mnie wygląda na to, że powinien działać bez problemu. A jednak tak nie jest. czego mi brakuje? Próbowałem szukać czegoś takiego jak funkcja table.compare, którą ktoś mógł już napisać, ale nie ma takiego szczęścia w jej znalezieniu. Dzięki za wszelkie sugestie!

Dodatkowe informacje:

Powodem Mam porównanie tabel jest w grze mastermaind typu. Oznacza to, że następujące trzy zasady muszą obowiązywać przy porównywaniu tabel. Stworzona przeze mnie funkcja polegała na tym, że zacząłem działać, myśląc, że mogę pracować od tego miejsca.

1. Z porównania tabel, jeśli zespół liczb, Ccount zwiększona o 1.
2. Porównując tabel, jeżeli istnieje wartość w innym położeniu, wskazującym Pcount przyrost o 1

Przykładowo , z tabelą wartości {1, 3, 3, 4} i domniemaną wartością {4, 4, 3, 1}, to zwróci Pcount of 2 (the 4 and the 1) i Ccount of 1 (the trzy na trzeciej pozycji). Myślę, że jedną z najtrudniejszych części będzie porównanie, które pozwoli rozpoznać, że drugie 4 w odgadywaniu nie powinno w ogóle zwiększać Pcount.

Answer 1

Jeśli porównujesz obiekty, które są bardziej niż objecty Tabley w sensie obiektowym, wtedy będę patrzeć na realizację funkcji sposób Lua OO.

Coś jak to powinno załatwić sprawę:

GameState = {} 
GameState.mt = {} 
GameState.mt.fns = {} 
GameState.mt.__index = GameState.mt.fns 

function GameState.new(a,b,c,d) 
-- TODO: put argument checks here... 
    local retval = {} 
    retval[1] = a 
    retval[2] = b 
    retval[3] = c 
    retval[4] = d 
    setmetatable(retval, GameState.mt) 
    return retval 
end 

function GameState.mt.fns.print(self) 
    print(" GameState: ", self[1], self[2], self[3], self[4]) 
end 

function GameState.mt.__tostring(self) 
    return "GameState: "..self[1].." "..self[2].." "..self[3].." "..self[4] 
end 

function GameState.mt.__eq(self, other) 
    -- Check it's actually a GameState, and all its bits match 
    return getmetatable(other)==GameState.mt and 
    (self[1] == other[1]) and 
    (self[2] == other[2]) and 
    (self[3] == other[3]) and 
    (self[4] == other[4]) 
end 

Potem go używać tak:

state1 = GameState.new(1,2,3,4) 
state2 = GameState.new(1,2,3,4) 

print("State 1 is:") 
state1:print() 

print("State 2 is:") 
print(state2) 

print("state1 == state2 : ", state1 == state2) 

print("Changing state 2") 
state2[1]=2 

print("state1 == state2 : ", state1 == state2) 

Answer 2

Nieznaczne wariant na kodzie, który powinien pracować jest:

function comparetables(t1, t2) 
    if #t1 ~= #t2 then return false end 
    for i=1,#t1 do 
    if t1[i] ~= t2[i] then return false end 
    end 
    return true 
end 

jednak używam czegoś więcej tak: Sprawdza typy argumentów, ich metatables i kilku innych przypadkach.

-- This is not clever enough to find matching table keys 
-- i.e. this will return false 
-- recursive_compare({ [{}]:1 }, { [{}]:1 }) 
-- but this is unusual enough for me not to care ;) 
-- It can also get stuck in infinite loops if you use it on 
-- an evil table like this: 
--  t = {} 
--  t[1] = t 

function recursive_compare(t1,t2) 
    -- Use usual comparison first. 
    if t1==t2 then return true end 
    -- We only support non-default behavior for tables 
    if (type(t1)~="table") then return false end 
    -- They better have the same metatables 
    local mt1 = getmetatable(t1) 
    local mt2 = getmetatable(t2) 
    if(not recursive_compare(mt1,mt2)) then return false end 

    -- Check each key-value pair 
    -- We have to do this both ways in case we miss some. 
    -- TODO: Could probably be smarter and not check those we've 
    -- already checked though! 
    for k1,v1 in pairs(t1) do 
    local v2 = t2[k1] 
    if(not recursive_compare(v1,v2)) then return false end 
    end 
    for k2,v2 in pairs(t2) do 
    local v1 = t1[k2] 
    if(not recursive_compare(v1,v2)) then return false end 
    end 

    return true 
end 

Oto przykład tego w użyciu:

print(recursive_compare({1,2,3,{1,2,1}}, {1,2,3,{1,2,1}})) -- prints true 
print(recursive_compare({1,2,3,{1,2,1}}, {2,2,3,{1,2,3}})) -- prints false