Long year: Difference between revisions

{{trans|C++}}

 

F p(year)

R (year + (year I/ 4) - (year I/ 100) + (year I/ 400)) % 7

L(year) 2000..2100

I is_long_year(year)

 

{{out}}

 

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

RETURN ((y+(y/4)-(y/100)+(y/400)) MOD 7)

 

 

LMARGIN=oldLMARGIN ;restore left margin on the screen

{{out}}

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

=={{header|Ada}}==

The Ada calendar package handles dates for years 1901 through 2399. This program outputs all the long years within that range.

-- Calculate long years

-- Reference: https://en.wikipedia.org/wiki/ISO_week_date#Weeks_per_year

end loop;

end Main;

{{output}}

<pre>

=={{header|ALGOL 68}}==

{{Trans|ALGOL W}}

# finding years where 1st Jan or 31st Dec are Thursdays #

# returns the day of the week of the specified date (d/m/y), Sunday = 1 #

IF is long year( year ) THEN print( ( " ", whole( year, 0 ) ) ) FI

OD

{{out}}

<pre>

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

 

 

COMMENT

 

END

{{output}}

<pre>

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

Uses the Day_of_week procedure from the Day_of_the_week task.

% this is equivalent to finding years where %

% 1st Jan or 31st Dec are Thursdays %

if isLongYear( year ) then writeon( I_W := 5, S_W := 0, year )

end for_year

{{out}}

<pre>

long years 2000-2099: 2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099

</pre>

 

=={{header|APL}}==

 

{{Out}}

1801 1807 1812 1818 1824 1829 1835 1840 1846 1852 1857 1863 1868 1874 1880 1885

1891 1896 1903 1908 1914 1920 1925 1931 1936 1942 1948 1953 1959 1964

=={{header|AppleScript}}==

 

-- ISO8601 weeks begin on Mondays and belong to the year in which they have the most days.

-- A year which begins on a Thursday, or which begins on a Wednesday and is a leap year,

end repeat

 

 

{{output}}

On the other hand, since the cycle repeats every 400 years, it's possible to cheat with a precalculated look-up list:

 

return (y mod 400 is in {4, 9, 15, 20, 26, 32, 37, 43, 48, 54, 60, 65, 71, 76, 82, 88, 93, 99, 105, 111, 116, 122, 128, 133, 139, 144, 150, 156, 161, 167, 172, 178, 184, 189, 195, 201, 207, 212, 218, 224, 229, 235, 240, 246, 252, 257, 263, 268, 274, 280, 285, 291, 296, 303, 308, 314, 320, 325, 331, 336, 342, 348, 353, 359, 364, 370, 376, 381, 387, 392, 398})

end isLongYear

end repeat

 

 

=={{header|Arturo}}==

{{trans|Nim}}

 

date: to :date .format: "dd/MM/yyyy" ~"01/01/|year|"

 

 

print "Years with 53 weeks between 2000 and 2100:"

 

{{out}}

 

=={{header|AutoHotkey}}==

A := Mod(y + floor(y/4) - floor(y/100) + floor(y/400), 7)

y--, B := Mod(y + floor(y/4) - floor(y/100) + floor(y/400), 7)

return A=4 || B=3

y := 1999+A_Index

res .= Long_year(y) ? Y " ": ""

}

MsgBox % "Long Years 2000-2100 : " res

{{out}}

<pre>Long Years 2000-2100 : 2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099 </pre>

 

=={{header|AWK}}==

# syntax: GAWK -f LONG_YEAR.AWK

BEGIN {

return(0)

}

{{out}}

<pre>

 

 

return (y + int(y/4) - int(y/100) + int(y/400)) mod 7

end function

if isLongYear(y) then print y

next y

{{out}}

<pre>2004

2099</pre>

 

{{works with|BBC BASIC for Windows}}

 

REM The function as per specification.

NEXT

PRINT

{{out}}

<pre>

The long years between 2100 and 2200 are 2105 2111 2116 2122 2128 2133 2139 2144 2150 2156 2161 2167 2172 2178 2184 2189 2195

</pre>

 

=={{header|BCPL}}==

 

let p(y) = (y + y/4 - y/100 + y/400) rem 7

let start() be

for y = 2000 to 2100

{{out}}

<pre>2004

 

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

using System.Collections.Generic;

using System.Linq;

}

{{out}}

<pre>

 

=={{header|C}}==

#include <math.h>

 

printf("\n");

return 0;

 

{{out}}

 

=={{header|C++}}==

// https://en.wikipedia.org/wiki/ISO_week_date#Weeks_per_year

 

std::cout << '\n';

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(-> (java.time.LocalDate/of year 12 28)

(.get (.weekOfYear (java.time.temporal.WeekFields/ISO)))

(= 53)))

 

{{out}}

<pre>

</pre>

 

 

 

 

 

 

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

(mod (+ year (floor year 4) (- (floor year 100)) (floor year 400)) 7))

 

 

(format t "Long years between 1800 and 2100:~&~a~%"

 

{{Out}}

1970 1976 1981 1987 1992 1998 2004 2009 2015 2020 2026 2032 2037 2043 2048

2054 2060 2065 2071 2076 2082 2088 2093 2099)</pre>

 

=={{header|Dc}}==

{{trans|Tcl}}

{{works with|GNU dc|1.3.95}}

[1q]s1

[1r- r 1r- * 1r-]sO # O = logical OR

[Long years between 1800 and 2100:]P AP

1800 2100 lDx

 

{{out}}

Note: The Library '''System.DateUtils''' implement a '''WeeksInYear''',but not working, return 52 always.

{{Trans|C++}}

program Long_year;

 

Readln;

end.

 

=={{header|Elixir}}==

def long_year?(y) do

{:ok, jan1} = Date.new(y,1,1)

end

 

 

{{Out}}

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

 

: long-year? ( n -- ? ) 12 28 <date> week-number 53 = ;

 

"Year Long?\n-----------" print 1990 2021 [a,b]

{{out}}

<pre style="height:45ex">

 

=={{header|Forth}}==

: long? ( year -- flag ) dup dec31wd 4 = if drop 1 else 1 - dec31wd 3 = if 1 else 0 then then ;

 

{{Out}}

 

=={{header|Fortran}}==

program longyear

use iso_fortran_env, only: output_unit, input_unit

end function is_long_year

end program longyear

 

{{out}}

2026 2032 2037 2043 2048 2054 2060 2065 2071 2076

2082 2088 2093 2099 %

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println(longYears)

}

 

{{out}}

[2105 2111 2116 2122 2128 2133 2139 2144 2150 2156 2161 2167 2172 2178 2184 2189 2195]

</pre>

 

=={{header|Haskell}}==

import Data.Time.Calendar.WeekDate (toWeekDate)

 

 

main :: IO ()

{{Out}}

<pre>2004

2093

2099</pre>

 

=={{header|J}}==

{{trans|C}}

ily =: (4=p) +. 3=p@:<:

{{out}}

<pre>

=={{header|Java}}==

 

import java.time.LocalDate;

import java.time.temporal.WeekFields;

 

}

 

{{out}}

=={{header|JavaScript}}==

{{trans|TypeScript}}

const jan1 = new Date(year, 0, 1);

const dec31 = new Date(year, 11, 31);

console.log(y)

}

 

{{Out}}

 

===Using Zeller's congruence===

# Use Zeller's Congruence to determine the day of the week, given

# year, month and day as integers in the conventional way.

 

"Long years from 1900 to 2100 inclusive:",

{{out}}

<pre>

 

===Using mktime and gmtime===

# with 0 for Sunday, 1 for Monday, etc

# $year $month $day are conventional

 

"Long years from 1900 to 2100 inclusive:",

{{out}}

As above.

 

=={{header|Julia}}==

 

has53weeks(year) = week(Date(year, 12, 28)) == 53

println(year, " ", has53weeks(year) ? "Yes" : "No")

end

<pre>

Year 53 weeks?

 

=={{header|Kotlin}}==

fun main() {

val has53Weeks = { year: Int -> LocalDate.of(year, 12, 28).get(WeekFields.ISO.weekOfYear()) == 53 }

.forEach { year -> print("$year ")}

}

{{out}}

<pre style="height35ex">

 

 

 

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

lastyear = 2099;

years = Range[firstyear, lastyear];

If[firstday[[n]] == Thursday || lastday[[n]] == Thursday,

Style[years[[n]] " long year \n", Bold, Red] ,

{{out}}

<pre style="height:35ex">{2000 short

 

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

FROM InOut IMPORT WriteCard, WriteLn;

 

END;

END;

{{out}}

<pre>2004

 

=={{header|Nim}}==

 

proc has53weeks(year: Positive): bool =

for year in 2000..2100:

if year.has53weeks:

 

{{out}}

 

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

/ [x] - ИП0 4 ВП 2 / [x] +

^ ^ 7 / [x] 7 * - П1 4

- x#0 40 ИП1 3 - x#0 40 0 С/П

{{out}}

<pre>

</pre>

=={{header|Pascal}}==

var

y: integer;

if long_year(y) then

writeln(y)

{{Out}}

<pre>1993

==={{header|Free Pascal}}===

Using DateUtils and WeeksInYear to not reinvent this.

program Long_year;

 

Readln;

{$ENDIF}

{{out}}

<pre>

 

=={{header|Perl}}==

use warnings;

use DateTime;

}

print "\n";

{{out}}

<pre>1903 1908 1914 1920 1925 1931 1936 1942 1948 1953 1959 1964 1970 1976 1981 1987 1992 1998

 

=={{header|Phix}}==

{{out}}

<pre>

Long years in the 22nd century:{2105,2111,2116,2122,2128,2133,2139,2144,2150,2156,2161,2167,2172,2178,2184,2189,2195}

</pre>

 

=={{header|PHP}}==

return (53 == strftime('%V', gmmktime(0,0,0,12,28,$year)));

}

printf("%s\n", $y);

}

{{Out}}

<pre>1998

2037

2043</pre>

 

=={{header|PowerShell}}==

param([Int]$year)

53 -eq (Get-Date -Year $year -Month 12 -Day 28 -UFormat %V)

Write-Host $y

}

 

{{Out}}

{{trans|C++}}

{{works with|SWI Prolog}}

 

p(Year, P):-

 

main:-

 

{{out}}

2082 2088 2093 2099

</pre>

 

=={{header|Python}}==

{{Works with|Python|3.7}}

 

from datetime import date

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>2004

<code>dayofweek</code> is defined at [[Day of the week#Quackery]]

 

[ 1 1 rot dayofweek 4 = ]

31 12 rot dayofweek 4 = or ] is longyear ( n --> b )

100 times

[ 2000 i^ + longyear if

 

{{out}}

2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099 </pre>

 

 

=={{header|Raku}}==

{{works with|Rakudo|2019.11}}

December 28 is always in the last week of the year. (By ISO8601)

 

# Testing

say "Long years in the 20th century:\n", (1900..^2000).grep: &is-long;

say "\nLong years in the 21st century:\n", (2000..^2100).grep: &is-long;

{{out}}

<pre>Long years in the 20th century:

 

=={{header|REXX}}==

 

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> 1990 &nbsp; 2030 </tt>}}

 

 

=={{header|Ring}}==

see "long years 2000-2099: "

for year = 2000 to 2100

ok

next

{{out}}

<pre>

long years 2000-2099: 2004 2009 2015 2020 2026 2032 2037 2043 2048 2054 2060 2065 2071 2076 2082 2088 2093 2099

</pre>

 

=={{header|Ruby}}==

require 'date'

 

 

(2020..2030).each{|year| puts "#{year} is long? #{ long_year?(year) }." }

{{out}}

<pre>2020 is long? true.

=={{header|Rust}}==

 

 

use time::Date;

Date::try_from_ymd(year, 12, 28).map_or(false, |date| date.week() == 53)

}

{{out}}

<pre>

2093

2099

</pre>

 

{{Out}}Best seen running in your browser by [https://scastie.scala-lang.org/LDKMJ29SSrehyVbCmiMH1Q Scastie (remote JVM)].

 

import java.time.temporal.{ChronoField, IsoFields}

import java.time.{DayOfWeek, LocalDate, Month}

results.zipWithIndex.foreach(solution => println(s"Solution ${solution._2}: ${solution._1.mkString(" ")}"))

 

 

=={{header|Scheme}}==

The demo code uses <tt>iota</tt> as defined in SRFI-1, so won't work in Schemes lacking that function. Racket requires the addition of <tt>(require srfi/1)</tt>.

 

(remainder (apply + (map (lambda (d) (quotient year d)) '(1 4 -100 400))) 7))

 

 

(display "Long years between 1800 and 2100:") (newline)

 

{{Out}}

 

=={{header|Sidef}}==

Date.parse("#{year}-12-28", "%Y-%m-%d").week == 53

}

say ( "Long years in the 20th century:\n", (1900..^2000).grep(is_long_year))

say ("\nLong years in the 21st century:\n", (2000..^2100).grep(is_long_year))

{{out}}

<pre>

 

=={{header|Snobol}}==

DEC31WD DEC31WD = REMDR(Year + (Year / 4) - (Year / 100) + (Year / 400), 7) :(RETURN)

END_DEC31WD

 

END_ISOLONG

 

 

{{Out}}

2004

2009

 

=={{header|Swift}}==

let year1 = year - 1

let p = (year + (year / 4) - (year / 100) + (year / 400)) % 7

for range in [1900...1999, 2000...2099, 2100...2199] {

print("\(range): \(range.filter(isLongYear))")

 

{{out}}

 

{{trans|C++}}

## Reference: https://en.wikipedia.org/wiki/ISO_week_date#Weeks_per_year

 

puts "Long years between 1800 and 2100:"

print_long_years 1800 2100

{{out}}

<pre>

 

=={{header|Terraform}}==

Contents of main module:

 

source = "./iso-long-years"

start_year = 1995

output "long-years" {

value = module.iso-long-years.long-years

 

Contents of <tt>iso-long-years</tt> module:

 

type = number

}

value = compact([for y in [for n in local.year_list: tostring(n)]:

module.iso-long-year[y].isLong ? y : ""])

 

Contents of <tt>iso-long-year</tt> module:

 

type = string

}

 

output isLong {

value = (local.dec31 % 7 == 4 || local.jan1 % 7 == 4)

 

{{Out}}

"2043",

]</pre>

=={{header|TypeScript}}==

const jan1: Date = new Date(year, 0, 1);

const dec31: Date = new Date(year, 11, 31);

console.log(y)

}

 

{{Out}}

 

=== Thursdays check using cal(1) and grep(1) ===

cal 1 $1 | grep -q ' 3 *$' && return 0

cal 12 $1 | grep -q ' 26 *$'

 

=== Straightforward check using GNU date(1) ===

expr $(date -d "$1-12-28" +%V) = 53 >/dev/null

 

=== Direct computation with built-in arithmetic in newer shells ===

{{works with|Korn Shell}}

{{works with|Zsh}}

typeset -i y=$1

echo $(( (y + y / 4 - y / 100 + y / 400) % 7 ))

}

 

long_year() {

typeset -i y=$1

 

Demo code for any of the above:

 

if long_year $y; then

echo $y

fi

done | column

 

{{Out}}

<pre>1998 2004 2009 2015 2020 2026 2032 2037 2043</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-date}}

 

var centuries = ["20th", "21st", "22nd"]

}

System.print(longYears)

 

{{out}}

</pre>

 

 

 

{{out}}

<pre>

</pre>

 

=={{header|zkl}}==

foreach nm,y in (T(T("20th",1900), T("21st",2000), T("22nd",2100))){

println("\nLong years in the %s century:\n%s".fmt(nm,

[y..y+99].filter(isLongYear).concat(" ")));

{{out}}

<pre>