Algoritmo bisiesto

De Wikilibros, la colección de libros de texto de contenido libre.
Saltar a: navegación, buscar

Un año es bisiesto en el calendario Gregoriano, 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[editar]

Graf algo bisiesto.PNG

Implementaciones en diversos lenguajes de programación[editar]

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 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 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 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 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 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 Delphi 5[editar]

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[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 programando 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 anno;

     cout << "Año a consultar: ";
     cin  >> anno;
     cout << "El año " << anno << (esBisiesto(anno) ? "" : " no") << " es bisiesto." <<endl;
     
     cin.get();
     return 0;
}

Método programado en C#[editar]

        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 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 ASP/VB[editar]

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[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 Ruby[editar]

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)[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 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 Java[editar]

public boolean isLeap(int year) {
    return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}

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

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 Haskell[editar]

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

Véase también[editar]

Enlaces externos[editar]