Playground - Calcula años bisiestos

Leonardo de los angeles Espinoza Hernandez

student•

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️ . Me alegra que más estudiantes tomen está iniciativa para ayudar a la comunidad . La solución estará debajo del gif, pero antes de leerla te dejo un dato sacado de wikipedia acerca de los años bisiestos .

Los años bisiestos se añaden para corregir el desfase que existe entre la duración del año trópico: 365 días 5 h 48 min 45,10 s (365,242189 días) y el año calendario de 365 días. Esto requiere que cada cuatro años se corrija el año calendario por una acumulación no contabilizada de aproximadamente 1/4 de día por año que equivale a un día extra.

. Por lo que ahora sabes un poquito más que ayer

Explicación

Aquí tienes explicada la solución si es que no lograste completar este desafío. .

function isLeapYear(year) {
  // Primero verificamos que el número sea positivo
  // Y además el número sea entero
  if(year % 1 != 0 || year <= 0){
    return false
  }

  // Verificamos que el año sea divisible entre 4
 // (la regla básica de los años bisiestos) 
  if(year % 4 === 0){
    // Si el numero es múltiplo de 100 y de 400 entonces es bisiesto
    if(year % 100 === 0 && year % 400 === 0){
      return true
    }

    // Si solo es multiplo de 100 no lo es
    if(year % 100 === 0){
      return false
    }
    // Si solo es múltiplo de 4, también lo es
    return true
  }

  // si no cumple con nada de lo anterior, no es bisiesto
  return false
}

Dale like a este comentario para poder disfrutando de esta experiencia 🔥

Santiago Andres Alvarez Cuadros

student•

Hola Leo. En las pruebas faltó verificar que el algoritmo no apruebe si un año secular (últimos años de cada siglo que terminan en 00) no es bisiesto, como el caso de 1800 o 1900 que son seculares pero no bisiestos porque no son divisibles entre 400. . Por lo tanto, este algoritmo aprobó:

export function isLeapYear(year) {
  if (year > 0 && Number.isInteger(year)) {
    if (year % 4 === 0) {
      return true
    }
  }
  return false
}

Cuando no debería

Edwin Ricaurte

student•

function isLeapYear(year) {
  if (isNaN(year) || !Number.isInteger(year) || year < 0) {
    // Si el año no es un número entero o es negativo, devuelve false
    return false;
  } else if (year % 4 === 0 && year % 100 !== 0) {
    // Si el año es divisible por 4 pero no por 100, es bisiesto
    return true;
  } else if (year % 100 === 0 && year % 400 === 0) {
    // Si el año es divisible por 100 y también por 400, es bisiesto
    return true;
  } else {
    // En todos los demás casos, no es bisiesto
    return false;
  }
}

Orlando Sánchez

student•

Hola les dejo un detalle por acá. Las condiciones parecen contradictorias.

No es que deban cumplirse ambas.

Un año es bisiesto si cumple alguna de las siguientes condiciones:

Es divisible por 4, pero no por 100.

ó

Es divisible por 100 y por 400.

Ronald Oswaldo Perez Torres

student•

Gracias por esa aclaración

Juan Pablo Lagos Idrobo

student•

Gracias, me esta costando entender el problema

Aka SinssChoss

student•

Solución sin if 😉

🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧 🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧 🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧

Me ayudo de Wikipedia 🤭

Existe un algoritmo que parte de tres proposiciones lógicas (supuestos):

p: Es divisible entre 4 q: Es divisible entre 100 ( ~ q significa no divisible entre 100) r: Es divisible entre 400

La fórmula lógica para determinar si un año es bisiesto es la siguiente:

Lógica: p ^ q ( ~ q v r)

Traducido a código:

p && q ( !q || r)

Código

export function isLeapYear(year) {
  
 // Agrego el year > 0 para asegurar que sea positivo el año
  const p = (year % 4 == 0 && year > 0)
  const q = (year % 100 == 0 && year > 0)
  const r = (year % 400 == 0 && year > 0)

  return p && (!q || r)
}

Leonardo de los angeles Espinoza Hernandez

student•

Una INCREÍBLE solución 😮

Pero como consejo, a la hora de hacer código el otro detalle que debemos pensar es en los temas de legibilidad y mantenibilidad, variables descriptivos con las que se pueda intuir su propósito fácilmente. Pero en general, una solución que ni yo mismo imaginé 💪

Aka SinssChoss

student•

✅ Variables descriptivas

function isLeapYear(year) {
  const isDivisible4 = (year % 4 == 0 && year > 0)
  const isDivisible100 = (year % 100 == 0 && year > 0)
  const isDivisible400 = (year % 400 == 0 && year > 0)

  return isDivisible4 && (!isDivisible100 || isDivisible400)
}

Alvaro Eduardo Garzón Pira

student•

¡Hola tú! Teniendo en cuenta que en los anteriores playground LeoCode dejó comentarios anti-spoiler, dejo uno aquí también con una imagen para evitar que te comas un spoiler del ejercicio, yo haré lo mismo en este ejercicio adelantándome un poco a LeoCode, así que… Ten tu imagen random, ¡Pero hey! también dejaré la solución al final, así que si no has hecho el ejercicio y no quieres ver la solución aún, no leas lo que hay después de la imagen !image

¿Y la solución pa' cuándo?

Por su pollo, aquí la tienes, primero que todo, las condiciones que se dejan en la guía a pesar de ser exactas, siento que pueden ser un poco confusas... Quizás para ti no, o quizás opines lo mismo, así que recordar un problema similar un par de años atrás y recordé que me dijeron "Fácil, un año es bisiesto si es divisible por 4, así que, siguiendo esta lógica, deje un solo if en el que evalúa si es divisible en 4, usé el operador módulo (en el que obtiene el residuo de una división) y en caso que el residuo sea 0, es decir, que al dividir por 4 da un número entero, entonces es divisible por 4, llevando esta lógica a código, sería así:

export function isLeapYear(year) {
  if (year <= 0) return false;
  if (year % 4 === 0) {
    return true;
  }
  else {
    return false;
  }
}

Dejé dos if, debido a que en la guía dice Toma en cuenta que la función debe ser capaz de manejar valores no enteros o negativos. para que en caso que sea negativo, retorne un false de manera directa.

¿Quieres un reto? 😉

Este reto dependerá de ti, de tu motivación por aprender algo nuevo y de tu gusto por los retos, por más pequeños o grandes que sean, te reto a ti que lees esto, que hagas este ejercicio con el operador ternario ¿Primera vez que lo oyes? Muy útil y te recoomendaría que leyeras la documentación que dejé y soluciones este ejercicio con este operador, pero por favor, si vas a dejar alguna solución, deja una imagen al principio, di #NoALosSpoilersDeCodigo ¡Suerte en tu reto!

Teo Zavala

student•

Muy buen aporte

Jorge Enrique Arana Rosales

student•

Nayarith Jiménez

student•

Yo hice lo mismo!

Andrés Julian Caro Restrepo

student•

. . . . . .

export function isLeapYear(year) {
  // Tu código aquí 👈
  if ((((year % 4 == 0) && (year % 100 !== 0)) || ((year % 100 == 0) && (year % 400 == 0))) && (year >=0)) {
    return true;
  } else {
    return false;
  }
}

Fabián Salamanca

student•

De verdad me siento tonto con los retos (no estoy entndiendo nada) mi esposa me dice que es porque hay cosas que implementan en los retos que aún no hemos visto en el reto. voy y reviso y dicen que los retos se hacen con lo que ya hemos visto (veo las soluciones de mis compañeros y van con más cosas de las que hemos visto.

Leonardo de los angeles Espinoza Hernandez

student•

¡Hola! / No queremos hacerte sentir esta experiencia ¿te encuentras en el discord oficial de Platzi? cualquier traba o problema con el cual te encuentres nos la puedes hacer llegar por ahí y en comunidad revisamos a detalle que es lo que te parece complejo. Si de nuestro lado hace falta explicar más a fondo en las lecturas, lo haremos 💪. / ¡No te frustres! cualquier cosa por aquí estamos para ayudarte :D

Willer Alexander Bencomo Manrique

student•

somos 2... leo y leo, y cuando tocan los playgrounds y veo las soluciones... no encuentro ningun sentido a todo lo que leo, y resumo y trato de analizar, porque no hay ninguna formula para solucionar... o sere yo que estoy frustrado por este nuevo rumbo?

Erika Brito

student•

Héctor Adrián Avilés Ramírez

student•

Lo siento amiga, pero ese código no es el correcto, actualmente ya corrigieron las pruebas ya que en realidad al principio no probaban exactamente el resultado esperado, pero si a ese código le introduces el número 2024 te arrojará un false, cuando debería ser true.

Rosalee Castro

student•

Jejeje segunda prueba Concluida, siempre se aprende algo nuevo o te das cuenta que estas usando mal un signo :D. . . .. . .. . .. . . . . . . . . . .

export function isLeapYear(year) {
  if (year % 4 === 0 && year%100 !==0 && year >0 || year % 100 === 0 && year % 400 === 0 && year>0) {
    return true;
  } else { return false; }

}

Kyb3r Cipher

student•

Mi solucion:

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️ .

export function isLeapYear(year) {
  if (year < 0) { // For negative numbers
    return false;
  }

  if ((year % 4 === 0 && year % 100 !== 0) || (year % 100 === 0 && year % 400 === 0)) {
    return true
  } else {
    return false
  }
}

Robert Vásquez

student•

Sin animo de ofender o molestar, pero la verdad tengo que decirlo, la experiencia con el playground no es muy buena, para correr las pruebas se demora mucho.

Nohely Badillo

student•

¡Hola, Robert!

¿Nos podrías contar un poco más acerca de qué crees que se pueda mejorar en los playgrounds? Por favor :)

Katya Paola Solis sanchez

student•

Hola! Me siento un poco perdida con el operador % no lo comprendo muy bien y no se como utilizarlo !

Leonardo de los angeles Espinoza Hernandez

student•

¡Hola Katya! / El operador de módulo (o también conocido como resto) sirve para obtener el residuo de la división de enteros / Por ejemplo, si queremos obtener el residuo de la divisón de 13 entre 5, simplemente hacemos lo siguiente /

13 % 5 // nos devuelve 3

Esto debido a que primero divide los enteros (13 / 5 = 2) y después se hace la resta para verificar el residuo (5 * 2 = 10 y 13 - 10 = 3) / Espero te sirva de ayuda 💪

Edwin Absalón Martinez Moreno

student•

Esta es mi solución. sugiero tener mucho cuidado con el nivel en que corre cada if.

  export function isLeapYear(year) {
    //verifico que sea mayor que 0 y que su residuo al dividirlo entre 1 sea cero para estar seguro de que también es un entero
    if (year <= 0 && year % 1 != 0) {
      return false
    }
    // verifico que al dividirlo entre 4 su residuo sea de cero (divisible entre  4)
    if (year % 4 === 0) {
      //verifico que sea divisible entre 100 y 400
      if (year % 100 === 0 && year % 400 === 0) {
        return true
      }

      }
      //si solo es multiplo de 400 si lo es
    if (year % 400 === 0) {
        return true
    }

    //si solo es multiplo de 100 no lo es
    if (year % 100 === 0) {
        return false

    }
    // si no cumple con lo anterior entonces no lo es
    return false
}

Abril Darynka Tapia Sosa

student•

Hola, dejo mi solucion

Caminito anti spoilers 🚗 . . . . . . . . . . . . . . . . . . . . Llegamos 📍

export function isLeapYear(year) {
  if (year < 0 && !Number.isInteger(year)) return

  const isYearDividedBy4 = year % 4 === 0;
  const isYearDividedBy100 = year % 100 === 0;
  const isYearDividedBy400 = year % 400 === 0;
  return isYearDividedBy4 ? (isYearDividedBy100 && isYearDividedBy400) : false
}

Javier Hernandez

student•

Otro ejemplo...

export function isLeapYear(year) {
  let c1 = year % 4;
  let c2 = year % 100;
  let c3 = year % 400;

  if (year < 0) {
    return false;
  }

  if (!Number.isInteger(year)) {
    return false;
  }

  if ((c1 === 0 && c2 !== 0) || c3 === 0) {
    return true;
  } else {
    return false;
  }
}

Dave Juanes

student•

Por si alguien en 2025 esta con el challenge


export function isLeapYear(year) {

  if (year \<= 0 || !Number.isInteger(year)) return false;

  if (year % 400 === 0) return true;

  if (year % 100 === 0) return false;

  if (year % 4 === 0) return true;

  return false;

}

jorge vilchis

student•

aqui mi aporte

var year

export function isLeapYear(year) {

if (year < 0) {

return false

}

if ((year % 4 == 0 && year % 100 !== 0) || (year % 400 == 0)) {

return true

} else {

return false

}

console.log(${isLeapYear(year) ? 'El año si es bisiesto' : 'El año no es bisiesto'})

felipe castilla

student•

export function isLeapYear(year) { if (isLeapYear / 4 && !100) { return true; } else (isLeapYear / 100 && 400) { return false; } }; no se cual es el error

felipe castilla

student•

como mirar los errores del código

Juan Ramirez Bastidas

student•

Okay, ya dí con la solución, pero no me ha quedado claro por qué debo devolver false en el caso de que year sea negativo o no entero. ¿Me podrían ayudar?

Oscar Andrey Martinez Calderon

student•

Son las condiciones específicas del ejercicio, sólo puedes retornar true o false, si no das una condición para cuando es negativo o decimal te arroja un undefined

Juan Ramirez Bastidas

student•

Entiendo, ahora me queda claro 👍. La duda me surgió porque pueden haber años con símbolo negativo, pero claro, la idea es seguir los requerimientos del ejercicio 😋.

function isLeapYear(year) {
  // Primero verificamos que el número sea positivo
  // Y además el número sea entero
  if(year % 1 != 0 || year <= 0){
    return false
  }

  // Verificamos que el año sea divisible entre 4
 // (la regla básica de los años bisiestos) 
  if(year % 4 === 0){
    // Si el numero es múltiplo de 100 y de 400 entonces es bisiesto
    if(year % 100 === 0 && year % 400 === 0){
      return true
    }

    // Si solo es multiplo de 100 no lo es
    if(year % 100 === 0){
      return false
    }
    // Si solo es múltiplo de 4, también lo es
    return true
  }

  // si no cumple con nada de lo anterior, no es bisiesto
  return false
}

function isLeapYear(year) {
  if (isNaN(year) || !Number.isInteger(year) || year < 0) {
    // Si el año no es un número entero o es negativo, devuelve false
    return false;
  } else if (year % 4 === 0 && year % 100 !== 0) {
    // Si el año es divisible por 4 pero no por 100, es bisiesto
    return true;
  } else if (year % 100 === 0 && year % 400 === 0) {
    // Si el año es divisible por 100 y también por 400, es bisiesto
    return true;
  } else {
    // En todos los demás casos, no es bisiesto
    return false;
  }
}

export function isLeapYear(year) {
  
 // Agrego el year > 0 para asegurar que sea positivo el año
  const p = (year % 4 == 0 && year > 0)
  const q = (year % 100 == 0 && year > 0)
  const r = (year % 400 == 0 && year > 0)

  return p && (!q || r)
}

function isLeapYear(year) {
  const isDivisible4 = (year % 4 == 0 && year > 0)
  const isDivisible100 = (year % 100 == 0 && year > 0)
  const isDivisible400 = (year % 400 == 0 && year > 0)

  return isDivisible4 && (!isDivisible100 || isDivisible400)
}

export function isLeapYear(year) {
  // Tu código aquí 👈
  if ((((year % 4 == 0) && (year % 100 !== 0)) || ((year % 100 == 0) && (year % 400 == 0))) && (year >=0)) {
    return true;
  } else {
    return false;
  }
}

export function isLeapYear(year) {
  if (year < 0) { // For negative numbers
    return false;
  }

  if ((year % 4 === 0 && year % 100 !== 0) || (year % 100 === 0 && year % 400 === 0)) {
    return true
  } else {
    return false
  }
}

  export function isLeapYear(year) {
    //verifico que sea mayor que 0 y que su residuo al dividirlo entre 1 sea cero para estar seguro de que también es un entero
    if (year <= 0 && year % 1 != 0) {
      return false
    }
    // verifico que al dividirlo entre 4 su residuo sea de cero (divisible entre  4)
    if (year % 4 === 0) {
      //verifico que sea divisible entre 100 y 400
      if (year % 100 === 0 && year % 400 === 0) {
        return true
      }

      }
      //si solo es multiplo de 400 si lo es
    if (year % 400 === 0) {
        return true
    }

    //si solo es multiplo de 100 no lo es
    if (year % 100 === 0) {
        return false

    }
    // si no cumple con lo anterior entonces no lo es
    return false
}

export function isLeapYear(year) {
  if (year < 0 && !Number.isInteger(year)) return

  const isYearDividedBy4 = year % 4 === 0;
  const isYearDividedBy100 = year % 100 === 0;
  const isYearDividedBy400 = year % 400 === 0;
  return isYearDividedBy4 ? (isYearDividedBy100 && isYearDividedBy400) : false
}

export function isLeapYear(year) {
  let c1 = year % 4;
  let c2 = year % 100;
  let c3 = year % 400;

  if (year < 0) {
    return false;
  }

  if (!Number.isInteger(year)) {
    return false;
  }

  if ((c1 === 0 && c2 !== 0) || c3 === 0) {
    return true;
  } else {
    return false;
  }
}

export function isLeapYear(year) {

  if (year \<= 0 || !Number.isInteger(year)) return false;

  if (year % 400 === 0) return true;

  if (year % 100 === 0) return false;

  if (year % 4 === 0) return true;

  return false;

}

Playground - Calcula años bisiestos

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios