Algoritmo bisiesto
Un año es bisiesto en el calendario Gregoriano, si es divisible entre 4 y no divisible entre 100, y también si es divisible entre 400.
En programación, el algoritmo para calcular si un año es bisiesto es un algoritmo útil para la realización de calendarios.
Considérese las siguientes proposiciones o enunciados lógicos:
- p: Es divisible entre 4
- ¬q: No es divisible entre 100
- r: Es divisible entre 400
La fórmula lógica que se suele usar para establecer si un año es bisiesto sería cuando [p y ¬q] ó [r] es verdadera, pero esta otra p y [¬q ó r] sería más eficiente.
Diagrama de flujo[editar]
Implementaciones en diversos lenguajes de programación[editar]
Método programado en ADA[editar]
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Characters.Handling;
procedure algoritmo_bisiesto is
anio : Integer;
procedure Bisiesto(anio:Integer) is
begin
if (anio mod 400 = 0 or anio mod 4 = 0) and not(anio mod 100 = 0) then
Put("Es bisiesto.");
else
Put("No es bisiesto.");
end if;
end Bisiesto;
begin
Put("Dime un año: ");
Get(anio);
Bisiesto(anio);
end algoritmo_bisiesto;
Método programado en Assembly Language (ASM Intel x86)[editar]
;Este es un macro que a partir del dato ingresado en el parametro PrAnio define si dicho año es bisiesto, el resultado se guarda en el parametro Bisiesto
;ATENCION: El parametro PrAnio deber ser del tipo DW
Bisiesto Macro PrAnio, Bisiesto
Local Evaluar, Evaluar2, EsBisiesto, NoBisiesto, Salir ;Declara las etiquetas locales usadas por el macro
Mov AX, PrAnio ;Mueve el parametro anio al registro AX
Mov DX, 0000h ;Limpia DX para una division
Mov BX, 0190h ;Mueve a BX 400d
DIV BX ;Realiza la operacion ANIO/400d
CMP DX, 0000h ;Compara el residuo de la operacion con 0
JE EsBisiesto ;Si es igual entonces el año es bisiesto, sino hace otra comparacion
JNE Evaluar ;Salta si la division anterior no dio un resultado positivo a la siguiente condicional
Evaluar:
Mov AX, PrAnio ;Mueve a AX el año ingresado por el usuario
Mov DX, 0000h ;Reinicializa el registro DX
Mov BX, 0004h ;Mueve a BX 00004h
Div BX ;Hace la division AX/0004h
CMP DX, 0000h ;Compara el residuo de la division con 0h
JE Evaluar2 ;Salta a la segunda comparacion si el residuo de la division es 0
JNE NoBisiesto ;Si el residuo de la division es diferente de cero define que no es año bisiesto
Evaluar2:
Mov DX, 0000h ;Reinicializa el registro DX
Mov AX, PrAnio ;Mueve el año ingresado por el usuario a AX
Mov BX, 0064h ;Mueve a BX 100d
Div BX ;Anio / 100d
CMP DX, 0000h ;Compara el residuo de la division con 0h
JNE EsBisiesto ;Si el residuo no es cero, entonces se define que es año bisiesto
JE NoBisiesto ;Si el residuo es cero el año es un año normal
EsBisiesto:
Mov Bisiesto, 01h ;Define el año como un año bisiesto poniendo 1 en el resultado
JMP Salir ;Salta al final del macro
NoBisiesto:
Mov Bisiesto, 00h ;Define el año como un año normal poniendo 0 en el resultado
JMP Salir ;Salta al final del macro
Salir:
EndM
Método programado en Arduino[editar]
int a;
void setup() {
a=2004; //Ingrese el año a determinar ejemplo 2014
Serial.begin(9600);
if (a%400==0){
Serial.println("Es bisiesto");
}
else if (a%4==0 & a%100!=0){
Serial.println("Es bisiesto");
}
else
{
Serial.println("No es bisiesto");
}
}
void loop() {
}
Método programado en AS3[editar]
var today:Date = new Date();
function esBisiesto(year:Number):Boolean {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
//uso:
var yearactual=String(today.getFullYear());
var annoActual=Number(yearactual);
bisiesto=esBisiesto(annoActual);
// respuesta: true o false
Método programado en ASP/VB[editar]
function bisiesto(anio)
if ( (anio mod 4 = 0) and (anio mod 100 <> 0) ) or (anio mod 400 = 0) then
bisiesto = true 'Es bisiesto
else
bisiesto = false 'No es bisiesto
end if
end function
Método programado en C[editar]
#include <stdio.h>
int atoi (const char * string);
int isLeap(int year)
{
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
int main(int argc, char** argv)
{
if (isLeap(atoi(argv[1]))) printf("Año bisiesto.\n");
else printf("Año NO bisiesto.\n");
return 0;
}
Método programado en C++[editar]
#include <iostream>
using namespace std;
bool esBisiesto(int year)
{
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
int main()
{
int year;
cout << "Año a consultar: ";
cin >> year;
cout << "El año " << year << (esBisiesto(year) ? "" : " no") << " es bisiesto." <<endl;
cin.get();
return 0;
}
class Bisiesto
{
double año;
string salida = "";
public void IngresarDatos(double añ)
{
año = añ;
}
public void Calcularaño()
{
if (año % 4 == 0 && año % 100 != 0 || año % 400 == 0)
{
salida = "El año " + año + " es bisiesto";
}
else { salida = "El año " + año + " no es bisiesto"; }
}
public string Imprimir()
{
return salida;
}
}
}
Método programado en Delphi 5[editar]
Sea anio una variable Integer = Año a analizar. Sea B una variable Booleana cuyo valor True=Bisiesto, False=No bisiesto.
procedure Bisiesto(anio:Integer);
Begin
If anio mod 4=0 then
If anio mod 100 = 0 then
If anio mod 400=0 then B:=True
else B:=False
else B:=True
else B:=False
End;
Como todo lenguaje de programación de alto nivel, Delphi tiene una función para resolver lo anterior: IsLeapYear (A), que es una función Booleana cuyo valor True=Bisiesto, False=No bisiesto.
Método programado en Fortran90[editar]
program bisiestopr
implicit none
integer :: a
write(*,*) "Dime un año:"
read(*,*) a
if (esbisiesto(a)) then
write(*,*) "El año es bisiesto"
else
write(*,*) "El año no es bisiesto"
endif
contains
function esbisiesto(an)
logical :: esbisiesto
integer :: an
if (mod(an,4) == 0 .and. mod(an,100) /= 0 .or. mod(an,400)==0) then
esbisiesto=.true.
else
esbisiesto=.false.
endif
end function esbisiesto
end program bisiestopr
Método programado en Haskell[editar]
esBisiesto::Int->Bool
esBisiesto x =( mod x 400==0) || (mod x 4==0) && not (mod x 100==0)
Método programado en Java[editar]
public boolean isLeap(int year) {
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
Método programado en Javascript[editar]
// Función que determina si un año es bisiesto o no
// beta3designs 2009
function es_bisiesto(year) {
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
En Javascript ES6
let leapYear = (y) => y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
Método programado en Lisp[editar]
(defun leap-p (year)
(or
(and (zerop (mod year 4))
(not (zerop (mod year 100))))
(zerop (mod year 400))))
Método programado en Matlab[editar]
year = input('Introduzca el año que desea averiguar si es bisiesto:');
if (mod(year,4) == 0) && (mod(year,100) ~= 0) || (mod(year,400)==0)
disp('Es bisiesto');
else
disp('No es bisiesto');
end
Método programado en Pascal[editar]
function esBisiesto(anio:integer):boolean;
begin
esBisiesto := (anio MOD 400 = 0) OR ((anio MOD 100 <> 0) AND (anio MOD 4 = 0));
// Si retorna esBisiesto=True , el año es bisiesto.
end;
Método programado en PSeInt (en perfil estricto)[editar]
SubProceso Bisiesto(anio)
Si (anio MOD 400 = 0) o (anio MOD 4 = 0) y ~(anio MOD 100 = 0) Entonces
Escribir 'Es bisiesto.';
Sino
Escribir 'No es bisiesto.';
FinSi
FinSubProcesoMétodo programado en PHP (opción 1)[editar]
function esBisiesto($year=NULL) {
$year = ($year==NULL)? date('Y'):$year;
return ( ($year%4 == 0 && $year%100 != 0) || $year%400 == 0 ); // devolvemos true si es bisiesto
}
Método programado en PHP (opción 2)[editar]
function esBisiesto($year=NULL) {
return checkdate(2, 29, ($year==NULL)? date('Y'):$year); // devolvemos true si es bisiesto
}
Método programado en PL/I[editar]
COMPROBAR_ANY_BISIESTO: PROC(ANY);
DCL ANY PIC'(4)9';
DCL NUMANY BIN FIXED(15) INIT (0);
DCL MODANY BIN FIXED(15) INIT (0);
NUMANY = ANY;
IF MOD(NUMANY,4) = 0 THEN
DO;
MODANY = MOD(NUMANY,400);
IF MODANY = 100
| MODANY = 200
| MODANY = 300 THEN
TIPANY = 0;
ELSE
TIPANY = 1;
END;
ELSE
TIPANY = 0;
END COMPROBAR_ANY_BISIESTO;
Método programado en Perl[editar]
sub EsBisiesto{
my $Anyo=shift;
my $Bisiesto=0;
if($Anyo=~/^\d+$/){
if (!($Anyo % 400)){$Bisiesto=1}
elsif(!($Anyo % 100)){$Bisiesto=0}
elsif(!($Anyo % 4 )){$Bisiesto=1}
}
return $Bisiesto;
}
Método programado en Python[editar]
def esBisiesto(year):
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
Al igual que en Delphi, Python también tiene una función para averiguar si un año es bisiesto o no:
import calendar
def esBisiesto(year):
return calendar.isleap(year)
Método programado en R[editar]
TipoAnio = function(anio) { # La funciones DIV y MOD en R son "%/%" y "%%"
a0 <- "Anio_Regular" ; a4 <- "Anio_Bisiesto" # Crear Etiqueta del anio
anioS <- ifelse(anio %% 100 == 0, anio/100, anio) # Tomar el siglo o el anio
anioT <- ifelse(anioS %% 4 == 0, a4, a0) # Asignar la etiqueta condicional
data.frame(Anio = anio, Tipo = anioT) } # Mostrar cuadro de resultado
# Por ejemplo evaluar c(1600,1700,1800,1900,1970,1972,2000,2016)
TipoAnio( c(1600,1700,1800,1900,1970,1972,2000,2016) )
Método programado en Ruby[editar]
def es_bisiesto?(year)
year % 4 == 0 && year % 100 != 0 || year % 400 == 0
end
Otra forma de saber si el año es bisiesto es usando la librería 'date':
require 'date'
def es_bisiesto?(year)
Date.leap?(year)
end
Método programado en VBA, también válido para VB y ASP[editar]
Public Function AnioBisiesto(ByVal ElAnio As Long) As Boolean
'Funcion para verificar si un año es bisiesto. Ju@nK 2009 www.juank.es
Dim x(2) As Long
x(0) = ElAnio Mod (4) ' tiene que ser 0
x(1) = ElAnio Mod (100) ' no tiene que ser 0
x(2) = ElAnio Mod (400) ' tiene que ser 0
AnioBisiesto = (x(2) = 0 Or (x(0) = 0 And x(1) <> 0))
End Function
Método programado en VB.NET[editar]
''' <summary>
''' El año es bisiesto S/N
''' </summary>
''' <param name="año">el año que se analiza</param>
''' <returns>un valor logico, True, si el año analizado es bisiesto, False, en caso contrario</returns>
''' <remarks>
''' <code> https://support.microsoft.com/es-es/kb/214019 </code>
''' <para> Cómo determinar si un año es un año bisiesto </para>
''' <para> 1. Si el año es divisible por 4, vaya al paso 2. Si no es así, vaya al paso 5. </para>
''' <para> 2. Si el año es divisible por 100, vaya al paso 3. Si no es así, diríjase al paso 4. </para>
''' <para> 3. Si el año es divisible por 400, vaya al paso 4. Si no es así, vaya al paso 5. </para>
''' <para> 4. El año es un año bisiesto (tiene 366 días). </para>
''' <para> 5.El año no es un año bisiesto (tiene 365 días). </para>
''' </remarks>
Function IsBisiesto(ByVal año As Integer) As Boolean
Dim bisiesto As Boolean = False ' (Valor por defecto) No es bisiesto
If ((año Mod 4 = 0) And (año Mod 100 <> 0)) Or (año Mod 400 = 0) Then
bisiesto = True 'Es bisiesto
End If
Return bisiesto
End Function
Método programado en Visual FoxPro (opción 1)[editar]
FUNCTION EsBisiesto(tnAnio)
RETURN (tnAnio%4 = 0 AND tnAnio%100 # 0) OR tnAnio%400 = 0
ENDFUNC
Método programado en Visual FoxPro (opción 2)[editar]
FUNCTION EsBisiesto(tnAnio)
RETURN NOT EMPTY(DATE(tnAnio, 02, 29))
ENDFUNC
Método programado en ML[editar]
fun bisiesto y = ((x mod 4 == 0 andalso x mod 100 != 0) orelse x mod 400 == 0);