Leap year: Difference between revisions

{{trans|Python}}

 

I year % 100 == 0

R year % 400 == 0

 

=={{header|360 Assembly}}==

When R15 = zero, the year is a leap year.

Otherwise it is not.

LPCK CSECT

USING LPCK,15

BR 14

END

 

Sample invocation from a COBOL program:

=={{header|68000 Assembly}}==

 

move.l #2018,d0

bsr leap_year

moveq.l #0,d1

rts

 

=={{header|8080 Assembly}}==

 

jmp test

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

jmp 5

no: db 'NOT '

 

 

=={{header|Action!}}==

IF year MOD 100=0 THEN

IF year MOD 400=0 THEN

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Leap_year.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

if (year % 100 == 0) {

return (year % 400 == 0);

}

return (year % 4 == 0);

 

=={{header|Ada}}==

-- Adjust the type of Year if you use a different one.

function Is_Leap_Year (Year : Integer) return Boolean is

 

-- To improve speed a bit more, use with

 

=={{header|ALGOL 60}}==

{{works with|A60}}

integer year;

 

if isLeapYear(year) then outstring(1,"True\n") else outstring(1, "False\n")

end for year

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format''ted transput}}

PROC year days = (YEAR year)DAY: # Ignore 1752 CE for the moment #

printf(($g(0)" is "b("","not ")"a leap year."l$, year, is leap year(year)))

OD

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% returns true if year is a leap year, false otherwise %

% assumes year is in the Gregorian Calendar %

)

end for_year

 

=={{header|ALGOL-M}}==

BEGIN

 

 

END

{{out}}

<pre>

=={{header|APL}}==

Returns 1 if leap year, 0 otherwise:

∇ z←Leap year

Z←(0=4|year)∧(0=400|year)∨~0=100|year

∇

A much neater version of the above relies on the fact that every rule is an exception the the previous one:

∇ z←Leap year

z←0≠.=400 100 4∘.|year

∇

This essentially works by running an XOR reduction over the divisibility by 4, 100, and 400. Some APL implementations support tacit (a.k.a. points-free) programming:

Leap←0≠.=400 100 4∘.|⊢

Dyalog APL version 18.0 added a built-in date-time function:

Leap←0⎕DT,∘2 29¨

This works by extending the year to February 29 of that year, and then checking if the date is valid.

 

With any of the above definitions, no loop is necessary to check each year of an array:

Leap 1899 1900 1901 1902 1903 1904 1905 1999 2000 2001 2002 2003 2004

{{out}}

0 0 0 0 0 1 0 0 1 0 0 0 1

 

=={{header|AppleScript}}==

return y mod 4 is equal to 0 and (y mod 100 is not equal to 0 or y mod 400 is equal to 0)

end leap_year

 

 

=={{header|Arc}}==

(= leap? (fn (year)

(if (and (is 0 (mod year 4)) (isnt 0 (mod year 100))) year

(unless (< 0 (+ (mod year 100) (mod year 400))) year))))

<b>Output:</b>

(map [leap? _] '(1900 1904 2000 2019 2020 2100))

;; => '( 1904 2000 2020 )

 

=={{header|Arturo}}==

1600 1660 1724 1788 1848 1912 1972

2032 2092 2156 2220 2280 2344 2348

]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

{

if (Mod(year, 100) = 0)

}

 

{{out}}

<pre>Returns 1 if year is a leap year</pre>

or

{

return !Mod(Year, 4) && Mod(Year, 100) || !Mod(Year, 400)

}

 

{{out}}

<pre>The year 1600 was a leap year

 

=={{header|AutoIt}}==

$Year = 2012

$sNot = " not"

 

; == But it exists the standard UDF "Date.au3" with this function: "_IsLeapYear($Year)"

{{out}}

<pre>

 

=={{header|AWK}}==

{

if ( year % 100 == 0 )

else

return ( year % 4 == 0 )

 

=={{header|Bash}}==

#!/bin/bash

 

# Save the above to a file named is_leap_year.sh, then issue the following command to run the 5 tests of the function

# bash is_leap_year.sh

 

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

A one-liner combination from the [[#Commodore_BASIC|Commodore BASIC]] and [[#GW_BASIC|GW-BASIC]] solutions.

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

function leapyear(year_)

if (year_ mod 4) <> 0 then return FALSE

if (year_ mod 4) = 3 then print ""

next year_

 

 

==={{header|BBC BASIC}}===

INPUT "Enter a year: " year%

IF FNleap(year%) THEN

DEF FNleap(yr%)

 

Much quicker without full evaluation:

 

IF yr% MOD 4 THEN =FALSE

IF yr% MOD 400 ELSE =TRUE

IF yr% MOD 100 ELSE =FALSE

 

==={{header|Commodore BASIC}}===

An old-timey solution:

 

Or, using Simons' BASIC's MOD function:

===={{header|Simons' BASIC}}====

 

==={{header|GW-BASIC}}===

Prints all the leap years from 1750 to 2021. Note the correct behaviour of 1800, 1900, and 2000.

20 GOSUB 1000

30 IF L = 1 THEN PRINT Y;" ";

1020 IF Y MOD 100 = 0 AND Y MOD 400 <> 0 THEN RETURN

1030 L = 1

{{out}}<pre>

1752 1756 1760 1764 1768 1772 1776 1780 1784 1788 1792 1796 1804 1808 1812 1816 1820 1824 1828

 

==={{header|IS-BASIC}}===

110 FOR I=1990 TO 2020

120 IF LEAPY(I) THEN

160 END IF

170 NEXT

 

==={{header|Sinclair ZX81 BASIC}}===

ZX81 BASIC does not support user-defined functions, even the single-expression functions that are provided by many contemporary dialects; so we have to fake it using a subroutine and pass everything in global variables.

An example showing how to call it:

20 GOSUB 5000

30 PRINT Y;" IS ";

40 IF NOT L THEN PRINT "NOT ";

50 PRINT "A LEAP YEAR."

 

==={{Header|Tiny BASIC}}===

REM by Jjuanhdez, 06/2022

 

110 IF (Y - (Y / 400) * 400) <> 0 THEN GOTO 120

LET L = 1

 

==={{header|ZX Spectrum Basic}}===

 

==={{header|QBasic}}===

Note that the <code>year%</code> function is not needed for most modern BASICs.

DECLARE FUNCTION isLeapYear% (yr AS INTEGER)

DECLARE FUNCTION year% (date AS STRING)

FUNCTION year% (date AS STRING)

year% = VAL(RIGHT$(date, 4))

 

==={{header|QL SuperBASIC}}===

AUTO

REM Is% a non-proleptic Gregorian year y$<=9999 leap (0) 0R ordinary (1)?

END DEF Is%

ctrl+space

using only power-of-2 divisions. N.B. the inverted logic brings home the BaCon code's flaw

{{output}}

==={{header|BaCon}}===

From the Ada shortcut calculation

FUNCTION leapyear(NUMBER y) TYPE NUMBER

RETURN IIF(MOD(y, 4) = 0, IIF(MOD(y, 16) = 0, IIF(MOD(y, 100) != 0, TRUE, FALSE), TRUE), FALSE)

WEND

 

 

{{out}}

 

=={{header|Batch File}}==

 

::The Main Thing...

echo %year% is NOT a leap year.

goto :EOF

{{out}}

<pre>1900 is NOT a leap year.

 

=={{header|BCPL}}==

 

let leap(year) = year rem 400 = 0 | (year rem 4 = 0 & year rem 100 ~= 0)

writef("%N %S a leap year.*N",

years!i, leap(years!i) -> "is", "is not")

{{out}}

<pre>1899 is not a leap year.

{{trans|C}}

 

v*%"d"\!%4::,,"is".:<|

>\45*:*%!+#v_ "ton"vv<

v"ear."+550<,,,,*84<$#

 

{{out}}

 

=={{header|Bracmat}}==

=

. mod$(!arg.100):0

)

)

{{out}}

<pre>1600 is a leap year

 

=={{header|C}}==

 

int is_leap_year(int year)

printf("%d is %sa leap year.\n", year, (is_leap_year(year) == 1 ? "" : "not "));

}

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

 

class Program

}

}

{{out}}

<pre>1900 is not a leap year.

Uses C++11. Compile with

g++ -std=c++11 leap_year.cpp

 

bool is_leap_year(int year) {

std::cout << year << (is_leap_year(year) ? " is" : " is not") << " a leap year.\n";

}

{{out}}

<pre>

 

=={{header|Clipper}}==

 

=={{header|Clojure}}==

 

=={{header|CLU}}==

return(year//400 =0 cor (year//4 = 0 cand year//100 ~= 0))

end is_leap_year

stream$putl(po, "a leap year.")

end

{{out}}

<pre>1899 is not a leap year.

 

=={{header|COBOL}}==

PROGRAM-ID. leap-year.

 

 

GOBACK

 

Using Date Intrinsic Functions

program-id. leap-yr.

*> Given a year, where 1601 <= year <= 9999

.

end program leap-yr.

{{out}}

<pre>

 

=={{header|Common Lisp}}==

(destructuring-bind (fh h f)

(mapcar #'(lambda (n) (zerop (mod year n))) '(400 100 4))

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE LeapYear;

IMPORT StdLog, Strings, Args;

END Do;

END LeapYear.

Execute: ^Q LeapYear.Do 2000 2004 2013~<br/>

{{out}}

=={{header|Crystal}}==

 

p Time.leap_year?(2021)

 

<pre>

 

=={{header|D}}==

 

bool leapYear(in uint y) pure nothrow {

1973, 2100, 2107, 2200, 2203, 2289];

assert(filter!leapYear(bad ~ good).equal(good));

 

 

Using the datetime library:

 

void main() {

assert(DateTime(2000, 1, 1).isLeapYear);

}

 

=={{header|Dart}}==

 

bool leapYear(num year) {

return (year % 400 == 0) || (( year % 100 != 0) && (year % 4 == 0));

// Source: https://api.flutter.dev/flutter/quiver.time/isLeapYear.html

}

 

=={{header|Dc}}==

Directly taken from Wikipedia.

{{works with|GNU dc}}

[1q]s1

 

1989 lTx

1900 lTx

{{out}}

<pre>

=={{header|Delphi}}/{{header|Pascal}}==

Delphi has standard function IsLeapYear in SysUtils unit.

 

{$APPTYPE CONSOLE}

Writeln(Year, ' is not a Leap year');

Readln;

 

=={{header|Draco}}==

year%400=0 or (year%4=0 and year%100/=0)

corp

"a leap year.")

od

{{out}}

<pre>1899 is not a leap year.

 

=={{header|DWScript}}==

begin

Result:= (y mod 4 = 0)

PrintLn('Checking non-leap years');

for i in bad do

 

=={{header|Dyalect}}==

 

if y % 100 == 0 {

y % 400 == 0

}

 

 

{{out}}

 

=={{header|Ela}}==

 

=={{header|Elixir}}==

 

{{out}}

=={{header|Emacs Lisp}}==

{{trans|Scheme}}

(apply (lambda (a b c) (or a (and (not b) c)))

(mapcar (lambda (n) (zerop (mod year n)))

 

=={{header|Erlang}}==

-module(gregorian).

-export([leap/1]).

 

leap( Year ) -> calendar:is_leap_year( Year ).

 

=={{header|ERRE}}==

 

FUNCTION LEAP(YR%)

END IF

END LOOP

 

=={{header|Euphoria}}==

return remainder(year,4)=0 and remainder(year,100)!=0 or remainder(year,400)=0

 

=={{header|Excel}}==

Take two cells, say A1 and B1, in B1 type in :

 

=IF(OR(NOT(MOD(A1,400)),AND(NOT(MOD(A1,4)),MOD(A1,100))),"Leap Year","Not a Leap Year")

 

{{out}}

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(y,

OR(

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

assert isLeapYear 1996

assert isLeapYear 2000

assert not (isLeapYear 2001)

 

=={{header|Factor}}==

Call ''leap-year?'' word from ''calendars'' vocabulary. For example:

Factor uses proleptic Gregorian calendar.

 

=={{header|Fermat}}==

 

=={{header|Forth}}==

dup 400 mod 0= if drop true exit then

dup 100 mod 0= if drop false exit then

 

Or more simply (but always computing three "mod"):

 

=={{header|Fortran}}==

implicit none

 

end function leap_year

{{out}}

<pre> F T F T </pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> 1800 is not a leap year

 

=={{header|FutureBasic}}==

 

// In-line C function to generate random number in range

next

 

 

Output (results will vary for random years):

 

=={{header|Gambas}}==

Dim dDate As Date

Dim siYear As Short = InputBox("Enter a year", "Leap year test")

Message(siYear & sMessage)

 

 

Output:

 

=={{header|GAP}}==

return (n mod 4 = 0) and ((n mod 100 <> 0) or (n mod 400 = 0));

end;

IsLeapYear := function(n)

return DaysInYear(n) = 366;

 

=={{header|Genie}}==

Dialect conversion from Vala entry.

 

/*

Leap year, in Genie

for year in years

status:string = year.is_leap_year() ? "" : "not "

 

{{out}}

 

=={{header|Go}}==

return year%400 == 0 || year%4 == 0 && year%100 != 0

 

=={{header|Groovy}}==

Solution:

{{out}}

<pre style="height:30ex;overflow:scroll;">1904

=={{header|GW-BASIC}}==

{{works with|PC-BASIC|any}}

10 ' Leap year

20 DEF FN ISLEAPYEAR(Y%) = ((Y% MOD 4 = 0) AND (Y% MOD 100 <> 0)) OR (Y% MOD 400 = 0)

160 END

200 DATA 1900, 1994, 1996, 1997, 2000

{{out}}

<pre>

 

=={{header|Harbour}}==

 

=={{header|Haskell}}==

'''Simple version'''

import Control.Monad

import Control.Arrow

 

isleapsf j | 0==j`mod`100 = 0 == j`mod`400

'''Algorithmic'''

Example using isleap

1900 is not a leap year

1994 is not a leap year

1996 is a leap year

1997 is not a leap year

 

'''TDD version'''

 

isLeapYear::Int->Bool

,TestCase $ assertEqual "64 is a leap year" True $ isLeapYear 64

,TestCase $ assertEqual "2000 is a leap year" True $ isLeapYear 2000

 

=={{header|Hy}}==

(and

(= (% y 4) 0)

(or

(!= (% y 100) 0)

 

=={{header|Icon}} and {{header|Unicon}}==

Gives leap year status for 2000,1900,2012 and any arguments you give

every y := !([2000,1900,2012]|||arglist) do

write("The year ",y," is ", leapyear(y) | "not ","a leap year.")

procedure leapyear(year) #: determine if year is leap

if (numeric(year) % 4 = 0 & year % 100 ~= 0) | (numeric(year) % 400 = 0) then return

 

=={{header|J}}==

Example use:

 

=={{header|Java}}==

Both values are printed in the output.

 

import java.text.MessageFormat;

 

}

 

{{out}}

<pre>The year 1800 is leaper: false / false.

{{works with|Java|8}}

 

 

public class IsLeap {

}

}

 

=={{header|JavaScript}}==

Or, by setting the day to the 29th and checking if the day remains

 

=={{header|jq}}==

{{trans|Julia}}

'''Examples''':

value as $value

| ($value|f) | if . then empty else error("assertion violation: \($value) => \(.)") end;

 

((2100, 2014, 1900, 1800, 1700, 1499) | assert(.; leap|not))

{{out}}

$ jq -n -f Leap_year.jq

{{works with|Julia|0.6}}

 

 

@assert all(isleap, [2400, 2012, 2000, 1600, 1500, 1400])

 

=={{header|K}}==

 

a@&leapyear'a:1900,1994,1996,1997,2000

 

=={{header|Kotlin}}==

 

=={{header|Lasso}}==

#y % 400 == 0 ? return true

#y % 100 == 0 ? return false

isLeapYear(#test)

'\r'

 

{{out}}

=={{header|Liberty BASIC}}==

=== Simple method ===

print "leap"

else

function leap(n)

leap=date$("2/29/";n)

 

=== Calculated method ===

select case

case year mod 400 = 0

else

print year;" is not a leap year."

 

=={{header|Lingo}}==

return date(year, 2, 29).month=2

 

=={{header|LiveCode}}==

return (year MOD 4 is 0) AND ((year MOD 400 is 0) OR (year MOD 100 is not 0))

end isLeapYear

1996 is true

1997 is false

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

 

attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }

{{out}}

<pre>1900 is not a leap year.

 

=={{header|Logo}}==

output equal? 0 modulo :n :d

end

to leapyear? :y

output ifelse multiple? :y 100 [multiple? :y 400] [multiple? :y 4]

 

=={{header|Logtalk}}==

( mod(Year, 4) =:= 0, mod(Year, 100) =\= 0 ->

true

; mod(Year, 400) =:= 0

 

=={{header|LOLCODE}}==

HAI 1.3

HOW IZ I Leap YR Year

 

KTHXBYE

{{Out}}

<pre>1900 is NOT a leap year

 

=={{header|Lua}}==

return year%4==0 and (year%100~=0 or year%400==0)

 

=={{header|Maple}}==

if not year mod 4 = 0 or (year mod 100 = 0 and not year mod 400 = 0) then

return false;

return true;

end if;

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Dates are handled by built-in functions in the Wolfram Language

 

=={{header|MATLAB}} / {{header|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.

TrueFalse = (eomday(year,2) == 29);

 

===Using Logical and modular functions===

 

=={{header|Maxima}}==

 

=={{header|Mercury}}==

 

is_leap_year(Year) :-

 

Usage:

 

:- interface.

 

write_year_kind(Year, !IO) :-

io.format("%d %s a leap year.\n",

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

=={{header|MiniScript}}==

return year%4==0 and (year % 100 or not year % 400)

 

=={{header|MIPS Assembly}}==

Pass year in a0, returns boolean in v0.

IsLeap: andi $a1, $a0, 3 #a0 is year to test

bnez $a1 NotLeap

NotLeap:li $v0, 0

jr $ra

 

=={{header|МК-61/52}}==

0 0 ПП 18 ИП0 4 ПП 18 / {x}

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

Print(2000);

ReadChar

 

=={{header|MUMPS}}==

Usage: <pre>USER>W $SELECT($$ILY^ROSETTA(1900):"Yes",1:"No")

No

=={{header|Nanoquery}}==

{{trans|Python}}

if (year % 100 = 0)

return (year % 400 = 0)

return (year % 4 = 0)

end

 

=={{header|Neko}}==

Translating from C

 

<doc><h2>Leap year, in Neko</h2></doc>

**/

var tests = $array(2000, 1997, 1996, 1994, 1990, 1980, 1900)

var cnt = $asize(tests)

 

{{out}}

=={{header|Nemerle}}==

Demonstrating implementation as well as use of standard library function.

using System.Console;

using Nemerle.Assertions;

DateTime.IsLeapYear(DateTime.Now.Year));

}

{{out}}

<pre>2000 is a leap year: True

prior to the Gregorian cut-over and leap-year rules in the Julian calendar

are different to those for the Gregorian calendar.

 

options replace format comments java crossref savelog symbols nobinary

 

method isFalse public constant binary returns boolean

{{out}}

<pre>

 

=={{header|Nim}}==

let year = 1980

echo isLeapYear(year)

else: year mod 4 == 0

 

{{out}}

<pre>true

 

=={{header|NS-HUBASIC}}==

20 IF A-(A/100)*100=0 AND A-(A/400)*400<>0 THEN RESULT$="NOT "

 

=={{header|Oberon-2}}==

PROCEDURE IsLeapYear(year: INTEGER): BOOLEAN;

BEGIN

END

END IsLeapYear;

 

=={{header|Objeck}}==

class LeapYear {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

if (year mod 100) = 0

then (year mod 400) = 0

Using Unix Time functions:

let tm =

Unix.mktime {

}

in

 

=={{header|Oforth}}==

 

 

=={{header|ooRexx}}==

::routine isLeapYear

use arg year

d = .datetime~new(year, 1, 1)

return d~isLeapYear

 

=={{header|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.

i_iyear AS INTEGER

):

1997 isLeapYear( 1997 ) SKIP

2000 isLeapYear( 2000 )

 

=={{header|Oz}}==

fun {IsLeapYear Year}

case Year mod 100 of 0 then

{System.showInfo Y#" is NOT a leap year."}

end

{{out}}

<pre>1900 is NOT a leap year.

 

=={{header|PARI/GP}}==

if(n%400==0, return(1));

if(n%100==0, return(0));

n%4==0

 

Alternate version:

 

{{works with|PARI/GP|2.6.0 and above}}

if(n%4,0,

n%100,1,

n%400,0,1

)

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

uses

sysutils;//includes isLeapYear

TestYear(2100);

TestYear(1904);

Output:

<pre>1900 is NO leap year

 

=={{header|Perl}}==

my $year = shift;

if ($year % 100 == 0) {

}

return ($year % 4 == 0);

 

Or more concisely:

 

 

Alternatively, using functions/methods from CPAN modules:

 

print Date_LeapYear(2000);

 

use DateTime;

my $date = DateTime->new(year => 2000);

 

=={{header|Phix}}==

Available as an auto-include, implemented as:

<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">is_leap_year</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #0000FF;">(</span><span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">400</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

 

=={{header|PHP}}==

function isLeapYear($year) {

if ($year % 100 == 0) {

}

return ($year % 4 == 0);

With <code>date('L')</code>:

function isLeapYear($year) {

return (date('L', mktime(0, 0, 0, 2, 1, $year)) === '1')

 

=={{header|Picat}}==

foreach(Y in [1600,1700,1899,1900,2000,2006,2012])

println(Y=cond(leap_year(Y),leap_year,not_leap_year))

(Year mod 4 == 0, Year mod 100 != 0)

;

 

{{out}}

 

=={{header|PicoLisp}}==

{{out}}

<pre>: (isLeapYear 2010)

 

=={{header|PL/I}}==

dcl year fixed bin (31);

 

else

put skip edit(year, 'is not a leap year') (p'9999b', a);

 

{{out}}

 

=={{header|PL/M}}==

 

/* CP/M BDOS SYSTEM CALL */

END;

 

{{out}}

<pre>

 

=={{header|PostScript}}==

dup dup

4 mod 0 eq % needs to be divisible by 4

400 mod 0 eq % or by 400

or

 

=={{header|PowerShell}}==

 

=={{header|Prolog}}==

{{Works with|SWI-Prolog}}

partition(is_leap_year, L, LIn, LOut),

format('leap years : ~w~n', [LIn]),

R100 is Year mod 100,

R400 is Year mod 400,

{{out}}

leap years : [1996,2000]

not leap years : [1900,1994,1997]

 

There is an handy builtin that simplifies a lot, ending up in a simple query:

 

?- findall(Y, (between(1990,2030,Y),day_of_the_year(date(Y,12,31),366)), L).

L = [1992, 1996, 2000, 2004, 2008, 2012, 2016, 2020, 2024, 2028].

 

=={{header|PureBasic}}==

If (Year%4=0 And Year%100) Or Year%400=0

ProcedureReturn #True

ProcedureReturn #False

EndIf

 

=={{header|Python}}==

or

if year % 100 == 0:

return year % 400 == 0

Asking for forgiveness instead of permission:

 

def is_leap_year(year):

except ValueError:

return False

 

=={{header|Q}}==

 

=={{header|Quackery}}==

{{trans|Forth}}

dup 100 mod 0 = iff [ drop false ] done

 

=={{header|R}}==

ifelse(year%%100==0, year%%400==0, year%%4==0)

}

for (y in c(1900, 1994, 1996, 1997, 2000)) {

cat(y, ifelse(isLeapYear(y), "is", "isn't"), "a leap year.\n")

{{out}}

<pre>

 

=={{header|Racket}}==

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2010.07}}

In Rakudo 2010.07, <code>Date.is-leap-year</code> is implemented as

$y %% 4 and not $y %% 100 or $y %% 400

 

=={{header|Rapira}}==

if (year /% 100) = 0 then

return (year /% 400) = 0

fi

return (year /% 4) = 0

 

=={{header|Raven}}==

$year 100 % 0 = if

$year 400 % 0 =

 

=={{header|REBOL}}==

{Returns true if the specified year is a leap year; false otherwise.}

year [date! integer!]

div?: func [n] [zero? year // n]

to logic! any [all [div? 4 not div? 100] div? 400]

 

=={{header|Retro}}==

dup #400 mod n:zero? [ drop #-1 #0 ] [ #1 ] choose 0; drop

dup #100 mod n:zero? [ drop #0 #0 ] [ #1 ] choose 0; drop

 

=={{header|REXX}}==

===local variables===

 

===with short-circuit===

The REXX language doesn't support short-circuits, so here is a version that does a short-circuit.

if yr//4\==0 then return 0 /*Not ÷ by 4? Not a leap year.*/

 

===no local variables===

This version doesn't need a PROCEDURE to hide local variable(s) &nbsp; [because there aren't any local variables],

<br>but it does invoke the &nbsp; '''ARG''' &nbsp; BIF multiple times.

 

===handles 2 digit year===

<br>the current century is assumed &nbsp; (i.e., &nbsp; no ''year'' windowing).

<br><br>If a year below 100 is to be used, the year should have leading zeroes added (to make it four digits).

if y//4\==0 then return 0 /*Not ÷ by 4? Not a leap year.*/

if length(y)==2 then y=left(date('S'),2)y /*adjust for a 2─digit YY year.*/

 

=={{header|Ring}}==

give year

leap = isLeapYear(year)

but (year % 4) = 0 return true

else return false ok

 

=={{header|RPG}}==

{{works with|RPGIII|}}

 

C *ENTRY PLIST

C PARM YEAR 40 input (year)

C*

C DONE TAG

 

=={{header|Ruby}}==

 

 

The leap? method is aliased as gregorian_leap? And yes, there is a julian_leap? method.

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

let factor = |x| year % x == 0;

factor(4) && (!factor(100) || factor(400))

 

=={{header|S-BASIC}}==

Since S-BASIC has no MOD operator or function, we have to supply one.

rem - compute p mod q

function mod(p, q = integer) = integer

 

end

{{out}}

<pre>

By default, [http://docs.oracle.com/javase/7/docs/api/index.html?java/util/GregorianCalendar.html java.util.GregorianCalendar] switches from Julian calendar to Gregorian calendar at 15 October 1582.

 

 

===JDK 8===

Using JSR-310 java.time.

 

===Implementation===

For proleptic Gregorian calendar:

 

 

//or use Java's calendar class

c.setGregorianChange(new java.util.Date(Long.MinValue))

c.isLeapYear(year)

 

=={{header|Scheme}}==

(apply (lambda (a b c) (or a (and (not b) c)))

(map (lambda (m) (zero? (remainder n m)))

 

=={{header|Seed7}}==

This function is part of the "time.s7i" library. It returns TRUE if the year is a leap year in the Gregorian calendar.

Original source: [http://seed7.sourceforge.net/algorith/date.htm#isLeapYear]

 

=={{header|Sidef}}==

if (year %% 100) {

return (year %% 400);

}

return (year %% 4);

 

or a little bit simpler:

 

=={{header|Smalltalk}}==

Smalltalk has a built-in method named <tt>isLeapYear</tt>:

Date today isLeapYear.

 

=={{header|SNOBOL4}}==

Predicate leap( ) succeeds/fails, returns nil.

leap eq(remdr(yr,400),0) :s(return)

eq(remdr(yr,100),0) :s(freturn)

yr = '1900'; eval(test)

yr = '2000'; eval(test)

{{out}}

<pre>0: 1066

 

=={{header|Standard ML}}==

 

=={{header|Stata}}==

Given a dataset with a "year" variable, generate a variable "leap" which is 1 for a leap year, 0 otherwise.

 

 

See also the article '''[https://www.stata.com/support/faqs/data-management/leap-year-indicators/ How do I identify leap years in Stata?]''' by Nicholas J. Cox in Stata FAQ.

 

=={{header|Swift}}==

return year.isMultiple(of: 100) ? year.isMultiple(of: 400) : year.isMultiple(of: 4)

}

[1900, 1994, 1996, 1997, 2000].forEach { year in

print("\(year): \(isLeapYear(year: year) ? "YES" : "NO")")

{{out}}

<pre>1900: NO

=={{header|Tcl}}==

The "classic" modulo comparison:

return [expr {($year % 4 == 0) && (($year % 100 != 0) || ($year % 400 == 0))}]

}

isleap1 1989 ;# => 0

isleap1 1900 ;# => 0

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.)

return [expr {[clock format [clock scan "$year-02-29" -format "%Y-%m-%d"] -format "%m-%d"] eq "02-29"}]

}

isleap2 1989 ;# => 0

isleap2 1900 ;# => 0

 

=={{header|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"

{{out}}

<pre>

=={{header|uBasic/4tH}}==

{{trans|BBC BASIC}}

INPUT "Enter a year: "; y

IF FUNC(_FNleap(y)) THEN

 

_FNleap Param (1)

 

=={{header|UNIX Shell}}==

Original Bourne:

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;

 

Using GNU date(1):

date -d "$1-02-29" >/dev/null 2>&1;

 

Defining a bash function <tt>is_leap</tt> which accepts a YEAR argument, and uses no IO redirection, nor any extra processes.

local year=$(( 10#${1:?'Missing year'} ))

(( year % 4 == 0 && ( year % 100 != 0 || year % 400 == 0 ) )) && return 0

return 1

 

Using the cal command: ''(note that this invokes two processes with IO piped between them and is relatively heavyweight compared to the above shell functions: leap and is_leap)''

<!-- actually, it *is* correct for dates from 1752 and after. Since the Gregorian calendar didn't exist prior to that date,

it doesn't make sense to hold this task accountable for years prior -->

cal 02 $1 | grep -q 29

}

 

=={{header|Ursa}}==

This program takes a year as a command line argument.

set year (int args<1>)

if (= (mod year 4) 0)

else

out year " is not a leap year" endl console

Output in Bash:

<pre>$ ursa leapyear.u 1900

 

=={{header|Vala}}==

DateYear[] years = { 1900, 1994, 1996, 1997, 2000 };

foreach ( DateYear year in years ) {

print (@"$year is $(status)a leap year.\n");

}

{{out}}

<pre>

 

=={{header|VBA}}==

Leap_year = (Month(DateSerial(year, 2, 29)) = 2)

 

=={{header|VBScript}}==

Function IsLeapYear(yr)

IsLeapYear = False

End If

Next

 

{{Out}}

 

=={{header|Vedit macro language}}==

#2 = (#1 % 4 == 0) && ((#1 % 100 != 0) || (#1 % 400 == 0))

if (#2) {

Message(" is not leap year\n")

}

 

The following version requires Vedit 6.10 or later:

if (Is_Leap_Year(#1)) {

Message(" is leap year\n")

Message(" is not leap year\n")

}

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

Public Function IsLeapYear1(ByVal theYear As Integer) As Boolean

'this function utilizes documented behaviour of the built-in DateSerial function

IsLeapYear2 = IIf(theYear Mod 100 = 0, theYear Mod 400 = 0, theYear Mod 4 = 0)

End Function

Testing:

Sub Main()

'testing the above functions

Next i

End Sub

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

{{out}}

<pre>1900 is not a leap year.

 

=={{header|Vlang}}==

return year %400 ==0 || (year%4 ==0 && year%100!=0)

}

}

}

Returns:

<pre>1952

 

=={{header|WDTE}}==

 

let multiple of n => == (% n of) 0;

multiple 4 => '';

default => ' not';

 

=={{header|WebAssembly}}==

First, with syntactic sugar that allows us to put opcode arguments after the opcode itself:

;; function isLeapYear: returns 1 if its argument (e.g. 2004) is a leap year, 0 otherwise.

;; Returns year%4==0 and (year%100!=0 or year%400==0)

)

(export "isLeapYear" (func $isLeapYear))

 

And then the same code, without the syntactic sugar:

;; function isLeapYear: returns 1 if its argument (e.g. 2004) is a leap year, 0 otherwise.

;; Returns year%4==0 and (year%100!=0 or year%400==0)

)

(export "isLeapYear" (func $isLeapYear))

 

=={{header|Wortel}}==

isLeapYear !?{\~%%1H \~%%4H \~%%4}

!-isLeapYear @range[1900 2000]

Returns:

<pre>[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]</pre>

 

=={{header|Wren}}==

return ((y % 4 == 0) && (y % 100!= 0)) || (y % 400 == 0)

}

if (c % 15 == 0) System.print()

}

 

{{out}}

=={{header|X86 Assembly}}==

Using FASM syntax. Leaf function fits nicely into your program.

; Input year as signed dword in EAX

IsLeapYear:

.100:

test eax,11b

 

=={{header|XLISP}}==

(AND (= (MOD YEAR 4) 0) (OR (/= (MOD YEAR 100) 0) (= (MOD YEAR 400) 0))))

 

; Test the function

{{out}}

<pre>(#T #T () #T () () #T #T () #T)</pre>

 

=={{header|XPL0}}==

int Y;

[if rem(Y/100)=0 then return rem(Y/400)=0;

return rem(Y/4)=0;

 

 

=={{header|Yabasic}}==

if mod(year, 4) <> 0 then return false : fi

if mod(year, 100) = 0 and mod(year, 400) <> 0 then return false : fi

if mod(year, 4) = 3 then print : fi

next year

 

 

=={{header|Yorick}}==

This solution is vectorized and can be applied to scalar or array input.

return ((y % 4 == 0) & (y % 100 != 0)) | (y % 400 == 0);

Interactive example usage:

<pre>> is_leap(1988)

 

=={{header|zkl}}==

T(1988,1989,1900,2000).apply(Time.Date.isLeapYear)

 

{{omit from|GUISS|Only the operator can read the calendar}}