Algoritmo bisiesto

De Wikilibros, la colección de libros de texto de contenido libre.
Ir a la navegación Ir a la búsqueda

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]

Graf algo bisiesto.PNG

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]

 1 int a;
 2 
 3 void setup() {
 4   
 5   a=2004; //Ingrese el año a determinar ejemplo 2014
 6   
 7   Serial.begin(9600);
 8     if (a%400==0){
 9   Serial.println("Es bisiesto");  
10   }
11   else if (a%4==0 & a%100!=0){
12     Serial.println("Es bisiesto");
13   }
14   else
15   {
16     Serial.println("No es bisiesto");  
17   }
18 
19  
20 }
21 
22 void loop() {
23 }

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

     cout << "Año a consultar: ";
     cin  >> anio;
     cout << "El año " << anio << (esBisiesto(anio) ? "" : " 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 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;
}

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]

1 year = input('Introduzca el año que desea averiguar si es bisiesto:');
2 
3 if (mod(year,4) == 0) && (mod(year,100) ~= 0) || (mod(year,400)==0)
4     disp('Es bisiesto');
5 else
6     disp('No es bisiesto');
7 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

Enlaces externos[editar]