funciones – bucles y variables python

estuve haciendo un juego del 3 en raya con una inteligencia artificial que en principio debería determinar cuando una jugada es ganadora, ese es el actual objetivo en principio, el problema que me surge es que me gana sin ni tan si quiera jugar por algún motivo, creo que el problema esta relacionado contra el bucle for dentro de la función jugada_ordenador, pero no es cual es el problema sinceramente, aquí les dejo el código para que le echen un vistazo.

import random


# --------- variables goblales -----------

# esto es la matriz donde trabajaremos, en este caso tan solo es una tupla
Tablero = ("-", "-", "-",
         "-", "-", "-",
         "-", "-", "-")

TableroImaginario=("-", "-", "-",
                 "-", "-", "-",
                 "-", "-", "-")

# Esta variable indicara si el juego debe seguir o ha finalizado
el_juego_funciona = True

# Esta variable nos indicara quien es el ganador si lo hay, sino permanecera en estado None
Ganador = None
GanadorImaginario = None
#  Esta variable indica de quien es el turno, de forma predeterminada empezaran las cruces 
jugador_humano="X"
ordenador="O"
Jugador_del_Turno = jugador_humano
# ------------- funciones ---------------

# Jugar al 3 en ralla
def Jugar():

  # reiniciar el tablero
  MostrarTablero()

  # bucle principal, el bucle cerrara cuando haya ganador o tablas
  while el_juego_funciona:

    #Jugada de cada jugador
    #*************
    Jugada(Jugador_del_Turno)

    # comprobamos victoria y empate
    Comprobar_fin_juego()

    # cambiamos de X a O y viceversa
    Cambiar_jugador()
  
  # Cuando el bucle principal termina indicamos quien ha ganado
  if Ganador == "X" or Ganador == "O":
    print(Ganador + " ha ganado. ")
  elif Ganador == None:
    print("Tablas.")


# aqui mostramos el tablero de pantalla, en un lado tendremos nuestro propio tablero y en el otro una indicacion numerica
def MostrarTablero():
  print("n")
  print(" " +  Tablero(0) + " | " + Tablero (1) + " | " + Tablero(2)    +"            1|2|3")
  print("------------" +                                                 "          -----")
  print(" " +  Tablero(3) + " | " + Tablero (4) + " | " + Tablero(5)    +"            4|5|6")
  print("------------" +                                                 "          -----")
  print(" " +  Tablero(6) + " | " + Tablero (7) + " | " + Tablero(8)    +"            7|8|9")
  print("n")


# funcion usada para las jugadas, ambos jugadores comparten funcion
def Jugada(Jugador):

    if Jugador=="X":
        jugada_humana()
    elif Jugador=="O":
        jugada_ordenador()


def jugada_ordenador():
    #tramemos las variables globales.
    global GanadorImaginario
    contador=0
    print("es turno del ordenador ")
    for i in range(1,9):
        TableroImaginario=Tablero
        posicionImaginaria= i
        posicionImaginaria=int(posicionImaginaria)
        posicionImaginaria-=1
        if TableroImaginario(posicionImaginaria)== "-":
            TableroImaginario(posicionImaginaria)="O"
            comprobar_victoria_imaginaria()
            if GanadorImaginario== "O":
                Tablero(posicionImaginaria)="O"
                contador=1
                break
            else:
                pass

        else:
            pass
    if contador==0:
        valido=False
        while not valido:
            posicion= random.randint(1,9)
            posicion= int(posicion) -1
             # Nos aseguramos que se coloca en una casilla no escogida previamente
            if Tablero(posicion) == "-":
             valido = True
            else:
             print("El ordenador esta pensando ")
    return


def jugada_humana():
    # pedimos una jugada
  print("es el turno del Jugador ")
  posicion = input("elige una casilla entre 1-9: ")

  # valido sera un valor para generar un bucle que solo se abrira cuando se de una jugada valida
  valido = False
  while not valido:

    # Nos aseguramos de que juegan dentro del tablero
    while posicion not in ("1", "2", "3", "4", "5", "6", "7", "8", "9"):
      posicion = input("Input invalido. elige una casilla entre 1-9: ")
 
    # corregimos la posicion para que el ordenador la entienda
    posicion = int(posicion) - 1

    # Nos aseguramos que se coloca en una casilla no escogida previamente
    if Tablero(posicion) == "-":
      valido = True
    else:
      print("casilla ocupada, piensa otra opcion. ")

  # colocamos la pieza en nuestra "matriz"
  Tablero(posicion) = "X"

  # refrescamos el tablero con la nueva jugada
  MostrarTablero()

# funcion para comprobar el final de juego
def Comprobar_fin_juego():
  comprobar_victoria()
  comprobar_tablas()


# funcion para comrpobar si hay una victoria
def comprobar_victoria():
  # Set global variables
  global Ganador
  # traemos las variables globales necesarias
  ganador_fila = comprobar_filas()
  ganador_columna = comprobar_columnas()
  ganador_diagonal = comprobar_diagonales()
  # Obtenemos el jugador victorioso
  if ganador_fila:
    Ganador = ganador_fila
  elif ganador_columna:
    Ganador = ganador_columna
  elif ganador_diagonal:
    Ganador = ganador_diagonal
  else:
    Ganador = None


# comprobacion de cada fila
def comprobar_filas():
  # traemos las variables globales necesarias
  global el_juego_funciona
  # comprobamos que todos los valores en una fila sean iguales y no esten vacios
  fila_1 =Tablero(0) ==Tablero(1) ==Tablero(2) != "-"
  fila_2 =Tablero(3) ==Tablero(4) ==Tablero(5) != "-"
  fila_3 =Tablero(6) ==Tablero(7) ==Tablero(8) != "-"
  # si hay linea hay victoria
  if fila_1 or fila_2 or fila_3:
    el_juego_funciona = False
  # obtenemos el ganador
  if fila_1:
    return Tablero(0) 
  elif fila_2:
    return Tablero(3) 
  elif fila_3:
    return Tablero(6) 
  # seguimos el codigo si no hay fila
  else:
    return None


# comprobamos las columnas para ganar
def comprobar_columnas():
  # traemos las variables globales necesarias
  global el_juego_funciona
  # comprobamos que tienen el mismo valor y no estan vacias
  columna_1 =Tablero(0) ==Tablero(3) ==Tablero(6) != "-"
  columna_2 =Tablero(1) ==Tablero(4) ==Tablero(7) != "-"
  columna_3 =Tablero(2) ==Tablero(5) ==Tablero(8) != "-"
  # si hay columna hay victoria
  if columna_1 or columna_2 or columna_3:
    el_juego_funciona = False
  #  obtenemos el ganador
  if columna_1:
     return Tablero(0) 
  elif columna_2:
    return Tablero(1) 
  elif columna_3:
    return Tablero(2) 
  # seguimos el codigo si no hay columna
  else:
    return None


# comprobamos las diagonales para ganar
def comprobar_diagonales():
  # traemos las variables globales necesarias
  global el_juego_funciona
  # comprobamos que tengan el mismo valor y no sea vacio
  diagonal_1 =Tablero(0) ==Tablero(4) ==Tablero(8) != "-"
  diagonal_2 =Tablero(2) ==Tablero(4) ==Tablero(6) != "-"
  # si hay diagonal hay victoria
  if diagonal_1 or diagonal_2:
    el_juego_funciona = False
  # obtenemos el ganador
  if diagonal_1:
    return Tablero(0) 
  elif diagonal_2:
    return Tablero(2)
  #continuamos el codigo
  else:
    return None


# funcion para comprobar si hay tablas
def comprobar_tablas():
  # traemos las variables globales necesarias
  global el_juego_funciona
  # si el tablero esta lleno hay tablas
  if "-" not in Tablero:
    el_juego_funciona = False
    return True
  # De otra forma no hay tablas
  else:
    return False


def comprobar_victoria_imaginaria():
    Ganador_fila_imaginaria = comprobar_filas_imaginarias()
    Ganador_columna_imaginaria = comprobar_columnas_imaginarias()
    Ganador_diagonal_imaginaria = comprobar_diagonales_imaginarias()

    if Ganador_fila_imaginaria:
      GanadorImaginario = Ganador_fila_imaginaria
    elif Ganador_columna_imaginaria:
     GanadorImaginario = Ganador_columna_imaginaria
    elif Ganador_diagonal_imaginaria:
      GanadorImaginario = Ganador_diagonal_imaginaria
    else:
      GanadorImaginario = None



def comprobar_filas_imaginarias():
 # comprobamos que todos los valores en una fila sean iguales y no esten vacios
  fila_1imaginaria =TableroImaginario(0) ==TableroImaginario(1) ==TableroImaginario(2) != "-"
  fila_2imaginaria =TableroImaginario(3) ==TableroImaginario(4) ==TableroImaginario(5) != "-"
  fila_3imaginaria =TableroImaginario(6) ==TableroImaginario(7) ==TableroImaginario(8) != "-"
  # obtenemos el ganador
  if fila_1imaginaria:
    return TableroImaginario(0) 
  elif fila_2imaginaria:
    return TableroImaginario(3) 
  elif fila_3imaginaria:
    return TableroImaginario(6) 
  # seguimos el codigo si no hay fila
  else:
    return None

def comprobar_columnas_imaginarias():
    # comprobamos que tienen el mismo valor y no estan vacias
  columna_1imaginaria =TableroImaginario(0) ==TableroImaginario(3) ==TableroImaginario(6) != "-"
  columna_2imaginaria =TableroImaginario(1) ==TableroImaginario(4) ==TableroImaginario(7) != "-"
  columna_3imaginaria =TableroImaginario(2) ==TableroImaginario(5) ==TableroImaginario(8) != "-"

  #  obtenemos el ganador
  if columna_1imaginaria:
     return TableroImaginario(0) 
  elif columna_2imaginaria:
    return TableroImaginario(1) 
  elif columna_3imaginaria:
    return TableroImaginario(2) 
  # seguimos el codigo si no hay columna
  else:
    return None

def comprobar_diagonales_imaginarias():
    # comprobamos que tengan el mismo valor y no sea vacio
  diagonal_1imaginaria =TableroImaginario(0) ==TableroImaginario(4) ==TableroImaginario(8) != "-"
  diagonal_2imaginaria =TableroImaginario(2) ==TableroImaginario(4) ==TableroImaginario(6) != "-"

  # obtenemos el ganador
  if diagonal_1imaginaria:
    return TableroImaginario(0) 
  elif diagonal_2imaginaria:
    return TableroImaginario(2)
  #continuamos el codigo
  else:
    return None

#  funcion para cambiar jugador en cada turno
def Cambiar_jugador():
  # traemos las variables globales necesarias
  global Jugador_del_Turno
  #si el jugador es X pasamos a O
  if Jugador_del_Turno == jugador_humano:
    Jugador_del_Turno = ordenador
  #  si el jugador es O pasamos a X
  elif Jugador_del_Turno == ordenador:
    Jugador_del_Turno = jugador_humano

Jugar()

input("pulsa enter para terminar el juego")

en principio entiendo que la lógica de juego esta bien ya que hice una versión para dos jugadores con las mismas bases, y la parte seleccionar números aleatorios por parte de la “IA” debería funcionar correctamente también ya que tengo otra versión en la que tan solo juega de dicha forma, espero que esos detalles les sirvan de ayuda.

c++ – Problema bucles y void

Necesito hacer un programa al que le des una cantidad de filas y que me de así:
Fila 1: 1
Fila 2: 1 2
Fila 3: 1 2 3
Fila 4: 1 2 3 4 Así hasta la fila N.
Por cierto, soy bastante nuevo, así que necesito algún consejo para saber como usar el void con las funciones en este tipos de ocasiones, acá hice lo máximo que pude, corríjanme todo lo que quieran, gracias.

#include <iostream>

using namespace std;

void DibujarFilas(int N);

int main () {
    int n;
    cout << "Digite numero de filas: " << endl;
    cin >> n;
    DibujarFilas(n);
    return 0;
}

void DibujarFilas(int N) {
    
    int n = 1;
    int k;
    bool fin = false;
    while(!fin) {
        cout << N << " ";
        if(N == k) fin = true;
        N++;
    }
}

bucles – como hacer/ modificar este loop en R?

Tengo una base de datos con 121 filas y como 10 columnas. Una de estas columnas corresponde las estaciones, otra a profundidad y el resto a variables químicas (temperatura, salinidad, etc.). Quiero calcular el valor integrado de estas propiedades químicas por estación, usando la función de oce:: integrationTrapezoid. Es la primera vez que hago un loop, así que no sé cómo. ¿me podrían ayudar/orientar en cómo hacerlo? Gracias.

dA<-matrix(data=NA, nrow=121, ncol=3) for (Station in unique(datos$Station)) {dA(Station, cd) <- integrateTrapezoid(cd, Profundidad..m., "cA") }

Station Depth temp
1 10 28
1 50 25
1 100 15
1 150 10
2 9 27
2 45 24
2 98 14
2 152 11
3 11 28.7
3 48 23
3 102 14
3 148 9

bucles – Iteracion en lista Python

Mi codigo es

scripts = (
    ("Banana", "Apple", "Orange"),
    ("Tomate", "Aji", "Aguacate")
)

Cuando realizo una iteracion el FOUND sale bien porque solo aparece una vez, pero, el “else” aparece muchas veces (muchas mas si tengo mas en la lista, que es lo que pretendo).

for index, sublist in enumerate(scripts):
    if "Banana" in sublist: 
        print(f"FOUND {index}")
        print(sublist)
    else:
        print("no found")
    

Mi pregunta es: es posible hacer que el else solo aparezca una vez? Ya que recorre toda la lista y no es lo que quiero.

bucles – El While infinito (Python)

estoy haciendo un ejercicio de una lista de compras con un while y varios if y elif y pues teoricamente todo bien hasta que llega la opción en la que debe cerrar el ciclo y no lo hace. Quisiera que me pudieran orientar sobre lo que estoy haciendo mal, muchas gracias, les dejo mi codigo:

accion = print("Programa Lista de la compra, ingrese un articulo para añadirlo a la lista o Q para salir: n")
accion = None
lista= ()
while accion != 'Q':
    articulo = input("Ingrese el artículo que desea añadir a la lista (Q para salir):  ")
    if articulo == 'Q':
        print("Su lista de la compra es: "+ str(lista))
    elif articulo != 'Q':
        conf=input("¿Desea agregar {} a la lista de compra?(S/N)".format(articulo))
        if conf == 'S':
            lista.append(articulo)
    else:
        print("Su Lista de la compra es " + str(lista))

VSCode no completa los bucles en Python

estoy usando Python con VSCode y todo bien asta hace un tiempo, el vscode no esta mostrandome sugerencias para autocompletar los bucles, me refiero a que el editor completa la sintaxis principal y de ahi yo lo completo con lo que quiero, es muy raro porque hasta hace poco si lo hacia, no he instalado nada ni movido ninguna configuracion.
por ejemplo yo escribia “while” y en las sugerencias me daba la opcion de autocompletar con el “in” etc.
incluso instale Pycharm para ver si era cosa del editor pero en primera instancia tampoco sale (o quiza no lo haya configurado) recalco que en vscode uso PyLance

introducir la descripción de la imagen aquí

Gracias de antemano por sus respuestas

bucles – Problema en loop con levelplot y subplot, solo grafica la ultima figura en R

Quiero generar una imagen con 9 mapas, sin embargo cuando al pasar por el loop solo imprime la ultima figura.

La figura es un mapa de lluvia con isolineas de presión para 9 meses del año. Este es el cacho de mi código que buscar generar el grafico:

mapTheme <- rasterTheme(region = brewer.pal(9, "GnBu"))

png("mapas.png")
par(mfrow=c(3,3)
for (j in 1:9){
          plt<-levelplot(pcp_raster, margin = F, at=at.sca, pretty=TRUE, 
                           par.settings = mapTheme,
                           colorkey=TRUE,main=paste("Month",j,sep = ""))+ 
                 contourplot(slp_raster, margin = F,pretty=TRUE,colorkey=FALSE,
                             col="red",labels=list(cex=0.7),
                             cuts=6)+
                 layer(sp.lines(Mex_outline, col="black", lwd=0.5))
          print(plt)
    }
   dev.off()

De antemano muchas gracias.

javascript – usar bucles para repetir una pregunta al usuario

hola necesito ayuda para desarrollar este problema, cuando el usuario dijite la cantidad de usuario , la pregunta de cantidad vendida por ese vendedor se repita esa misma cantidad, y que luego cada resultado se multiplique y se divida, cumpliendo una condición que la dice el problema.

Una empresa desea calcular la comisión que le deben pagar a cada uno de los vendedores, al vendedor le corresponde el 2.5 % de la comisión, sobre aquellos artículos cuyos precios sean inferiores a $100.000 y el 75 % cuyo precio sea de $100.000 o más. El programa debe ser flexible para n vendedores.