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|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}}==

∇

 

=={{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|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}}==

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}}===

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

DEF FN Is%(y$)

END DEF Is%

ctrl+space

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

1600 0

1700 1

</pre>

 

 

 

 

{{out}}

</pre>

 

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

 

::The Main Thing...

echo %year% is NOT a leap year.

goto :EOF

{{out}}

<pre>1900 is NOT a leap year.

Press any key to continue . . .</pre>

 

 

=={{header|Befunge}}==

{{trans|C}}

 

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

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

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

 

{{out}}

1997 is not a leap year.

2000 is a leap year.</pre>

 

=={{header|Bracmat}}==

=

. mod$(!arg.100):0

)

)

{{out}}

<pre>1600 is a leap year

 

=={{header|C}}==

 

{

}

 

{

}

{{out}}

<pre>

1997 is not a leap year.

2000 is a leap year.

</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|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|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}}

 

<pre>true</pre>

 

=={{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}}

2012 Leap Year

</pre>

 

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

2008

2012</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}}==

 

 

=={{header|Kotlin}}==

 

=={{header|Lasso}}==

#y % 400 == 0 ? return true

#y % 100 == 0 ? return false

isLeapYear(#test)

'\r'

 

{{out}}

true</pre>

 

 

=={{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;

 

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)

# or

 

if year mod 100 == 0:

year mod 400 == 0

else: year mod 4 == 0

 

{{out}}

<pre>true

true</pre>

 

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

PROCEDURE IsLeapYear(year: INTEGER): BOOLEAN;

BEGIN

END

END IsLeapYear;

 

=={{header|Objeck}}==

class LeapYear {

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

}

}

 

=={{header|OCaml}}==

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:

 

=={{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|PicoLisp}}==

{{out}}

<pre>: (isLeapYear 2010)

: (isLeapYear 1700)

-> NIL</pre>

 

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

dcl year fixed bin (31);

 

else

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

 

{{out}}

2000 is a leap year

2001 is not a leap year

</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|Python}}==

or

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|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|Rust}}==

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

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

 

=={{header|Scala}}==

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

0: 1900

1: 2000</pre>

 

=={{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}}==

}

 

{{out}}

</pre>

 

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

</pre>

 

 

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;

 

 

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}}==

<pre>

</pre>

 

=={{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|WDTE}}==

 

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

multiple 4 => '';

default => ' not';

 

=={{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|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)

> is_leap([1988,1989,1900,2000])

[1,0,0,1]</pre>

 

=={{header|zkl}}==

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

 

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