Wikilibros

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
FinSubProceso

Mé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);

Enlaces externos

editar
Obtenido de «https://es.wikibooks.org/w/index.php?title=Algoritmo_bisiesto&oldid=410829»