año bisiesto

Para encontrar años bisiestos, ¿por qué el año debe ser indivisible por 100 y divisible por 400? Entiendo por qué debe ser divisible por 4. Por favor, explique el algoritmo.

La duración de un año es (más o menos) 365.242196 días. Así que tenemos que restar, más o menos, un cuarto de día para que se ajuste:

365.242196 – 0.25 = 364.992196 (agregando 1 día en 4 años): ¡pero vaya, ahora es demasiado pequeño! agreguemos un centésimo de un día (al no agregar ese día una vez cada cien años :-))

364.992196 + 0,01 = 365.002196 (oops, un poco demasiado grande, agreguemos ese día de todos modos una vez en aproximadamente 400 años)

365.002196 – 1/400 = 364.999696

Casi ahora, juega con segundos de vez en cuando, y estás listo.

(Nota: la razón por la cual no se aplican más correcciones después de este paso es porque un año también CAMBIOS EN LONGITUD !!, es por eso que los segundos son la solución más flexible, ver por ejemplo aquí )

Es por eso que supongo

Hay un algoritmo en wikipedia para determinar los años bisiestos:

function isLeapYear (year): if ((year modulo 4 is 0) and (year modulo 100 is not 0)) or (year modulo 400 is 0) then true else false 

Hay mucha información sobre este tema en la página wikipedia sobre años bisiestos , información inclusiva sobre diferentes calendarios.

En términos generales, el algoritmo para calcular un año bisiesto es el siguiente …

Un año será bisiesto si es divisible por 4 pero no por 100. Si un año es divisible por 4 y por 100, no es un año bisiesto a menos que también sea divisible por 400.

Por lo tanto, años como 1996, 1992, 1988, etc., son años bisiestos porque son divisibles por 4 pero no por 100. Durante siglos, la regla 400 es importante. Por lo tanto, los años del siglo 1900, 1800 y 1700, mientras que todos los divisibles por 4 también son exactamente divisibles por 100. Como no son más divisibles por 400, no son años bisiestos.

esto es suficiente para verificar si un año es bisiesto.

 if( (year%400==0 || year%100!=0) &&(year%4==0)) cout<<"It is a leap year"; else cout<<"It is not a leap year"; 

a) El año es 365.242199 días.

b) Si todos los años fueran 365 días, en 100 años perderíamos 24.2199 días. Es por eso que agregamos 24 días por siglo (cada 4 años, EXCEPTO cuando es divisible por 100)

c) Pero aún así perdemos 0.21299 días / siglo. Entonces en 4 siglos perdemos 0.8796 días. Es por eso que agregamos 1 día por 4 siglos (cada cuarto siglo tenemos un año bisiesto).

d) Pero eso significa que perdemos -0.1204 días (avanzamos) por cuatricentenario (4 siglos). Entonces, en 8 cuatricentenarios (3200 años) NO contamos un año bisiesto.

e) Pero eso significa que perdemos 0.0368 días por 3200 años. Entonces en 24×3200 años (= 76800 años) perdemos 0.8832 días. Es por eso que contamos un año bisiesto.

y así sucesivamente … (para entonces habremos destruido el planeta, entonces no importa)

Sin embargo, lo que no puedo entender es por qué no contamos un año bisiesto cada 500 años en lugar de 400. De esa forma, convergeríamos más rápidamente a la hora correcta (perderíamos 2,3 horas / 500 años).

Estoy seguro de que Wikipedia puede explicarlo mejor que yo, pero básicamente tiene que ver con el hecho de que si agregas un día extra cada cuatro años nos adelantaríamos al sol ya que el tiempo de orbitar alrededor del sol es menor que 365.25 días, así que lo compensamos al no agregar días bisiestos en años que no son divisibles entre 400 p. Ej. 1900.

Espero que ayude

Aquí hay una implementación simple del algoritmo de wikipedia , usando el operador ternario de javascript:

 isLeapYear = (year % 100 === 0) ? (year % 400 === 0) : (year % 4 === 0); 

Realmente deberías tratar de google primero.

Wikipedia tiene una explicación de los años bisiestos . El algoritmo que describes es para el calendario gregoriano Proleptic .

Se puede encontrar más información sobre las matemáticas a su alrededor en el artículo Calendar Algorithms .

Devuelve verdadero si el año de entrada es bisiesto

Código básico moderno:

  If year mod 4 = 0, then leap year if year mod 100 then normal year if year mod 400 then leap year else normal year 

La regla de hoy comenzó en 1582 dC La regla del calendario juliano con cada 4 ° año comenzó en 46 aC, pero no es coherente antes del 10 d. C. según lo declarado por César. Sin embargo, agregaron algunos años bisiestos cada 3 años de vez en cuando en los años anteriores: Los años bisiestos fueron por lo tanto 45 aC, 42 aC, 39 aC, 36 aC, 33 aC, 30 aC, 27 aC, 24 aC, 21 aC, 18 Antes de Cristo, 15 aC, 12 aC, 9 aC, 8 dC, 12 dC Antes del año no se agregaba el año bisiesto 45BC. http://www.wwu.edu/depts/skywise/leapyear.html

El año 0 no existe como es … 2BC 1BC 1AD 2AD … para algunos cálculos esto puede ser un problema.

 function isLeapYear(year: Integer): Boolean; begin result := false; if year > 1582 then // Todays calendar rule was started in year 1582 result := ((year mod 4 = 0) and (not(year mod 100 = 0))) or (year mod 400 = 0) else if year > 10 then // Between year 10 and year 1582 every 4th year was a leap year result := year mod 4 = 0 else //Between year -45 and year 10 only certain years was leap year, every 3rd year but the entire time case year of -45, -42, -39, -36, -33, -30, -27, -24, -21, -18, -15, -12, -9: result := true; end; end; 

¿No será mucho mejor si damos un paso más allá? Asumiendo que cada año 3200 no sea un año bisiesto, la duración del año vendrá

 364.999696 + 1/3200 = 364.999696 + .0003125 = 365.0000085 

y después de esto, se requerirá el ajuste después de alrededor de 120000 años.

PHP:

 // is number of days in the year 366? (php days of year is 0 based) return ((int)date('z', strtotime('Dec 31')) === 365); 

Los años bisiestos son arbitrarios, y el sistema utilizado para describirlos es una construcción hecha por el hombre. No hay porqué.

Lo que quiero decir es que podría haber sido un año bisiesto cada 28 años y tendríamos una semana extra en esos años bisiestos … pero los poderes decidieron convertirlo en un día cada 4 años para ponerse al día.

También tiene que ver con que la Tierra se tome 365,25 días molestos para dar la vuelta al sol, etc. Por supuesto que no es realmente 365.25 es un poco menos ( 365.242222 … ), por lo que para corregir esta discrepancia decidieron abandonar el salto. años que son divisibles por 100.

Si está interesado en las razones de estas reglas, es porque el tiempo que le toma a la tierra hacer exactamente una órbita alrededor del sol es un valor decimal largo e imprecisa. No es exactamente 365.25. Es ligeramente inferior a 365.25, por lo que cada 100 años, debe eliminarse un día bisiesto (365.25 – 0.01 = 365.24). Pero eso tampoco es exactamente correcto. El valor es ligeramente mayor que 365.24. Por lo tanto, solo 3 de cada 4 veces se aplicará la regla de los 100 años (o en otras palabras, agregue nuevamente en 1 día cada 400 años; 365.25 – 0.01 + 0.0025 = 365.2425).

En promedio, hay aproximadamente 365.2425 días en un año en este momento (la Tierra se está desacelerando, pero ignorémoslo por el momento).

La razón por la que tenemos años bisiestos cada 4 años es porque eso nos lleva a 365.25 en promedio [(365+365+365+366) / 4 = 365.25, 1461 days in 4 years] .

La razón por la que no tenemos años bisiestos en los 100 múltiplos es para llegar a 365.24 `[(1461 x 25 – 1) / 100 = 365.24, 36,524 días en 100 años.

Entonces la razón por la que una vez más tenemos un año bisiesto en 400-múltiplos es para llegar a 365.2425 [(36,524 x 4 + 1) / 400 = 365.2425, 146,097 days in 400 years] .

Creo que puede haber otra regla en 3600-múltiplos, pero nunca he codificado (el Y2K fue una cosa, pero la planificación de mil quinientos años en el futuro no es necesaria en mi opinión, ten en cuenta que he estado mal antes).

Entonces, las reglas son, en prioridad decreciente:

  • múltiplo de 400 es un año bisiesto.
  • múltiplo de 100 no es un año bisiesto.
  • múltiplo de 4 es un año bisiesto.
  • cualquier otra cosa no es un año bisiesto.

Aquí viene una idea bastante obscura. Cuando cada año divisible con 100 obtiene 365 días, ¿qué se debe hacer en este momento? En el futuro lejano, cuando incluso años divisibles con 400 solo pueden obtener 365 días.

Entonces hay una posibilidad o razón para hacer correcciones en años divisibles con 80. Los años normales tendrán 365 días y los divisibles con 400 pueden obtener 366 días. O es esta una situación suelta suelto.

Podrías simplemente verificar si el número del Año es divisible por 4 y 400. Realmente no necesitas comprobar si es indivisible por 100. La razón por la cual 400 se cuestiona es porque de acuerdo con el Calendario Gregoriano, nuestra “duración del día” es un poco apagado, y así compensar eso, tenemos 303 años regulares (365 días cada uno) y 97 años bisiestos (366 días cada uno). La diferencia de esos 3 años extra que no son años bisiestos es mantenerse en el ciclo con el calendario gregoriano, que se repite cada 400 años. Busque la ecuación de congruencia de Christian Zeller. Ayudará a comprender la verdadera razón. Espero que esto ayude 🙂

En el calendario gregoriano, se deben tener en cuenta tres criterios para identificar los años bisiestos:

  1. El año es uniformemente divisible por 4;
  2. Si el año puede dividirse uniformemente entre 100, NO es un año bisiesto, a menos que;
  3. El año también es divisible equitativamente por 400. Luego es un año bisiesto. Por qué el año dividido entre 100 no es un año bisiesto

Python 3.5

 def is_leap_baby(year): if ((year % 4 is 0) and (year % 100 is not 0)) or (year % 400 is 0): return "{0}, {1} is a leap year".format(True, year) return "{0} is not a leap year".format(year) print(is_leap_baby(2014)) print(is_leap_baby(2012)) 

En Java continuación, el código calcula el conteo de años bisiestos entre dos años dados. Determine el punto inicial y final del ciclo.

Entonces, si el parámetro módulo 4 es igual a 0 y el parámetro módulo 100 no es igual a 0 o el parámetro módulo 400 es igual a cero, entonces es un año bisiesto y aumenta el contador.

 static int calculateLeapYearCount(int year, int startingYear) { int min = Math.min(year, startingYear); int max = Math.max(year, startingYear); int counter = 0; for (int i = min; i < max; i++) { if ((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) { counter = counter + 1; } } return counter; } 

acabo de escribir esto en Coffee-Script:

 is_leap_year = ( year ) -> assert isa_integer year return true if year % 400 == 0 return false if year % 100 == 0 return true if year % 4 == 0 return false # parseInt? that's not even a word. # Let's rewrite that using real language: integer = parseInt isa_number = ( x ) -> return Object.prototype.toString.call( x ) == '[object Number]' and not isNaN( x ) isa_integer = ( x ) -> return ( isa_number x ) and ( x == integer( x ) ) 

por supuesto, la verificación de validez realizada aquí va un poco más allá de lo que se solicitó, pero creo que es necesario hacer una buena progtwigción.

tenga en cuenta que los valores de retorno de esta función indican años bisiestos en el llamado calendario gregoriano proleptico, por lo que para el año 1400 indica false , mientras que en realidad ese año fue bisiesto, de acuerdo con el calendario juliano utilizado en ese momento. todavía lo dejaré como tal en la biblioteca de fecha y hora que estoy escribiendo porque escribir el código correcto para lidiar con las fechas rápidamente se sorprende, así que solo apoyaré el calendario gregoriano (o me pagarán por otro).