Trifulcas

# ─────────────────────────────────────────────
# BLOQUE 1: Contar cuántas veces aparece la letra 'a' en una cadena
# ─────────────────────────────────────────────

# La cadena está en mayúsculas. Si buscamos solo "a" minúscula,
# no encontraríamos nada porque "A" y "a" son caracteres distintos para Python.
cadena="HOLA QUE TAL?"

# El contador acumulador empieza en 0 antes del bucle.
# Cada vez que encontremos una 'a' (en cualquier forma) sumaremos 1.
contador =0

# El for recorre la cadena carácter a carácter.
# En cada vuelta, letra toma el valor del siguiente carácter.
for letra in cadena:

    # letra.lower() convierte la letra actual a minúscula SOLO para la comparación,
    # no modifica la cadena original. Así podemos comparar siempre con "a" minúscula
    # sin importar si en la cadena original era "A" o "a".
    # Ejemplos:
    #   "A".lower() → "a"    "H".lower() → "h"    "a".lower() → "a"
    if letra.lower()=="a":
        contador+=1  # encontramos una 'a' (en cualquier forma), sumamos 1

# El print está fuera del bucle: muestra el total al terminar.
print(contador)
# Resultado: 2  (la 'A' de "HOLA" y la 'A' de "TAL")
#
# Alternativa sin bucle usando el método count():
#   total = cadena.lower().count("a")
#   print(total)
# Pero hacerlo con el bucle a mano ayuda a entender cómo funciona count() por dentro.


# ─────────────────────────────────────────────
# BLOQUE 2: Recorrer una cadena con letras y números mezclados
# ─────────────────────────────────────────────

# Una cadena puede contener cualquier tipo de carácter: letras, números, símbolos.
# El for los recorre todos sin distinción, uno a uno.
cadena="DX450"

# En cada vuelta, caracter toma el valor: "D", luego "X", luego "4", "5", "0"
for caracter in cadena:
    print(caracter)

# Resultado:
#   D
#   X
#   4
#   5
#   0
#
# Fíjate en que "4", "5" y "0" son caracteres de texto, no números enteros.
# Para operar matemáticamente con ellos habría que convertirlos con int("4") = 4.


# ─────────────────────────────────────────────
# BLOQUE 3: Invertir una cadena letra a letra
# ─────────────────────────────────────────────

cadena="hola"

# La cadena invertida empieza vacía. La iremos construyendo dentro del bucle.
# Es un acumulador de texto en lugar de un acumulador numérico.
cadena_invertida=""

# El truco está en el orden en que pegamos cada letra nueva.
# En vez de añadir la letra al FINAL (como haríamos normalmente),
# la ponemos al PRINCIPIO: letra + cadena_invertida
# Así cada letra nueva empuja a las anteriores hacia la derecha.
for letra in cadena:
    cadena_invertida=letra+cadena_invertida
    # Traza paso a paso:
    # Vuelta 1: letra="h"  →  cadena_invertida = "h"  + ""    = "h"
    # Vuelta 2: letra="o"  →  cadena_invertida = "o"  + "h"   = "oh"
    # Vuelta 3: letra="l"  →  cadena_invertida = "l"  + "oh"  = "loh"
    # Vuelta 4: letra="a"  →  cadena_invertida = "a"  + "loh" = "aloh"

print(cadena_invertida)
# Resultado: aloh
#
# Alternativa con slicing (atajo de Python para invertir cadenas):
#   print(cadena[::-1])
# El [::-1] significa: recorre la cadena de atrás hacia adelante con paso -1.
# Pero construirlo con el bucle enseña el concepto de concatenación acumulativa.


# ─────────────────────────────────────────────
# BLOQUE 4: Sumar solo los dígitos numéricos de una cadena mixta
# ─────────────────────────────────────────────

# La cadena mezcla letras y números. Solo queremos sumar los dígitos.
cadena="2026J"

# Acumulador numérico que irá sumando los dígitos encontrados.
total=0

for letra in cadena:

    # Los caracteres en Python tienen un orden (orden ASCII/Unicode).
    # Los dígitos "0" al "9" están ordenados consecutivamente en ese sistema,
    # por lo que comparar letra>="0" and letra<="9" es una forma válida de
    # comprobar si un carácter es un dígito numérico.
    # Ejemplos:
    #   "2" >= "0" and "2" <= "9"  →  True   (es un dígito)
    #   "J" >= "0" and "J" <= "9"  →  False  (es una letra)
    #   "6" >= "0" and "6" <= "9"  →  True   (es un dígito)
    if letra>="0" and letra<="9":

        # int(letra) convierte el carácter "2" en el número entero 2.
        # Sin esta conversión estaríamos sumando texto y daría error.
        # Ejemplo: int("2") = 2    int("0") = 0    int("6") = 6
        total=total+int(letra)
        # Traza paso a paso:
        # Vuelta 1: letra="2"  →  es dígito  →  total = 0 + 2 = 2
        # Vuelta 2: letra="0"  →  es dígito  →  total = 2 + 0 = 2
        # Vuelta 3: letra="2"  →  es dígito  →  total = 2 + 2 = 4  (segundo 2 del "2026")
        # Vuelta 4: letra="6"  →  es dígito  →  total = 4 + 6 = 10
        # Vuelta 5: letra="J"  →  NO es dígito → no entra en el if, total no cambia

print(total)
# Resultado: 10  (2 + 0 + 2 + 6 = 10)
#
# Alternativa usando el método isdigit():
#   if letra.isdigit():
#       total = total + int(letra)
# isdigit() devuelve True si el carácter es un dígito, False si no lo es.
# Es más legible que comparar con "0" y "9", pero ambas formas son correctas.


# ─────────────────────────────────────────────
# BLOQUE 5: Separar letras y números de una cadena mixta
# ─────────────────────────────────────────────

# La cadena mezcla letras y números sin ningún orden fijo.
cadena="23GH123JOP"

# Dos acumuladores de texto, uno para letras y otro para números.
# Ambos empiezan vacíos y se irán llenando dentro del bucle.
letras=""
numeros=""

# El for recorre todos los caracteres uno a uno.
for letra in cadena:

    # Usamos la misma comparación del bloque anterior para detectar dígitos.
    # Si el carácter está entre "0" y "9" es un número, si no es una letra.
    if letra>="0" and letra<="9":
        numeros=numeros+letra  # pegamos el dígito al final de la cadena de números
    else:
        letras=letras+letra    # pegamos la letra al final de la cadena de letras

    # Traza paso a paso:
    # Vuelta 1:  letra="2"  →  es dígito  →  numeros="2",      letras=""
    # Vuelta 2:  letra="3"  →  es dígito  →  numeros="23",     letras=""
    # Vuelta 3:  letra="G"  →  NO dígito  →  numeros="23",     letras="G"
    # Vuelta 4:  letra="H"  →  NO dígito  →  numeros="23",     letras="GH"
    # Vuelta 5:  letra="1"  →  es dígito  →  numeros="231",    letras="GH"
    # Vuelta 6:  letra="2"  →  es dígito  →  numeros="2312",   letras="GH"
    # Vuelta 7:  letra="3"  →  es dígito  →  numeros="23123",  letras="GH"
    # Vuelta 8:  letra="J"  →  NO dígito  →  numeros="23123",  letras="GHJ"
    # Vuelta 9:  letra="O"  →  NO dígito  →  numeros="23123",  letras="GHJO"
    # Vuelta 10: letra="P"  →  NO dígito  →  numeros="23123",  letras="GHJOP"

# Ambos print están fuera del bucle: muestran los resultados finales.
print(letras)   # Resultado: GHJOP
print(numeros)  # Resultado: 23123
#
# Fíjate en que los números se guardan como texto ("23123"), no como un entero.
# Si quisiéramos el valor numérico tendríamos que convertirlo: int(numeros) = 23123.
# Si quisiéramos SUMAR los dígitos en lugar de concatenarlos, usaríamos
# total = total + int(letra) como en el bloque anterior.

# ─────────────────────────────────────────────
# BLOQUE 1: Recorrer un rango y mostrar cada número
# ─────────────────────────────────────────────

# for con rangos  ← título original del programa

# range(1, 11) genera la secuencia: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
# REGLA IMPORTANTE: el primer número SÍ se incluye, el segundo NO.
# Por eso para llegar al 10 hay que escribir 11 como límite.
# En cada vuelta del bucle, la variable numero toma el valor siguiente de la secuencia.
for numero in range(1,11):
    print(numero)

# Resultado: imprime los números del 1 al 10, cada uno en su línea.
#
# Variaciones de range() que conviene conocer:
#   range(5)         → 0, 1, 2, 3, 4          (un solo argumento: empieza en 0)
#   range(0, 10, 2)  → 0, 2, 4, 6, 8          (tercer argumento: el salto entre números)
#   range(10, 0, -1) → 10, 9, 8, 7... 1       (salto negativo: cuenta hacia atrás)
#   range(0, 100, 5) → 0, 5, 10, 15... 95     (de 5 en 5)


# ─────────────────────────────────────────────
# BLOQUE 2: Sumar todos los números del 1 al 10
# ─────────────────────────────────────────────

# El acumulador es una variable que empieza en 0 ANTES del bucle
# y va sumando valores en cada vuelta.
# Si lo inicializáramos dentro del bucle, se reiniciaría a 0 en cada vuelta
# y nunca acumularía nada. Por eso SIEMPRE se declara fuera.
suma=0

for numero in range(1,11):
    suma+=numero  # es exactamente lo mismo que escribir: suma = suma + numero
                  # Traza paso a paso de cómo crece suma:
                  # Vuelta 1:  suma = 0  + 1  = 1
                  # Vuelta 2:  suma = 1  + 2  = 3
                  # Vuelta 3:  suma = 3  + 3  = 6
                  # Vuelta 4:  suma = 6  + 4  = 10
                  # Vuelta 5:  suma = 10 + 5  = 15
                  # Vuelta 6:  suma = 15 + 6  = 21
                  # Vuelta 7:  suma = 21 + 7  = 28
                  # Vuelta 8:  suma = 28 + 8  = 36
                  # Vuelta 9:  suma = 36 + 9  = 45
                  # Vuelta 10: suma = 45 + 10 = 55

# El print está FUERA del bucle (sin sangría).
# Si estuviera dentro con sangría, imprimiría el subtotal en cada vuelta.
# Al estar fuera, solo imprime el resultado final cuando el bucle ha terminado.
print(suma)
# Resultado: 55
#
# Curiosidad matemática: la fórmula de Gauss da el mismo resultado sin bucle:
#   n * (n+1) / 2  →  10 * 11 / 2 = 55
# Pero construir el bucle a mano es la mejor forma de entender el patrón acumulador.


# ─────────────────────────────────────────────
# BLOQUE 3: Mostrar solo los números pares del 1 al 10
# ─────────────────────────────────────────────

# Este bloque combina un for con un if dentro.
# El for genera todos los números del 1 al 10.
# El if filtra: solo deja pasar los que cumplen la condición.
for numero in range(1,11):

    # El operador % (módulo) devuelve el resto de una división.
    # Si numero % 2 == 0, el resto al dividir entre 2 es cero → el número es par.
    # Ejemplos:  4 % 2 = 0  →  par      5 % 2 = 1  →  impar
    #            6 % 2 = 0  →  par      7 % 2 = 1  →  impar
    if numero % 2 == 0:
        print(numero)

# Resultado: 2  4  6  8  10  (cada uno en su línea)
#
# Para imprimir los IMPARES en su lugar, solo habría que cambiar == 0 por != 0:
#   if numero % 2 != 0:
#       print(numero)
# Resultado: 1  3  5  7  9
#
# Alternativa con range de salto 2 (sin necesidad de if):
#   for numero in range(2, 11, 2):   → genera directamente 2, 4, 6, 8, 10
#       print(numero)


# ─────────────────────────────────────────────
# BLOQUE 4: Dibujar un triángulo de asteriscos
# ─────────────────────────────────────────────

# Este bloque usa una propiedad de Python muy útil:
# multiplicar una cadena de texto por un número la repite ese número de veces.
# Ejemplos:
#   "*" * 1  →  *
#   "*" * 3  →  ***
#   "*" * 5  →  *****
#   "ab" * 3 →  ababab
for numero in range(1,11):
    print("*"*numero)  # en cada vuelta, numero vale 1, 2, 3... 10
                       # así que se imprimen 1, 2, 3... 10 asteriscos seguidos

# Resultado visual (un triángulo que crece):
#   *
#   **
#   ***
#   ****
#   *****
#   ******
#   *******
#   ********
#   *********
#   **********
#
# Para un triángulo invertido (que decrece) bastaría con invertir el range:
#   for numero in range(10, 0, -1):
#       print("*" * numero)
# Resultado: empieza con 10 asteriscos y va bajando hasta 1.


# ─────────────────────────────────────────────
# BLOQUE 5: Tabla de multiplicar de un número
# ─────────────────────────────────────────────

# Tabla de multiplicar  ← comentario original

# El factor es el número del que queremos calcular la tabla.
# Cambiando este valor obtenemos cualquier tabla de multiplicar.
factor=7

# El range va del 1 al 10 (el 11 no se incluye).
# En cada vuelta, numero toma los valores 1, 2, 3... 10.
for numero in range(1,11):

    # La f-string permite construir el texto con las variables directamente.
    # {numero}       → el multiplicador (1, 2, 3... 10)
    # {factor}       → siempre 7
    # {numero*factor}→ el resultado
    print(f"{numero} X {factor} = {numero*factor}")

# ─────────────────────────────────────────────
# BLOQUE 1: Recorrer una lista de frutas
# ─────────────────────────────────────────────

# Una lista es una colección de elementos entre corchetes, separados por comas.
# Cada elemento va entre comillas porque son cadenas de texto (strings).
frutas=["melón", "sandía", "banana", "melocotón"]

# El bucle for recorre la lista elemento a elemento.
# En cada vuelta, la variable fruta toma el valor del elemento actual.
# Vuelta 1: fruta = "melón"
# Vuelta 2: fruta = "sandía"
# Vuelta 3: fruta = "banana"
# Vuelta 4: fruta = "melocotón"
# Cuando se acaban los elementos, el bucle termina solo.
for fruta in frutas:
    print(fruta)

# La variable puede llamarse como quieras. fruta es un nombre descriptivo
# que nos ayuda a entender qué contiene, pero podría llamarse x, elemento o cosa.
# Variación con índice (si también quisieras saber la posición):
#   for i, fruta in enumerate(frutas):
#       print(i, fruta)
# Resultado: 0 melón / 1 sandía / 2 banana / 3 melocotón


# ─────────────────────────────────────────────
# BLOQUE 2: Recorrer una cadena de texto carácter a carácter
# ─────────────────────────────────────────────

# Una cadena de texto (string) también es iterable: el for puede recorrerla
# letra a letra igual que recorre una lista elemento a elemento.
# La variable puede tener cualquier nombre, aunque sea absurdo como cacahuete_pelado.
# Esto demuestra que Python no exige nombres con sentido, pero tú sí deberías ponerlos.
for cacahuete_pelado in "hola que tal":
    print(cacahuete_pelado)

# Cada carácter se imprime en su propia línea, incluyendo los espacios.
# Resultado: h / o / l / a /   / q / u / e /   / t / a / l
#            (los espacios también son caracteres y también se imprimen)
#
# Un nombre más descriptivo sería:
#   for caracter in "hola que tal":
#       print(caracter)


# ─────────────────────────────────────────────
# BLOQUE 3: Recorrer un rango de números con range()
# ─────────────────────────────────────────────

# range(inicio, fin) genera una secuencia de números enteros.
# IMPORTANTE: el número final NO se incluye. range(1, 11) genera del 1 al 10.
# Para incluir el 11 habría que escribir range(1, 12).
for numero in range(1,11):
    print(numero)

# Variaciones útiles de range():
#   range(5)        → del 0 al 4 (si solo hay un argumento, empieza en 0)
#   range(1, 11)    → del 1 al 10
#   range(0, 11, 2) → 0, 2, 4, 6, 8, 10  (tercer argumento es el paso o salto)
#   range(10, 0, -1)→ 10, 9, 8... 1  (paso negativo = cuenta hacia atrás)


# ─────────────────────────────────────────────
# BLOQUE 4: Sumar números con un acumulador
# ─────────────────────────────────────────────

# suma los números del 1 al 100  ← comentario original
# (aunque el range solo llega al 5, el comentario indica la intención original)

# El acumulador es una variable que empieza en 0 y va acumulando valores.
# Es el patrón más habitual en bucles: inicializar antes, acumular dentro.
suma=0

# range(1, 6) genera: 1, 2, 3, 4, 5  (el 6 no se incluye)
for numero in range(1,6):
    suma+=numero  # suma += numero  es lo mismo que  suma = suma + numero
                  # Vuelta 1: suma = 0 + 1 = 1
                  # Vuelta 2: suma = 1 + 2 = 3
                  # Vuelta 3: suma = 3 + 3 = 6
                  # Vuelta 4: suma = 6 + 4 = 10
                  # Vuelta 5: suma = 10 + 5 = 15

# El print está FUERA del bucle (sin sangría).
# Si estuviera dentro, imprimiría el valor parcial en cada vuelta.
# Al estar fuera, solo imprime el resultado final una vez.
print(suma)
# Resultado: 15
#
# Para sumar del 1 al 100 como dice el comentario original,
# solo habría que cambiar range(1,6) por range(1,101)
# La famosa fórmula de Gauss da el mismo resultado: n*(n+1)/2 = 100*101/2 = 5050


# ─────────────────────────────────────────────
# BLOQUE 5: Contar las letras 'a' en una cadena
# ─────────────────────────────────────────────

# COntar el número de aes en una cadena  ← comentario original (con errata en la C)
# Recorro la cadena y si es una a, la cuento  ← estrategia en comentario original

cadena="hola que tal estás, Bárbara"

# ¿Sé recorrer una cadena?      ← preguntas guía del autor para plantearse el problema
# ¿Sé como averiguar si una letra es una a?
# ¿Sé contar?
# Estas tres preguntas son exactamente cómo debe pensar un programador:
# descomponer el problema en partes pequeñas antes de escribir código.

# El contador empieza en 0. Cada vez que encontremos una 'a' sumaremos 1.
cuenta=0

# El for recorre la cadena carácter a carácter, igual que en el bloque 2.
for letra in cadena:

    # Comprobamos si la letra actual es una 'a' minúscula o una 'á' con tilde.
    # Sin la segunda condición, la 'á' de "estás" y las de "Bárbara" no se contarían.
    # Nota: la 'B' mayúscula de "Bárbara" no se cuenta porque solo buscamos minúsculas.
    # Si también quisiéramos contar la 'A' mayúscula habría que añadir: or letra == "A"
    if letra == "a" or letra == "á":
        cuenta+=1  # encontramos una 'a', sumamos 1 al contador

# El print está fuera del bucle: muestra el total al terminar de recorrer toda la cadena.
# La f-string permite insertar la variable cuenta directamente en el texto con {cuenta}.
print(f"La cadena tiene {cuenta} letras 'a'")
# Resultado: La cadena tiene 6 letras 'a'
# Las 'a' encontradas son: hol[a] qu[e] t[a]l est[á]s, B[á]rb[a]r[a]
#                                (posiciones 3, 9, 11, 17, 21, 24... aprox)
#
# Alternativa con método built-in (sin bucle):
#   total = cadena.count("a") + cadena.count("á")
#   print(total)
# Python tiene muchas funciones ya hechas, pero construir el bucle a mano
# es la mejor forma de entender cómo funcionan por dentro.

# ─────────────────────────────────────────────
# BLOQUE 1: Comprobar si un número es par o impar
# ─────────────────────────────────────────────

numero=4  # guardamos el número que queremos analizar

# El operador % (módulo) devuelve el resto de la división.
# Si dividimos un número entre 2 y el resto es 0, el número es par.
# Ejemplo: 4 % 2 = 0  →  es par
#          7 % 2 = 1  →  es impar
if numero%2==0:
    print("Es par")   # se ejecuta si el resto es 0
else:
    print("Es impar") # se ejecuta si el resto es 1 (cualquier otro caso)


# ─────────────────────────────────────────────
# BLOQUE 2: Recorrer los números del 1 al 12 y decir si cada uno es par o impar
# ─────────────────────────────────────────────

contador=1  # el contador empieza en 1 (primer número que queremos mostrar)

# El bucle se repite mientras el contador sea menor o igual a 12.
# Cuando contador llegue a 13, la condición será falsa y el bucle terminará.
while contador<=12:

    print(contador)  # mostramos el número actual

    # Dentro del bucle comprobamos si ese número concreto es par o impar,
    # usando la misma lógica de antes (resto de dividir entre 2)
    if contador % 2 == 0:
        print("Es par")
    else:
        print("Es impar")

    # Muy importante: sumamos 1 al contador al final de cada vuelta.
    # Sin esta línea, contador siempre valdría 1 y el bucle nunca terminaría.
    contador=contador+1


# ─────────────────────────────────────────────
# BLOQUE 3: Comprobar si un año es bisiesto
# ─────────────────────────────────────────────

anyo=2100  # el año que queremos comprobar

# Un año es bisiesto si cumple UNA de estas dos condiciones:
#   1) Es divisible entre 4  Y  NO es divisible entre 100
#      (años normales bisiestos: 2024, 2028...)
#   2) Es divisible entre 400
#      (excepción a la regla anterior: 1600, 2000... sí son bisiestos)
# El año 2100 es divisible entre 4 PERO también entre 100 y NO entre 400,
# por eso NO es bisiesto (¡trampa habitual en los ejercicios!)
if (anyo%4==0 and anyo%100!=0) or anyo%400==0:
    print("Es bisiesto")
else:
    print("NO es bisiesto")


# ─────────────────────────────────────────────
# BLOQUE 4: Comprobar si un número es primo
# ─────────────────────────────────────────────

numero=15   # el número que queremos analizar
contador=2  # empezamos a probar divisores desde 2 (el 1 no cuenta)

# Partimos de que el número ES primo hasta que demostremos lo contrario
es_primo=True

# Un número es primo si no es divisible por ningún número entre 2 y él mismo.
# Probamos todos los posibles divisores desde 2 hasta numero-1.
while contador<numero:

    # Si el resto de dividir numero entre contador es 0,
    # significa que contador es un divisor exacto → el número NO es primo
    if numero%contador==0:
        es_primo=False  # cambiamos la bandera: ya sabemos que no es primo
        break           # break interrumpe el bucle inmediatamente,
                        # no tiene sentido seguir buscando más divisores

    contador=contador+1  # si no era divisible, probamos con el siguiente número

# Aquí ya salimos del bucle. Usamos la variable es_primo para saber el resultado.
# 15 = 3 × 5, así que no es primo. es_primo habrá quedado en False.
if es_primo:
    print("Es primo")
else:
    print("No es primo")


# ─────────────────────────────────────────────
# BLOQUE 5: Convertir huevos en docenas
# ─────────────────────────────────────────────

huevos=30  # cantidad total de huevos que tenemos

# // es la división entera: devuelve solo la parte entera, sin decimales.
# 30 // 12 = 2  (caben 2 docenas completas en 30 huevos)
docenas=huevos//12

# % es el módulo (resto): lo que sobra después de repartir las docenas.
# 30 % 12 = 6  (sobran 6 huevos después de formar las 2 docenas)
resto=huevos%12

# Las f-strings (cadenas que empiezan por f"...") permiten meter variables
# directamente dentro del texto usando llaves {variable}.
print(f"huevos: {huevos} son {docenas} docenas y quedan resto: {resto}")
# Resultado: huevos: 30 son 2 docenas y quedan resto: 6


# ─────────────────────────────────────────────
# BLOQUE 6: Desglosar una cantidad de dinero en billetes y monedas
# ─────────────────────────────────────────────

dinero=18  # cantidad en euros que queremos desglosar

# Cuántos billetes de 5€ caben en 18€
# 18 // 5 = 3  →  3 billetes de 5€  (que son 15€)
billetes=dinero//5

# Lo que sobra después de usar los billetes de 5€
# 18 % 5 = 3  →  quedan 3€ sueltos
resto=dinero%5

# De esos 3€ sueltos, cuántas monedas de 2€ podemos usar
# 3 // 2 = 1  →  1 moneda de 2€  (que son 2€)
monedas2=resto//2

# Lo que sobra después de las monedas de 2€ → monedas de 1€
# 3 % 2 = 1  →  1 moneda de 1€
monedas1=resto%2

# Mostramos el resultado completo
print(f"{dinero} € son {billetes} billetes de 5€, {monedas2} monedas de 2 € y {monedas1} monedas de 1 €")
# Resultado: 18 € son 3 billetes de 5€, 1 monedas de 2 € y 1 monedas de 1 €


# ─────────────────────────────────────────────
# BLOQUE 7: Convertir segundos en días, horas, minutos y segundos
# ─────────────────────────────────────────────

segundos=743214  # total de segundos que queremos convertir

# PASO 1: calcular los días
# Un día tiene 86400 segundos (24h × 60min × 60seg = 86400)
# 743214 // 86400 = 8  →  8 días completos
dias=segundos//86400

# Lo que sobra después de los días (en segundos)
# 743214 % 86400 = 49614  →  49614 segundos restantes
resto_dias=segundos%86400

# PASO 2: de los segundos restantes, calcular las horas
# Una hora tiene 3600 segundos (60min × 60seg = 3600)
# 49614 // 3600 = 13  →  13 horas completas
horas=resto_dias//3600

# Lo que sobra después de las horas (en segundos)
# 49614 % 3600 = 2814  →  2814 segundos restantes
resto_horas=resto_dias%3600

# PASO 3: de los segundos restantes, calcular los minutos
# Un minuto tiene 60 segundos
# 2814 // 60 = 46  →  46 minutos completos
minutos=resto_horas//60

# Lo que sobra después de los minutos son los segundos finales
# 2814 % 60 = 54  →  54 segundos
resto_segundos=resto_horas%60

# Mostramos el resultado completo desglosado
print(f"{segundos} segundos son {dias} días, {horas} horas, {minutos} minutos y {resto_segundos} segundos")
# Resultado: 743214 segundos son 8 días, 13 horas, 46 minutos y 54 segundos

opcion=1
while opcion!=0:
    opcion=int(input("1- Saludo, 2- Despedida, 0 - Salir "))
    if opcion==1:
        print("Hola")
    if opcion==2:
        print("Adios")
    if opcion!=0 and opcion!=1 and opcion!=2:
        print("Opción incorrecta, fíjate bien anda, que vas despistao")

print("Fin del programa, gracias por participar")

opcion=1
while opcion!=0:
    opcion=int(input("1- Saludo, 2- Despedida, 0 - Salir "))
    if opcion==1:
        print("Hola")
    elif opcion==2:
        print("Adios")
    elif opcion!=0:
        print("Opción incorrecta, fíjate bien anda, que vas despistao")

print("Fin del programa, gracias por participar")

# Para conceder un préstamo el banco exige que el cliente tenga ingresos suficientes (>1800)
# y buen historial crediticio. Las dos condiciones deben cumplirse.

ingresos_mensuales = 2200
historial_crediticio = "bueno"

if ingresos_mensuales>1800 and historial_crediticio=="bueno":
    print("Se le concede el préstamo")
else:
    print("Te quedas sin préstamo, pringado")

# El museo ofrece entrada gratuita a jubilados o a menores de 12 años.
# Con que se cumpla una de las dos condiciones es suficiente.

edad = 9
es_jubilado = False

if edad<12 or es_jubilado:
    print("Entrada gratuita")
else:
    print("A pagar, prenda")


# Una multa se genera solo si el conductor supera el límite y además es zona escolar,
# donde las consecuencias son más graves.

velocidad = 65
limite = 50
zona_escolar = True

if velocidad>limite and zona_escolar:
    print("Multazo pa ti")
else:
    print("Por esta vez te libras, pero te vigilo")

# Un cliente puede reservar una habitación si hay disponibilidad y ha hecho el pago por adelantado
# y la estancia es de al menos dos noches.

habitaciones_libres = 3
pago_realizado = True
noches = 2

if habitaciones_libres>0 and pago_realizado and noches>=2:
    print("Puedes reservar")
else:
    print("Lo siento, te quedas en la calle")

# Se activa una alerta si la temperatura es extremadamente alta o extremadamente baja,
# cualquiera de las dos situaciones es peligrosa. >38 alta <-5 baja

temperatura = -8

if temperatura>38 or temperatura<-5:
    print("OJO CUIDAO, alerta metereológica")

# Una aplicación envía una notificación si el usuario tiene mensajes sin leer o
# si han pasado más de 7 días desde su última visita.

mensajes_sin_leer = 0
dias_sin_entrar = 10

if mensajes_sin_leer>0 and dias_sin_entrar>7:
    print("Notificacion de mensajes")

# Una planta tiene un problema si 
# tiene las hojas amarillas y  (condicion: hojas_amarillas)
# lleva más de siete días sin regar (condición: dias_sin_regar>7)
# o la temperatura ambiente es menor de 18 (condicion: temperatura_ambiente<18
# y no tiene luz directa (condicion: not tiene_luz_directa)

dias_sin_regar = 4
temperatura_ambiente = 15
tiene_luz_directa = False
hojas_amarillas = True

if (hojas_amarillas and dias_sin_regar>7) or (temperatura_ambiente<18 and not tiene_luz_directa):
    print("Cuida la planta que tiene problemas. En una semana a la basura")

edad=25
socio=True
bien_vestido=True

# Para entrar en el club tienes que tener más de 18 años y ser socio
if edad>=18 and socio and bien_vestido:
    print("Puedes entrar")
else:
    print("Lo siento, no  tienes permitida la entrada")

if edad<18:
    print("Lo siento, no  tienes permitida la entrada")
elif not socio:
    print("Lo siento, no  tienes permitida la entrada")
elif not bien_vestido:
    print("Lo siento, no  tienes permitida la entrada")
else:
    print("Puedes entrar")

dia_semana="lunes"

if dia_semana=="sabado" or dia_semana=="domingo":
    print("Fin de semana")
else:
    print("Día laborable")

departamento="marketing"
directivo=False

# Hay un requerimiento para los que sean de marketing y no sean directivos

if departamento=="marketing" and not directivo:
    print("Te envío mail")

# ¿Voy a la casa de la playa? Si es fin de semana y no están mis padres
dia_semana="sabado"
estan_padres=False

if (dia_semana=="sabado" or dia_semana=="domingo") and not estan_padres:
    print("¡P'a la casa de la playa!!!")
else:
    print("Me quedo aburriéndome")

Ejercicio — Clasificador de candidatos a un puesto de trabajo

Una empresa quiere automatizar el primer filtro de selección de personal. Tu tarea es escribir un programa que evalúe a un candidato y decida en qué categoría queda según tres criterios aplicados en orden.

Los datos del candidato

Declara estas cuatro variables al inicio del programa con los valores que quieras para probar:

• nombre — nombre completo del candidato (texto)
• años_experiencia — años de experiencia laboral (número entero)
• nivel_ingles — nivel según el Marco Europeo: «A2», «B1», «B2», «C1»  (texto)
• disponibilidad_inmediata — si puede incorporarse ya o no (booleano)

Las reglas de evaluación

El programa debe aplicar los criterios en este orden, de forma que si no se supera uno no se comprueba el siguiente:

Primer filtro — Experiencia. Si el candidato tiene 3 o más años de experiencia, pasa al siguiente filtro. Si tiene entre 1 y 2 años, queda descartado y el mensaje debe indicar cuántos años le faltan para volver a aplicar. Si tiene 0 años, queda descartado con un mensaje que le recomienda empezar por prácticas.

Segundo filtro — Nivel de inglés. Solo llegan aquí los candidatos que superaron el primer filtro. Si el nivel es C1  se considera avanzado y pasa al tercer filtro. Si el nivel es B2 se considera intermedio-alto y también pasa, pero con una nota de mejora. Si el nivel es B1 o inferior queda descartado por nivel insuficiente.

Tercer filtro — Disponibilidad. Solo llegan aquí los que superaron los dos filtros anteriores. Si tiene disponibilidad inmediata y nivel de inglés C1, TOP, si tiene B2 B. Si no la tiene y C1 A, si tiene B2 C

Las categorías posibles

Según el camino recorrido, el candidato debe quedar en una de estas categorías:

• Candidato TOP — experiencia suficiente, inglés avanzado y disponibilidad inmediata
• Candidato A — experiencia suficiente, inglés avanzado pero sin disponibilidad inmediata
• Candidato B — experiencia suficiente, inglés intermedio-alto y disponibilidad inmediata
• Candidato C — experiencia suficiente, inglés intermedio-alto pero sin disponibilidad inmediata
• Candidato descartado — no supera el filtro de experiencia o de idioma

El formato de salida

El programa debe imprimir por pantalla una ficha con este aspecto (los valores cambiarán según los datos):

EVALUACIÓN DE CANDIDATO: [nombre]
========================================
Experiencia: APTA  /  NO APTA
Inglés: AVANZADO  /  INTERMEDIO-ALTO  /  INSUFICIENTE
----------------------------------------
Categoría: [categoría asignada]
Decisión:  [mensaje explicativo]

La línea de inglés solo debe aparecer si el candidato superó el filtro de experiencia.

Prueba tu solución con estos cuatro casos

Una vez escrito el programa, cambia los valores de las variables y comprueba que obtienes el resultado correcto en cada caso:

# Una empresa quiere automatizar el primer filtro de selección de personal.
# Tu tarea es escribir un programa que evalúe a un candidato y decida en qué categoría
# queda según tres criterios aplicados en orden.

# Candidato TOP — experiencia suficiente, inglés avanzado y disponibilidad inmediata
# Candidato A — experiencia suficiente, inglés avanzado pero sin disponibilidad inmediata
# Candidato B — experiencia suficiente, inglés intermedio-alto y disponibilidad inmediata
# Candidato C — experiencia suficiente, inglés intermedio-alto pero sin disponibilidad inmediata
# Candidato descartado — no supera el filtro de experiencia o de idioma

# EVALUACIÓN DE CANDIDATO: [nombre]
# ========================================
# Experiencia: APTA  /  NO APTA
# Inglés: AVANZADO  /  INTERMEDIO-ALTO  /  INSUFICIENTE
# ----------------------------------------
# Categoría: [categoría asignada]
# Decisión:  [mensaje explicativo]

# inicializo las variables
nombre = "Jotapé"
anos_experiencia =5
nivel_ingles="C1"
disponibilidad_inmediata = True

# Imprimo la cabecera
print("EVALUACIÓN DE CANDIDATO: ",nombre)
print("="*40)

# El primer filtro es la experiencia
if anos_experiencia<3:
    # Si tiene menos de 3 años de experiencia no es apto
    print("Experiencia: NO APTA")
    # Comprobamos si tiene 0 o más años
    if anos_experiencia==0:
        # Si no tiene ninguna experiencia lo mandamos a prácticas
        print("Decisión: Te recomendamos empezar por prácticas")
    else:
        # Si tiene experiencia le decimos que vuelva cuando tenga 3 años
        # Lo calculamos restando 3 menos sus años de experiencia
        print(f"Decisión: Aplica en {3-anos_experiencia} años")
else:
    # Si tiene más de 3 años de experiencia seguimos con los siguientes filtros
    print("Experiencia: APTA")
    # Comprobamos el nivel de inglés
    if nivel_ingles=="C1":
        # Si el nivel de inglés es C1 ponemos avanzado y comprobamos la disponibilidad para
        # teerminar de afinar laa categoría
        print("Inglés: AVANZADO")
        # como disponibilidad_inmediata es booleana no hace falta que lo igualemos a True
        if disponibilidad_inmediata:
            print("Categoría: TOP")
        else:
            print("Categoría: A")
        print("Decisión: Aceptado")
    else:
        if nivel_ingles=="B2":
            print("Inglés: INTERMEDIO-ALTO")
            if disponibilidad_inmediata:
                print("Categoría: B")
            else:
                print("Categoría: C")
            print("Decisión: Aceptado")
        else:
            print("Inglés: INSUFICIENTE")
            print("Decición: No admitido por nivel de inglés")

Tenemos una empresa de autocares y queremos saber si un conductor puede o no conducir
Si lleva más de 5 horas trabajando ese día, no puede
Si tiene menos, se tienen en cuenta dos cosas
Si lleva trabajados más de 56 horas en la semana, tampoco puede conducir
Si tiene menos de 56 horas, si lleva más de 3 días seguidos trabajando, tampoco puede conducir

Variables:

horas_hoy
horas_semana
dias_consecutivos

Resultado:

«Puede conducir» / «NO puede conducir»