Cómo generar una matriz con permutaciones donde cualquier cuadrado de 2×2 tenga 4 valores no idénticos.

Digamos que mi matriz se ve así (siempre cuadrada):



a1 a2 a3

b1 b2 b3

c1 c2 c3

Quiero que los elementos en el cuadro, (a1, a2, b1, b2), (a2, a3, b2, b3), etc. no sean similares, es decir: a1 != a2 != b1 != b2.

Tengo este código para generar la matriz de forma recursiva:

def generar(elementos): if not elementos: return (), final = [] for items in generar(elementos[:-1]): for item in elementos[-1]: final.append(items + (item,)) return final

def producto(*args, repetir=1): pools = [list(pool) for pool in args] * repetir return list(generar(pools)) def principal(): D = 3 combinaciones = producto([0, 128, 196], repetir=D) matrices = producto(combinaciones, repetir=D) return matrices

donde elementos es una lista de números enteros (número desconocido), digamos [0, 128, 196] y repetir es el tamaño de la matriz cuadrada.

Quiero aplicar la regla en algún lugar de la función, de modo que solo genere matrices de acuerdo con esa regla que mencioné.

Entonces, al final el resultado final sería todas las posibles variaciones de matrices 3×3, pero aplicando esa regla.

Preferiría hacerlo sin importar pandas o algo así.

davy.ai

July 25, 2023 at 8:56 am

Para asegurarnos de que los elementos en las matrices generadas sigan la regla de no ser similares dentro de cada cuadrado de 2×2, podemos modificar la función generate para verificar esta condición antes de agregar los elementos generados. Una forma de hacer esto es la siguiente:

def generate(elements, size):
    if not elements:
        return (),

    final = []
    for items in generate(elements[:-1], size):
        for item in elements[-1]:
            # verificar la similitud dentro de cada cuadrado de 2x2
            if len(items) >= size:
                last_row = items[-size:]
                second_last_row = items[-2*size:-size]
                if last_row[0] == second_last_row[0] or \
                    last_row[1] == second_last_row[1] or \
                    last_row[0] == last_row[1] or \
                    second_last_row[0] == second_last_row[1] or \
                    last_row[0] == second_last_row[1] or \
                    last_row[1] == second_last_row[0]:
                    continue
            final.append(items + (item,))
    return final

Aquí, hemos agregado un nuevo parámetro size a generate, que es el tamaño de la matriz cuadrada. El código verifica la similitud dentro de cada cuadrado de 2×2 utilizando las dos últimas filas generadas hasta ahora en items. Si hay similitud, se omite agregar el elemento actual a la lista final.

Luego, debemos modificar la función product para pasar el parámetro size a generate. Podemos hacer esto agregando otro parámetro a product y pasándolo a generate:

def product(size, *args, repeat=1):
    pools = [list(pool) for pool in args] * repeat
    return list(generate(pools, size))

def main():
    D = 3
    matrices = product(D, [0, 128, 196], repeat=D)
    return matrices

Ahora, la variable matrices contendrá todas las posibles variaciones de las matrices de 3×3 que siguen la regla de no tener elementos similares dentro de cada cuadrado de 2×2.

Answer

davy.ai

July 25, 2023 at 8:56 am
Para asegurarnos de que los elementos en las matrices generadas sigan la regla de no ser similares dentro de cada cuadrado de 2×2, podemos modificar la función generate para verificar esta condición antes de agregar los elementos generados. Una forma de hacer esto es la siguiente:
```
def generate(elements, size):
    if not elements:
        return (),

    final = []
    for items in generate(elements[:-1], size):
        for item in elements[-1]:
            # verificar la similitud dentro de cada cuadrado de 2x2
            if len(items) >= size:
                last_row = items[-size:]
                second_last_row = items[-2*size:-size]
                if last_row[0] == second_last_row[0] or \
                    last_row[1] == second_last_row[1] or \
                    last_row[0] == last_row[1] or \
                    second_last_row[0] == second_last_row[1] or \
                    last_row[0] == second_last_row[1] or \
                    last_row[1] == second_last_row[0]:
                    continue
            final.append(items + (item,))
    return final
```
Aquí, hemos agregado un nuevo parámetro size a generate, que es el tamaño de la matriz cuadrada. El código verifica la similitud dentro de cada cuadrado de 2×2 utilizando las dos últimas filas generadas hasta ahora en items. Si hay similitud, se omite agregar el elemento actual a la lista final.

Luego, debemos modificar la función product para pasar el parámetro size a generate. Podemos hacer esto agregando otro parámetro a product y pasándolo a generate:
```
def product(size, *args, repeat=1):
    pools = [list(pool) for pool in args] * repeat
    return list(generate(pools, size))

def main():
    D = 3
    matrices = product(D, [0, 128, 196], repeat=D)
    return matrices
```
Ahora, la variable matrices contendrá todas las posibles variaciones de las matrices de 3×3 que siguen la regla de no tener elementos similares dentro de cada cuadrado de 2×2.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Cómo generar una matriz con permutaciones donde cualquier cuadrado de 2×2 tenga 4 valores no idénticos.

Answer

davy.ai