Playground - Averigua si un año es bisiesto

…

Mi solucion

def is_leap_year(year):
    # tu código aquí 👈
    if year > 0:
        if(year % 4 == 0) and (year % 100 != 0):
            return True
        elif (year % 100 == 0) and (year % 400 == 0):
            return True
        else:
            return False
    else:
        return False


result = is_leap_year(-2004)
print(result)

def is_leap_year(year):
    # Revisa si el año es un entero positivo
    if not isinstance(year, int) or year <= 0:
        return False

    # Revisa si el año es divisible entre 4, 100 o 400
    if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
        return True

    return False

La solución comienza evaluando si el año es un entero positivo. Posteriormente evalúa en una sola línea las condiciones que hacen a un año bisiesto tomando en cuenta el siguiente diagrama:

Soy nuevo en Python y batalle bastante pero al fin pude, o eso creo jejejeje!

Una vez lo hice lo refactorice, debo confesar, estaba bueno el reto, me costó bastante. Porque la guía confunde la parte de “Si es divisible por 100 debe serlo por 400 también.”, confunde porque el anterior enunciado decía, pero no por 100.
.

En wiki fue más claro:

.
Un año es bisiesto si es:

• Divisible entre 4.
• No divisible entre 100.
• Divisible entre 400. (2000 y 2400 son bisiestos pues aún siendo divisibles entre 100 lo son también entre 400. Pero los años 1900, 2100, 2200 y 2300 no lo son porque solo son divisibles entre 100).

para establecer si un año dado es bisiesto: es bisiesto si es divisible entre cuatro y (no es divisible entre 100 o es divisible entre 400).

.
.
.
.

def is_leap_year(year):
    if year%4==0 and year%100 !=0 and year >0:
        return True
    elif year%100==0 and year%400==0 and year >0:
        return True
    else:return False

Mi solución:
.
.
.
.
.
.
.
.
.
.

def is_leap_year(year):
    if year % 4 == 0 and year > 0:
        if year % 100 != 0: return True
        elif year % 400 == 0: return True
        else: return False
    else: return False

El año debe ser divisible entre 4.
El año no debe ser divisible entre 100.
Sin embargo, si el año es divisible entre 400, 

Entonces se considera bisiesto.
Entonces, la afirmación “es bisiesto si es divisible entre cuatro y (no es divisible entre 100 o es divisible entre 400)” es una forma precisa de expresar las reglas para determinar si un año es bisiesto. Esto significa que los años como 2000 y 2400 son bisiestos porque son divisibles entre 400, y los años como 1900, 2100, 2200 y 2300 no son bisiestos porque son divisibles entre 100 pero no entre 400.

No sé como colocar el escudo anti-spoiler, pero aqui estña:
.

def is_leap_year(year):
    # tu código aquí 👈
    if (year > 0) and (year % 100 != 0 and year % 4 == 0) or (year % 100 == 0 and year % 400 == 0):
      return True
    else:
      return False

if is_leap_year(2024):
  print("yes")
else:
  print("no")

Me permito compartir mi código, no sé por qué al inicio no pasaban las pruebas y luego sí pasó (era el mismo código).

def is_leap_year(year):
    condition1= year % 4
    condtion2 = year % 100
    condition3 = year % 400
    if year <= 0  and year % 1 <= 0:
        return (False)
    elif condition1 == 0 and condtion2 != 0:
        return(True)
    elif condtion2 == 0 and condition3 == 0:
        return(True)
    else:
        return(False)

result = is_leap_year(2024)
print(result)

def is_leap_year(year):
   if type(year) != str and year > 0 and type(year) == int:
       if year % 4 == 0 and year % 100 != 0:
           return True
       elif year % 100 == 0 and year % 400 == 0:           
           return True
       else:
           return False           
   else:
        return False

Les comparto mi solución:

def is_leap_year(year):
    # tu código aquí 👈
    if year < 0:
        return False
    elif type(year) == float:
        return False
    elif (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
        return True
    else:
        return False
    pass

Un nuevo día, ojala pueda completar el reto dentro del tiempo

debería decir : Un año es bisiesto si cumple con - “cualquiera de las dos” - condiciones:

def is_leap_year(year):
if ((year % 100 != 0 and year % 4 == 0 ) or (year % 100 == 0 and year % 400 == 0)) and year > 0 :
return True
else:
return False

def is_leap_year(year):

if  (year > 0):
    if (year % 4 == 0 and  year % 100 != 0 ) and (year % 100 == 0 and year % 400 == 0):
        return True
    else:
        return False

una forma sin utilizar tanto if

def is_leap_year(year): 
    return ((year%4==0 and year%100!=0) or (year%100==0 and year%400==0)) and year>0


print(is_leap_year(-2024))

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

def is_leap_year(year):
    if year < 0 or type(year).__name__ != 'int': 
        return False
    if (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
        return True
    else: 
        return False

.
.
.

def is_leap_year(year):
    return (year > 0) and (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
    

Listo!!!

Año = int(input(“Ingrese el año:”))
def Bisiesto(Año):
if (Año % 4 == 0) and (Año % 100 != 0):
return False
else:
return True
print(f" El año {Año} se considera como un año {Bisiesto(Año)} bisiesto")

*
*
*
*
me confundieron en la primera prueba pues a hora que se confunan los que lean mi codigo

def is_leap_year(year):
    # tu código aquí 👈
    CUATRO = 4
    CIEN = 100
    
    firt_condition = (1 - bool(year % CUATRO)) * bool(year % CIEN)

    second_condition = (1 - bool(year % CIEN)) * (1 - bool(year % (CUATRO * CIEN)))

    return bool((firt_condition + second_condition) * year > 0)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
(

…
…
…
Mi solución:

# programa para calcular el año bisiesto

def is_leap_year(year):
    # tu código aquí
    if not (isFlotant(year) or isInt(year)):
        print("It's not a number!")
    elif (year<0):
        if (isInt(year) and year<0):
             print("Int Number: '{}' ".format(year), " is less than cero")
        elif (isFlotant(year)):
            if (year<0):
               print("Float Number: '{}'".format(year), " is less than cero")
            else:
               print("Number incorrect")
    elif (year%4 == 0 and year%100 != 0) or year%400 == 0:
        return True
    return False

def isInt(variable):
	try:
		int(variable)
		if (type(variable) == int):
			return True
		else:
			return False
	except:
		return False

def isFlotant(variable):
    try:
        float(variable)
        if (type(variable) == float):
            return True
        else:
            return False
    except:
        return False

#prueba
print("is_leap_year(""'a'""): ", is_leap_year("a"),"\n")

result = is_leap_year(-2024)
print("is_leap_year(-2024): ", result, "\n")

result = is_leap_year("-2024")
print("is_leap_year(""-2024""): ", result, "\n")

result = is_leap_year(-1984.25)
print("is_leap_year(-1984.25): ", result, "\n")

result = is_leap_year(1984.25)
print("is_leap_year(1984.25): ", result, "\n")

result = is_leap_year(2000)
print("is_leap_year(2000): ", result, "\n")

result = is_leap_year(1800)
print("is_leap_year(1800): ", result, "\n")

Solution:

.

def is_leap_year(year):
    if year >= 0:
        if (not year % 4 and year % 100) or not year % 100 and (not year % 400):
            return True
    return False

def is_leap_year(year):
    if year <= 0 and year % 1 != 0:
        return False
    else: 
        return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0

Comparto mi solución:

def is_leap_year(year):
    # tu código aquí 👈
    if (year < 0):
        return False
    elif (year % 4 == 0 and year % 100 != 0):
        return True
    elif (year % 100 == 0 and year % 400 == 0):
        return True
    else:
        return False


result = is_leap_year(2031)
print("El año ingresado es bisiesto?")
print(result) 

Solución 😄…
.

.
.
.
.

def is_leap_year(year):
    if not isinstance(year, int) or year < 0:
        return False

    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        return True

    return False

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

def is_leap_year(year):
    if year <= 0:
        return False
    elif year % 4 == 0 and year % 100 != 0:
        return True
    elif year % 100 == 0 and year % 400 == 0:
        return True
    else: 
        return False

.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
def is_leap_year(year):
if year < 0 or isinstance(year, float):
return False
elif year % 400 == 0:
return True
elif year % 100 == 0:
return False
elif year % 4 == 0:
return True
else:
return False

def is_leap_year(year):
    return (year % 4 == and year > 0) and (year % 100 != 0 or year % 400 == 0)

‘’’

‘’’

def is_leap_year(year):
    return year > 0 and year % 4 == 0 and year % 100 != 0 or year % 400 == 0

Nota: Python tiene una función propia para hacer esto.

import calendar
def esBisiesto(year):
    return calendar.isleap(year)

.
.
.
.
.
.
.
.
.
.
Mi solución:

def is_leap_year(year):
    if year < 0:
        return False
    elif year % 4 == 0 and not year % 100 == 0:
        return True
    elif year % 100 == 0 and year % 400 == 0:
        return True
    else:
        return False

def is_leap_year(year):
    # tu código aquí 👈
    bisiesto = False

    if year < 0 or float(year) == year:
        bisiesto = False

    if year > 0:
        if (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
            bisiesto = True
        
    return bisiesto

result = is_leap_year(2104)
print(result)

def is_leap_year(year):
    if year % 4 == 0:
        if year % 100 != 0 or year % 400 == 0:
            return True
    return False

response = is_leap_year(2000)
print(response)

Yo lo resolví de la siguiente forma

def is_leap_year(year):
    # tu código aquí 👈
    if year >= 0:
        if year % 4 == 0 and not year % 100 == 0:
            return True
        elif year % 100 == 0 and year % 400 == 0:
            return True
        else:
            return False
    else:
        return False

fecha = is_leap_year(2000)
fecha = is_leap_year(-2024)
fecha = is_leap_year(1984.25)

No se si esto le sucede a alguien mas, o si es por mi navegador, pero cuando me equivoco en el primer intento y luego valido y hago pruebas para que esto no vuelva a suceder, y vuelvo a correr las pruebas, el sistema se pega y pierdo los intentos

Aquí la solución que hice

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

def is_leap_year(year):
    if year < 0:
        return False    
    elif (float(year) % 4) == 0 and (year % 100) != 0:
        return True
    elif (float(year) % 100) == 0 and (year % 400) == 0:
        return True
    else:
        return False
    pass

print(is_leap_year(2000))
print(is_leap_year(-2024))
print(is_leap_year(1984.25))

segun ChatGPT

Alerta de Spoiler
:
:
:
:
def is_leap_year(year):
if isinstance(year, int) and year > 0:
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
return True
else:
return False
else:
return False

Solicitar al usuario el año

while True:
try:
year = int(input("Ingrese un año (solo números enteros positivos): "))
break
except ValueError:
print(“Entrada inválida. Intente nuevamente.”)

Llamar a la función is_leap_year

if is_leap_year(year):
print(year, “es un año bisiesto.”)
else:
print(year, “no es un año bisiesto.”)

pass

def is_leap_year(year):
    # tu código aquí 👈
    if year < 0:
        return False
    elif (year % 4 == 0 and year % 100 != 0):
        return True
    elif (year % 100 == 0 and year % 400 == 0):
        return True
    else:
        return False        

bisiesto = is_leap_year(1984.25)
print (bisiesto)```

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Mi solucion

.
.
.
.

.
.
.

Mi aporte

def is_leap_year(year):

    if year < 0:
        return False

    if year % 4 == 0 and year % 100 != 0 or year % 100 == 0 and year % 400 ==0:
        return True

    return False

Mi solución:

def is_leap_year(year):
    if year < 0:
        year *= -1
        return False
    if year % 4 == 0 and year % 100 != 0:
        return True
    elif year % 100 == 0 and year % 400 == 0:
        return True
    else:
        return False

.
.
.
.
.
.
.
.

Aquí ya me salío de una forma que me pregunte el año con un input:

# 08 - Averigua si un año es bisiesto

def is_leap_year():

  year = float(input("Cual es el año: "))
  
  if (year % 4 == 0) or (year % 100 == 0):
  
    print(f"el año {year} es bisiesto")

  elif (year % 100 == 0) and (year % 400 == 0):
    print(f"el año {year} es bisiesto")

  else:
    print(f"El año {year} no es bisiesto")

is_leap_year()

# Solución:

def is_leap_year(year):
    
    if year < 0:
        return False
    elif year % 4 == 0 and year % 100 != 0:
        return True
    elif year % 100 == 0 and year % 400 == 0:
        return True

    return False
    pass

Mi solución

Es increíble como un ejercicio tan sencillo puede tener tanas soluciones correctas, esta es una de las tantas maravillas que podemos encontrar en el camino cuando aprendemos a programar.
La programación es una herramienta que combinada con un poco de imaginación y creatividad podemos crear grandes cosas.
Este reto es solo el principio, por eso

#NuncaParenDeAprender

.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def is_leap_year(year):
    # tu código aquí 👈
    if year <= 0: return False
    if year % 100 == 0 and year % 400 == 0: 
        return True
    elif year % 100 == 0:
        return False
    else:
        return year % 4 == 0

Listo !!!

def is_leap_year(year):
   if year > 0:
      if year % 4 == 0 and  year % 100 != 0 or year % 100 == 0 and year % 400 == 0:
         return True
      else:
         return False
   else:
      return False

print(is_leap_year(2000))
print(is_leap_year(-2024))
print(is_leap_year(1984.25))

Mi solución final

def is_leap_year(year):
    if year < 0:
        return False
    elif year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
        return True
    else:
        return False

Mi solucion considerando mayor a 0 y solo int

def is_leap_year(year):
    if year<=0 or type(year).__name__!='int':
        bi = False
    elif year%4 == 0 and year%100 != 0:
        bi = True
    elif  year%100==0 and year%400==0: 
        bi = True
    else: bi = False

    return bi

is_leap_year(2000)

.
.
.
.
.
.
.
.
.
.
.

def is_leap_year(year):
    return True if ((year % 4 == 0 and not year % 100 == 0) or (year % 100 == 0 and year % 400 == 0)) and year > 0 else False

.
.
.
.
.
.
.
.

def is_leap_year(year):
    if (year % 1 != 0 or year <= 0):
        return False
    else:
        if (year % 4 == 0 and year % 100 != 0) or (year % 100 == 0 and year % 400 == 0):
            return True
        return False

def is_leap_year(year):
    if year > 1582:
        if year % 4 == 0:
            if year % 100 == 0:
                if year % 400 == 0:
                   resultado = True
                else:
                   resultado = False    
            else:
                resultado = True
        else:
            resultado = False
    else:
        resultado = False

    return resultado

.
.
.

<def is_leap_year(year):

    if year < 0:
       return False

    if year % 4 == 0 and year % 100 != 0:
        return True
    elif year % 100 == 0 and year % 400 == 0:
        return True
    else:
        return False
        
    pass> 

def is_leap_year(year):
    if year > 0:
        return True if year%4==0 and (year%100!=0 or year%400==0) else False
    return False

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
…
.

…
.
.
.
.
.
.
.
.
…
.
.
.
.
.
.
.
.
.
.
…
.
.
.
.
.

def is_leap_year(year):
    # tu código aquí 👈
    if isinstance(year,int) and year <= 0:
        return False
    
    if year%4 == 0 and year%100:
        return True
    elif year%100 == 0 and year%400==0:
        return True
    else:
        return False

.
.
.
.
.
.
.
.

def is_leap_year(year):
    if year % 4 == 0 and (year % 400 == 0 or year % 100 != 0) and year > 0 and year == int(year):
        return True
    else:
        return False
    pass

.
.
.
.
.
.
.

Una solución

def is_leap_year(year):
    if year % 100 == 0 and year % 400 == 0 and year > 0:
        return True        
    if year % 4 == 0 and year % 100 !=0 and year > 0:
        return True
    else:
        return False

.
.
.
.
.
.
.

def is_leap_year(year):
    # tu código aquí 👈
    if not isinstance(year,int):
        return False

    if year < 0:
        return False

    return ((year % 100 == 0 and year % 400 == 0) or (year % 4 == 0 and not (year % 100 == 0)))

def is_leap_year(year):
    if year % 1 != 0 or year <=0:
      return False

    if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
        return True
    else:
        return False

.
.
.
.
.
.
.
.

def is_leap_year(year):
    result = False
    if (type(year) == int) and (year >= 0):
        result = (year % 4 == 0) and (year % 100 != 0)
        if (not result):
            result = (year % 4 == 0) and (year % 100 == 0)
            result = result and (year % 400 == 0)
    return result