Algoritmo bisiesto

Algoritmo bisiesto

Saltar a navegación, búsqueda

Un año es bisiesto si es divisible entre 4, excepto aquellos divisibles entre 100 pero no 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

Implementaciones en diversos lenguajes de programación

Método programado en Fortran90

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 Lisp

(defun leap-p (year)
  (or
   (and (zerop (mod year 4))
        (not (zerop (mod year 100))))
   (zerop (mod year 400))))

Método programado en C#

        static void Main(string[] args)
        {
            int año;
 
            Console.WriteLine("Ingrese año");
            año = int.Parse(Console.ReadLine());
            if (año % 4 == 0 && año % 100 != 0 || año % 400 == 0)
            {
                Console.WriteLine("El año {0} es bisiesto", año);
            }
 
            else
            {
                Console.WriteLine("El año {0} no es bisiesto", año);
            }
 
            Console.ReadLine();
        }

Método programado en C# (alternativo con if anidados)

//---Declaro---
            int año = 0;
            int moduloCuatro = 0;
            int moduloCien = 0;
            int moduloCuatroCien = 0;
            salida = "";
 
            //--- Ingreso el año ---
            Console.WriteLine("Ingrese el Año:");
            temp = Console.ReadLine();
            año = Int32.Parse(temp);
            moduloCuatro = año %4;
            moduloCien = año %100;
            moduloCuatroCien = año % 400;
            salida = "El año " + año ;
 
            if (moduloCuatro==0)
            {
                if (moduloCien==0)
                {
                    if (moduloCuatroCien == 0)
                    {
                        salida += " es Bisiesto";
                    }
                    else
                    {
                        salida += " no es Bisiesto";
                    }
                }
                else
                {
                    salida += " es Bisiesto";
               }
            }
            else
            {
                salida += " no es Bisiesto";
            }
            Console.WriteLine(salida);

Método programado en AS3

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 PHP (opción 1)

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)

function esBisiesto($year=NULL) {
    return checkdate(2, 29, ($year==NULL)? date('Y'):$year); // devolvemos true si es bisiesto
}

Método programado en Delphi 5

Sea A una variable Integer = Año a analizar. Sea B una variable Booleana cuyo valor True=Bisiesto, False=No bisiesto.

If A mod 4=0 then
   If A mod 100=0 then
      If A mod 400=0 then B:=True
         else B:=False
      else B:=True
   else B:=False

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 programando en C++/C

#include <iostream>
 
bool esBisiesto(int year) 
{
     return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
 
int main()
{
     int anno;
     std::cout << "Año a consultar: ";
     std::cin  >> anno;
     std::cout << "El año " << anno << (esBisiesto(anno) ? "" : " no") << " es bisiesto." << std::endl;
}

programacion en dev-c++

1. include <iostream>

using namespace std;

int main() { int aaaa; cout<<"introdusca año a determinar"<<endl; cin>>aaaa; if((aaaa%4== 0)&&(aaaa%100 != 0 || aaaa % 400==0)) { cout<<"Anio biciestro"<<endl;} else cout<<"anio no biciestro"<<endl;

cout<<"By cba nam"; system("pause");

return 0;
}

Método programado en ASP/VB

function bisiesto(ano)
	if ( (ano mod 4 = 0) and (ano mod 100 <> 0) ) or (ano mod 400 = 0) then
		bisiesto = true 'Es bisiesto
	else
		bisiesto = false 'No es bisiesto
	end if 
end function

Método programado en PL/I

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 Ruby

def es_bisiesto(anio);return (anio%4==0 && anio%100!=0)||(anio%400==0);end; #true si es bisiesto

Método programado en Visual FoxPro (opción 1)

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)

FUNCTION EsBisiesto(tnAnio)
    RETURN NOT EMPTY(DATE(tnAnio, 02, 29))
ENDFUNC

Método programado en Python

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 Java

public boolean isLeap(int anno) {
        if((anno % 4 == 0 && anno % 100 != 0) || anno % 400 == 0) {
            return true;
        }else {
            return false;
        }   
}

Método programado en VBA, también válido para VB, asp

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 Assembly Language (ASM Intel x86)

;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 Javascript

// 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) ? true : false;
}

Método programado en Perl

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 Haskell

esBisiesto :: Integer -> Bool
esBisiesto anio = ( (mod anio 400) == 0 ) || ( ((mod anio 4) == 0 ) && not ((mod anio 100) == 0) )

Véase también

• Año bisiesto
• 29 de febrero

Enlaces externos

• PHP: Método GetDate
• PHP: Método checkdate

Obtenido de "Algoritmo bisiesto"