Martin Flores's questions

Hello, good, I have a problem with this horse chess code, the execution is more than good when executing it, but when putting the coordinates using the values ​​of m and n with the signs // to be able to take it, it does not work as I want since the user It will ask me if I want it to be in the mere right, left, top, bottom corner and any point but when executing it takes a long time in some numbers when executing it as -9 and 2 in another if it gives me a point like -7 and 9 Could you help me if I can use this method or another method to put the coordinates:

# Dimensiones: para que exista un ciclo pedimos que ninguno sea
# par, ambos mayores que 5. Hay otros casos donde existe ciclo.
m = 8
n = 8
ciclo = True # buscar recorrido cerrado (ciclo)
print("Esto es a traves de division")
Valor1= int(input("Ingrese el número de fila deseada ==> "))
Valor2= int(input("Ingrese el número de colummna deseada ==> "))  
#############################################################################
# - El vértice correspondiente a (i, j) es k = 1 + i + j * m,
# i, j = divmod(k - 1, m)
# - Los vecinos de (i, j) son de la forma
# (i ± 2, j ± 1) y (i ± 1, j ± 2)
# siempre que queden en el tablero.
def kdeij(i, j):
   return 1 + i + m * j
###############################################################################
def ijdek(k):
   return divmod(k - 1, m)
#############################################################################
# ponemos la raíz en el centro para que sea rápido
#raiz = kdeij(m // Valor1, n // Valor2) este es el que estaba usando
raiz = kdeij(m //2, n//2)
#################################################################################
# Construcción de vecinos
mn = m * n # cantidad de vértices
mn1 = mn + 1 # para range
###################################################################################
vecinos = [[] for k in range(mn1)]
vecinos[0] = None
#######################################################################################
# No hay vecinos con un mismo j,
# Ponemos sólo los de arriba (los de abajo se dan por simetría).
vecinos = [[] for v in range(mn1)]
vecinos[0] = None

for i in range(m):
   for j in range(n):
     k = kdeij(i, j)
       ii = i - 2
       if ii >= 0:
           jj = j + 1
           if jj < n:
              kk = kdeij(ii, jj)
                vecinos[k].append(kk)
                vecinos[kk].append(k)
       ii = i - 1
       if ii >= 0:
           jj = j + 2
           if jj < n:
              kk = kdeij(ii, jj)
                vecinos[k].append(kk)
                vecinos[kk].append(k)
       ii = i + 1
       if ii < m:
           jj = j + 2
           if jj < n:
              kk = kdeij(ii, jj)
                vecinos[k].append(kk)
                vecinos[kk].append(k)
       ii = i + 2
       if ii < m:
           jj = j + 1
           if jj < n:
              kk = kdeij(ii, jj)
                vecinos[k].append(kk)
                vecinos[kk].append(k)
#----------------------------------------------#
# Función a usar
#----------------------------------------------#
def hamilton(m, n, vecinos, raiz=1, ciclo=True):
#####################################################################################
  def grado(v):
    a = [u for u in vecinos[v] if padre[u] == None]
    return len(a)
#####################################################################################
def visitar(u):
    nonlocal cuenta, llegamos
    cuenta = cuenta + 1

    if llegamos:
        return
    if len(ciclov) < mn: # En este punto todavía no llegamos
        a = [v for v in vecinos[u] if padre[v] == None]
        if a != []:
            a.sort(key=grado)
            for v in a:
                padre[v] = u
                ciclov.append(v)
                visitar(v)
                if llegamos:
                   return
                padre[v] = None
                ciclov.pop()
    elif (len(ciclov) == mn):
        if not ciclo:
            llegamos = True
        if (u in vecinosraiz):
            llegamos = True
            ciclov.append(raiz)
# en otro caso len(ciclov) == mn1
mn = m * n # cantidad de vértices
mn1 = mn + 1 # para vértices entre 1 y mn

vecinosraiz = vecinos[raiz]

ciclov = [raiz] # empezamos desde la raíz
padre = [None for v in range(mn1)]

padre[raiz] = raiz

cuenta = 0
llegamos = False

visitar(raiz)

print(40 * "-")
print("Cantidad de entradas a visitar:", cuenta)
if llegamos:
    return ciclov
print("No hay ciclo de hamilton")
return []
############################################################################
# fin de función
#################################################################################
ciclo = hamilton(m, n, vecinos, raiz, True)
#################################################################################
print(40 * '-')
print('Ciclo resultante:')
print(ciclo)
print('Longitud:', len(ciclo))
#----------------------------------------------
# Representación como tablero
#----------------------------------------------
# cantidad de espacios para que no se superpongan los números
s = len(str(mn1)) + 1
formato = "{:" + str(s) + "}"
# buscamos la inversa del ciclo
pos = [None for v in range(mn1)]
for p in range(mn):
      pos[ciclo[p]] = p + 1
print(40 * "-")
print("Recorrido del tablero (posiciones en cada movimiento representadas en un numero de 
inicio al final):")
#######################################################################################
for j in range(n-1, -1, -1):
  k = 1 + m * j
  for i in range(m):
      print(formato.format(pos[k + i]), end="")
  print()
#####################################################################################

Hello good, I have a problem of black and white knights on how to move them in L position, in this code in each function it makes a turn of about 45° until the black and white pieces make a complete turn to the position in which they started , but using the way knights move in chess. This is the code I am using:

chessBoard = [["N", "▢", "N"], ["▢", "▢", "▢"], ["B", "▢", "B"]]

# def printBoard(columnList):
#    fila = len(columnList)
#    columna = len(columnList[0])
#    for i in range(fila):
#            for j in range(columna):
#                print(" {0} ".format(columnList[i][j]), sep=',', end='')
#            print('')


def rotar_matriz(matriz):
    rotada = []
    for i in range(len(matriz[0])):
        rotada.append([])
        for j in range(len(matriz)):
            rotada[i].append(matriz[len(matriz) - 1 - j][i])
    return rotada


print("\n-----------------------\n")
for fila in chessBoard:
    for e in fila:
        print(e, sep=",", end=" ")
print()
print("\n-----------------------\n")

rotada_1 = rotar_matriz(chessBoard)
for fila in rotada_1:
    for e in fila:
        print(e, sep=",", end=" ")
print()
print("\n-----------------------\n")

rotada_2 = rotar_matriz(rotada_1)
for fila in rotada_2:
    for e in fila:
        print(e, sep=",", end=" ")
print()
print("\n-----------------------\n")

rotada_3 = rotar_matriz(rotada_2)
for fila in rotada_3:
    for e in fila:
        print(e, sep=",", end=" ")
print()
print("\n-----------------------\n")

rotada_4 = rotar_matriz(rotada_3)
for fila in rotada_4:
    for e in fila:
        print(e, sep=",", end=" ")
print()
print("\n-----------------------\n")
print("\n***********************\n")
# printBoard(chessBoard)
print("\n***********************\n")

From this code you have the first N to move to the right 2 times then go down a 1 that would give in the L position, just as the white below the first black has to go up 2 times then go to the right in 1 that each piece is move in L to the right but don't be too close to the other glued together, like a square you turn it, a square rhombus appears, then you turn it again it's square again, you turn it again, a rhombus comes out, you turn it about 4 to 6 times in L each one without touching until they turn around

Hello, I am trying to put numerical values ​​in a table-matrix where, when it is 4x4, 6x6 or 8x8, the user puts the corresponding queens in positions that one wants (according to the expansion or growth, if he wants it to be 4x4, he can only put 4 with 6x6 put 6) that they are seen with the 'X' symbol in the boxes you want and the rest of the boxes are considered 0 and that it is not using the random function in a random way that it is as the user puts it I don't know if can as it is written in the function or it has to be one by one. This is the code I am using:

import random
# <============================== functions ==============================> #
# it will create a initial state of queens for us :
Reyna= int(input("Cuantas Reinas desea Usar(Solo se aceptan Numeros Pares no Impares) "))
def randomRestart():
columnList = [0] * Reyna
for col in range(Reyna):
    columnList[col] = random.randint(1, Reyna)
return columnList

def printBoard(columnList):
for row in range(Reyna, 0, -1):
    for col in range(Reyna):
        if columnList[col] == row:
            print("X", end="  ")
        else:
            print(0, end="  ")
    print()

queensPositions = randomRestart()
print("Posicion de Columnas de Las Reinas : ", queensPositions)
print("Posicion Inicial de las Reinas: ")
print('\n***********************\n')
printBoard(queensPositions)
print('\n***********************\n')
print("==========================================================================")

This is the result it gives with the random function: