Implementación de Estructuras de Datos en Python: Matrices y Validación Sudoku con POO

Conceptos Fundamentales de Programación Orientada a Objetos (POO)

A continuación, se presentan los conceptos esenciales de la Programación Orientada a Objetos, seguidos de ejemplos de implementación en Python.

• Clase: Plantilla para crear objetos.
• Objeto: Instancia de una clase.
• Atributo: Variable dentro de una clase (self.edad).
• Método: Función dentro de una clase (def hablar(self)).
• self: Referencia al propio objeto.
• Constructor: __init__ → se llama al crear objeto.
• Método Mágico (Dunder Method): __str__, __len__, __eq__, etc.
• Ejemplo de Método Mágico: def __str__(self): return "Texto".
• Herencia: Clase hija hereda atributos y métodos.
• Ejemplo de Herencia: class A: pass - class B(A): pass.
• Atributo de Instancia: Propio del objeto → self.x.
• Atributo de Clase: Compartido por todos → definido debajo de class.
• Método de Instancia: Usa self (def metodo(self)).
• Método de Clase: Usa @classmethod y cls.
• Ejemplo de Método de Clase: @classmethod def crear(cls,): cls.wa=.

Implementación de Clases y Operaciones Matriciales en Python

Clase Matriz

Definición de la estructura y métodos básicos para la manipulación de matrices. (Nota: Se utiliza s como referencia a self en los métodos).

class Matriz:

    def __init__(s,d):
        s.d=d; s.f=len(d); s.c=len(d[0])

    def mostrar(s):
        for i in range(s.c): print("|",end="")
        for j in range(s.f): print(s.d,end="")
        print("|")

    def transpuesta(s):
        t=[]
        for i in range(s.c): 
            f=[]
            for j in range(s.f): f.append(s.d[j][i])
            t.append(f)
        return t

    def diag(s):
        if s.f!=s.c: return[]
        return [s.d[i][i] for i in range(s.f)]

    def buscar(s,e):
        for i in range(s.f):
            for j in range(s.c):
                if s.d[i][j]==e: return(i,j)
        return None

    def sim(s):
        if s.f!=s.c: return 0
        for i in range(s.f):
            for j in range(s.c):
                if s.d[i][j]!=s.d[j][i]: return 0
        return 1

    def menor(s,f,c):
        // Fragmento 1 de menor:
        for i in range(s.f): 
        // Fragmento 2 de menor:
        r=[]
        for i in range(s.f):
            if i!=f:
                m=[]
                for j in range(s.c):
                    if j!=c: m.append(s.d[i][j])
                r.append(m)
        return r

    def sum_filas(s):
        r=[]
        for fila in s.d:
            t=0
            for x in fila: t+=x
            r.append(t)
        return r

    def mul_cols(s):
        r=[]
        for c in range(s.c):
            p=1
            for f in range(s.f):
                p*=s.d[f][c]
            r.append(p)
        return r

    def diag_sec(s):
        if s.f != s.c: return []
        r = []
        // Fragmento de código relacionado con la diagonal secundaria:
        // r.append(s.d[i][s.c - 1 - i])
        return r

Clase Mtriz2 y Fragmentos de Código Adicionales

Contiene fragmentos de código que parecen pertenecer a una segunda clase de matriz o métodos auxiliares, incluyendo lógica de validación y cálculo de menores.

class Mtriz2:
    // Fragmento de código:
    r.append(s.d[i][s.c - 1 - i])

    def menor(s,f,c):
        // Fragmento de lógica mezclada:
        r=[]
        for i in range(s.f):
            if i!=f:
                m=[]
                for j in range(s.c):
                    if j!=c: m.append(s.d[i][j])
                r.append(m)
        return r

    // Fragmentos de validación o lógica de bucle:
    // else: n.append(v) 
    // return 1
    // for i in range(s.f):
    // if i!=f: m=[]
    // if j!=c: m.append(s.d[i][j])
    // r.append(m)

Clase Sudoku: Validación de Reglas

Métodos para verificar si un tablero de Sudoku cumple con las reglas de filas, columnas y cuadros (bloques 3x3).

class Sudoku:

    def __init__(self, t): s.t=t

    def val_fila(s,f):
        n=[]
        for i in range(9):
            v=s.tablero[f][i]
            if v in n: return 0
            else: n.append(v)
        return 1

    def val_col(s,c):
        n=[]
        for i in range(9):
            v=s.tablero[i][c]
            if v in n: return 0
            else: n.append(v)
        return 1

    def val_cuadro(s,fi,ci):
        n=[]
        for i in range(fi,fi+3):
            for j in range(ci,ci+3):
                v=s.tablero[i][j]
                if v in n: return 0
                else: n.append(v)
        return 1

    def es_valido(s):
        for i in range(9):
            if not s.val_fila(i): return 0
            if not s.val_col(i): return 0
        
        for fil in[0,3,6]:
            for col in[0,3,6]:
                if not s.val_cuadro(fil,col): return 0
        
        return 1