Comparación de dos tablas de índice por valor de índice en lua

Question

Estoy intentando comparar dos tablas de igual longitud con una función, ya que no conozco otra forma de hacerlo. Sin embargo, con la siguiente función, no se puede registrar, y no tengo idea de por qué. Espero que alguien pueda proporcionar información sobre este problema o que tenga una mejor manera de comparar las dos tablas.

Las tablas se rellenan con el siguiente código:

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

Es idéntica para ambas tablas, excepto, por supuesto, los nombres de las tablas individuales. Las tablas se están llenando correctamente y se muestran correctamente cuando las imprimo. Aquí hay dos mesas para el bien de esta pregunta:

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

Obviamente, estos dos mesas van a ser iguales entre sí. La función que escribí para comparar las tablas de índice es el siguiente:

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 

He intentado hacer

print(comparetables(tableone,tabletwo)) 

para ver si va a imprimir "verdadero", pero sin suerte. Para mí, parece que debería funcionar sin problemas. Sin embargo, no es así. ¿Qué me estoy perdiendo? Intenté buscar algo así como una función de tabla.compare que alguien ya haya escrito, pero no tuve tanta suerte encontrando una. Gracias por cualquier sugerencia!

Información adicional:

La razón por la que estoy comparando las tablas es para un juego de tipo mastermaind. Eso significa que se deben aplicar las siguientes tres reglas al comparar tablas. La función que creé era solo para comenzar, pensando que podría trabajar desde allí.

1. Al comparar las tablas, si los números coinciden, cCount aumenta en 1.
2. Al comparar tablas, si existe el valor en una posición de índice diferente, incremento PCOUNT por 1

Por ejemplo , con una tabla de valores {1, 3, 3, 4} y una suposición de {4, 4, 3, 1}, devolvería el recuento de 2 (el 4 y el 1) y una cuenta de 1 (el tres en la tercera posición). Creo que una de las partes más difíciles va a obtener la comparación para reconocer que los segundos 4 en la conjetura no deberían incrementar el Pcount en absoluto.

Answer 1

Si usted está comparando los objetos que son más objecty de Tabley en un sentido orientado a objetos, entonces me vería en la aplicación de las funciones de la forma lua OO.

Algo como esto debe hacer el truco:

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 

A continuación, tendrá que utilizar de esta manera:

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

Una ligera variante en su código que debe trabajar es:

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 

Sin embargo yo uso algo más parecido a esto: Se comprueba los tipos de los argumentos, sus metatablas, y algunos otros casos.

-- 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 

He aquí un ejemplo de ello en uso:

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