Leap year
You are encouraged to solve this task according to the task description, using any language you may know.
Determine whether a given year is a leap year in the Gregorian calendar.
See Also
ActionScript
<lang actionscript>public function isLeapYear(year:int):Boolean {
if (year % 100 == 0) {
return (year % 400 == 0);
}
return (year % 4 == 0);
}</lang>
Ada
<lang Ada>-- Incomplete code, just a sniplet to do the task. Can be used in any package or method. -- Adjust the type of Year if you use a different one. function Is_Leap_Year (Year : Integer) return Boolean is begin
if Year rem 100 = 0 then
return Year rem 400 = 0;
else
return Year rem 4 = 0;
end if;
end Is_Leap_Year;
-- Should be faster without conditional and only one remainder (the other two are really binary and)
function Is_Leap_Year (Year : Integer) return Boolean is
begin
return (Year rem 4 = 0) and ((Year rem 100 /= 0) or (Year rem 16 = 0));
end Is_Leap_Year;
-- To improve speed a bit more, use with
pragma Inline (Is_Leap_Year);</lang>
ALGOL 68
<lang algol68>MODE YEAR = INT, MONTH = INT, DAY = INT;
PROC year days = (YEAR year)DAY: # Ignore 1752 CE for the moment #
( month days(year, 2) = 28 | 365 | 366 );
PROC month days = (YEAR year, MONTH month) DAY:
( month | 31,
28 + ABS (year MOD 4 = 0 AND year MOD 100 /= 0 OR year MOD 400 = 0),
31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
PROC is leap year = (YEAR year)BOOL: year days(year)=366;
test:(
[]INT test cases = (1900, 1994, 1996, 1997, 2000);
FOR i TO UPB test cases DO
YEAR year = test cases[i];
printf(($g(0)" is "b("","not ")"a leap year."l$, year, is leap year(year)))
OD
)</lang> Output:
1900 is not a leap year. 1994 is not a leap year. 1996 is a leap year. 1997 is not a leap year. 2000 is a leap year.
AppleScript
<lang applescript>on leap_year(y) if (y mod 100 is equal to 0) then return (y mod 400 is equal to 0) end if return (y mod 4 is equal to 0) end leap_year
leap_year(1900)</lang>
AutoHotkey
<lang autohotkey>MsgBox % "The year 1600 was " . (IsLeapYear(1600) ? "" : "not ") . "a leap year"
IsLeapYear(Year) {
Return, !Mod(Year, 100) && !Mod(Year, 400) && !Mod(Year, 4)
}</lang>
AutoIt
<lang AutoIt>;AutoIt Version: 3.2.10.0 $Yr=1600 ConsoleWrite ($Yr &" is ") if isLeapYear($Yr) Then
ConsoleWrite ("leap year")
Else
ConsoleWrite ("not leap year")
EndIf
Func isLeapYear($year)
If IsInt($year/100) Then
Return IsInt($year/400)
EndIf
Return IsInt($year/4)
EndFunc</lang>
AWK
<lang AWK>function leapyear( year ) {
if ( year % 100 == 0 )
return ( year % 400 == 0 )
else
return ( year % 4 == 0 )
}</lang>
BASIC
Note that the year% function is not needed for most modern BASICs.
<lang qbasic>DECLARE FUNCTION diy% (y AS INTEGER)
DECLARE FUNCTION isLeapYear% (yr AS INTEGER)
DECLARE FUNCTION year% (date AS STRING)
PRINT isLeapYear(year(DATE$))
FUNCTION diy% (y AS INTEGER)
IF y MOD 4 THEN
diy = 365
ELSEIF y MOD 100 THEN
diy = 366
ELSEIF y MOD 400 THEN
diy = 365
ELSE
diy = 366
END IF
END FUNCTION
FUNCTION isLeapYear% (yr AS INTEGER)
isLeapYear = (366 = diy(yr))
END FUNCTION
FUNCTION year% (date AS STRING)
year% = VAL(RIGHT$(date, 4))
END FUNCTION</lang>
BBC BASIC
<lang bbcbasic> REPEAT
INPUT "Enter a year: " year%
IF FNleap(year%) THEN
PRINT ;year% " is a leap year"
ELSE
PRINT ;year% " is not a leap year"
ENDIF
UNTIL FALSE
END
DEF FNleap(yr%)
= (yr% MOD 4 = 0) AND ((yr% MOD 400 = 0) OR (yr% MOD 100 <> 0))</lang>
Bracmat
<lang bracmat> ( leap-year
=
. mod$(!arg.100):0
& `(mod$(!arg.400):0) { The backtick skips the remainder of the OR operation,
even if the tested condition fails. }
| mod$(!arg.4):0
)
& 1600 1700 1899 1900 2000 2006 2012:?tests & whl
' ( !tests:%?test ?tests
& ( leap-year$!test&out$(!test " is a leap year")
| out$(!test " is not a leap year")
)
)
& ;</lang> Output:
1600 is a leap year 1700 is not a leap year 1899 is not a leap year 1900 is not a leap year 2000 is a leap year 2006 is not a leap year 2012 is a leap year
C/C++
<lang c>#include <stdio.h>
- include <stdbool.h>
bool is_leap_year(int year) {
return !(year % 4) && year % 100 || !(year % 400);
}
int main() {
int test_case[] = {1900, 1994, 1996, 1997, 2000}, key, end;
for (key = 0, end = sizeof(test_case)/sizeof(test_case[0]); key < end; ++key) {
int year = test_case[key];
printf("%d is %sa leap year.\n", year, is_leap_year(year) ? "" : "not ");
}
}</lang> Output:
1900 is not a leap year. 1994 is not a leap year. 1996 is a leap year. 1997 is not a leap year. 2000 is a leap year.
C#
<lang csharp>using System;
class Program {
static void Main()
{
foreach (var year in new[] { 1900, 1994, 1996, DateTime.Now.Year })
{
Console.WriteLine("{0} is {1}a leap year.",
year,
DateTime.IsLeapYear(year) ? string.Empty : "not ");
}
}
}</lang> Sample output:
1900 is not a leap year. 1994 is not a leap year. 1996 is a leap year. 2010 is not a leap year.
Clojure
<lang clojure>(defn leap-year? [y]
(and (zero? (mod y 4)) (or (pos? (mod y 100)) (zero? (mod y 400)))))</lang>
COBOL
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. leap-year.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 examples VALUE "19001994199619972000".
03 year PIC 9(4) OCCURS 5 TIMES
INDEXED BY year-index.
01 remainders.
03 400-rem PIC 9(4).
03 100-rem PIC 9(4).
03 4-rem PIC 9(4).
PROCEDURE DIVISION.
PERFORM VARYING year-index FROM 1 BY 1 UNTIL 5 < year-index
MOVE FUNCTION MOD(year (year-index), 400) TO 400-rem
MOVE FUNCTION MOD(year (year-index), 100) TO 100-rem
MOVE FUNCTION MOD(year (year-index), 4) TO 4-rem
IF 400-rem = 0 OR ((100-rem NOT = 0) AND 4-rem = 0)
DISPLAY year (year-index) " is a leap year."
ELSE
DISPLAY year (year-index) " is not a leap year."
END-IF
END-PERFORM
GOBACK
.</lang>
Common Lisp
<lang lisp>(defun leap-year-p (year)
(destructuring-bind (fh h f)
(mapcar #'(lambda (n) (zerop (mod year n))) '(400 100 4))
(or fh (and (not h) f))))</lang>
Component Pascal
BlackBox Component Builder <lang oberon2> MODULE LeapYear; IMPORT StdLog, Strings, Args;
PROCEDURE IsLeapYear(year: INTEGER): BOOLEAN; BEGIN IF year MOD 4 # 0 THEN
RETURN FALSE
ELSE IF year MOD 100 = 0 THEN IF year MOD 400 = 0 THEN RETURN TRUE ELSE RETURN FALSE END ELSE RETURN TRUE END END END IsLeapYear;
PROCEDURE Do*; VAR p: Args.Params; year,done,i: INTEGER; BEGIN Args.Get(p); FOR i := 0 TO p.argc - 1 DO Strings.StringToInt(p.args[i],year,done); StdLog.Int(year);StdLog.String(":>");StdLog.Bool(IsLeapYear(year));StdLog.Ln END;
END Do;
END LeapYear.
</lang>
Execute: ^Q LeapYear.Do 2000 2004 2013~
Output:
2000:> $TRUE 2004:> $TRUE 2013:> $FALSE
D
<lang d>import std.algorithm;
bool leapYear(in uint y) pure nothrow {
return (y % 4) == 0 && (y % 100 || (y % 400) == 0);
}
void main() {
auto good = [1600, 1660, 1724, 1788, 1848, 1912, 1972, 2032,
2092, 2156, 2220, 2280, 2344, 2348];
auto bad = [1698, 1699, 1700, 1750, 1800, 1810, 1900, 1901,
1973, 2100, 2107, 2200, 2203, 2289];
assert(filter!leapYear(bad ~ good).equal(good));
}</lang>
Delphi/Pascal
Delphi has standard function IsLeapYear in SysUtils unit. <lang Delphi>program TestLeapYear;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
Year: Integer;
begin
Write('Enter the year: ');
Readln(Year);
if IsLeapYear(Year) then
Writeln(Year, ' is a Leap year')
else
Writeln(Year, ' is not a Leap year');
Readln;
end.</lang>
DWScript
<lang Delphi>function IsLeapYear(y : Integer) : Boolean; begin
Result:= (y mod 4 = 0)
and ( ((y mod 100) <> 0)
or ((y mod 400) = 0) );
end;
const good : array [0..13] of Integer =
[1600,1660,1724,1788,1848,1912,1972,2032,2092,2156,2220,2280,2344,2348];
const bad : array [0..13] of Integer =
[1698,1699,1700,1750,1800,1810,1900,1901,1973,2100,2107,2200,2203,2289];
var i : Integer;
PrintLn('Checking leap years'); for i in good do
if not IsLeapYear(i) then PrintLn(i);
PrintLn('Checking non-leap years'); for i in bad do
if IsLeapYear(i) then PrintLn(i);</lang>
Ela
<lang ela>isLeap y | y % 100 == 0 = y % 400 == 0
| else = y % 4 == 0</lang>
Erlang
<lang erlang> -module(gregorian). -export([leap/1]).
leap( Year ) -> calendar:is_leap_year( Year ). </lang>
Euphoria
<lang euphoria>function isLeapYear(integer year)
return remainder(year,4)=0 and remainder(year,100)!=0 or remainder(year,400)=0
end function</lang>
Excel
Take two cells, say A1 and B1, in B1 type in :
<lang Excel> =IF(OR(NOT(MOD(A1;400));AND(NOT(MOD(A1;4));MOD(A1;100)));"Leap Year";"Not a Leap Year") </lang>
Output for various years :
<lang> 1900 Not a Leap Year 1954 Not a Leap Year 1996 Leap Year 2003 Not a Leap Year 2012 Leap Year </lang>
F#
<lang fsharp>let isLeapYear = System.DateTime.IsLeapYear assert isLeapYear 1996 assert isLeapYear 2000 assert not (isLeapYear 2001) assert not (isLeapYear 1900)</lang>
Factor
Call leap-year? word from calendars vocabulary. For example: <lang factor>USING: calendar prettyprint ; 2011 leap-year? .</lang> Factor uses proleptic Gregorian calendar.
Forth
<lang forth>: leap-year? ( y -- ? )
dup 400 mod 0= if drop true exit then
dup 100 mod 0= if drop false exit then
4 mod 0= ;</lang>
Or more simply (but always computing three "mod"): <lang forth>: leap-year? dup 4 mod 0= over 16 mod 0= rot 25 mod 0= not or and ;</lang>
Fortran
<lang fortran>program leap
implicit none
write(*,*) leap_year([1900, 1996, 1997, 2000])
contains
pure elemental function leap_year(y) result(is_leap) implicit none logical :: is_leap integer,intent(in) :: y
is_leap = (mod(y,4)==0 .and. .not. mod(y,100)==0) .or. (mod(y,400)==0)
end function leap_year
end program leap</lang> Output:
F T F T
GAP
<lang gap>IsLeapYear := function(n)
return (n mod 4 = 0) and ((n mod 100 <> 0) or (n mod 400 = 0));
end;
- alternative using built-in function
IsLeapYear := function(n)
return DaysInYear(n) = 366;
end;</lang>
Go
<lang go>func isLeap(year int) bool {
return year%400 == 0 || year%4 == 0 && year%100 != 0
}</lang>
Groovy
Solution: <lang groovy>(1900..2012).findAll {new GregorianCalendar().isLeapYear(it)}.each {println it}</lang> Output:
1904 1908 1912 1916 1920 1924 1928 1932 1936 1940 1944 1948 1952 1956 1960 1964 1968 1972 1976 1980 1984 1988 1992 1996 2000 2004 2008 2012
Haskell
Simple version <lang haskell>import Data.List import Control.Monad import Control.Arrow
leaptext x b | b = show x ++ " is a leap year" | otherwise = show x ++ " is not a leap year"
isleapsf j | 0==j`mod`100 = 0 == j`mod`400 | otherwise = 0 == j`mod`4</lang> Algorithmic <lang haskell>isleap = foldl1 ((&&).not).flip map [400, 100, 4]. ((0==).).mod</lang> Example using isleap <lang haskell>*Main> mapM_ (putStrLn. (ap leaptext isleap)) [1900,1994,1996,1997,2000] 1900 is not a leap year 1994 is not a leap year 1996 is a leap year 1997 is not a leap year 2000 is a leap year</lang>
TDD version <lang haskell>import Test.HUnit
isLeapYear::Int->Bool isLeapYear y
| mod y 400 == 0 = True | mod y 100 == 0 = False | mod y 4 == 0 = True | otherwise = False
tests = TestList[TestCase $ assertEqual "4 is a leap year" True $ isLeapYear 4
,TestCase $ assertEqual "1 is not a leap year" False $ isLeapYear 1
,TestCase $ assertEqual "64 is a leap year" True $ isLeapYear 64
,TestCase $ assertEqual "2000 is a leap year" True $ isLeapYear 2000
,TestCase $ assertEqual "1900 is not a leap year" False $ isLeapYear 1900</lang>
Icon and Unicon
Gives leap year status for 2000,1900,2012 and any arguments you give <lang Icon>procedure main(arglist) every y := !([2000,1900,2012]|||arglist) do
write("The year ",y," is ", leapyear(y) | "not ","a leap year.")
end
procedure leapyear(year) #: determine if year is leap
if (numeric(year) % 4 = 0 & year % 100 ~= 0) | (numeric(year) % 400 = 0) then return
end</lang>
J
<lang j>isLeap=: 0 -/@:= 4 100 400 |/ ]</lang> Example use: <lang j> isLeap 1900 1996 1997 2000 0 1 0 1</lang>
Java
By default, java.util.GregorianCalendar switches from Julian calendar to Gregorian calendar at 15 October 1582.
<lang java>new java.util.GregorianCalendar().isLeapYear(year)</lang>
For proleptic Gregorian calendar:
<lang java>public static boolean isLeapYear(int year){
if(year % 100 == 0)
return year % 400 == 0;
return year % 4 == 0;
}</lang>
JavaScript
<lang javascript>var isLeapYear = function (year) { return (year % 100 === 0) ? (year % 400 === 0) : (year % 4 === 0); };</lang> Or, by setting the day to the 29th and checking if the day remains <lang javascript>// Month values start at 0, so 1 is for February var isLeapYear = function (year) { return new Date(year, 1, 29).getDate() === 29; };</lang>
K
<lang K> leapyear:{(+/~x!'4 100 400)!2}
a@&leapyear'a:1900,1994,1996,1997,2000
1996 2000</lang>
Liberty BASIC
Simple method
<lang lb>if leap(1996)then
print "leap"
else
print "ordinary"
end if wait
function leap(n)
leap=date$("2/29/";n)
end function</lang>
Calculated method
<lang lb> year = 1908
select case
case year mod 400 = 0
leapYear = 1
case year mod 4 = 0 and year mod 100 <> 0
leapYear = 1
case else
leapYear = 0
end select
if leapYear = 1 then
print year;" is a leap year."
else
print year;" is not a leap year."
end if</lang>
Logo
<lang logo>to multiple? :n :d
output equal? 0 modulo :n :d
end to leapyear? :y
output ifelse multiple? :y 100 [multiple? :y 400] [multiple? :y 4]
end</lang>
Logtalk
<lang logtalk>leap_year(Year) :-
( mod(Year, 4) =:= 0, mod(Year, 100) =\= 0 ->
true
; mod(Year, 400) =:= 0
).</lang>
Lua
<lang Lua>function isLeapYear(year)
return year%4==0 and (year%100~=0 or year%400==0)
end</lang>
Mathematica
<lang Mathematica>isLeapYear[y_]:= y~Mod~4 == 0 && (y~Mod~100 != 0 || y~Mod~400 == 0)</lang>
MATLAB / Octave
MATLAB, conveniently, provides a function that returns the last day of an arbitrary month of the calendar given the year. Using the fact that February is 29 days long during a leap year, we can write a one-liner that solves this task. <lang MATLAB>function TrueFalse = isLeapYear(year)
TrueFalse = (eomday(year,2) == 29);
end</lang>
Maxima
<lang maxima>leapyearp(year) := is(mod(year, 4) = 0 and
(mod(year, 100) # 0 or mod(year, 400) = 0))$</lang>
МК-61/52
<lang>П0 1 0 0 / {x} x=0 14 ИП0 4 0 0 ПП 18 ИП0 4 ПП 18 / {x} x=0 24 1 С/П 0 С/П</lang>
MUMPS
<lang MUMPS>ILY(X) ;IS IT A LEAP YEAR?
QUIT ((X#4=0)&(X#100'=0))!((X#100=0)&(X#400=0))</lang>
Usage:
USER>W $SELECT($$ILY^ROSETTA(1900):"Yes",1:"No") No USER>W $SELECT($$ILY^ROSETTA(2000):"Yes",1:"No") Yes USER>W $SELECT($$ILY^ROSETTA(1999):"Yes",1:"No") No
Nemerle
Demonstrating implementation as well as use of standard library function. <lang Nemerle>using System; using System.Console; using Nemerle.Assertions; using Nemerle.Imperative;
module LeapYear {
IsLeapYear(year : int) : bool
requires year >= 1582 otherwise throw ArgumentOutOfRangeException("year must be in Gregorian calendar.")
// without the contract enforcement would work for proleptic Gregorian Calendar
// in that case we might still want to require year > 0
{
when (year % 400 == 0) return true;
when (year % 100 == 0) return false;
when (year % 4 == 0) return true;
false
}
Main() : void
{
WriteLine("2000 is a leap year: {0}", IsLeapYear(2000));
WriteLine("2100 is a leap year: {0}", IsLeapYear(2100));
try {
WriteLine("1500 is a leap year: {0}", IsLeapYear(1500));
}
catch {
|e is ArgumentOutOfRangeException => WriteLine(e.Message)
}
WriteLine("1500 is a leap year: {0}", DateTime.IsLeapYear(1500)); // is false, indicating use of proleptic
// Gregorian calendar rather than reverting to
// Julian calendar
WriteLine("{0} is a leap year: {1}", DateTime.Now.Year,
DateTime.IsLeapYear(DateTime.Now.Year));
}
}</lang> Output:
2000 is a leap year: True 2100 is a leap year: False Specified argument was out of the range of valid values. Parameter name: year must be in Gregorian calendar. 1500 is a leap year: False 2013 is a leap year: False
NetRexx
Demonstrates both a Gregorian/proleptic Gregorian calendar leap-year algorithm and use of the Java library's GregorianCalendar object to determine which years are leap-years.
Note that the Java library indicates that the year 1500 is a leap-year as the Gregorian calendar wasn't established until 1582. The Java library implements the Julian calendar for dates prior to the Gregorian cut-over and leap-year rules in the Julian calendar are different to those for the Gregorian calendar. <lang NetRexx>/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
years = '1500 1580 1581 1582 1583 1584 1600 1700 1800 1900 1994 1996 1997 2000 2004 2008 2009 2010 2011 2012 2100 2200 2300 2400 2500 2600' years['l-a'] = years['n-a'] = years['l-j'] = years['n-j'] =
loop y_ = 1 to years.words
year = years.word(y_)
if isLeapyear(year) then years['l-a'] = years['l-a'] year
else years['n-a'] = years['n-a'] year
if GregorianCalendar().isLeapYear(year) then years['l-j'] = years['l-j'] year
else years['n-j'] = years['n-j'] year
end y_
years['l-a'] = years['l-a'].strip years['n-a'] = years['n-a'].strip years['l-j'] = years['l-j'].strip years['n-j'] = years['n-j'].strip
say ' Sample years:' years['all'].changestr(' ', ',') say ' Leap years (algorithmically):' years['l-a'].changestr(' ', ',') say ' Leap years (Java library) :' years['l-j'].changestr(' ', ',') say ' Non-leap years (algorithmically):' years['n-a'].changestr(' ', ',') say ' Non-leap years (Java library) :' years['n-j'].changestr(' ', ',')
return
-- algorithmically method isLeapyear(year = int) public constant binary returns boolean
select when year // 400 = 0 then ly = isTrue when year // 100 \= 0 & year // 4 = 0 then ly = isTrue otherwise ly = isFalse end return ly
method isTrue public constant binary returns boolean
return 1 == 1
method isFalse public constant binary returns boolean
return \isTrue</lang>
- Output
Sample years: 1500,1580,1581,1582,1583,1584,1600,1700,1800,1900,1994,1996,1997,2000,2004,2008,2009,2010,2011,2012,2100,2200,2300,2400,2500,2600
Leap years (algorithmically): 1580,1584,1600,1996,2000,2004,2008,2012,2400
Leap years (Java library) : 1500,1580,1584,1600,1996,2000,2004,2008,2012,2400
Non-leap years (algorithmically): 1500,1581,1582,1583,1700,1800,1900,1994,1997,2009,2010,2011,2100,2200,2300,2500,2600
Non-leap years (Java library) : 1581,1582,1583,1700,1800,1900,1994,1997,2009,2010,2011,2100,2200,2300,2500,2600
Oberon-2
<lang oberon2> PROCEDURE IsLeapYear(year: INTEGER): BOOLEAN; BEGIN
IF year MOD 4 # 0 THEN
RETURN FALSE
ELSE
IF year MOD 100 = 0 THEN
IF year MOD 400 = 0 THEN
RETURN TRUE
ELSE
RETURN FALSE
END
ELSE
RETURN TRUE
END
END
END IsLeapYear; </lang>
Objeck
<lang objeck>bundle Default {
class LeapYear {
function : Main(args : String[]) ~ Nil {
test_case := [1900, 1994, 1996, 1997, 2000];
each(i : test_case) {
test_case[i]->Print();
if(IsLeapYear(test_case[i])) {
" is a leap year."->PrintLine();
}
else {
" is not a leap year."->PrintLine();
};
};
}
function : native : IsLeapYear(year : Int) ~ Bool {
if(year % 4 = 0 & year % 100 <> 0) {
return true;
}
else if(year % 400 = 0) {
return true;
};
return false; } }
}</lang>
OCaml
<lang ocaml>let is_leap_year ~year =
if (year mod 100) = 0 then (year mod 400) = 0 else (year mod 4) = 0</lang>
Using Unix Time functions: <lang ocaml>let is_leap_year ~year =
let tm =
Unix.mktime {
(Unix.gmtime (Unix.time())) with
Unix.tm_year = (year - 1900);
tm_mon = 1 (* feb *);
tm_mday = 29
}
in
(tm.Unix.tm_mday = 29)</lang>
ooRexx
<lang ooRexx>
- routine isLeapYear
use arg year d = .datetime~new(year, 1, 1) return d~isLeapYear
</lang>
OpenEdge/Progress
The DATE function converts month, day, year integers to a date data type and will set the error status if invalid values are passed. <lang progress>FUNCTION isLeapYear RETURNS LOGICAL (
i_iyear AS INTEGER
):
DATE( 2, 29, i_iyear ) NO-ERROR. RETURN NOT ERROR-STATUS:ERROR.
END FUNCTION. /* isLeapYear */
MESSAGE
1900 isLeapYear( 1900 ) SKIP 1994 isLeapYear( 1994 ) SKIP 1996 isLeapYear( 1996 ) SKIP 1997 isLeapYear( 1997 ) SKIP 2000 isLeapYear( 2000 )
VIEW-AS ALERT-BOX.</lang>
Oz
<lang oz>declare
fun {IsLeapYear Year}
case Year mod 100 of 0 then
Year mod 400 == 0
else
Year mod 4 == 0
end end
in
for Y in [1900 1996 1997 2000] do
if {IsLeapYear Y} then
{System.showInfo Y#" is a leap year."}
else
{System.showInfo Y#" is NOT a leap year."}
end end</lang>
Output:
1900 is NOT a leap year. 1996 is a leap year. 1997 is NOT a leap year. 2000 is a leap year.
PARI/GP
<lang parigp>isLeap(n)={
if(n%400==0, return(1)); if(n%100==0, return(0)); n%4==0
};</lang>
Alternate version: <lang parigp>isLeap(n)=!(n%if(n%100,4,400))</lang>
<lang parigp>isLeap(n)={
if(n%4,0,
n%100,1,
n%400,0,1
)
};</lang>
Perl
<lang Perl>sub leap {
my $yr = $_[0];
if ($yr % 100 == 0) {
return ($yr % 400 == 0);
}
return ($yr % 4 == 0);
}</lang> Or more concisely: <lang Perl>sub leap {!($_[0] % 100) ? !($_[0] % 400) : !($_[0] % 4)}</lang> Using library function/method: <lang Perl>use Date::Manip; Date_LeapYear($year);
use Date::Manip::Base; my $dmb = new Date::Manip::Base; $dmb->leapyear($year);</lang>
Perl 6
<lang perl6>say "$year is a {Date.is-leap-year($year) ?? 'leap' !! 'common'} year."</lang>
In Rakudo 2010.07, Date.is-leap-year is implemented as
<lang perl6>multi method is-leap-year($y = $!year) {
$y %% 4 and not $y %% 100 or $y %% 400
}</lang>
PHP
<lang php><?php function isLeapYear(year) {
if (year % 100 == 0) {
return (year % 400 == 0);
}
return (year % 4 == 0);
}</lang>
With date('L'):
<lang php><?php
function isLeapYear(year) {
return (date('L', mktime(0, 0, 0, 2, 1, year)) === '1')
}</lang>
PicoLisp
<lang PicoLisp>(de isLeapYear (Y)
(bool (date Y 2 29)) )</lang>
Output:
: (isLeapYear 2010) -> NIL : (isLeapYear 2008) -> T : (isLeapYear 1600) -> T : (isLeapYear 1700) -> NIL
PL/I
<lang pli>dcl mod builtin; dcl year fixed bin (31);
do year = 1900, 1996 to 2001;
if mod(year, 4) = 0 &
(mod(year, 100) ^= 0 |
mod(year, 400) = 0) then
put skip edit(year, 'is a leap year') (p'9999b', a);
else
put skip edit(year, 'is not a leap year') (p'9999b', a)'
end;</lang>
Output:
1900 is not a leap year 1996 is a leap year 1997 is not a leap year 1998 is not a leap year 1999 is not a leap year 2000 is a leap year 2001 is not a leap year
PostScript
<lang postscript>/isleapyear {
dup dup 4 mod 0 eq % needs to be divisible by 4 exch 100 mod 0 ne % but not by 100 and exch 400 mod 0 eq % or by 400 or
} def</lang>
PowerShell
<lang powershell>function isLeapYear ($year) {
If (([System.Int32]::TryParse($year, [ref]0)) -and ($year -le 9999))
{ $bool = [datetime]::isleapyear($year) } else { throw "Year format invalid. Use only numbers up to 9999." } return $bool }</lang>
Prolog
<lang Prolog>leap_year(L) :- partition(is_leap_year, L, LIn, LOut), format('leap years : ~w~n', [LIn]), format('not leap years : ~w~n', [LOut]).
is_leap_year(Year) :- R4 is Year mod 4, R100 is Year mod 100, R400 is Year mod 400, ( (R4 = 0, R100 \= 0); R400 = 0).</lang> Output : <lang Prolog> ?- leap_year([1900,1994,1996,1997,2000 ]). leap years : [1996,2000] not leap years : [1900,1994,1997] L = [1900,1994,1996,1997,2000].</lang>
PureBasic
<lang PureBasic>Procedure isLeapYear(Year)
If (Year%4=0 And Year%100) Or Year%400=0 ProcedureReturn #True Else ProcedureReturn #False EndIf
EndProcedure</lang>
Python
<lang python>import calendar calendar.isleap(year)</lang> or <lang python>def is_leap_year(year):
if year % 100 == 0:
return year % 400 == 0
return year % 4 == 0</lang>
Asking for forgiveness instead of permission: <lang python>import datetime
def is_leap_year(year):
try:
datetime.date(year, 2, 29)
except ValueError:
return False
return True</lang>
R
<lang R>isLeapYear <- function(year) {
ifelse(year%%100==0, year%%400==0, year%%4==0)
}
for (y in c(1900, 1994, 1996, 1997, 2000)) {
print(paste(y, " is ", ifelse(isLeapYear(y), "", "not "), "a leap year.", sep=""))
}</lang> Output:
1900 is not a leap year. 1994 is not a leap year. 1996 is a leap year. 1997 is not a leap year. 2000 is a leap year.
Racket
<lang racket>(define (leap-year? y)
(and (zero? (modulo y 4)) (or (positive? (modulo y 100)) (zero? (modulo y 400)))))</lang>
Raven
<lang Raven>define is_leap_year use $year
$year 100 % 0 = if
$year 400 % 0 =
$year 4 % 0 =</lang>
REBOL
<lang rebol>leap-year?: func [
{Returns true if the specified year is a leap year; false otherwise.}
year [date! integer!]
/local div?
][
either date? year [year: year/year] [
if negative? year [throw make error! join [script invalid-arg] year]
]
; The key numbers are 4, 100, and 400, combined as follows:
; 1) If the year is divisible by 4, it’s a leap year.
; 2) But, if the year is also divisible by 100, it’s not a leap year.
; 3) Double but, if the year is also divisible by 400, it is a leap year.
div?: func [n] [zero? year // n]
to logic! any [all [div? 4 not div? 100] div? 400]
]</lang>
Retro
<lang Retro> : isLeapYear? ( y-f )
dup 400 mod 0 = [ drop -1 0 ] [ 1 ] if 0; drop dup 100 mod 0 = [ drop 0 0 ] [ 1 ] if 0; drop 4 mod 0 = ;</lang>
This is provided by the standard calendar library.
REXX
local variables
<lang rexx>leapyear: procedure; parse arg yr
return yr//400==0 | (yr//100\==0 & yr//4==0)</lang>
no local variables
This version doesn't need a PROCEDURE to hide local variable(s). <lang rexx>leapyear: return arg(1)//400==0 | (arg(1)//100\==0 & arg(1)//4==0)</lang>
Ruby
<lang ruby>require 'date' def leap_year?(year)
Date.new(year).leap?
end</lang>
By default, Date switches from Julian calendar to Gregorian calendar at 1582 October 15, the day of calendar reform in Italy and Catholic countries. With Julian calendar, 1500 and 1400 are leap years.
<lang ruby>[2000, 1900, 1800, 1700, 1600, 1500, 1400].each do |year|
print year, (leap_year? year) ? " is" : " is not", " a leap year.\n"
end</lang>
2000 is a leap year. 1900 is not a leap year. 1800 is not a leap year. 1700 is not a leap year. 1600 is a leap year. 1500 is a leap year. 1400 is a leap year.
To use proleptic Gregorian calendar, a program must pass Date::GREGORIAN. <lang ruby>require 'date' def leap_year?(year)
Date.new(year, 1, 1, Date::GREGORIAN).leap?
end</lang> With proleptic Gregorian calendar, 1500 and 1400 are not leap years.
2000 is a leap year. 1900 is not a leap year. 1800 is not a leap year. 1700 is not a leap year. 1600 is a leap year. 1500 is not a leap year. 1400 is not a leap year.
Run BASIC
<lang runbasic>if date$("02/29/" + mid$(date$("mm/dd/yyyy"),7,4)) then print "leap year" else print "not"</lang>
Scala
By default, java.util.GregorianCalendar switches from Julian calendar to Gregorian calendar at 15 October 1582.
<lang scala>//use Java's calendar class new java.util.GregorianCalendar().isLeapYear(year)</lang>
For proleptic Gregorian calendar:
<lang scala>def isLeapYear(year:Int)=if (year%100==0) year%400==0 else year%4==0;
//or use Java's calendar class def isLeapYear(year:Int):Boolean = {
val c = new java.util.GregorianCalendar c.setGregorianChange(new java.util.Date(Long.MinValue)) c.isLeapYear(year)
}</lang>
Scheme
<lang scheme>(define (leap-year? n) (apply (lambda (a b c) (or a (and (not b) c)))
(map (lambda (m) (zero? (remainder n m)))
'(400 100 4))))</lang>
Seed7
This function is part of the "time.s7i" library. It returns TRUE if the year is a leap year in the Gregorian calendar. <lang seed7>const func boolean: isLeapYear (in integer: year) is
return (year rem 4 = 0 and year rem 100 <> 0) or year rem 400 = 0;</lang>
Original source: [1]
SNOBOL4
Predicate leap( ) succeeds/fails, returns nil. <lang SNOBOL4> define('leap(yr)') :(end_leap) leap eq(remdr(yr,400),0) :s(return)
eq(remdr(yr,100),0) :s(freturn) eq(remdr(yr,4),0) :s(return)f(freturn)
end_leap
- # Test and display (with ?: kluge)
test = "output = ('10' ? (*leap(yr) 1 | 0)) ': ' yr"
yr = '1066'; eval(test)
yr = '1492'; eval(test)
yr = '1900'; eval(test)
yr = '2000'; eval(test)
end</lang> Output:
0: 1066 1: 1492 0: 1900 1: 2000
Tcl
The "classic" modulo comparison: <lang tcl>proc isleap1 {year} {
return [expr {($year % 4 == 0) && (($year % 100 != 0) || ($year % 400 == 0))}]
} isleap1 1988 ;# => 1 isleap1 1989 ;# => 0 isleap1 1900 ;# => 0 isleap1 2000 ;# => 1</lang> Does Feb 29 exist in the given year? If not a leap year, the clock command will return "03-01". (This code will switch to the Julian calendar for years before 1582.) <lang tcl>proc isleap2 year {
return [expr {[clock format [clock scan "$year-02-29" -format "%Y-%m-%d"] -format "%m-%d"] eq "02-29"}]
} isleap2 1988 ;# => 1 isleap2 1989 ;# => 0 isleap2 1900 ;# => 0 isleap2 2000 ;# => 1</lang>
TUSCRIPT
<lang tuscript>$$ MODE TUSCRIPT LOOP year="1900'1994'1996'1997'2000",txt="" SET dayoftheweek=DATE(number,29,2,year,number) IF (dayoftheweek==0) SET txt="not " PRINT year," is ",txt,"a leap year" ENDLOOP</lang> Output:
1900 is not a leap year 1994 is not a leap year 1996 is a leap year 1997 is not a leap year 2000 is a leap year
UNIX Shell
Original Bourne: <lang sh>leap() {
if expr $1 % 4 >/dev/null; then return 1; fi if expr $1 % 100 >/dev/null; then return 0; fi if expr $1 % 400 >/dev/null; then return 1; fi return 0;
}</lang>
Using GNU date(1): <lang sh>leap() {
date -d "$1-02-29" >/dev/null 2>&1;
}</lang>
Using the cal command:
<lang sh>leap() {
cal 02 $1 | grep -q 29
} </lang>
Vala
<lang Vala>void main() {
DateYear[] years = {1900, 1994, 1996, 1997, 2000};
foreach (DateYear year in years) {
string status = year.is_leap_year() ? "" : "not ";
print("%d is %sa leap year.\n", (int) year, status);
}
}</lang>
Vedit macro language
<lang vedit>while (#1 = Get_Num("Year: ")) {
#2 = (#1 % 4 == 0) && ((#1 % 100 != 0) || (#1 % 400 == 0))
if (#2) {
Message(" is leap year\n")
} else {
Message(" is not leap year\n")
}
}</lang>
The following version requires Vedit 6.10 or later: <lang vedit>while (#1 = Get_Num("Year: ")) {
if (Is_Leap_Year(#1)) {
Message(" is leap year\n")
} else {
Message(" is not leap year\n")
}
}</lang>
X86 Assembly
Using FASM syntax. Leaf function fits nicely into your program. <lang asm> align 16
- Input year as signed dword in EAX
IsLeapYear:
test eax,11b jz .4 retn ; 75% : ZF=0, not a leap year
.4:
mov ecx,100 cdq idiv ecx test edx,edx jz .100 cmp edx,edx retn ; 24% : ZF=1, leap year
.100:
test eax,11b retn ; 1% : ZF=?, leap year if EAX%400=0</lang>
XPL0
<lang XPL0>func LeapYear(Y); \Return 'true' if Y is a leap year int Y; [if rem(Y/100)=0 then return rem(Y/400)=0; return rem(Y/4)=0; ];</lang>
Yorick
This solution is vectorized and can be applied to scalar or array input. <lang yorick>func is_leap(y) {
return ((y % 4 == 0) & (y % 100 != 0)) | (y % 400 == 0);
}</lang> Interactive example usage:
> is_leap(1988) 1 > is_leap([1988,1989,1900,2000]) [1,0,0,1]
- Programming Tasks
- Date and time
- ActionScript
- Ada
- ALGOL 68
- AppleScript
- AutoHotkey
- AutoIt
- AWK
- BASIC
- BBC BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- COBOL
- Common Lisp
- Component Pascal
- D
- Delphi
- Pascal
- DWScript
- Ela
- Erlang
- Euphoria
- Excel
- F Sharp
- Factor
- Forth
- Fortran
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- K
- Liberty BASIC
- Logo
- Logtalk
- Lua
- Mathematica
- MATLAB
- Octave
- Maxima
- МК-61/52
- MUMPS
- Nemerle
- NetRexx
- Oberon-2
- Objeck
- OCaml
- OoRexx
- OpenEdge/Progress
- Oz
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PostScript
- PowerShell
- Prolog
- PureBasic
- Python
- R
- Racket
- Raven
- REBOL
- Retro
- REXX
- Ruby
- Run BASIC
- Scala
- Scheme
- Seed7
- SNOBOL4
- Tcl
- TUSCRIPT
- UNIX Shell
- UNIX Shell examples needing attention
- Examples needing attention
- Vala
- Vedit macro language
- X86 Assembly
- XPL0
- Yorick
- GUISS/Omit