Five weekends: Difference between revisions

Added Easylang
m (→‎Run BASIC: fixed typo in section name)
(Added Easylang)
 
(191 intermediate revisions by 75 users not shown)
Line 1:
{{task|Date and time}}
[[Category:Puzzles]]
The month of October in 2010 has five Fridays, five Saturdays, and five Sundays.
 
 
'''The task'''
;Task:
# Write a program to show all months that have this same characteristic of five full weekends from the year 1900 through 2100 (Gregorian calendar).
# Show the ''number'' of months with this property (there should be 201).
# Show at least the first and last five dates, in order.
 
 
'''Algorithm suggestions'''
* Count the number of Fridays, Saturdays, and Sundays in every month.
* Find all of the 31-day months that begin on Friday.
 
 
'''Extra credit'''
 
Count and/or show all of the years which do not have at least one five-weekend month (there should be 29).
 
 
;Related tasks
* [[Day of the week]]
* [[Last Friday of each month]]
* [[Find last sunday of each month]]
<br><br>
 
=={{header|360 Assembly}}==
{{trans|Fortran}}
For maximum compatibility, this program uses only the basic instruction set (S/360)
and two ASSIST macros (XDECO, XPRNT) to keep the code as short as possible.
<syntaxhighlight lang="360asm">* Five weekends 31/05/2016
FIVEWEEK CSECT
USING FIVEWEEK,R13 base register
B 72(R15) skip savearea
DC 17F'0' savearea
STM R14,R12,12(R13) prolog
ST R13,4(R15) "
ST R15,8(R13) "
LR R13,R15 "
LM R10,R11,=AL8(0) nko=0; nok=0
LH R6,Y1 y=y1
LOOPY CH R6,Y2 do y=y1 to y2
BH ELOOPY
MVI YF,X'00' yf=0
LA R7,1 im=1
LOOPIM C R7,=F'7' do im=1 to 7
BH ELOOPIM
LR R1,R7 im
SLA R1,1 *2 (H)
LH R2,ML-2(R1) ml(im)
ST R2,M m=ml(im)
MVC D,=F'1' d=1
L R4,M m
C R4,=F'2' if m<=2
BH MSUP2
L R8,M m
LA R8,12(R8) mw=m+12
LR R9,R6 y
BCTR R9,0 yw=y-1
B EMSUP2
MSUP2 L R8,M mw=m
LR R9,R6 yw=y
EMSUP2 LR R4,R9 ym
SRDA R4,32 .
D R4,=F'100' yw/100
ST R5,J j=yw/100
ST R4,K k=yw//100
LR R4,R8 mw
LA R4,1(R4) mw+1
MH R4,=H'26' (mw+1)*26
SRDA R4,32 .
D R4,=F'10' (mw+1)*26/10
LR R2,R5 "
A R2,D d
A R2,K d+k
L R3,K k
SRA R3,2 k/4
AR R2,R3 (mw+1)*26/10+k/4
L R3,J j
SRA R3,2 j/4
AR R2,R3 (mw+1)*26/10+k/4+j/4
LA R5,5 5
M R4,J 5*j
AR R2,R5 (mw+1)*26/10+k/4+j/4
SRDA R2,32 .
D R2,=F'7' (d+(mw+1)*26/10+k+k/4+j/4+5*j)/7
C R2,=F'6' if dow=friday
BNE NOFRIDAY
XDECO R6,XDEC y
MVC PG+0(4),XDEC+8 output y
LR R1,R7 im
MH R1,=H'3' *3
LA R14,MN-3(R1) @mn(im)
MVC PG+5(3),0(R14) output mn(im)
XPRNT PG,8 print buffer
LA R11,1(R11) nok=nok+1
MVI YF,X'01' yf=1
NOFRIDAY LA R7,1(R7) im=im+1
B LOOPIM
ELOOPIM L R4,YF yf
CLI YF,X'00' if yf=0
BNE EYFNE0
LA R10,1(R10) nko=nko+1
EYFNE0 LA R6,1(R6) y=y+1
B LOOPY
ELOOPY XDECO R11,XDEC nok
MVC PG+0(4),XDEC+8 output nok
MVC PG+4(12),=C' occurrences'
XPRNT PG,80 print buffer
XDECO R10,XDEC nko
MVC PG+0(4),XDEC+8 output nko
MVC PG+4(33),=C' years with no five weekend month'
XPRNT PG,80 print buffer
L R13,4(0,R13) epilog
LM R14,R12,12(R13) "
XR R15,R15 "
BR R14 exit
Y1 DC H'1900' year start
Y2 DC H'2100' year stop
ML DC H'1',H'3',H'5',H'7',H'8',H'10',H'12'
MN DC C'jan',C'mar',C'may',C'jul',C'aug',C'oct',C'dec'
YF DS X year flag
M DS F month
D DS F day
J DS F j=yw/100
K DS F j=mod(yw,100)
PG DC CL80'....-' buffer
XDEC DS CL12 temp for XDECO
YREGS
END FIVEWEEK</syntaxhighlight>
{{out}}
<pre>
1901-mar
1902-aug
1903-may
1904-jan
1904-jul
1905-dec
1907-mar
1908-may
...
2094-jan
2094-oct
2095-jul
2097-mar
2098-aug
2099-may
2100-jan
2100-oct
201 occurrences
29 years with no five weekend month
</pre>
 
=={{header|Action!}}==
Day of the week is determined using [https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto.27s_methods Sakamoto] method.
<syntaxhighlight lang="action!">;https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto.27s_methods
BYTE FUNC DayOfWeek(INT y BYTE m,d) ;1<=m<=12, y>1752
BYTE ARRAY t=[0 3 2 5 0 3 5 1 4 6 2 4]
BYTE res
 
IF m<3 THEN
y==-1
FI
res=(y+y/4-y/100+y/400+t(m-1)+d) MOD 7
RETURN (res)
 
PROC Main()
BYTE ARRAY m31=[1 3 5 7 8 10 12]
INT ARRAY years(250)
BYTE ARRAY months(250)
INT y
BYTE i,m,mCount,yCount,found,c
 
mCount=0 yCount=0 c=0
FOR y=1900 TO 2100
DO
found=0
FOR i=0 TO 6
DO
m=m31(i)
IF DayOfWeek(y,m,1)=5 THEN
years(mCount)=y
months(mCount)=m
found=1
mCount==+1
FI
OD
IF found=0 THEN
yCount==+1
FI
OD
Print("5-weekend months in 1900-2100: ") PrintBE(mCount)
Print("non 5-weekend years in 1900-2100: ") PrintBE(yCount)
PutE()
 
FOR i=0 TO 4
DO
PrintI(years(i)) Put('/) PrintBE(months(i))
OD
PrintE("...")
FOR i=mCount-5 TO mCount-1
DO
PrintI(years(i)) Put('/) PrintBE(months(i))
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Five_weekends.png Screenshot from Atari 8-bit computer]
<pre>
5-weekend months in 1900-2100: 201
non 5-weekend years in 1900-2100: 29
 
1901/3
1902/8
1903/5
1904/1
1904/7
...
2097/3
2098/8
2099/5
2100/1
2100/10
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">
<lang Ada>
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Calendar.Formatting; use Ada.Calendar;
Line 39 ⟶ 249:
Put_Line ("Number of months:" & Integer'Image (Months));
end Five_Weekends;
</syntaxhighlight>
</lang>
{{out|Sample output:}}
<pre style="height:30ex;overflow:scroll">
1901 3
Line 246 ⟶ 456:
</pre>
 
=={{header|ALGOL 68}}==
{{trans|Fortran|Note: This specimen retains the original [[#Fortran|Fortran]] coding style. [http://rosettacode.org/mw/index.php?title=Five_weekends&action=historysubmit&diff=107850&oldid=107848 diff]}}
{{works with|ALGOL 68|Revision 1 - no extensions to language used.}}
{{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''.}}
<syntaxhighlight lang="algol68">five_weekends: BEGIN
INT m, year, nfives := 0, not5 := 0;
BOOL no5weekend;
MODE MONTH = STRUCT(
INT n,
[3]CHAR name
) # MODE MONTH #;
[]MONTH month = (
MONTH(13, "Jan"),
MONTH(3, "Mar"),
MONTH(5, "May"),
MONTH(7, "Jul"),
MONTH(8, "Aug"),
MONTH(10, "Oct"),
MONTH(12, "Dec")
);
FOR year FROM 1900 TO 2100 DO
IF year = 1905 THEN printf($"..."l$) FI;
no5weekend := TRUE;
FOR m TO UPB month DO
IF n OF month(m) = 13 THEN
IF day_of_week(1, n OF month(m), year-1) = 6 THEN
IF year<1905 OR year > 2096 THEN printf(($g, 5zl$, name OF month(m), year)) FI;
nfives +:= 1;
no5weekend := FALSE
FI
ELSE
IF day_of_week(1, n OF month(m), year) = 6 THEN
IF year<1905 OR year > 2096 THEN printf(($g, 5zl$, name OF month(m), year)) FI;
nfives +:= 1;
no5weekend := FALSE
FI
FI
OD;
IF no5weekend THEN not5 +:= 1 FI
OD;
printf(($g, g(0)l$, "Number of months with five weekends between 1900 and 2100 = ", nfives));
printf(($g, g(0)l$, "Number of years between 1900 and 2100 with no five weekend months = ", not5));
# contains #
PROC day_of_week = (INT d, m, y)INT: BEGIN
INT j, k;
j := y OVER 100;
k := y MOD 100;
(d + (m+1)*26 OVER 10 + k + k OVER 4 + j OVER 4 + 5*j) MOD 7
END # function day_of_week #;
SKIP
END # program five_weekends #</syntaxhighlight>
{{out}}
<pre>
Mar 1901
Aug 1902
May 1903
Jan 1904
Jul 1904
...
Mar 2097
Aug 2098
May 2099
Jan 2100
Oct 2100
Number of months with five weekends between 1900 and 2100 = 201
Number of years between 1900 and 2100 with no five weekend months = 29
</pre>
 
=={{header|Amazing Hopper}}==
<p>VERSION 1</p>
<syntaxhighlight lang="txt">
#include <jambo.h>
 
#context Obtiene suma de días de weekend
Args ( Domingo, Viernes, Sábado )
Not zero( Val( [3:end,Domingo] Of 'calendario' )), Get summatory
Not zero( Val( [3:end,Viernes] Of 'calendario' )), Get summatory, Add it
Not zero( Val( [3:end,Sábado ] Of 'calendario' )), Get summatory, Add it
Return\\
 
#define __PRNNL__ {"\n"}print
#synon __PRNNL__ *Print it
#defn Paralosdías(*) #GENCODE $$$*$$$ #ATCMLIST; #ENDGEN;
#enum 1,DOMINGO,6,VIERNES,7,SABADO
 
Main
Set stack 15
 
Init zero (calendario, candidato, total, columna)
/* Configura meses */
Meses={}, mes largo = {}
Let list ( Meses := "Enero ","Febrero ","Marzo ","Abril ","Mayo ",\
"Junio ","Julio ","Agosto ","Septiembre","Octubre ",\
"Noviembre ","Diciembre " )
Let list ( mes largo := 1, 3, 5, 7, 8, 10, 12 )
/* Busca los meses con weekend larguísimo */
Loop for (año = 1900, #( año <= 2100), ++año)
Loop for( i=1, #(i<=7), ++i)
Let ( calendario := Calendar( [i] Of 'mes largo' ---Backup to 'candidato'---,año,1) )
 
Para los días 'DOMINGO, VIERNES, SABADO' Obtiene suma de días de weekend
When ( Is equal to '15' ){
++total, Print (año," : ", [candidato] Of 'Meses'," | ")
When ( columna++ Is equal to '3' ) { Prnl, columna=0 }
}
Back
Back
Set ( Utf8("\nTotal de años con weekend de 5 días = "), total ), and Print it
End
 
Subrutines
</syntaxhighlight>
{{out}}
<pre>
1901 : Marzo | 1902 : Agosto | 1903 : Mayo | 1904 : Enero |
1904 : Julio | 1905 : Diciembre | 1907 : Marzo | 1908 : Mayo |
1909 : Enero | 1909 : Octubre | 1910 : Julio | 1911 : Diciembre |
1912 : Marzo | 1913 : Agosto | 1914 : Mayo | 1915 : Enero |
1915 : Octubre | 1916 : Diciembre | 1918 : Marzo | 1919 : Agosto |
1920 : Octubre | 1921 : Julio | 1922 : Diciembre | 1924 : Agosto |
1925 : Mayo | 1926 : Enero | 1926 : Octubre | 1927 : Julio |
1929 : Marzo | 1930 : Agosto | 1931 : Mayo | 1932 : Enero |
1932 : Julio | 1933 : Diciembre | 1935 : Marzo | 1936 : Mayo |
1937 : Enero | 1937 : Octubre | 1938 : Julio | 1939 : Diciembre |
1940 : Marzo | 1941 : Agosto | 1942 : Mayo | 1943 : Enero |
1943 : Octubre | 1944 : Diciembre | 1946 : Marzo | 1947 : Agosto |
1948 : Octubre | 1949 : Julio | 1950 : Diciembre | 1952 : Agosto |
1953 : Mayo | 1954 : Enero | 1954 : Octubre | 1955 : Julio |
1957 : Marzo | 1958 : Agosto | 1959 : Mayo | 1960 : Enero |
1960 : Julio | 1961 : Diciembre | 1963 : Marzo | 1964 : Mayo |
1965 : Enero | 1965 : Octubre | 1966 : Julio | 1967 : Diciembre |
1968 : Marzo | 1969 : Agosto | 1970 : Mayo | 1971 : Enero |
1971 : Octubre | 1972 : Diciembre | 1974 : Marzo | 1975 : Agosto |
1976 : Octubre | 1977 : Julio | 1978 : Diciembre | 1980 : Agosto |
1981 : Mayo | 1982 : Enero | 1982 : Octubre | 1983 : Julio |
1985 : Marzo | 1986 : Agosto | 1987 : Mayo | 1988 : Enero |
1988 : Julio | 1989 : Diciembre | 1991 : Marzo | 1992 : Mayo |
1993 : Enero | 1993 : Octubre | 1994 : Julio | 1995 : Diciembre |
1996 : Marzo | 1997 : Agosto | 1998 : Mayo | 1999 : Enero |
1999 : Octubre | 2000 : Diciembre | 2002 : Marzo | 2003 : Agosto |
2004 : Octubre | 2005 : Julio | 2006 : Diciembre | 2008 : Agosto |
2009 : Mayo | 2010 : Enero | 2010 : Octubre | 2011 : Julio |
2013 : Marzo | 2014 : Agosto | 2015 : Mayo | 2016 : Enero |
2016 : Julio | 2017 : Diciembre | 2019 : Marzo | 2020 : Mayo |
2021 : Enero | 2021 : Octubre | 2022 : Julio | 2023 : Diciembre |
2024 : Marzo | 2025 : Agosto | 2026 : Mayo | 2027 : Enero |
2027 : Octubre | 2028 : Diciembre | 2030 : Marzo | 2031 : Agosto |
2032 : Octubre | 2033 : Julio | 2034 : Diciembre | 2036 : Agosto |
2037 : Mayo | 2038 : Enero | 2038 : Octubre | 2039 : Julio |
2041 : Marzo | 2042 : Agosto | 2043 : Mayo | 2044 : Enero |
2044 : Julio | 2045 : Diciembre | 2047 : Marzo | 2048 : Mayo |
2049 : Enero | 2049 : Octubre | 2050 : Julio | 2051 : Diciembre |
2052 : Marzo | 2053 : Agosto | 2054 : Mayo | 2055 : Enero |
2055 : Octubre | 2056 : Diciembre | 2058 : Marzo | 2059 : Agosto |
2060 : Octubre | 2061 : Julio | 2062 : Diciembre | 2064 : Agosto |
2065 : Mayo | 2066 : Enero | 2066 : Octubre | 2067 : Julio |
2069 : Marzo | 2070 : Agosto | 2071 : Mayo | 2072 : Enero |
2072 : Julio | 2073 : Diciembre | 2075 : Marzo | 2076 : Mayo |
2077 : Enero | 2077 : Octubre | 2078 : Julio | 2079 : Diciembre |
2080 : Marzo | 2081 : Agosto | 2082 : Mayo | 2083 : Enero |
2083 : Octubre | 2084 : Diciembre | 2086 : Marzo | 2087 : Agosto |
2088 : Octubre | 2089 : Julio | 2090 : Diciembre | 2092 : Agosto |
2093 : Mayo | 2094 : Enero | 2094 : Octubre | 2095 : Julio |
2097 : Marzo | 2098 : Agosto | 2099 : Mayo | 2100 : Enero |
2100 : Octubre |
Total de años con weekend de 5 días = 201
</pre>
<p>VERSION 2</p>
<p>Esta versión genera el mismo resultado, sin hacer uso de la macro "calendar", con la diferencia que ahora le añadí el conteo de los días que no tienen el famoso "five weekend":</p>
<syntaxhighlight lang="txt">
#include <jambo.h>
 
#define __PRNNL__ {"\n"}print
#synon __PRNNL__ *Print it
#synon Set *Set
 
Main
Set stack 15
 
Init zero (candidato, total, sin weekend largo, sw, columna, fecha)
/* Configura meses */
mes largo = {}
Let list ( mes largo := 1, 3, 5, 7, 8, 10, 12 )
/* Busca los meses con weekend larguísimo */
Loop for (año = 1900, #( año <= 2100), ++año)
Loop for( i=1, #(i<=7), ++i)
 
Let ( candidato := [i] Of 'mes largo' )
Let ( fecha := Multicat ("1/",Str(candidato),"/",Str(año)) )
 
When ( Strday 'fecha' Is equal to '"Viernes"', \
And ( Days of month 'fecha' Compared to '31', Are equals? )) {
++total, sw=1
Print (año," : ", Just left (13, Month name 'candidato')," | ")
When ( columna++ Is equal to '3' ) { Prnl, columna=0 }
}
Back
When ( Not( sw ) ) { ++ sin weekend largo }, sw=0
Back
now Set ( Utf8("\nTotal de años con weekend de 5 días = "), total )
and Set ( Utf8("\nAños sin weekend de 5 días: "), sin weekend largo) then Print it
End
</syntaxhighlight>
{{out}}
<pre>
1901 : Marzo | 1902 : Agosto | 1903 : Mayo | 1904 : Enero |
1904 : Julio | 1905 : Diciembre | 1907 : Marzo | 1908 : Mayo |
...
2093 : Mayo | 2094 : Enero | 2094 : Octubre | 2095 : Julio |
2097 : Marzo | 2098 : Agosto | 2099 : Mayo | 2100 : Enero |
2100 : Octubre |
Total de años con weekend de 5 días = 201
Años sin weekend de 5 días: 29
 
</pre>
 
=={{header|AppleScript}}==
 
<lang AppleScript>set fiveWeekendMonths to {}
===Imperative===
 
<syntaxhighlight lang="applescript">set fiveWeekendMonths to {}
set noFiveWeekendYears to {}
 
Line 295 ⟶ 737:
set y to y + 12
end
resultText</langsyntaxhighlight>
 
Output{{out}} (can always add "display dialog resultText" for GUI output):
<pre>Months with five weekends (201):
1901-March, 1902-August, 1903-May, 1904-January, 1904-July, ...
Line 306 ⟶ 748:
1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063
2068, 2074, 2085, 2091, 2096</pre>
 
===Functional===
<syntaxhighlight lang="applescript">-- TEST -----------------------------------------------------------------------
on run
fiveWeekends(1900, 2100)
end run
 
-- FIVE WEEKENDS --------------------------------------------------------------
 
-- fiveWeekends :: Int -> Int -> Record
on fiveWeekends(fromYear, toYear)
set lstYears to enumFromTo(fromYear, toYear)
-- yearMonthString :: (Int, Int) -> String
script yearMonthString
on |λ|(lstYearMonth)
((item 1 of lstYearMonth) as string) & " " & ¬
item (item 2 of lstYearMonth) of ¬
{"January", "", "March", "", "May", "", ¬
"July", "August", "", "October", "", "December"}
end |λ|
end script
-- addLongMonthsOfYear :: [(Int, Int)] -> [(Int, Int)]
script addLongMonthsOfYear
on |λ|(lstYearMonth, intYear)
-- yearMonth :: Int -> (Int, Int)
script yearMonth
on |λ|(intMonth)
{intYear, intMonth}
end |λ|
end script
lstYearMonth & ¬
map(yearMonth, my longMonthsStartingFriday(intYear))
end |λ|
end script
-- leanYear :: Int -> Bool
script leanYear
on |λ|(intYear)
0 = length of longMonthsStartingFriday(intYear)
end |λ|
end script
set lstFullMonths to map(yearMonthString, ¬
foldl(addLongMonthsOfYear, {}, lstYears))
set lstLeanYears to filter(leanYear, lstYears)
{{|number|:length of lstFullMonths}, ¬
{firstFive:(items 1 thru 5 of lstFullMonths)}, ¬
{lastFive:(items -5 thru -1 of lstFullMonths)}, ¬
{leanYearCount:length of lstLeanYears}, ¬
{leanYears:lstLeanYears}}
end fiveWeekends
 
-- longMonthsStartingFriday :: Int -> [Int]
on longMonthsStartingFriday(intYear)
-- startIsFriday :: Int -> Bool
script startIsFriday
on |λ|(iMonth)
weekday of calendarDate(intYear, iMonth, 1) is Friday
end |λ|
end script
filter(startIsFriday, [1, 3, 5, 7, 8, 10, 12])
end longMonthsStartingFriday
 
-- calendarDate :: Int -> Int -> Int -> Date
on calendarDate(intYear, intMonth, intDay)
tell (current date)
set {its year, its month, its day, its time} to ¬
{intYear, intMonth, intDay, 0}
return it
end tell
end calendarDate
 
-- GENERIC FUNCTIONS ----------------------------------------------------------
 
-- enumFromTo :: Enum a => a -> a -> [a]
on enumFromTo(m, n)
set {intM, intN} to {fromEnum(m), fromEnum(n)}
if intM > intN then
set d to -1
else
set d to 1
end if
set lst to {}
if class of m is text then
repeat with i from intM to intN by d
set end of lst to chr(i)
end repeat
else
repeat with i from intM to intN by d
set end of lst to i
end repeat
end if
return lst
end enumFromTo
 
-- fromEnum :: Enum a => a -> Int
on fromEnum(x)
set c to class of x
if c is boolean then
if x then
1
else
0
end if
else if c is text then
if x ≠ "" then
id of x
else
missing value
end if
else
x as integer
end if
end fromEnum
 
-- filter :: (a -> Bool) -> [a] -> [a]
on filter(f, xs)
tell mReturn(f)
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if |λ|(v, i, xs) then set end of lst to v
end repeat
return lst
end tell
end filter
 
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
 
 
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="applescript">{{|number|:201},
{firstFive:{"1901 March", "1902 August", "1903 May", "1904 January", "1904 July"}},
{lastFive:{"2097 March", "2098 August", "2099 May", "2100 January", "2100 October"}},
{leanYearCount:29},
{leanYears:{1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979,
1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074,
2085, 2091, 2096}}}</syntaxhighlight>
 
===Using integer math===
An alternative to the date object manipulation methods above.
<syntaxhighlight lang="applescript">on monthsWithFiveWeekends(startYear, endYear)
set Dec1 to (current date)
tell Dec1 to set {its day, its month, its year} to {1, December, startYear - 1}
set daysFromBaseFriday to (Dec1's weekday as integer) - Friday
set longMonths to {"January", "March", "May", "July", "August", "October", "December"}
set daysBetween to {31, 59, 61, 61, 31, 61, 61} -- Days since starts of preceding long months.
set hits to {}
set hitlessYears to {}
repeat with y from startYear to endYear
set noHIts to true
-- Find long months that begin on Fridays.
repeat with i from 1 to 7
set daysFromBaseFriday to daysFromBaseFriday + (daysBetween's item i)
if ((i = 2) and (y mod 4 = 0) and ((y mod 100 > 0) or (y mod 400 = 0))) then ¬
set daysFromBaseFriday to daysFromBaseFriday + 1 -- Leap year.
if (daysFromBaseFriday mod 7 = 0) then
set end of hits to (longMonths's item i) & (space & y)
set noHIts to false
end if
end repeat
if (noHIts) then set end of hitlessYears to y
end repeat
return {hits:hits, hitlessYears:hitlessYears}
end monthsWithFiveWeekends
 
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
 
on task()
set {startYear, endYear} to {1900, 2100}
set theResults to monthsWithFiveWeekends(startYear, endYear)
set output to {((count theResults's hits) as text) & " of the months from " & startYear & ¬
" to " & endYear & " have five weekends,", ¬
"the first and last five of these months being:"}
set end of output to join(theResults's hits's items 1 thru 5, ", ") & " …"
set end of output to "… " & join(theResults's hits's items -5 thru -1, ", ")
set hitlessCount to (count theResults's hitlessYears)
set end of output to linefeed & hitlessCount & " of the years have no such months:"
set cut to (hitlessCount + 1) div 2
set end of output to join(theResults's hitlessYears's items 1 thru cut, ", ")
set end of output to join(theResults's hitlessYears's items (cut + 1) thru -1, ", ")
return join(output, linefeed)
end task
 
task()</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"201 of the months from 1900 to 2100 have five weekends,
the first and last five of these months being:
March 1901, August 1902, May 1903, January 1904, July 1904 …
… March 2097, August 2098, May 2099, January 2100, October 2100
 
29 of the years have no such months:
1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001
2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096"</syntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">longMonths: [1 3 5 7 8 10 12]
dates: []
 
yearsWithout: 0
 
loop 1900..2100 'year [
found?: false
loop longMonths 'month [
dt: to :date .format:"d-M-YYYY" ~"1-|month|-|year|"
if friday? dt [
'dates ++ @[@[dt\Month year]]
found?: true
]
]
if not? found? ->
inc 'yearsWithout
]
 
print.lines map first.n:5 dates 'd -> ~"|to :string d\0|, |to :string d\1|"
print "..."
print.lines map last.n:5 dates 'd -> ~"|to :string d\0|, |to :string d\1|"
 
print ""
print ["Found" size dates "months in total."]
print ["There are" yearsWithout "years without any month that has 5 full weekends."]</syntaxhighlight>
 
{{out}}
 
<pre>March, 1901
August, 1902
May, 1903
January, 1904
July, 1904
...
March, 2097
August, 2098
May, 2099
January, 2100
October, 2100
 
Found 201 months in total.
There are 29 years without any month that has 5 full weekends.</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">Year := 1900
End_Year := 2100
31_Day_Months = 01,03,05,07,08,10,12
Line 344 ⟶ 1,077:
Years with no 5 day weekends between 1900 and 2100 : %No_5_Weekend_Count%
%All_Years_Without_5_Weekend%
)</langsyntaxhighlight>
 
=={{header|ALGOL 68AutoIt}}==
Call the Funktion with $ret > 1 And $ret < 3 to determine Returned Array
{{trans|Fortran}} Note: This specimen retains the original [[#Fortran|Fortran]] coding style. [http://rosettacode.org/mw/index.php?title=Five_weekends&action=historysubmit&diff=107850&oldid=107848 diff]
1 - All found Weekend Dates
{{works with|ALGOL 68|Revision 1 - no extensions to language used.}}
2 - Years Without 5 Weekend Months
{{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].}}
3 - Year and Month with 5 Weekends
{{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''.}}
<syntaxhighlight lang="autoit">
<lang algol68>five_weekends: BEGIN
#include <Date.au3>
INT m, year, nfives := 0, not5 := 0;
#include <Array.au3>
BOOL no5weekend;
$array = Five_weekends(1)
_ArrayDisplay($array)
MODE MONTH = STRUCT(
$array = Five_weekends(2)
INT n,
_ArrayDisplay($array)
[3]CHAR name
$array = Five_weekends(3)
) # MODE MONTH #;
_ArrayDisplay($array)
 
[]MONTH month = (
Func Five_weekends($ret = 1)
MONTH(13, "Jan"),
If $ret < 1 Or $ret > 3 Then Return SetError(1, 0, 0)
MONTH(3, "Mar"),
Local $avDateArray[1]
MONTH(5, "May"),
Local $avYearArray[1]
MONTH(7, "Jul"),
Local $avMonthArray[1]
MONTH(8, "Aug"),
For $iYear = 1900 To 2100
MONTH(10, "Oct"),
Local $checkyear = False
MONTH(12, "Dec")
For $iMonth = 1 To 12
);
If _DateDaysInMonth($iYear, $iMonth) <> 31 Then ContinueLoop ; Month has less then 31 Days
If _DateToDayOfWeek($iYear, $iMonth, "01") <> 6 Then ContinueLoop ;First Day is not a Friday
FOR year FROM 1900 TO 2100 DO
_ArrayAdd($avMonthArray, $iYear & "-" & _DateToMonth($iMonth))
IF year = 1905 THEN printf($"..."l$) FI;
$checkyear = True
no5weekend := TRUE;
For $s = 1 To 31
FOR m TO UPB month DO
Local $Date = _DateToDayOfWeek($iYear, $iMonth, $s)
IF n OF month(m) = 13 THEN
If $Date = 6 Or $Date = 7 Or $Date = 1 Then ; if Date is Friday, Saturday or Sunday
IF day_of_week(1, n OF month(m), year-1) = 6 THEN
_ArrayAdd($avDateArray, $iYear & "\" & StringFormat("%02d", $iMonth) & "\" & StringFormat("%02d", $s))
IF year<1905 OR year > 2096 THEN printf(($g, 5zl$, name OF month(m), year)) FI;
EndIf
nfives +:= 1;
Next
no5weekend := FALSE
Next
FI
If Not $checkyear Then _ArrayAdd($avYearArray, $iYear)
ELSE
Next
IF day_of_week(1, n OF month(m), year) = 6 THEN
$avDateArray[0] = UBound($avDateArray) - 1
IF year<1905 OR year > 2096 THEN printf(($g, 5zl$, name OF month(m), year)) FI;
$avYearArray[0] = UBound($avYearArray) - 1
nfives +:= 1;
$avMonthArray[0] = UBound($avMonthArray) - 1
no5weekend := FALSE
If $ret = 1 FIThen
Return $avDateArray
FI
ElseIf $ret = 2 Then
OD;
Return $avYearArray
IF no5weekend THEN not5 +:= 1 FI
ElseIf $ret = 3 Then
OD;
Return $avMonthArray
EndIf
printf(($g, g(0)l$, "Number of months with five weekends between 1900 and 2100 = ", nfives));
EndFunc ;==>Five_weekends
printf(($g, g(0)l$, "Number of years between 1900 and 2100 with no five weekend months = ", not5));
</syntaxhighlight>
 
# contains #
=={{header|AWK}}==
 
PROC day_of_week = (INT d, m, y)INT: BEGIN
<syntaxhighlight lang="awk">
INT j, k;
# usage: awk -f 5weekends.awk cal.txt
j := y OVER 100;
 
k := y MOD 100;
# Filter a file of month-calendars, such as
(d + (m+1)*26 OVER 10 + k + k OVER 4 + j OVER 4 + 5*j) MOD 7
# ...
END # function day_of_week #;
## January 1901
SKIP
## Mo Tu We Th Fr Sa Su
END # program five_weekends #</lang>
## 1 2 3 4 5 6
Output:
## 7 8 9 10 11 12 13
## 14 15 16 17 18 19 20
## 21 22 23 24 25 26 27
## 28 29 30 31
# ...
## March 1901
## Mo Tu We Th Fr Sa Su
## 1 2 3
## 4 5 6 7 8 9 10
## 11 12 13 14 15 16 17
## 18 19 20 21 22 23 24
## 25 26 27 28 29 30 31
# ...
# This file is generated by a script for the unix-shell,
# see http://rosettacode.org/wiki/Five_weekends#UNIX_Shell
 
BEGIN { print("# Month with 5 weekends:")
badYears = numW5 = 0;
lastW5 = -1
}
 
0+$2>33 { if( $2>currYear ) { # calendar-header: month, year
if( lastW5==numW5 ) {
badYears++; sep="\n"
if( badYears % 10 ) { sep=" " }
bY=bY currYear sep; # collect years in string
##print badYears,":", currYear
}
lastW5=numW5
}
WE=0; currYear=$2; currMY = $1 " " $2;
##print currMY;
next
}
 
/^Mo/ { next } # skip lines with weekday-names
 
{ $0 = substr($0,13) } # cut inputline, leave Fr,Sa,Su only
 
NF>2 { WE++; # 3 fields left => complete weekend found
if( WE>4 ) {
numW5++; printf("%4d : %s\n", numW5, currMY)
}
}
 
END { print("# Found", numW5, "month with 5 weekends.")
print("# Found", badYears, "years with no month having 5 weekends:")
print(bY)
}
</syntaxhighlight>
 
See also: [http://rosettacode.org/wiki/Five_weekends#UNIX_Shell unix-shell] and [http://rosettacode.org/wiki/Calendar#AWK Calendar].
 
{{out}}
<pre>
# Month with 5 weekends:
Mar 1901
1 : March 1901
Aug 1902
2 : August 1902
May 1903
3 : May 1903
Jan 1904
Jul 4 : January 1904
5 : July 1904
6 : December 1905
...
196 : July 2095
Mar 2097
197 : March 2097
Aug 2098
198 : August 2098
May 2099
199 : May 2099
Jan 2100
Oct 200 : January 2100
201 : October 2100
Number of months with five weekends between 1900 and 2100 = 201
# Found 201 month with 5 weekends.
Number of years between 1900 and 2100 with no five weekend months = 29
# Found 29 years with no month having 5 weekends:
1900 1906 1917 1923 1928 1934 1945 1951 1956 1962
1973 1979 1984 1990 2001 2007 2012 2018 2029 2035
2040 2046 2057 2063 2068 2074 2085 2091 2096
</pre>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> INSTALL @lib$+"DATELIB"
DIM Month$(12)
Month$() = "","January","February","March","April","May","June", \
\ "July","August","September","October","November","December"
num% = 0
FOR year% = 1900 TO 2100
PRINT ; year% ": " ;
oldnum% = num%
FOR month% = 1 TO 12
IF FN_dim(month%,year%) = 31 IF FN_dow(FN_mjd(1,month%,year%)) = 5 THEN
num% += 1
PRINT Month$(month%), ;
ENDIF
NEXT
IF num% = oldnum% PRINT "(none)" ELSE PRINT
NEXT year%
PRINT "Total = " ; num%</syntaxhighlight>
{{out}}
<pre>
1900: (none)
1901: March
1902: August
1903: May
1904: January July
1905: December
1906: (none)
...
2093: May
2094: January October
2095: July
2096: (none)
2097: March
2098: August
2099: May
2100: January October
Total = 201
</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <time.h>
 
Line 451 ⟶ 1,285:
printf("%d total\n", n);
return 0;
}</langsyntaxhighlight>
Output{{out}} (note that the C library may not be able to handle all dates; the output may vary across systems):
<pre>
Error: 1900 January
Line 483 ⟶ 1,317:
 
Not your typical method. Requires <code>ncal</code>.
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
 
Line 522 ⟶ 1,356:
 
return 0;
}</langsyntaxhighlight>
{{out}}
output
<pre>
1901-03 1902-08 1903-05 1904-01 1904-07 1905-12 1907-03 1908-05 1909-01 1909-10 1910-07 1911-12 1912-03 1913-08 1914-05 1915-01
Line 532 ⟶ 1,366:
Total: 201
</pre>
 
=={{header|C sharp|C#}}==
===With iteration===
<syntaxhighlight lang="csharp">using System;
 
namespace _5_Weekends
{
class Program
{
const int FIRST_YEAR = 1900;
const int LAST_YEAR = 2100;
static int[] _31_MONTHS = { 1, 3, 5, 7, 8, 10, 12 };
 
static void Main(string[] args)
{
int totalNum = 0;
int totalNo5Weekends = 0;
 
for (int year = FIRST_YEAR; year <= LAST_YEAR; year++)
{
bool has5Weekends = false;
 
foreach (int month in _31_MONTHS)
{
DateTime firstDay = new DateTime(year, month, 1);
if (firstDay.DayOfWeek == DayOfWeek.Friday)
{
totalNum++;
has5Weekends = true;
Console.WriteLine(firstDay.ToString("yyyy - MMMM"));
}
}
 
if (!has5Weekends) totalNo5Weekends++;
}
Console.WriteLine("Total 5-weekend months between {0} and {1}: {2}", FIRST_YEAR, LAST_YEAR, totalNum);
Console.WriteLine("Total number of years with no 5-weekend months {0}", totalNo5Weekends);
}
}
}</syntaxhighlight>
{{out}}
<pre>
1901 - March
1902 - August
1903 - May
1904 - January
1904 - July
1905 - December
...
2095 - July
2097 - March
2098 - August
2099 - May
2100 - January
2100 - October
Total 5-weekend months between 1900 and 2100: 201
Total number of years with no 5-weekend months 29
</pre>
 
===With LINQ===
<syntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Collections.Generic;
 
public class Program
{
public static void Main()
{
const int startYear = 1900, endYear = 2100;
var query = (
from year in startYear.To(endYear)
from month in 1.To(12)
where DateTime.DaysInMonth(year, month) == 31
select new DateTime(year, month, 1) into date
where date.DayOfWeek == DayOfWeek.Friday
select date)
.ToList();
Console.WriteLine("Count: " + query.Count);
Console.WriteLine();
Console.WriteLine("First and last 5:");
for (int i = 0; i < 5; i++)
Console.WriteLine(query[i].ToString("MMMM yyyy"));
Console.WriteLine("...");
for (int i = query.Count - 5; i < query.Count; i++)
Console.WriteLine(query[i].ToString("MMMM yyyy"));
Console.WriteLine();
Console.WriteLine("Years without 5 weekends:");
Console.WriteLine(string.Join(" ", startYear.To(endYear).Except(query.Select(dt => dt.Year))));
}
}
 
public static class IntExtensions
{
public static IEnumerable<int> To(this int start, int end) => Enumerable.Range(start, end - start + 1);
}</syntaxhighlight>
{{out}}
<pre>
Count: 201
 
First and last 5:
March 1901
August 1902
May 1903
January 1904
July 1904
...
March 2097
August 2098
May 2099
January 2100
October 2100
 
Years without 5 weekends:
1900 1906 1917 1923 1928 1934 1945 1951 1956 1962 1973 1979 1984 1990 2001 2007 2012 2018 2029 2035 2040 2046 2057 2063 2068 2074 2085 2091 2096</pre>
 
=={{header|C++}}==
{{libheader|Boost}}
<langsyntaxhighlight lang="cpp">#include <vector>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <algorithm>
Line 577 ⟶ 1,527:
std::cout << std::endl ;
return 0 ;
}</langsyntaxhighlight>
sample{{out|Sample output:}}
<pre style="height:30ex;overflow:scroll">
Between 1900 and 2100 , there are 201 months with 5 complete weekends!
Line 816 ⟶ 1,766:
</pre>
 
=={{header|C=Using sharp|C#}}++20===
<syntaxhighlight lang="c++">
<lang csharp>using System;
 
#include <chrono>
namespace _5_Weekends
#include <iostream>
{
#include <vector>
class Program
{
const int FIRST_YEAR = 1900;
const int LAST_YEAR = 2100;
static int[] _31_MONTHS = { 1, 3, 5, 7, 8, 10, 12 };
 
int main() {
static void Main(string[] args)
const std::vector<std::chrono::month> long_months = { std::chrono::January, std::chrono::March,
{
std::chrono::May, std::chrono::July, std::chrono::August, std::chrono::October, std::chrono::December };
int totalNum = 0;
int totalNo5Weekends = 0;
 
int month_count = 0;
for (int year = FIRST_YEAR; year <= LAST_YEAR; year++)
int blank_years = 0;
{
for ( int y = 1900; y <= 2100; ++y ) {
bool has5Weekends = false;
bool blank_year = true;
for ( std::chrono::month m : long_months ) {
std::chrono::year_month_day first_of_month{std::chrono::year{y}, m, std::chrono::day{1}};
if ( std::chrono::weekday{first_of_month} == std::chrono::Friday ) {
std::cout << first_of_month.year() << " " << first_of_month.month() << std::endl;
month_count++;
blank_year = false;
}
}
if ( blank_year ) {
blank_years++;
}
}
std::cout << "Found " << month_count << " months with five Fridays, Saturdays and Sundays." << std::endl;
std::cout << "There were " << blank_years << " years with no such months." << std::endl;
}
</syntaxhighlight>
{{ out }}
<pre>
1901 Mar
1902 Aug
1903 May
1904 Jan
1904 Jul
// elided... //
2097 Mar
2098 Aug
2099 May
2100 Jan
2100 Oct
Found 201 months with five Fridays, Saturdays and Sundays.
There were 29 years with no such months.
</pre>
 
=={{header|Ceylon}}==
foreach (int month in _31_MONTHS)
<b>module.ceylon</b>
{
<syntaxhighlight lang="ceylon">
DateTime firstDay = new DateTime(year, month, 1);
module rosetta.fiveweekends "1.0.0" {
if (firstDay.DayOfWeek == DayOfWeek.Friday)
import ceylon.time "1.2.2";
{
}
totalNum++;
</syntaxhighlight>
has5Weekends = true;
<b>run.ceylon</b>
Console.WriteLine(firstDay.ToString("yyyy - MMMM"));
<syntaxhighlight lang="ceylon">
}
import ceylon.time {
}
date,
Date
}
import ceylon.time.base {
january,
december,
friday,
Month
}
 
shared void run() {
if (!has5Weekends) totalNo5Weekends++;
[Date[],Integer[]] result = fiveWeekendsRecursive();
}
 
Console.WriteLine("Total 5-weekend months between {0} and {1}: {2}", FIRST_YEAR, LAST_YEAR, totalNum);
value fiveWeekendFirstOfMonths = result[0];
Console.WriteLine("Total number of years with no 5-weekend months {0}", totalNo5Weekends);
Integer[] yearsWithNoFiveWeekendMonths = result[1];
}
 
print("# five weekend months = ``fiveWeekendFirstOfMonths.size``");
print("# years without five weekend months = ``yearsWithNoFiveWeekendMonths.size``");
yearsWithNoFiveWeekendMonths.each(print);
}
 
[Date[], Integer[]] fiveWeekendsRecursive()
=> fiveWeekendsRecursiveInner{ year = 1900;
month = january;
fiveWeekendFirstOfMonths = [];
yearsWithNoFiveWeekendMonths = []; };
 
[Date[], Integer[]] fiveWeekendsRecursiveInner(Integer year,
Month month,
Date[] fiveWeekendFirstOfMonths,
Integer[] yearsWithNoFiveWeekendMonths) {
if (year > 2100) {
return [fiveWeekendFirstOfMonths,yearsWithNoFiveWeekendMonths];
}
 
}</lang>
Date firstOfMonth = date{ year = year; month = month; day = 1; };
Output
 
Boolean isFiveWeekendMonth =
(month.numberOfDays() == 31 && friday == firstOfMonth.dayOfWeek);
 
Boolean hasNoFiveWeekends =
month == december &&
! isFiveWeekendMonth &&
fiveWeekendFirstOfMonths.filter((date) => date.year == year).size == 0;
 
return fiveWeekendsRecursiveInner(if (month == december) then year+1 else year,
if (month == december) then january else month.plusMonths(1),
if (isFiveWeekendMonth)
then fiveWeekendFirstOfMonths.withTrailing(firstOfMonth)
else fiveWeekendFirstOfMonths,
if (hasNoFiveWeekends)
then yearsWithNoFiveWeekendMonths.withTrailing(year)
else yearsWithNoFiveWeekendMonths);
}
 
</syntaxhighlight>
{{out}}
<pre>
# five weekend months = 201
1901 - March
# years without five weekend months = 29
1902 - August
1900
1903 - May
1906
1904 - January
1917
1904 - July
1923
1905 - December
1928
...
1934
2095 - July
1945
2097 - March
1951
2098 - August
1956
2099 - May
1962
2100 - January
1973
2100 - October
1979
Total 5-weekend months between 1900 and 2100: 201
1984
Total number of years with no 5-weekend months 29
1990
2001
2007
2012
2018
2029
2035
2040
2046
2057
2063
2068
2074
2085
2091
2096
 
</pre>
 
=={{header|Clojure}}==
<langsyntaxhighlight Clojurelang="clojure">(import java.util.GregorianCalendar
java.text.DateFormatSymbols)
 
Line 884 ⟶ 1,927:
(println month "-" year))
count
(println "Total Months: " ,))</langsyntaxhighlight>
 
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
program-id. five-we.
data division.
working-storage section.
1 wk binary.
2 int-date pic 9(8).
2 dow pic 9(4).
2 friday pic 9(4) value 5.
2 mo-sub pic 9(4).
2 months-with-5 pic 9(4) value 0.
2 years-no-5 pic 9(4) value 0.
2 5-we-flag pic 9(4) value 0.
88 5-we-true value 1 when false 0.
1 31-day-mos pic 9(14) value 01030507081012.
1 31-day-table redefines 31-day-mos.
2 mo-no occurs 7 pic 99.
1 cal-date.
2 yr pic 9(4).
2 mo pic 9(2).
2 da pic 9(2) value 1.
procedure division.
perform varying yr from 1900 by 1
until yr > 2100
set 5-we-true to false
perform varying mo-sub from 1 by 1
until mo-sub > 7
move mo-no (mo-sub) to mo
compute int-date = function
integer-of-date (function numval (cal-date))
compute dow = function mod
((int-date - 1) 7) + 1
if dow = friday
perform output-date
add 1 to months-with-5
set 5-we-true to true
end-if
end-perform
if not 5-we-true
add 1 to years-no-5
end-if
end-perform
perform output-counts
stop run
.
 
output-counts.
display "Months with 5 weekends: " months-with-5
display "Years without 5 weekends: " years-no-5
.
 
output-date.
display yr "-" mo
.
end program five-we.
</syntaxhighlight>
{{out}}
<pre>
1901-03
1902-08
1903-05
1904-01
1904-07
. . .
2097-03
2098-08
2099-05
2100-01
2100-10
Months with 5 weekends: 0201
Years without 5 weekends: 0029
</pre>
 
=={{header|CoffeeScript}}==
<syntaxhighlight lang="coffeescript">
startsOnFriday = (month, year) ->
# 0 is Sunday, 1 is Monday, ... 5 is Friday, 6 is Saturday
new Date(year, month, 1).getDay() == 5
 
has31Days = (month, year) ->
new Date(year, month, 31).getDate() == 31
 
checkMonths = (year) ->
month = undefined
count = 0
month = 0
while month < 12
if startsOnFriday(month, year) and has31Days(month, year)
count += 1
console.log year + ' ' + month + ''
month += 1
count
 
fiveWeekends = ->
startYear = 1900
endYear = 2100
year = undefined
monthTotal = 0
yearsWithoutFiveWeekends = []
total = 0
year = startYear
while year <= endYear
monthTotal = checkMonths(year)
total += monthTotal
# extra credit
if monthTotal == 0
yearsWithoutFiveWeekends.push year
year += 1
console.log 'Total number of months: ' + total + ''
console.log ''
console.log yearsWithoutFiveWeekends + ''
console.log 'Years with no five-weekend months: ' + yearsWithoutFiveWeekends.length + ''
return
 
fiveWeekends()
 
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="text">
1901 2
1902 7
1903 4
1904 0
1904 6
1905 11
1907 2
1908 4
1909 0
1909 9
1910 6
1911 11
1912 2
1913 7
1914 4
1915 0
1915 9
1916 11
1918 2
1919 7
1920 9
1921 6
1922 11
1924 7
..
 
Total number of months: 201
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096
 
Years with no five-weekend months: 29
</syntaxhighlight>
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">;; Given a date, get the day of the week. Adapted from
;; http://lispcookbook.github.io/cl-cookbook/dates_and_times.html
 
(defun day-of-week (day month year)
(nth-value
6
(decode-universal-time
(encode-universal-time 0 0 0 day month year 0)
0)))
 
(defparameter *long-months* '(1 3 5 7 8 10 12))
 
(defun sundayp (day month year)
(= (day-of-week day month year) 6))
 
(defun ends-on-sunday-p (month year)
(sundayp 31 month year))
 
;; We use the "long month that ends on Sunday" rule.
(defun has-five-weekends-p (month year)
(and (member month *long-months*)
(ends-on-sunday-p month year)))
 
;; For the extra credit problem.
(defun has-at-least-one-five-weekend-month-p (year)
(let ((flag nil))
(loop for month in *long-months* do
(if (has-five-weekends-p month year)
(setf flag t)))
flag))
 
(defun solve-it ()
(let ((good-months '())
(bad-years 0))
(loop for year from 1900 to 2100 do
;; First form in the PROGN is for the extra credit.
(progn (unless (has-at-least-one-five-weekend-month-p year)
(incf bad-years))
(loop for month in *long-months* do
(when (has-five-weekends-p month year)
(push (list month year) good-months)))))
(let ((len (length good-months)))
(format t "~A months have five weekends.~%" len)
(format t "First 5 months: ~A~%" (subseq good-months (- len 5) len))
(format t "Last 5 months: ~A~%" (subseq good-months 0 5))
(format t "Years without a five-weekend month: ~A~%" bad-years))))
</syntaxhighlight>
 
{{out}}
<pre>201 months have five weekends.
First 5 months: ((7 1904) (1 1904) (5 1903) (8 1902) (3 1901))
Last 5 months: ((10 2100) (1 2100) (5 2099) (8 2098) (3 2097))
Years without a five-weekend month: 29</pre>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.datetime, std.algorithm, std.range;
 
autoDate[] m5w(in Date start=Date(1900,1,1), in Date end=Date(2100,12,31)) pure /*nothrow*/ {
Date[]typeof(return) res;
// adjust to 1st day
for (Date when = Date(start.year, start.month, 1);
when < end;
when.add!"months"(1)) {
// Such month must have 3+4*7 days and start at friday
 
if (when.endOfMonthDay == 31 && // Suchfor month5 mustFULL have 3+4*7weekends.
if (when.dayOfWeekdaysInMonth == 5) // days and start at31 friday&&
reswhen.dayOfWeek ~== when; // for 5 FULL weekendsDayOfWeek.fri)
res ~= when;
}
return res;
}
 
bool noM5wByYear(in int year) pure {
return m5w(Date(year, 1, 1), Date(year, 12, 31)).length == 0empty;
}
 
void main() {
autoimmutable m = m5w();Date(1900, //1, use1), defaultDate(2100, input12, 31));
writeln("There are ", m.length,
" months of which the first and last five are:");
foreach (d; m[0 .. 5] ~ m[$ - 5 .. $])
writeln(d.toSimpleString()[0 .. $ -2 3]);
 
autoimmutable noM5wn = filter!noM5wByYear(iota(1900, 2101).filter!noM5wByYear().walkLength();
writelnwritefln("There\nThere are ", walkLength(noM5w), "%d years in the range that do not have ", ~
"range that do not have months with five weekends.", n);
}</langsyntaxhighlight>
{{out}}
Output:
<pre>There are 201 months of which the first and last five are:
1901-Mar-
1902-Aug-
1903-May-
1904-Jan-
1904-Jul-
2097-Mar-
2098-Aug-
2099-May-
2100-Jan-
2100-Oct-
 
There are 29 years in the range that do not have months with five weekends</pre>
There are 29 years in the range that do not have months with five weekends.</pre>
===Simpler Version===
<syntaxhighlight lang="d">void main() {
import std.stdio, std.datetime, std.traits;
 
enum first_year = 1900;
enum last_year = 2100;
 
uint totalNo5Weekends;
immutable(Date)[] fiveWeekendMonths;
foreach (immutable year; first_year .. last_year + 1) {
bool has5Weekends = false;
 
foreach (immutable month; EnumMembers!Month) {
immutable firstDay = Date(year, month, 1);
if (firstDay.daysInMonth == 31 &&
firstDay.dayOfWeek == DayOfWeek.fri) {
has5Weekends = true;
fiveWeekendMonths ~= firstDay;
}
}
 
if (!has5Weekends)
totalNo5Weekends++;
}
 
writefln("Total 5-weekend months between %d and %d: %d",
first_year, last_year, fiveWeekendMonths.length);
foreach (immutable date; fiveWeekendMonths[0 .. 5])
writeln(date.month, ' ', date.year);
"...".writeln;
foreach (immutable date; fiveWeekendMonths[$ - 5 .. $])
writeln(date.month, ' ', date.year);
 
writeln("\nTotal number of years with no 5-weekend months: ",
totalNo5Weekends);
}</syntaxhighlight>
{{out}}
<pre>Total 5-weekend months between 1900 and 2100: 201
mar 1901
aug 1902
may 1903
jan 1904
jul 1904
...
mar 2097
aug 2098
may 2099
jan 2100
oct 2100
 
Total number of years with no 5-weekend months: 29</pre>
 
 
=={{header|Dart}}==
<syntaxhighlight lang="dart">
main() {
var total = 0;
var empty = <int>[];
for (var year = 1900; year < 2101; year++) {
var months =
[1, 3, 5, 7, 8, 10, 12].where((m) => DateTime(year, m, 1).weekday == 5);
print('$year\t$months');
total += months.length;
if (months.isEmpty) empty.add(year);
}
print('Total: $total');
print('Year with none: $empty');
}
</syntaxhighlight>
{{out|Sample output}}
<pre style="height:30ex;overflow:scroll">
1900 ()
1901 (3)
1902 (8)
1903 (5)
1904 (1, 7)
...
2098 (8)
2099 (5)
2100 (1, 10)
Total: 201
Year with none: [1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096]
</pre>
 
=={{header|Delphi}}==
<langsyntaxhighlight lang="delphi">program FiveWeekends;
 
{$APPTYPE CONSOLE}
Line 966 ⟶ 2,299:
Writeln(Format('Months with 5 weekends: %d', [lFiveWeekendCount]));
Writeln(Format('Years with no 5 weekend months: %d', [lYearsWithout]));
end.</langsyntaxhighlight>
 
=={{header|EasyLang}}==
<syntaxhighlight>
func leap year .
return if year mod 4 = 0 and (year mod 100 <> 0 or year mod 400 = 0)
.
func weekday year month day .
normdoom[] = [ 3 7 7 4 2 6 4 1 5 3 7 5 ]
c = year div 100
r = year mod 100
s = r div 12
t = r mod 12
c_anchor = (5 * (c mod 4) + 2) mod 7
doom = (s + t + (t div 4) + c_anchor) mod 7
anchor = normdoom[month]
if leap year = 1 and month <= 2
anchor = (anchor + 1) mod1 7
.
return (doom + day - anchor + 7) mod 7 + 1
.
mdays[] = [ 31 28 31 30 31 30 31 31 30 31 30 31 ]
mon$[] = [ "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec" ]
#
for year = 1900 to 2100
for m to 12
if mdays[m] = 31 and weekday year m 1 = 6
print year & "-" & mon$[m]
sum += 1
.
.
.
print "Total : " & sum
</syntaxhighlight>
{{out}}
<pre>
1901-Mar
1902-Aug
1903-May
1904-Jan
1904-Jul
.
.
2097-Mar
2098-Aug
2099-May
2100-Jan
2100-Oct
Total : 201
</pre>
 
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">defmodule Date do
@months { "January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December" }
def five_weekends(year) do
for m <-[1,3,5,7,8,10,12], :calendar.day_of_the_week(year, m, 31) == 7, do: elem(@months, m-1)
end
end
 
months = Enum.map(1900..2100, fn year -> {year, Date.five_weekends(year)} end)
{none, months5} = Enum.partition(months, fn {_,m} -> Enum.empty?(m) end)
count = Enum.reduce(months5, 0, fn {year, months}, acc ->
IO.puts "#{year} : #{Enum.join(months, ", ")}"
acc + length(months)
end)
IO.puts "Found #{count} month with 5 weekends."
IO.puts "\nFound #{length(none)} years with no month having 5 weekends:"
IO.puts "#{inspect Enum.map(none, fn {y,_}-> y end)}"</syntaxhighlight>
 
{{out}}
<pre>
1901 : March
1902 : August
1903 : May
1904 : January, July
1905 : December
...
2095 : July
2097 : March
2098 : August
2099 : May
2100 : January, October
Found 201 month with 5 weekends.
 
Found 29 years with no month having 5 weekends:
[1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096]
</pre>
 
=={{header|Erlang}}==
Two examples, both based on first building a nested list-of-lists like [Year1, Year2, ..., YearN], where each year is a sublist of year and month tuples, like [{YearN, 1}, {YearN, 2}, ..., {YearN, 12}].<br>
First, a pretty compact example intended for use with <b>escript</b>:
<langsyntaxhighlight lang="erlang">
#!/usr/bin/env escript
%%
Line 1,001 ⟶ 2,422:
has_five({_Year, _Month}, _DaysNot31) ->
false.
</syntaxhighlight>
</lang>
Second, a more verbose Erlang module:
<langsyntaxhighlight lang="erlang">
-module(five_weekends).
 
Line 1,055 ⟶ 2,476:
find_years_without_5w_months(List) ->
[Y || {[{Y,_M}|_], 0} <- List].
</syntaxhighlight>
</lang>
{{out}}
Output
<pre>
There are 201 months with five full weekends.
Line 1,100 ⟶ 2,521:
2091
2096
</pre>
 
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM FIVE_WEEKENDS
 
DIM M$[12]
 
PROCEDURE MODULO(X,Y->MD)
IF Y=0 THEN
MD=X
ELSE
MD=X-Y*INT(X/Y)
END IF
END PROCEDURE
 
PROCEDURE WD(M,D,Y->RES%)
IF M=1 OR M=2 THEN
M+=12
Y-=1
END IF
MODULO(365*Y+INT(Y/4)-INT(Y/100)+INT(Y/400)+D+INT((153*M+8)/5),7->RES)
RES%=RES+1.0
END PROCEDURE
 
BEGIN
M$[]=("","JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE","JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER")
PRINT(CHR$(12);) ! CLS
FOR YEAR=1900 TO 2100 DO
FOREACH MONTH IN (1,3,5,7,8,10,12) DO ! months with 31 days
WD(MONTH,1,YEAR->RES%)
IF RES%=6 THEN ! day #6 is Friday
PRINT(YEAR;": ";M$[MONTH])
CNT%=CNT%+1
! IF CNT% MOD 20=0 THEN GET(K$) END IF ! press a key for next page
END IF
END FOR
END FOR
PRINT("Total =";CNT%)
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
1901: MARCH
1902: AUGUST
1903: MAY
1904: JANUARY
1904: JULY
1905: DECEMBER
...
2093: MAY
2094: JANUARY
2094: OCTOBER
2095: JULY
2097: MARCH
2098: AUGUST
2099: MAY
2100: JANUARY
2100: OCTOBER
Total = 201</pre>
 
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">
--Five Weekend task from Rosetta Code wiki
--User:Lnettnay
 
include std/datetime.e
 
atom numbermonths = 0
sequence longmonths = {1, 3, 5, 7, 8, 10, 12}
sequence yearsmonths = {}
atom none = 0
datetime dt
 
for year = 1900 to 2100 do
atom flag = 0
for month = 1 to length(longmonths) do
dt = new(year, longmonths[month], 1)
if weeks_day(dt) = 6 then --Friday is day 6
flag = 1
numbermonths += 1
yearsmonths = append(yearsmonths, {year, longmonths[month]})
end if
end for
 
if flag = 0 then
none += 1
end if
end for
 
puts(1, "Number of months with five full weekends from 1900 to 2100 = ")
? numbermonths
 
puts(1, "First five and last five years, months\n")
 
for count = 1 to 5 do
? yearsmonths[count]
end for
 
for count = length(yearsmonths) - 4 to length(yearsmonths) do
? yearsmonths[count]
end for
 
puts(1, "Number of years that have no months with five full weekends = ")
? none
</syntaxhighlight>
{{out}}
<pre>
Number of months with five full weekends from 1900 to 2100 = 201
First five and last five years, months
{1901,3}
{1902,8}
{1903,5}
{1904,1}
{1904,7}
{2097,3}
{2098,8}
{2099,5}
{2100,1}
{2100,10}
Number of years that have no months with five full weekends = 29
</pre>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
let main argv =
let (yearFrom, yearTo) = (1900, 2100)
 
let monthsWith5We year =
[1; 3; 5; 7; 8; 10; 12] |>
List.filter (fun month -> DateTime(year, month, 1).DayOfWeek = DayOfWeek.Friday)
 
let ym5we =
[yearFrom .. yearTo]
|> List.map (fun year -> year, (monthsWith5We year))
 
let countMonthsWith5We =
ym5we
|> List.sumBy (snd >> List.length)
 
let countYearsWithout5WeMonths =
ym5we
|> List.sumBy (snd >> List.isEmpty >> (function|true->1|_->0))
 
let allMonthsWith5we =
ym5we
|> List.filter (snd >> List.isEmpty >> not)
 
printfn "%d months in the range of years from %d to %d have 5 weekends."
countMonthsWith5We yearFrom yearTo
printfn "%d years in the range of years from %d to %d have no month with 5 weekends."
countYearsWithout5WeMonths yearFrom yearTo
printfn "Months with 5 weekends: %A ... %A"
(List.take 5 allMonthsWith5we)
(List.take 5 (List.skip ((List.length allMonthsWith5we) - 5) allMonthsWith5we))
0</syntaxhighlight>
{{out}}
<pre>201 months in the range of years from 1900 to 2100 have 5 weekends.
29 years in the range of years from 1900 to 2100 have no month with 5 weekends.
Months with 5 weekends: [(1901, [3]); (1902, [8]); (1903, [5]); (1904, [1; 7]); (1905, [12])] ... [(2095, [7]); (2097, [3]); (2098, [8]); (2099, [5]); (2100, [1; 10])]</pre>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: calendar calendar.format formatting io kernel math
sequences ;
 
: timestamps>my ( months -- )
[ { MONTH bl YYYY nl } formatted 2drop ] each ;
 
: month-range ( start-year #months -- seq )
[ <year> ] [ <iota> ] bi* [ months time+ ] with map ;
: find-five-weekend-months ( months -- months' )
[ [ friday? ] [ days-in-month ] bi 31 = and ] filter ;
1900 12 201 * month-range find-five-weekend-months
[ length "%d five-weekend months found.\n" printf ]
[ 5 head timestamps>my "..." print ]
[ 5 tail* timestamps>my ] tri</syntaxhighlight>
{{out}}
<pre>
201 five-weekend months found.
Mar 1901
Aug 1902
May 1903
Jan 1904
Jul 1904
...
Mar 2097
Aug 2098
May 2099
Jan 2100
Oct 2100
</pre>
 
Line 1,106 ⟶ 2,721:
 
Using Zeller's congruence
<langsyntaxhighlight lang="fortran">program Five_weekends
implicit none
 
Line 1,162 ⟶ 2,777:
end function Day_of_week
end program Five_weekends</langsyntaxhighlight>
{{out}}
Output
<pre>Mar 1901
Aug 1902
Line 1,177 ⟶ 2,792:
Number of months with five weekends between 1900 and 2100 = 201
Number of years between 1900 and 2100 with no five weekend months = 29</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' version 23-06-2015
' compile with: fbc -s console
 
Function wd(m As Integer, d As Integer, y As Integer) As Integer
' Zellerish
' 0 = Sunday, 1 = Monday, 2 = Tuesday, 3 = Wednesday
' 4 = Thursday, 5 = Friday, 6 = Saturday
 
If m < 3 Then ' If m = 1 Or m = 2 Then
m += 12
y -= 1
End If
Return (y + (y \ 4) - (y \ 100) + (y \ 400) + d + ((153 * m + 8) \ 5)) Mod 7
End Function
 
' ------=< MAIN >=------
' only months with 31 day can have five weekends
' these months are: January, March, May, July, August, October, December
' in nr: 1, 3, 5, 7, 8, 10, 12
' the 1e day needs to be on a friday (= 5)
 
Dim As String month_names(1 To 12) => {"January","February","March",_
"April","May","June","July","August",_
"September","October","November","December"}
Dim As Integer m, yr, total, i, j, yr_without(200)
Dim As String answer
 
For yr = 1900 To 2100 ' Gregorian calendar
answer = ""
For m = 1 To 12 Step 2
If m = 9 Then m = 8
If wd(m , 1 , yr) = 5 Then
answer = answer + month_names(m) + ", "
total = total + 1
End If
Next
If answer <> "" Then
Print Using "#### | "; yr;
Print Left(answer, Len(answer) -2) ' get rid of extra " ,"
Else
i = i + 1
yr_without(i) = yr
End If
Next
 
Print
Print "nr of month for 1900 to 2100 that has five weekends";total
Print
Print i;" years don't have months with five weekends"
 
For j = 1 To i
Print yr_without(j); " ";
If j Mod 8 = 0 Then Print
Next
Print
 
' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre>1901 | March
1902 | August
1903 | May
1904 | January, July
1905 | December
...
2095 | July
2097 | March
2098 | August
2099 | May
2100 | January, October
 
nr of month from 1900 to 2100 that has five weekends 201
 
29 years don't have months with five weekends
1900 1906 1917 1923 1928 1934 1945 1951
1956 1962 1973 1979 1984 1990 2001 2007
2012 2018 2029 2035 2040 2046 2057 2063
2068 2074 2085 2091 2096 </pre>
 
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=fbeb1b7a06fff3da3f8b262ee5d71390 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim aMonth As Short[] = [1, 3, 5, 7, 8, 10, 12] 'All 31 day months
Dim aMMStore As New String[] 'To store results
Dim siYear, siMonth, siCount As Short 'Various variables
Dim dDay As Date 'To store the day to check
Dim sTemp As String 'Temp string
 
For siYear = 1900 To 2100 'Loop through each year
For siMonth = 0 To 6 'Loop through each 31 day month
dDay = Date(siYear, aMonth[siMonth], 1) 'Get the date of the 1st of the month
If WeekDay(dDay) = 5 Then aMMStore.Add(Format(dDay, "mmmm yyyy")) 'If the 1st is a Friday then store the result
Next
Next
 
For Each sTemp In aMMStore 'For each item in the stored array..
Inc siCount 'Increase siCount
If siCount < 6 Then Print aMMStore[siCount] 'If 1 of the 1st 5 dates then print it
If siCount = 6 Then Print String$(14, "-") 'Print a separator
If siCount > aMMStore.Max - 4 Then Print aMMStore[siCount - 1] 'If 1 of the last 5 dates then print it
Next
 
Print gb.NewLine & "Total months = " & Str(siCount) 'Print the number of months found
 
siCount = 0 'Reset siCount
sTemp = aMMStore.Join(",") 'Put all the stored dates in one string joined by commas
aMMStore.Clear 'Clear the store for reuse
 
For siYear = 1900 To 2100 'Loop through each year
If Not InStr(sTemp, Str(siYear)) Then 'If the year is not in the stored string then..
Inc siCount 'Increase siCount (Amount of years that don't have 5 weekend months)
aMMStore.Add(Str(siYear)) 'Add to the store
End If
Next
 
Print gb.NewLine & "There are " & Str(siCount) &
" years that do not have at least one five-weekend month" 'Print the amount of years with no 5 weekend months
Print aMMStore.Join(",") 'Print the years with no 5 weekend months
End</syntaxhighlight>
Output:
<pre>
August 1902
May 1903
January 1904
July 1904
December 1905
--------------
March 2097
August 2098
May 2099
January 2100
October 2100
 
Total months = 201
 
There are 29 years that do not have at least one five-weekend month
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096
</pre>
 
=={{header|GAP}}==
<langsyntaxhighlight lang="gap"># return a list of two lists :
# first is the list of months with five weekends between years y1 and y2 (included)
# second is the list of years without such months, in the same interval
Line 1,211 ⟶ 2,969:
# [ "Mar-1901", "Aug-1902", "May-1903", "Jan-1904", "Jul-1904" ]
r[1]{[n-4 .. n]};
# [ "Mar-2097", "Aug-2098", "May-2099", "Jan-2100", "Oct-2100" ]</langsyntaxhighlight>
 
=={{header|Go}}==
Using second algorithm suggestion:
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,263 ⟶ 3,022:
}
fmt.Println(len(haveNone), "total")
}</langsyntaxhighlight>
{{out}}
Output:
<pre>
Months with five weekends:
Line 1,307 ⟶ 3,066:
29 total
</pre>
 
=={{header|Groovy}}==
Solution:
<syntaxhighlight lang="groovy">enum Day {
Sun, Mon, Tue, Wed, Thu, Fri, Sat
static Day valueOf(Date d) { Day.valueOf(d.format('EEE')) }
}
 
def date = Date.&parse.curry('yyyy-M-dd')
def isLongMonth = { firstDay -> (firstDay + 31).format('dd') == '01'}
 
def fiveWeekends = { years ->
years.collect { year ->
(1..12).collect { month ->
date("${year}-${month}-01")
}.findAll { firstDay ->
isLongMonth(firstDay) && Day.valueOf(firstDay) == Day.Fri
}
}.flatten()
}</syntaxhighlight>
 
Test:
<syntaxhighlight lang="groovy">def ym = { it.format('yyyy-MM') }
def years = 1900..2100
def fiveWeekendMonths = fiveWeekends(years)
println "Number of five weekend months: ${fiveWeekendMonths.size()}"
fiveWeekendMonths.each { println (ym(it)) }</syntaxhighlight>
 
{{out}}
<pre style="height:30ex;overflow:scroll;">Number of five weekend months: 201
1901-03
1902-08
1903-05
1904-01
1904-07
1905-12
1907-03
1908-05
1909-01
1909-10
1910-07
1911-12
1912-03
1913-08
1914-05
1915-01
1915-10
1916-12
1918-03
1919-08
1920-10
1921-07
1922-12
1924-08
1925-05
1926-01
1926-10
1927-07
1929-03
1930-08
1931-05
1932-01
1932-07
1933-12
1935-03
1936-05
1937-01
1937-10
1938-07
1939-12
1940-03
1941-08
1942-05
1943-01
1943-10
1944-12
1946-03
1947-08
1948-10
1949-07
1950-12
1952-08
1953-05
1954-01
1954-10
1955-07
1957-03
1958-08
1959-05
1960-01
1960-07
1961-12
1963-03
1964-05
1965-01
1965-10
1966-07
1967-12
1968-03
1969-08
1970-05
1971-01
1971-10
1972-12
1974-03
1975-08
1976-10
1977-07
1978-12
1980-08
1981-05
1982-01
1982-10
1983-07
1985-03
1986-08
1987-05
1988-01
1988-07
1989-12
1991-03
1992-05
1993-01
1993-10
1994-07
1995-12
1996-03
1997-08
1998-05
1999-01
1999-10
2000-12
2002-03
2003-08
2004-10
2005-07
2006-12
2008-08
2009-05
2010-01
2010-10
2011-07
2013-03
2014-08
2015-05
2016-01
2016-07
2017-12
2019-03
2020-05
2021-01
2021-10
2022-07
2023-12
2024-03
2025-08
2026-05
2027-01
2027-10
2028-12
2030-03
2031-08
2032-10
2033-07
2034-12
2036-08
2037-05
2038-01
2038-10
2039-07
2041-03
2042-08
2043-05
2044-01
2044-07
2045-12
2047-03
2048-05
2049-01
2049-10
2050-07
2051-12
2052-03
2053-08
2054-05
2055-01
2055-10
2056-12
2058-03
2059-08
2060-10
2061-07
2062-12
2064-08
2065-05
2066-01
2066-10
2067-07
2069-03
2070-08
2071-05
2072-01
2072-07
2073-12
2075-03
2076-05
2077-01
2077-10
2078-07
2079-12
2080-03
2081-08
2082-05
2083-01
2083-10
2084-12
2086-03
2087-08
2088-10
2089-07
2090-12
2092-08
2093-05
2094-01
2094-10
2095-07
2097-03
2098-08
2099-05
2100-01
2100-10</pre>
 
'''Extra Credit:'''
 
Test:
<syntaxhighlight lang="groovy">def yearsWith = fiveWeekendMonths.collect { it.format('yyyy') as int } as Set
def yearsWithout = (years as Set) - yearsWith
println "\nNumber of years without a five weekend month: ${yearsWithout.size()}"
yearsWithout.each { println it }</syntaxhighlight>
 
{{out}}
<pre style="height:30ex;overflow:scroll;">Number of years without a five weekend month: 29
1900
1906
1917
1923
1928
1934
1945
1951
1956
1962
1973
1979
1984
1990
2001
2007
2012
2018
2029
2035
2040
2046
2057
2063
2068
2074
2085
2091
2096</pre>
 
=={{header|Harbour}}==
<syntaxhighlight lang="visualfoxpro">
PROCEDURE Main()
LOCAL y, m, d, nFound, cNames, nTot := 0, nNotFives := 0
LOCAL aFounds := {}
SET DATE ANSI
FOR y := 1900 TO 2100
nFound := 0 ; cNames := ""
FOR m := 1 TO 12
d := CtoD( hb_NtoS( y ) +"/" + hb_NtoS( m ) + "/1" )
IF CDoW( d ) == "Friday"
IF DaysInMonth( m ) == 31
nFound++
cNames += CMonth( d ) + " "
ENDIF
ENDIF
NEXT
IF nFound > 0
AAdd( aFounds, hb_NtoS( y ) + " : " + hb_NtoS( nFound ) + " ( " + Rtrim( cNames ) + " )" )
nTot += nFound
ELSE
nNotFives++
ENDIF
NEXT
? "Total months with five weekends: " + hb_NtoS( nTot )
? "(see bellow the first and last five years/months with five weekends)"
?
AEval( aFounds, { | e, n | Iif( n < 6, Qout( e ), NIL ) } )
Qout("...")
AEval( aFounds, { | e, n | Iif( n > Len(aFounds)-5, Qout( e ), NIL ) } )
?
? "Years with no five weekends months: " + hb_NtoS( nNotFives )
 
RETURN</syntaxhighlight>
 
{{out}}
<pre>
Total months with five weekends: 201
(see bellow the first and last five years/months with five weekends)
 
1901 : 1 ( March )
1902 : 1 ( August )
1903 : 1 ( May )
1904 : 2 ( January July )
1905 : 1 ( December )
...
2095 : 1 ( July )
2097 : 1 ( March )
2098 : 1 ( August )
2099 : 1 ( May )
2100 : 2 ( January October )
 
Years with no five weekends months: 29</pre>
 
=={{header|Haskell}}==
====Without using date libraries====
Not using any helper libraries, this code profits from Haskell's lazy evaluation.
Knowing that the first day of 1900 was a Monday, we make an infinit list of days and split it in years and months.
To do this, we take and drop days from the head of the list of days.
 
year 1900 = [Monday, Tuesday, Wednesday...] (365 items)
year 1904 = [Friday, Saturday, Sunday...] (366 items -- leap year)
 
and also:
 
year 1900 = [(January, [Monday, Tuesday..]), (February, [Thursday, Friday..]), ...]
 
Now it is easy to get all months with 31 days that start on Friday.
<syntaxhighlight lang="haskell">import Data.List (intercalate)
 
data DayOfWeek = Monday | Tuesday | Wednesday | Thursday | Friday |
Saturday | Sunday
deriving (Eq, Show)
 
-- the whole thing bases upon an infinite list of weeks
 
daysFrom1_1_1900 :: [DayOfWeek]
daysFrom1_1_1900 = concat $ repeat [Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday, Sunday]
 
data Month = January | February | March | April | May | June | July |
August | September | October | November | December
deriving (Show)
 
type Year = Int
type YearCalendar = (Year, [DayOfWeek])
type MonthlyCalendar = (Year, [(Month, [DayOfWeek])])
 
-- makes groups of 365 or 366 days for each year (infinite list)
 
yearsFrom :: [DayOfWeek] -> Year -> [YearCalendar]
yearsFrom s i = (i, yeardays) : yearsFrom rest (i + 1)
where
yeardays = take (leapOrNot i) s
yearlen = length yeardays
rest = drop yearlen s
leapOrNot n = if isLeapYear n then 366 else 365
 
yearsFrom1900 :: [YearCalendar]
yearsFrom1900 = yearsFrom daysFrom1_1_1900 1900
 
-- makes groups of days for each month of the year
 
months :: YearCalendar -> MonthlyCalendar
months (y, d) = (y, [(January, january), (February, february),
(March, march), (April, april), (May, may), (June, june),
(July, july), (August, august), (September, september),
(October, october), (November, november), (December, december)])
where
leapOrNot = if isLeapYear y then 29 else 28
january = take 31 d
february = take leapOrNot $ drop 31 d
march = take 31 $ drop (31 + leapOrNot) d
april = take 30 $ drop (62 + leapOrNot) d
may = take 31 $ drop (92 + leapOrNot) d
june = take 30 $ drop (123 + leapOrNot) d
july = take 31 $ drop (153 + leapOrNot) d
august = take 31 $ drop (184 + leapOrNot) d
september = take 30 $ drop (215 + leapOrNot) d
october = take 31 $ drop (245 + leapOrNot) d
november = take 30 $ drop (276 + leapOrNot) d
december = take 31 $ drop (306 + leapOrNot) d
 
-- see if a year is a leap year
 
isLeapYear n
| n `mod` 100 == 0 = n `mod` 400 == 0
| otherwise = n `mod` 4 == 0
 
-- make a list of the months of a year that have 5 weekends
-- (they must have 31 days and the first day must be Friday)
-- if the year doesn't contain any 5-weekended months, then
-- return the year and an empty list
 
whichFiveWeekends :: MonthlyCalendar -> (Year, [Month])
whichFiveWeekends (y, ms) = (y, map (\(m, _) -> m) found) -- extract the months & leave out their days
where found = filter (\(m, a@(d:ds)) -> and [length a == 31,
d == Friday]) ms
 
-- take all days from 1900 until 2100, grouping them by years, then by
-- months, and calculating whether they have any 5-weekended months
-- or not
 
calendar :: [MonthlyCalendar]
calendar = map months $ yearsFrom1900
 
fiveWeekends1900To2100 :: [(Year, [Month])]
fiveWeekends1900To2100 = takeWhile (\(y, _) -> y <= 2100) $
map whichFiveWeekends calendar
 
main = do
-- count the number of years with 5 weekends
let answer1 = foldl (\c (_, m) -> c + length m) 0 fiveWeekends1900To2100
-- take only the years with 5-weekended months
answer2 = filter (\(_, m) -> not $ null m) fiveWeekends1900To2100
-- take only the years without 5-weekended months
answer30 = filter (\(_, m) -> null m) fiveWeekends1900To2100
-- count how many years without 5-weekended months there are
answer31 = length answer30
-- show the years without 5-weekended months
answer32 = intercalate ", " $ map (\(y, m) -> show y) answer30
putStrLn $ "There are " ++ show answer1 ++ " months with 5 weekends between 1900 and 2100."
putStrLn "\nThe first ones are:"
mapM_ (putStrLn . formatMonth) $ take 5 $ answer2
putStrLn "\nThe last ones are:"
mapM_ (putStrLn . formatMonth) $ reverse $ take 5 $ reverse answer2
putStrLn $ "\n" ++ show answer31 ++ " years don't have at least one five-weekened month"
putStrLn "\nThose are:"
putStrLn answer32
formatMonth :: (Year, [Month]) -> String
formatMonth (y, m) = show y ++ ": " ++ intercalate ", " [ show x | x <- m ]</syntaxhighlight>
{{out}}
<pre>
There are 201 months with 5 weekends between 1900 and 2100.
 
The first ones are:
1901: March
1902: August
1903: May
1904: January, July
1905: December
 
The last ones are:
2095: July
2097: March
2098: August
2099: May
2100: January, October
 
29 years don't have at least one five-weekended month
 
Those are:
1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096
</pre>
 
====Using Data.Time====
<syntaxhighlight lang="haskell">import Data.List (intercalate)
import Data.List.Split (chunksOf)
import Data.Time (Day, fromGregorian, gregorianMonthLength)
import Data.Time.Calendar.WeekDate (toWeekDate)
 
---------------- MONTHS WITH FIVE WEEKENDS ---------------
 
fiveFridayMonths :: Integer -> [(Integer, Int)]
fiveFridayMonths y =
[1 .. 12]
>>= \m ->
[ (y, m)
| isFriday (fromGregorian y m 1),
31 == gregorianMonthLength y m
]
 
isFriday :: Day -> Bool
isFriday d = 5 == day
where
(_, _, day) = toWeekDate d
 
--------------------------- TEST -------------------------
main :: IO ()
main = do
let years = [1900 .. 2100]
xs = fiveFridayMonths <$> years
lean =
concat $
zipWith
(\months year -> [year | null months])
xs
years
n = (length . concat) xs
(putStrLn . intercalate "\n\n")
[ "How many five-weekend months 1900-2100 ?",
'\t' : show n,
"First five ?",
'\t' : show (concat (take 5 xs)),
"Last five ?",
'\t' : show (concat (drop (n - 5) xs)),
"How many lean years ? (No five-weekend months)",
'\t' : show (length lean),
"Which years are lean ?",
unlines $
('\t' :) . unwords . fmap show
<$> chunksOf 5 lean
]</syntaxhighlight>
{{Out}}
<pre>How many five-weekend months 1900-2100 ?
 
201
 
First five ?
 
[(1901,3),(1902,8),(1903,5),(1904,1),(1904,7)]
 
Last five ?
 
[(2097,3),(2098,8),(2099,5),(2100,10),(2100,1)]
 
How many lean years ? (No five-weekend months)
 
29
 
Which years are lean ?
 
1900 1906 1917 1923 1928
1934 1945 1951 1956 1962
1973 1979 1984 1990 2001
2007 2012 2018 2029 2035
2040 2046 2057 2063 2068
2074 2085 2091 2096</pre>
 
=={{header|Icon}} and {{header|Unicon}}==
<syntaxhighlight lang="icon">link datetime,printf
 
procedure main(A) # five weekends
printf( "There are %d months from %d to %d with five full weekends.\n",
*(L := fiveweekends(s := 1900, f := 2100)), s,f)
printf("The first and last five such months are:\n")
every printf("%s\n",L[1 to 5]|"..."|L[-4 to 0])
printf( "There are %d years without such months as follows:\n",
*(M := Bonus(s,f,L)))
every printf("%s\n",!M)
end
 
procedure fiveweekends(start,finish)
L := [] # months years with five weekends FRI-SUN
every year := start to finish & month := 1 to 12 do
if month = (2|4|6|9|11) then next
else if julian(month,1,year) % 7 = 4 then
put(L,sprintf("%d-%d-1",year,month))
return L
end
 
procedure Bonus(start,finish,fwe)
every insert(Y := set(), start to finish)
every insert(F := set(), integer(!fwe ? tab(find("-"))))
return sort(Y--F)
end</syntaxhighlight>
 
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.icn provides formatting]
[http://www.cs.arizona.edu/icon/library/src/procs/datetime.icn datetime.icn provides julian]
 
{{out}}
<pre>There are 201 months from 1900 to 2100 with five full weekends.
The first and last five such months are:
1901-3-1
1902-8-1
1903-5-1
1904-1-1
1904-7-1
...
2098-8-1
2099-5-1
2100-1-1
2100-10-1
There are 29 years without such months as follows:
1900
1906
1917
1923
1928
1934
1945
1951
1956
1962
1973
1979
1984
1990
2001
2007
2012
2018
2029
2035
2040
2046
2057
2063
2068
2074
2085
2091
2096</pre>
 
=={{header|Inform 7}}==
Inform 7 has no built-in date functions, so this solution implements date types and a day-of-week function.
 
<langsyntaxhighlight lang="inform7">Calendar is a room.
 
When play begins:
Line 1,412 ⟶ 3,790:
repeat with M running through months:
if M of Y is a happy month, decide no;
decide yes.</langsyntaxhighlight>
 
{{out}}
Output:
<pre>March 1901.
August 1902.
Line 1,427 ⟶ 3,805:
October 2100.
Found 201 months with five weekends and 29 years with no such months.</pre>
 
=={{header|Icon}} and {{header|Unicon}}==
<lang Icon>link datetime,printf
 
procedure main(A) # five weekends
printf( "There are %d months from %d to %d with five full weekends.\n",
*(L := fiveweekends(s := 1900, f := 2100)), s,f)
printf("The first and last five such months are:\n")
every printf("%s\n",L[1 to 5]|"..."|L[-4 to 0])
printf( "There are %d years without such months as follows:\n",
*(M := Bonus(s,f,L)))
every printf("%s\n",!M)
end
 
procedure fiveweekends(start,finish)
L := [] # months years with five weekends FRI-SUN
every year := start to finish & month := 1 to 12 do
if month = (2|4|6|9|11) then next
else if julian(month,1,year) % 7 = 4 then
put(L,sprintf("%d-%d-1",year,month))
return L
end
 
procedure Bonus(start,finish,fwe)
every insert(Y := set(), start to finish)
every insert(F := set(), integer(!fwe ? tab(find("-"))))
return sort(Y--F)
end</lang>
 
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.icn provides formatting]
[http://www.cs.arizona.edu/icon/library/src/procs/datetime.icn datetime.icn provides julian]
 
Output:<pre>There are 201 months from 1900 to 2100 with five full weekends.
The first and last five such months are:
1901-3-1
1902-8-1
1903-5-1
1904-1-1
1904-7-1
...
2098-8-1
2099-5-1
2100-1-1
2100-10-1
There are 29 years without such months as follows:
1900
1906
1917
1923
1928
1934
1945
1951
1956
1962
1973
1979
1984
1990
2001
2007
2012
2018
2029
2035
2040
2046
2057
2063
2068
2074
2085
2091
2096</pre>
 
 
=={{header|J}}==
<langsyntaxhighlight lang="j">require 'types/datetime numeric'
find5wkdMonths=: verb define
years=. range 2{. y
Line 1,511 ⟶ 3,813:
m5w=. (#~ 0 = weekday) >,{years;months;31 NB. 5 full weekends iff 31st is Sunday(0)
>'MMM YYYY' fmtDate toDayNo m5w
)</langsyntaxhighlight>
'''Usage:'''
<langsyntaxhighlight lang="j"> # find5wkdMonths 1900 2100 NB. number of months found
201
(5&{. , '...' , _5&{.) find5wkdMonths 1900 2100 NB. First and last 5 months found
Line 1,528 ⟶ 3,830:
Oct 2100
# (range -. {:"1@(_ ". find5wkdMonths)) 1900 2100 NB. number of years without 5 weekend months
29</langsyntaxhighlight>
 
=={{header|Java}}==
In Java 1.5+ you can add <code>import static java.util.Calendar.*;</code> to the list of imports and remove all other occurrences of <code>Calendar.</code> from the rest of the code (e.g. <code>Calendar.FRIDAY</code> would simply become <code>FRIDAY</code>). It's more portable (and probably more clear) to leave the <code>Calendar.</code>'s in.
<langsyntaxhighlight lang="java">import java.util.Calendar;
import java.util.GregorianCalendar;
 
public class FiveFSS {
private static boolean[] years = new boolean[201];
//dreizig tage habt september...
private static int[] month31 = {Calendar.JANUARY, Calendar.MARCH, Calendar.MAY,
Calendar.JULY, Calendar.AUGUST, Calendar.OCTOBER, Calendar.DECEMBER};
Line 1,564 ⟶ 3,865:
}
}
}</langsyntaxhighlight>
Output{{out}} (middle results cut out):
<pre style="height:30ex;overflow:scroll"> There are 201 months with five weekends from 1900 through 2100:
3-1901
Line 1,623 ⟶ 3,924:
 
=={{header|JavaScript}}==
===ES5===
<lang javascript>function startsOnFriday(month, year)
====Imperative====
<syntaxhighlight lang="javascript">function startsOnFriday(month, year)
{
// 0 is Sunday, 1 is Monday, ... 5 is Friday, 6 is Saturday
Line 1,667 ⟶ 3,970:
document.write('Years with no five-weekend months: ' + yearsWithoutFiveWeekends.length + '<br>');
}
fiveWeekends();</langsyntaxhighlight>
 
{{out|Sample output:}}
<pre>1901 2
1902 7
Line 1,685 ⟶ 3,988:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096
Years with no five-weekend months: 29</pre>
 
 
Here is an alternative solution that uses the offset between the first day of every month, generating the same solution but without relying on the Date object.
<syntaxhighlight lang="javascript">var Months = [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec'
];
 
var leap = 0,
// Relative offsets between first day of each month
offset = [3,0,3,2,3,2,3,3,2,3,2,3],
 
// Months that contain 31 days
longMonths = [1,3,5,7,8,10,12],
 
startYear = 1900,
year = startYear,
endYear = 2100,
 
// Jan 1, 1900 starts on a Monday
day = 1,
 
totalPerYear = 0,
total = 0,
without = 0;
 
for (; year < endYear + 1; year++) {
leap = totalPerYear = 0;
 
if (year % 4 === 0) {
if (year % 100 === 0) {
if (year % 400 === 0) {
leap = 1;
}
} else {
leap = 1;
}
}
 
for (var i = 0; i < offset.length; i++) {
for (var j = 0; day === 5 && j < longMonths.length; j++) {
if (i + 1 === longMonths[j]) {
console.log(year + '-' + Months[i]);
totalPerYear++;
total++;
break;
}
}
 
// February -- if leap year, then +1 day
if (i == 1) {
day = (day + leap) % 7;
} else {
day = (day + offset[i]) % 7;
}
}
 
if (totalPerYear === 0) {
without++;
}
}
 
console.log('Number of months that have five full weekends from 1900 to 2100: ' + total);
console.log('Number of years without any five full weekend months: ' + without);</syntaxhighlight>
{{out}}
<pre>1901-Mar
1902-Aug
1903-May
1904-Jan
1904-Jul
...
2097-Mar
2098-Aug
2099-May
2100-Jan
2100-Oct
Number of months that have five full weekends from 1900 to 2100: 201
Number of years without any five full weekend months: 29</pre>
 
====Functional====
<syntaxhighlight lang="javascript">(function () {
'use strict';
 
// longMonthsStartingFriday :: Int -> Int
function longMonthsStartingFriday(y) {
return [0, 2, 4, 6, 7, 9, 11]
.filter(function (m) {
return (new Date(Date.UTC(y, m, 1)))
.getDay() === 5;
});
}
 
// range :: Int -> Int -> [Int]
function range(m, n) {
return Array.apply(null, Array(n - m + 1))
.map(function (x, i) {
return m + i;
});
}
 
var lstNames = [
'January', '', 'March', '', 'May', '',
'July', 'August', '', 'October', '', 'December'
],
 
lstYears = range(1900, 2100),
 
lstFullMonths = lstYears
.reduce(function (a, y) {
var strYear = y.toString();
 
return a.concat(
longMonthsStartingFriday(y)
.map(function (m) {
return strYear + ' ' + lstNames[m];
})
);
}, []),
 
lstLeanYears = lstYears
.filter(function (y) {
return longMonthsStartingFriday(y)
.length === 0;
});
 
return JSON.stringify({
number: lstFullMonths.length,
firstFive: lstFullMonths.slice(0, 5),
lastFive: lstFullMonths.slice(-5),
leanYearCount: lstLeanYears.length
},
null, 2
);
})();</syntaxhighlight>
{{Out}}
<pre>{
"number": 201,
"firstFive": [
"1901 March",
"1902 August",
"1903 May",
"1904 January",
"1904 July"
],
"lastFive": [
"2097 March",
"2098 August",
"2099 May",
"2100 January",
"2100 October"
],
"leanYearCount": 29
}</pre>
 
===ES6===
<syntaxhighlight lang="javascript">(() => {
// longMonthsStartingFriday :: Int -> [Int]
const longMonthsStartingFriday = y =>
filter(m => (new Date(Date.UTC(y, m, 1)))
.getDay() === 5, [0, 2, 4, 6, 7, 9, 11]);
 
// Years -> YearMonths
// fullMonths :: [Int] -> [String]
const fullMonths = xs =>
foldl((a, y) => a.concat(
map(m => `${y.toString()} ${[
'January', '', 'March', '', 'May', '',
'July', 'August', '', 'October', '', 'December'
][m]}`, longMonthsStartingFriday(y))
), [], xs);
 
// leanYears :: [Int] -> [Int]
const leanYears = years =>
filter(y => longMonthsStartingFriday(y)
.length === 0, years);
 
// GENERIC ----------------------------------------------------------------
 
// A list of functions applied to a list of arguments
// <*> :: [(a -> b)] -> [a] -> [b]
const ap = (fs, xs) => //
[].concat.apply([], fs.map(f => //
[].concat.apply([], xs.map(x => [f(x)]))));
 
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
 
// filter :: (a -> Bool) -> [a] -> [a]
const filter = (f, xs) => xs.filter(f);
 
// foldl :: (b -> a -> b) -> b -> [a] -> b
const foldl = (f, a, xs) => xs.reduce(f, a);
 
// map :: (a -> b) -> [a] -> [b]
const map = (f, xs) => xs.map(f);
 
// show :: a -> String
const show = x => JSON.stringify(x, null, 2);
 
 
// TEST -------------------------------------------------------------------
const [lstFullMonths, lstLeanYears] = ap(
[fullMonths, leanYears], [enumFromTo(1900, 2100)]
);
 
return show({
number: lstFullMonths.length,
firstFive: lstFullMonths.slice(0, 5),
lastFive: lstFullMonths.slice(-5),
leanYearCount: lstLeanYears.length
});
})();</syntaxhighlight>
{{Out}}
<pre>{
"number": 201,
"firstFive": [
"1901 March",
"1902 August",
"1903 May",
"1904 January",
"1904 July"
],
"lastFive": [
"2097 March",
"2098 August",
"2099 May",
"2100 January",
"2100 October"
],
"leanYearCount": 29
}</pre>
 
=={{header|jq}}==
{{ works with|jq|1.4}}
 
'''Foundations: Zeller's Congruence'''
<syntaxhighlight lang="jq"> Use Zeller's Congruence to determine the day of the week, given
# year, month and day as integers in the conventional way.
# Emit 0 for Saturday, 1 for Sunday, etc.
#
def day_of_week(year; month; day):
if month == 1 or month == 2 then
[month + 12, year - 1]
else
[month, year]
end
| day + (13*(.[0] + 1)/5|floor)
+ (.[1]%100) + ((.[1]%100)/4|floor)
+ (.[1]/400|floor) - 2*(.[1]/100|floor)
| . % 7
;</syntaxhighlight>
'''Nuts and Bolts''':
<syntaxhighlight lang="jq">def weekday_of_last_day_of_month(year; month):
def day_before(day): (6+day) % 7;
 
if month==12 then day_before( day_of_week(year+1; 1; 1) )
else day_before( day_of_week( year; month+1; 1 ) )
end
;
# The only case where the month has 5 weekends is when the last day
# of the month falls on a Sunday and the month has 31 days.
#
def five_weekends(from; to):
reduce range(from; to) as $year
([]; reduce (1,3,5,7,8,10,12) as $month # months with 31 days
(.;
weekday_of_last_day_of_month($year; $month) as $day
| if $day == 1 then . + [[ $year, $month]] else . end ))
;
 
# Input [year, month] as conventional integers; print e.g. "Jan 2001"
def pp:
def month:
["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][.-1];
"\(.[1] | month) \(.[0])"
;</syntaxhighlight>
'''The Task''':
<syntaxhighlight lang="jq">five_weekends(1900;2101)
| "There are \(length) months with 5 weekends from 1900 to 2100 inclusive;",
"the first and last five are as follows:",
( .[0: 5][] | pp),
"...",
( .[length-5: ][] | pp),
"In this period, there are \( [range(1900;2101)] - map( .[0] ) | length ) years which have no five-weekend months."</syntaxhighlight>
{{out}}
<syntaxhighlight lang="sh">$ jq -r -n -f Five_Weekends.jq
There are 201 months with 5 weekends from 1900 to 2100 inclusive;
the first and last five are as follows:
Mar 1901
Aug 1902
May 1903
Jan 1904
Jul 1904
...
Mar 2097
Aug 2098
May 2099
Jan 2100
Oct 2100
In this period, there are 29 years which have no five-weekend months.</syntaxhighlight>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
 
<syntaxhighlight lang="julia">isweekend(dt::Date) = Dates.dayofweek(dt) ∈ (Dates.Friday, Dates.Saturday, Dates.Sunday)
 
function hasfiveweekend(month::Integer, year::Integer)
dmin = Date(year, month, 1)
dmax = dmin + Dates.Day(Dates.daysinmonth(dmin) - 1)
return count(isweekend, dmin:dmax) ≥ 15
end
 
months = collect((y, m) for y in 1900:2100, m in 1:12 if hasfiveweekend(m, y))
 
println("Number of months with 5 full-weekends: $(length(months))")
println("First five such months:")
for (y, m) in months[1:5] println(" - $y-$m") end
println("Last five such months:")
for (y, m) in months[end-4:end] println(" - $y-$m") end
 
# extra credit
yrs = getindex.(months, 1)
nyrs = 2100 - 1899 - length(unique(yrs))
 
println("Number of year with not one 5-full-weekend month: $nyrs")</syntaxhighlight>
 
{{out}}
<pre>Number of months with 5 full-weekends: 201
First five such months:
- 1904-1
- 1909-1
- 1915-1
- 1926-1
- 1932-1
Last five such months:
- 2062-12
- 2073-12
- 2079-12
- 2084-12
- 2090-12
Number of year with not one 5-full-weekend month: 29</pre>
 
=={{header|k}}==
<syntaxhighlight lang="k">
<lang k>
cal_j:(_jd[19000101]+!(-/_jd 21010101 19000101)) / enumerate the calendar
is_we:(cal_j!7) _lin 4 5 6 / identify friday saturdays and sundays
Line 1,701 ⟶ 4,349:
yn5:y@&~y _lin y5 / find any years not in the 5 weekend month list
`0:,"There are ",($#yn5)," years without any five-weekend months"
`0:,1_,/",",/:$yn5</langsyntaxhighlight>
{{out}}
Output:
<pre>
There are 201 months with five weekends
Line 1,719 ⟶ 4,367:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096</pre>
 
=={{header|MathematicaKotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
<lang Mathematica>years = {1900, 2100}; months = {1 ,3 ,5 ,7 ,8 ,10 ,12};
 
import java.util.*
 
fun main(args: Array<String>) {
val calendar = GregorianCalendar(1900, 0, 1)
val months31 = arrayOf(1, 3, 5, 7, 8, 10, 12)
val monthsWithFive = mutableListOf<String>()
val yearsWithNone = mutableListOf<Int>()
for (year in 1900..2100) {
var countInYear = 0 // counts months in a given year with 5 weekends
for (month in 1..12) {
if ((month in months31) && (Calendar.FRIDAY == calendar[Calendar.DAY_OF_WEEK])) {
countInYear++
monthsWithFive.add("%02d".format(month) + "-" + year)
}
calendar.add(Calendar.MONTH, 1)
}
if (countInYear == 0) yearsWithNone.add(year)
}
println("There are ${monthsWithFive.size} months with 5 weekends")
println("The first 5 are ${monthsWithFive.take(5)}")
println("The final 5 are ${monthsWithFive.takeLast(5)}")
println()
println("There are ${yearsWithNone.size} years with no months which have 5 weekends, namely:")
println(yearsWithNone)
}</syntaxhighlight>
 
{{out}}
<pre>
There are 201 months with 5 weekends
The first 5 are [03-1901, 08-1902, 05-1903, 01-1904, 07-1904]
The final 5 are [03-2097, 08-2098, 05-2099, 01-2100, 10-2100]
 
There are 29 years with no months which have 5 weekends, namely:
[1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096]
</pre>
 
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(
months = array(1, 3, 5, 7, 8, 10, 12),
fivemonths = array,
emptyears = array,
checkdate = date,
countyear
)
 
#checkdate -> day = 1
 
loop(-from = 1900, -to = 2100) => {
 
#countyear = false
 
#checkdate -> year = loop_count
 
with month in #months
do {
#checkdate -> month = #month
if(#checkdate -> dayofweek == 6) => {
#countyear = true
#fivemonths -> insert(#checkdate -> format(`YYYY MMM`))
}
}
 
if(not #countyear) => {
#emptyears -> insert(loop_count)
}
 
}
local(
monthcount = #fivemonths -> size,
output = 'Total number of months ' + #monthcount + '<br /> Starting five months '
)
 
loop(5) => {
#output -> append(#fivemonths -> get(loop_count) + ', ')
}
 
#output -> append('<br /> Ending five months ')
 
loop(-from = #monthcount - 5, -to = #monthcount) => {
#output -> append(#fivemonths -> get(loop_count) + ', ')
}
 
#output -> append('<br /> Years with no five weekend months ' + #emptyears -> size + '<br />')
 
with year in #emptyears do {
#output -> append(#year + ', ')
}
 
#output</syntaxhighlight>
{{out|Result}}
<pre>Total number of months 201
Starting five months 1901 Mar, 1902 Aug, 1903 May, 1903 Jan, 1904 Jul,
Ending five months 2095 Jul, 2097 Mar, 2098 Aug, 2099 May, 2099 Jan, 2100 Oct,
Years with no five weekend months 29
1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096,</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">
local months={"JAN","MAR","MAY","JUL","AUG","OCT","DEC"}
local daysPerMonth={31+28,31+30,31+30,31,31+30,31+30,0}
 
function find5weMonths(year)
local list={}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
 
for i,v in ipairs(daysPerMonth) do
if startday==4 then list[#list+1]=months[i] end
if i==1 and year%4==0 and year%100~=0 or year%400==0 then
startday=startday+1
end
startday=(startday+v)%7
end
return list
end
 
local cnt_months=0
local cnt_no5we=0
 
for y=1900,2100 do
local list=find5weMonths(y)
cnt_months=cnt_months+#list
if #list==0 then
cnt_no5we=cnt_no5we+1
end
print(y.." "..#list..": "..table.concat(list,", "))
end
print("Months with 5 weekends: ",cnt_months)
print("Years without 5 weekends in the same month:",cnt_no5we)
</syntaxhighlight>
{{out}}
<pre>1900 0:
1901 1: MAR
1902 1: AUG
1903 1: MAY
1904 2: JAN, JUL
1905 1: DEC
1906 0:
1907 1: MAR
1908 1: MAY
1909 2: JAN, OCT
...
...
...
2090 1: DEC
2091 0:
2092 1: AUG
2093 1: MAY
2094 2: JAN, OCT
2095 1: JUL
2096 0:
2097 1: MAR
2098 1: AUG
2099 1: MAY
2100 2: JAN, OCT
Months with 5 weekends: 201
Years without 5 weekends in the same month: 29</pre>
 
=={{header|Maple}}==
<syntaxhighlight lang="maple">five_weekends:= proc()
local i, month, count;
#Only months with 31 days can possibly satisfy the condition
local long_months := [1,3,5,7,8,10,12];
local months := ["January","February","March","April","May","June","July","August","September","October","November","December"];
count := 0;
for i from 1900 to 2100 by 1 do
for month in long_months do
if Calendar:-DayOfWeek(Date(i, month, 1)) = 6 then
printf("%d-%s\n", i, months[month]);
count++;
end if;
end do;
end do;
printf("%d months have five full weekends.\n", count);
end proc;
five_weekends();</syntaxhighlight>
{{Out|Output}}
<pre>1901-March
1902-August
1903-May
1904-January
1904-July
1905-December
1907-March
1908-May
1909-January
1909-October
1910-July
1911-December
1912-March
1913-August
1914-May
1915-January
1915-October
1916-December
1918-March
1919-August
1920-October
1921-July
1922-December
1924-August
1925-May
1926-January
1926-October
1927-July
1929-March
1930-August
1931-May
1932-January
1932-July
1933-December
1935-March
1936-May
1937-January
1937-October
1938-July
1939-December
1940-March
1941-August
1942-May
1943-January
1943-October
1944-December
1946-March
1947-August
1948-October
1949-July
1950-December
1952-August
1953-May
1954-January
1954-October
1955-July
1957-March
1958-August
1959-May
1960-January
1960-July
1961-December
1963-March
1964-May
1965-January
1965-October
1966-July
1967-December
1968-March
1969-August
1970-May
1971-January
1971-October
1972-December
1974-March
1975-August
1976-October
1977-July
1978-December
1980-August
1981-May
1982-January
1982-October
1983-July
1985-March
1986-August
1987-May
1988-January
1988-July
1989-December
1991-March
1992-May
1993-January
1993-October
1994-July
1995-December
1996-March
1997-August
1998-May
1999-January
1999-October
2000-December
2002-March
2003-August
2004-October
2005-July
2006-December
2008-August
2009-May
2010-January
2010-October
2011-July
2013-March
2014-August
2015-May
2016-January
2016-July
2017-December
2019-March
2020-May
2021-January
2021-October
2022-July
2023-December
2024-March
2025-August
2026-May
2027-January
2027-October
2028-December
2030-March
2031-August
2032-October
2033-July
2034-December
2036-August
2037-May
2038-January
2038-October
2039-July
2041-March
2042-August
2043-May
2044-January
2044-July
2045-December
2047-March
2048-May
2049-January
2049-October
2050-July
2051-December
2052-March
2053-August
2054-May
2055-January
2055-October
2056-December
2058-March
2059-August
2060-October
2061-July
2062-December
2064-August
2065-May
2066-January
2066-October
2067-July
2069-March
2070-August
2071-May
2072-January
2072-July
2073-December
2075-March
2076-May
2077-January
2077-October
2078-July
2079-December
2080-March
2081-August
2082-May
2083-January
2083-October
2084-December
2086-March
2087-August
2088-October
2089-July
2090-December
2092-August
2093-May
2094-January
2094-October
2095-July
2097-March
2098-August
2099-May
2100-January
2100-October
201 months have five full weekends.</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">years = {1900, 2100}; months = {1 ,3 ,5 ,7 ,8 ,10 ,12};
result = Select[Tuples[{Range@@years, months}], (DateString[# ~ Join ~ 1, "DayNameShort"] == "Fri")&];
 
Line 1,727 ⟶ 4,757:
Print["Last months: " , DateString[#,{"MonthName"," ","Year"}]& /@ result[[-5 ;; All]]];
Print[# // Length, " years without 5 weekend months:\n", #] &@
Complement[Range @@ years, Part[Transpose@result, 1]];</langsyntaxhighlight>
{{out}}
output:
<pre>201 months with 5 weekends
First months: {March 1901, August 1902, May 1903, January 1904, July 1904}
Line 1,736 ⟶ 4,766:
1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063,
2068, 2074, 2085, 2091, 2096}</pre>
 
=={{header|MATLAB}} / {{header|Octave}}==
 
<syntaxhighlight lang="matlab">longmonth = [1 3 5 7 8 10 12];
 
i = 1;
 
for y = 1900:2100
for m = 1:numel(longmonth)
[num,name] = weekday(datenum(y,longmonth(m),1));
if num == 6
x(i,:) = datestr(datenum(y,longmonth(m),1),'mmm yyyy'); %#ok<SAGROW>
i = i+1;
end
end
end
 
fprintf('There are %i months with 5 weekends between 1900 and 2100.\n',length(x))
 
fprintf('\n The first 5 months are:\n')
for j = 1:5
fprintf('\t %s \n',x(j,:))
end
 
fprintf('\n The final 5 months are:\n')
for j = length(x)-4:length(x)
fprintf('\t %s \n',x(j,:))
end</syntaxhighlight>
{{out}}
<pre>There are 201 months with 5 weekends between 1900 and 2100.
 
The first 5 months are:
Mar 1901
Aug 1902
May 1903
Jan 1904
Jul 1904
 
The final 5 months are:
Mar 2097
Aug 2098
May 2099
Jan 2100
Oct 2100 </pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">left(a, n) := makelist(a[i], i, 1, n)$
right(a, n) := block([m: length(a)], makelist(a[i], i, m - n + 1, m))$
 
a: [ ]$
for year from 1900 thru 2100 do
for month in [1, 3, 5, 7, 8, 10, 12] do
if weekday(year, month, 1) = 'friday then
a: endcons([year, month], a)$
 
length(a);
201
 
left(a, 5);
[[1901,3],[1902,8],[1903,5],[1904,1],[1904,7]]
 
right(a, 5);
[[2097,3],[2098,8],[2099,5],[2100,1],[2100,10]]</syntaxhighlight>
 
=={{header|MUMPS}}==
{{libheader|VA Kernel|22.0}}
<syntaxhighlight lang="mumps">
<lang MUMPS>
FIVE
;List and count the months between 1/1900 and 12/2100 that have 5 full weekends
Line 1,776 ⟶ 4,869:
. S:'N L=L_$S($L(L):",",1:"")_(R+1700)
W !,"For a total of "_C_" months.",!!,"There are "_$L(L,",")_" years with no five full weekends in any month.",!,"They are: "_L
Q</langsyntaxhighlight>Usage:<pre>
USER>d ^FIVE
 
Line 1,799 ⟶ 4,892:
There are 29 years with no five full weekends in any month.
They are: 1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096</pre>
 
=={{header|NetRexx}}==
 
<syntaxhighlight lang="netrexx">
/* NetRexx ************************************************************
* 30.08.2012 Walter Pachl derived from Rexx version 3
* omitting dead code left there
**********************************************************************/
options replace format comments java crossref savelog symbols
Numeric digits 20
nr5fwe=0
years_without_5fwe=0
mnl='Jan Mar May Jul Aug Oct Dec'
ml='1 3 5 7 8 10 12'
Loop j=1900 To 2100
year_has_5fwe=0
Loop mi=1 To ml.words()
m=ml.word(mi)
jd=greg2jul(j,m,1)
IF jd//7=4 Then Do /* 1st m j is a Friday */
nr5fwe=nr5fwe+1
year_has_5fwe=1
If j<=1905 | 2095<=j Then
Say mnl.word(mi) j 'has 5 full weekends'
End
End
If j=1905 Then Say '...'
if year_has_5fwe=0 Then years_without_5fwe=years_without_5fwe+1
End
Say ' '
Say nr5fwe 'occurrences of 5 full weekends in a month'
Say years_without_5fwe 'years without 5 full weekends'
exit
 
method greg2jul(yy,mm,d) public static returns Rexx
/***********************************************************************
* Converts a Gregorian date to the corresponding Julian day number
* 19891101 Walter Pachl REXXified algorithm published in CACM
* (Fliegel & vanFlandern, CACM Vol.11 No.10 October 1968)
***********************************************************************/
numeric digits 12
/***********************************************************************
* The published formula:
* res=d-32075+1461*(yy+4800+(mm-14)%12)%4+,
* 367*(mm-2-((mm-14)%12)*12)%12-3*((yy+4900+(mm-14)%12)%100)%4
***********************************************************************/
mma=(mm-14)%12
yya=yy+4800+mma
result=d-32075+1461*yya%4+367*(mm-2-mma*12)%12-3*((yya+100)%100)%4
Return result /* return the result */</syntaxhighlight>
Output: see Rexx version 3
 
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
#!/usr/local/bin/newlisp
 
(context 'KR)
 
(define (Kraitchik year month day)
; See https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Kraitchik.27s_variation
; Function adapted for specific task (not for general usage).
(if (or (= 1 month) (= 2 month))
(dec year)
)
;- - - -
(setf m-table '(_ 1 4 3 6 1 4 6 2 5 0 3 5)) ; - - - First element of list is dummy!
(setf m (m-table month))
;- - - -
(setf c-table '(0 5 3 1))
(setf century%4 (mod (int (slice (string year) 0 2)) 4))
(setf c (c-table century%4))
;- - - -
(setf yy* (slice (string year) -2))
(if (= "0" (yy* 0))
(setf yy* (yy* 1))
)
(setf yy (int yy*))
(setf y (mod (+ (/ yy 4) yy) 7))
;- - - -
(setf dow-table '(6 0 1 2 3 4 5))
(dow-table (mod (+ day m c y) 7))
)
 
(context 'MAIN)
 
(setf Fives 0)
(setf NotFives 0)
(setf Report '())
(setf months-table '((1 "Jan") (3 "Mar") (5 "May") (7 "Jul") (8 "Aug") (10 "Oct") (12 "Dec")))
(for (y 1900 2100)
(setf FivesFound 0)
(setf Names "")
(dolist (m '(1 3 5 7 8 10 12))
(setf Dow (KR:Kraitchik y m 1))
(if (= 5 Dow)
(begin
(++ FivesFound)
(setf Names (string Names " " (lookup m months-table)))
)
)
)
 
(if (zero? FivesFound)
(++ NotFives)
(begin
(setf Report (append Report (list (list y FivesFound (string "(" Names " )")))))
(setf Fives (+ Fives FivesFound))
)
)
)
 
 
;- - - - Display all report data
;(dolist (x Report)
; (println (x 0) ": " (x 1) " " (x 2))
;)
 
 
;- - - - Display only first five and last five records
(dolist (x (slice Report 0 5))
(println (x 0) ": " (x 1) " " (x 2))
)
(println "...")
(dolist (x (slice Report -5))
(println (x 0) ": " (x 1) " " (x 2))
)
 
(println "\nTotal months with five weekends: " Fives)
(println "Years with no five weekends months: " NotFives)
(exit)
</syntaxhighlight>
{{out}}
<pre>
1901: 1 ( Mar )
1902: 1 ( Aug )
1903: 1 ( May )
1904: 2 ( Jan Jul )
1905: 1 ( Dec )
...
2095: 1 ( Jul )
2097: 1 ( Mar )
2098: 1 ( Aug )
2099: 1 ( May )
2100: 2 ( Jan Oct )
 
Total months with five weekends: 201
Years with no five weekends months: 29
</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import times
 
const LongMonths = {mJan, mMar, mMay, mJul, mAug, mOct, mDec}
 
var sumNone = 0
for year in 1900..2100:
var none = true
for month in LongMonths:
if initDateTime(1, month, year, 0, 0, 0).weekday == dFri:
echo month, " ", year
none = false
if none: inc sumNone
 
echo "\nYears without a 5 weekend month: ", sumNone</syntaxhighlight>
{{out}}
<pre>March 1901
August 1902
May 1903
January 1904
July 1904
December 1905
[...]
March 2097
August 2098
May 2099
January 2100
October 2100
 
Years without a 5 weekend month: 29</pre>
 
=={{header|OCaml}}==
{{libheader|OCaml Calendar Library}}
 
<langsyntaxhighlight lang="ocaml">open CalendarLib
 
let list_first_five = function
Line 1,829 ⟶ 5,102:
List.iter print_month (list_first_five (List.rev !months));
List.iter print_month (List.rev (list_first_five !months));
;;</langsyntaxhighlight>
 
Output:
 
{{out}}
<pre>$ ocaml unix.cma str.cma -I +calendar calendarLib.cma five_we.ml
Number of months with 5 weekends: 201
Line 1,846 ⟶ 5,118:
2100-01
2100-10</pre>
 
=={{header|Oforth}}==
 
<syntaxhighlight lang="oforth">: fiveWeekEnd(y1, y2)
| y m |
 
ListBuffer new
y1 y2 for: y [
Date.JANUARY Date.DECEMBER for: m [
Date.DaysInMonth(y, m) 31 ==
[ y, m, 01 ] asDate dayOfWeek Date.FRIDAY == and
ifTrue: [ [ y, m ] over add ]
]
]
dup size println dup left(5) println right(5) println ;</syntaxhighlight>
 
{{out}}
<pre>
>fiveWeekEnd(1900, 2100)
201
[[1901, 3], [1902, 8], [1903, 5], [1904, 1], [1904, 7]]
[[2097, 3], [2098, 8], [2099, 5], [2100, 1], [2100, 10]]
</pre>
 
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">fiveWeekends()={
my(day=6); \\ 0 = Friday; this represents Thursday for March 1, 1900.
my(ny=[31,30,31,30,31,31,30,31,30,31,31,28],ly=ny,v,s);
ly[12]=29;
for(year=1900,2100,
v=if((year+1)%4,ny,ly); \\ Works for 1600 to 2398
for(month=1,12,
if(v[month] == 31 && !day,
if(month<11,
print(year" "month+2)
,
print(year+1" 1")
);
s++
);
day = (day + v[month])%7
)
);
s
};</syntaxhighlight>
 
=={{header|Pascal}}==
Line 1,851 ⟶ 5,168:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl -w
use DateTime ;
 
Line 1,884 ⟶ 5,201:
}
print "No long weekends in the following " . @workhardyears . " years:\n" ;
map { print "$_\n" } @workhardyears ;</langsyntaxhighlight>
{{out}}
Output:
<pre>There are 201 months with 5 full weekends!
The first 5 and the last 5 of them are:
Line 1,930 ⟶ 5,247:
</pre>
 
=={{header|Perl 6Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
{{works with|Rakudo|2010.11}}
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<lang perl6># A month has 5 weekends iff it has 31 days and starts on Friday.
<span style="color: #004080;">sequence</span> <span style="color: #000000;">m31</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"January"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"March"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"May"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"July"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"August"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"October"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"December"</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: #000000;">m</span><span style="color: #0000FF;">,</span>
my @years = 1900 .. 2100;
<span style="color: #000000;">nmonths</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
my @ym = @years X 1, 3, 5, 7, 8, 10, 12; # Months with 31 days
<span style="color: #004080;">string</span> <span style="color: #000000;">months</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span>
<span style="color: #000000;">none</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1900</span> <span style="color: #008080;">to</span> <span style="color: #000000;">2100</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">months</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #004080;">string</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m31</span><span style="color: #0000FF;">[</span><span style="color: #000000;">m</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">and</span> <span style="color: #7060A8;">day_of_week</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)=</span><span style="color: #008000;">"Friday"</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">months</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #000000;">months</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">", "</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">months</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">m31</span><span style="color: #0000FF;">[</span><span style="color: #000000;">m</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">nmonths</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">months</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">none</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">none</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d : %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">months</span><span style="color: #0000FF;">}))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Found %d months with five full weekends\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">nmonths</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">6</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">" ...\n"</span><span style="color: #0000FF;">}</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Found %d years with no month having 5 weekends:\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">none</span><span style="color: #0000FF;">)})</span>
<span style="color: #000000;">none</span><span style="color: #0000FF;">[</span><span style="color: #000000;">6</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">6</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">".."</span><span style="color: #0000FF;">}</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">none</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Found 201 months with five full weekends
1901 : March
1902 : August
1903 : May
1904 : January, July
1905 : December
...
2095 : July
2097 : March
2098 : August
2099 : May
2100 : January, October
Found 29 years with no month having 5 weekends:
{1900,1906,1917,1923,1928,"..",2068,2074,2085,2091,2096}
</pre>
 
=={{header|Picat}}==
my @happy = @ym.map({ Date.new: $^a, $^b, 1 }).grep: { .day-of-week == 5 };
<syntaxhighlight lang="picat">go ?=>
println("Months with five weekends:"),
FiveWeekends = [ [Year,Month] : Year in 1900..2100, Month in [1,3,5,7,8,10,12], dow(Year,Month,1) == 5],
WLen = FiveWeekends.len,
println(take(FiveWeekends,5)),
println("..."),
println(drop(FiveWeekends,WLen-5)),
println(len=WLen),
nl,
 
println("Years w/o five weekends:"),
say 'Happy month count: ', +@happy;
FiveWeekendYears = [Year : [Year,_] in FiveWeekends].remove_dups,
say 'First happy months: ' ~ @happy[^5];
NoHitYears = [Year : Year in 1900..2100, not member(Year,FiveWeekendYears)],
say 'Last happy months: ' ~ @happy[*-5 .. *];
NHLen = NoHitYears.len,
say 'Dreary years count: ', @years - @happy».year.uniq;</lang>
println(take(NoHitYears,5)),
println("..."),
println(drop(NoHitYears,NHLen-5)),
println(len=NHLen),
nl.
go => true.
 
% Day of week, Sakamoto's method
Output:
dow(Y, M, D) = R =>
T = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4],
if M < 3 then
Y := Y - 1
end,
R = (Y + Y // 4 - Y // 100 + Y // 400 + T[M] + D) mod 7.
 
% Days in a month.
<pre>Happy month count: 201
max_days_in_month(Year,Month) = Days =>
First happy months: 1901-03-01 1902-08-01 1903-05-01 1904-01-01 1904-07-01
if member(Month, [1,3,5,7,8,10,12]) then
Last happy months: 2097-03-01 2098-08-01 2099-05-01 2100-01-01 2100-10-01
Days = 31
Dreary years count: 29</pre>
elseif member(Month,[4,6,9,11]) then
Days = 30
else
if leap_year(Year) then
Days = 29
else
Days = 28
end
end.
 
leap_year(Year) =>
(Year mod 4 == 0, Year mod 100 != 0)
;
Year mod 400 == 0. </syntaxhighlight>
 
{{out}}
<pre>Months with five weekends:
[[1901,3],[1902,8],[1903,5],[1904,1],[1904,7]]
...
[[2097,3],[2098,8],[2099,5],[2100,1],[2100,10]]
len = 201
 
Years w/o five weekends:
[1900,1906,1917,1923,1928]
...
[2068,2074,2085,2091,2096]
len = 29</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(setq Lst
(make
(for Y (range 1900 2100)
Line 1,968 ⟶ 5,378:
(setq Lst (diff (range 1900 2100) (uniq (mapcar cadr Lst))))
(prinl "There are " (length Lst) " years with no five-weekend months:")
(println Lst)</langsyntaxhighlight>
{{out}}
Output:
<pre>There are 201 months with five weekends:
(Mar 1901)
Line 1,988 ⟶ 5,398:
 
=={{header|Pike}}==
<langsyntaxhighlight Pikelang="pike">int(0..1) weekends(object day)
{
return (<5,6,7>)[day->week_day()];
Line 2,005 ⟶ 5,415:
 
array rest = range->years() - have5->year();
write("%d years without any 5 weekend month:\n %{%d,%}\n", sizeof(rest), rest->year_no());</langsyntaxhighlight>
 
{{out}}
Output:
<pre>
found 201 months:
March 1901
Line 2,023 ⟶ 5,434:
29 years without any 5 weekend month:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096,
</pre>
 
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
<lang PL/I>
weekends: procedure options (main); /* 28/11/2011 */
declare tally fixed initial (0);
Line 2,051 ⟶ 5,463:
 
end weekends;
</syntaxhighlight>
</lang>
{{out}}
OUTPUT:
<pre>
Mar1901 has 5 weekends
Line 2,098 ⟶ 5,510:
end weekends;
</pre>
{{out}}
OUTPUT:
<pre>
1900 has no month of 5 weekends
Line 2,130 ⟶ 5,542:
2096 has no month of 5 weekends
</pre>
 
=={{header|PowerShell}}==
 
<syntaxhighlight lang="powershell">$fiveWeekends = @()
$yearsWithout = @()
foreach ($y in 1900..2100) {
$hasFiveWeekendMonth = $FALSE
foreach ($m in @("01","03","05","07","08",10,12)) {
if ((Get-Date "$y-$m-1").DayOfWeek -eq "Friday") {
$fiveWeekends += "$y-$m"
$hasFiveWeekendMonth = $TRUE
}
}
if ($hasFiveWeekendMonth -eq $FALSE) {
$yearsWithout += $y
}
}
Write-Output "Between the years 1900 and 2100, inclusive, there are $($fiveWeekends.count) months with five full weekends:"
Write-Output "$($fiveWeekends[0..4] -join ","),...,$($fiveWeekends[-5..-1] -join ",")"
 
Write-Output ""
Write-Output "Extra Credit: these $($yearsWithout.count) years have no such month:"
Write-Output ($yearsWithout -join ",")</syntaxhighlight>
 
{{Output}}
<pre>Between the years 1900 and 2100, inclusive, there are 201 months with five full weekends:
1901-03,1902-08,1903-05,1904-01,1904-07,...,2097-03,2098-08,2099-05,2100-01,2100-10
 
Extra Credit: these 29 years have no such month:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063
,2068,2074,2085,2091,2096</pre>
 
=={{header|Prolog}}==
Works with SWI-Prolog;
<syntaxhighlight lang="prolog">main() :-
weekends(1900, 2100, FiveWeekendList, RemainderWeekendList),
 
length(FiveWeekendList, FiveLen),
maplist(write, ["Total five weekend months:", FiveLen, '\n']),
slice(FiveWeekendList, 5, FirstFiveList),
maplist(write, ["First five {year,month} pairs:", FirstFiveList, '\n']),
slice(FiveWeekendList, -5, LastFiveList),
maplist(write, ["Last five {year,month} pairs:", LastFiveList, '\n']),
 
maplist(take_year, FiveWeekendList, FiveYearList),
list_to_set(FiveYearList, FiveYearSet),
maplist(take_year, RemainderWeekendList, RemainderYearList),
list_to_set(RemainderYearList, RemainderYearSet),
 
subtract(RemainderYearSet, FiveYearSet, NonFiveWeekendSet),
length(NonFiveWeekendSet, NonFiveWeekendLen),
maplist(write, ["Total years with no five weekend months:", NonFiveWeekendLen, '\n']),
writeln(NonFiveWeekendSet).
 
weekends(StartYear, EndYear, FiveWeekendList, RemainderWeekendList) :-
numlist(StartYear, EndYear, YearList),
numlist(1, 12, MonthList),
pair(YearList, MonthList, YearMonthList),
partition(has_five_weekends, YearMonthList, FiveWeekendList, RemainderWeekendList).
 
has_five_weekends({Year, Month}) :-
long_month(Month),
starts_on_a_friday(Year, Month).
 
starts_on_a_friday(Year, Month) :-
Date = date(Year, Month, 1),
day_of_the_week(Date, DayOfTheWeek),
DayOfTheWeek == 5.
 
take_year({Year, _}, Year).
 
long_month(1).
long_month(3).
long_month(5).
long_month(7).
long_month(8).
long_month(10).
long_month(12).
 
% Helpers
 
% https://stackoverflow.com/a/7739806
pair(L1, L2, Pairs):-findall({A,B}, (member(A, L1), member(B, L2)), Pairs).
 
slice(_, 0, []).
 
slice(List, N, NList):-
N < 0,
N1 is abs(N),
last_n_elements(List, N1, NList).
 
slice(List, N, NList):-
N > 0,
first_n_elements(List, N, NList).
 
first_n_elements(List, N, FirstN):-
length(FirstN, N),
append(FirstN, _, List).
 
last_n_elements(List, N, LastN) :-
length(LastN, N),
append(_, LastN, List).
</syntaxhighlight>
{{out}}
<pre>?- main.
Total five weekend months:201
First five {year,month} pairs:[{1901,3},{1902,8},{1903,5},{1904,1},{1904,7}]
Last five {year,month} pairs:[{2097,3},{2098,8},{2099,5},{2100,1},{2100,10}]
Total years with no five weekend months:29
[1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096]
true .</pre>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure DateG(year.w, month.b, day)
;Returns the number of days before or after the earliest reference date
;in PureBasic's Date Library (1 Jan 1970) based on an assumed Gregorian calendar calculation
Line 2,197 ⟶ 5,724:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
{{out|Sample output:}}
<pre>1901 3
1902 8
Line 2,217 ⟶ 5,744:
 
=={{header|Python}}==
<syntaxhighlight lang ="python">from datetime import timedelta(date, date
timedelta)
 
DAY = timedelta(days=1)
START, STOP = date(1900, 1, 1), date(2101, 1, 1)
WEEKEND = {6, 5, 4} # Sunday is day 6
FMT = '%Y %m(%B)'
 
 
def five_weekends_per_month(start: date = START,
stop: date = STOP) -> list[date]:
"""Compute months with five weekends between dates"""
current_date = start
last_month = weekend_days = 0
five_weekends = []
while current_date < stop:
if current_date.month != last_month:
if weekend_days >= 15:
five_weekends.append(current_date - DAY)
weekend_days = 0
last_month = current_date.month
if current_date.weekday() in WEEKEND:
weekend_days += 1
current_date += DAY
return five_weekends
 
def fiveweekendspermonth(start=START, stop=STOP):
'Compute months with five weekends between dates'
when = start
lastmonth = weekenddays = 0
fiveweekends = []
while when < stop:
year, mon, _mday, _h, _m, _s, wday, _yday, _isdst = when.timetuple()
if mon != lastmonth:
if weekenddays >= 15:
fiveweekends.append(when - DAY)
weekenddays = 0
lastmonth = mon
if wday in WEEKEND:
weekenddays += 1
when += DAY
return fiveweekends
 
dates = fiveweekendspermonthfive_weekends_per_month()
indent = ' '
print('f"There are %s{len(dates)} months of which the first and last five are:' % len(dates)")
print(indent + ('\n' + indent).join(d.strftime(FMT) for d in dates[:5]))
print(indent + '...')
print(indent + ('\n' + indent).join(d.strftime(FMT) for d in dates[-5:]))
 
years_without_five_weekends_months = (STOP.year - START.year
print('\nThere are %i years in the range that do not have months with five weekends'
% len(set(range(START.year, STOP.year)) - len({d.year for d in dates}))</lang>
print(f"\nThere are {years_without_five_weekends_months} years in the "
f"range that do not have months with five weekends")</syntaxhighlight>
 
'''Alternate Algorithm'''
 
The condition is equivalent to having a thirty-one day month in which the last day of the month is a Sunday.
<langsyntaxhighlight lang="python">LONGMONTHS = (1, 3, 5, 7, 8, 10, 12) # Jan Mar May Jul Aug Oct Dec
def fiveweekendspermonth2(start=START, stop=STOP):
return [date(yr, month, 31)
for yr in range(START.year, STOP.year)
for month in LONGMONTHS
if date(yr, month, 31).timetuple()[6] == 6 # Sunday
]
 
dates2 = fiveweekendspermonth2()
assert dates2 == dates</lang>
 
def five_weekends_per_month2(start: date = START,
'''Sample Output'''
stop: date = STOP) -> list[date]:
return [last_day
for year in range(start.year, stop.year)
for month in LONG_MONTHS
if (last_day := date(year, month, 31)).weekday() == 6] # Sunday
 
dates2 = five_weekends_per_month2()
assert dates2 == dates</syntaxhighlight>
 
{{out|Sample output}}
<pre>There are 201 months of which the first and last five are:
1901 03(March)
Line 2,282 ⟶ 5,815:
There are 29 years in the range that do not have months with five weekends</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ over 3 < if [ 1 - ]
=={{header|REXX}}==
dup 4 / over +
===version 1===
over 100 / -
This version uses the latest enhancements to the DATE built-in function.
swap 400 / +
<br>Not all REXX interpreters support this feature.
swap 1 -
<br><br>
[ table
Programming justification note: the inclusion of leapyear checking is present even though it wasn't needed as
0 3 2 5 0 3
<br>February can be excluded from the criteria of having five weekends. Having the leapyear routine included
5 1 4 6 2 4 ]
<br>allows for a general-purpose strategem of solving these types of problems without taking shortcuts to the
+ + 7 mod ] is dayofweek ( day month year --> weekday )
<br>solution (although shortcuts are generaly desireable). If there is a change in the criteria, the
<br>support for more (or less) checks can be supported easily, as well as supporting more criterium.
<lang rexx>
/*REXX program finds months with 5 weekends in them (given a date range)*/
 
[ 1 -
parse arg yStart yStop .
[ table
if yStart=='' then yStart=1900
$ "January" $ "February"
if yStop =='' then yStop =2100
$ "March" $ "April"
years=ystop-yStart+1
$ "May" $ "June"
month. =31 /*month days, Feb. is done later.*/
$ "July" $ "August"
month.4 =30
$ "September" $ "October"
month.6 =30
$ "November" $ "December" ]
month.9 =30
do ] is monthname ( monthnumber --> $ )
month.11=30
haps=0 /*num of five weekends happenings*/
[] [] temp put
yr5.=0 /*if a year has any five-weekends*/
201 times
[ true temp put
i^ 1900 +
' [ 1 3 5 7 8 10 12 ]
witheach
[ 2dup swap
1 unrot dayofweek
5 = iff
[ false temp replace
over join nested
swap dip join ]
else drop ]
temp take iff
[ temp take
swap join
temp put ]
else drop ]
temp take swap
say "There are "
dup size echo
say " months with five weekends."
cr cr
5 split swap
say "Five weekends: "
witheach
[ do swap
monthname echo$
sp echo
i if say ", " ]
cr say " ..."
cr space 15 of echo$
-5 split nip
witheach
[ do swap
monthname echo$
sp echo
i if say ", " ]
cr cr
say "Years without five weekends: "
witheach
[ echo
i if say ", "
i^ 8 mod 7 = if
[ cr space 29 of echo$ ] ]</syntaxhighlight>
 
{{out}}
do y=yStart to yStop /*process the years specified. */
do m=1 for 12; mm=right(m,2,0) /*process each month in each year*/
if m==2 then month.2=28+leapyear(y) /*handle num of days in Feb*/
wd.=0
do d=1 for month.m; dd=right(d,2,0)
dat_=y"-"mm'-'dd
_=left(date('W',dat_,"I"),2); upper _
wd._=wd._+1 /* _ is first 2 chars of weekday.*/
end /*d*/
if wd.su\==5 | wd.fr\==5 | wd.sa\==5 then iterate /*5 weekends ?*/
haps=haps+1 /*bump counter*/
say 'There are five weekends in' y date('M',dat_,"I")
yr5.y=1 /*indicate this year has one. */
end /*m*/
end /*y*/
 
<pre>There are 201 months with five weekends.
say
say 'There were' haps "occurance"s(haps) 'of five-weekend months in',
"year"s(years) yStart'-->'yStop
say
no5s=0
 
Five weekends: March 1901, August 1902, May 1903, January 1904, July 1904
do y=yStart to yStop
if yr5.y then iterate ...
March 2097, August 2098, May 2099, January 2100, October 2100
no5s=no5s+1
say y "doesn't have any five-weekend months."
end
 
Years without five weekends: 1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951,
say
1956, 1962, 1973, 1979, 1984, 1990, 2001, 2007,
say "There are" no5s 'year's(no5s),
2012, 2018, 2029, 2035, 2040, 2046, 2057, 2063,
"that haven't any five-weekend months in year"s(years) yStart'-->'yStop
2068, 2074, 2085, 2091, 2096</pre>
exit
 
=={{header|R}}==
<syntaxhighlight lang="rsplus">ms = as.Date(sapply(c(1, 3, 5, 7, 8, 10, 12),
function(month) paste(1900:2100, month, 1, sep = "-")))
ms = format(sort(ms[weekdays(ms) == "Friday"]), "%b %Y")
message("There are ", length(ms), " months with five weekends.")
message("The first five: ", paste(ms[1:5], collapse = ", "))
message("The last five: ", paste(tail(ms, 5), collapse = ", "))</syntaxhighlight>
 
=={{header|Racket}}==
/*─────────────────────────────────────LEAPYEAR subroutine──────────────*/
<syntaxhighlight lang="racket">
leapyear: procedure; arg y /*year could be: Y, YY, YYY, YYYY*/
#lang racket
if length(y)==2 then y=left(right(date(),4),2)y /*adjust for YY year.*/
(require srfi/19)
if y//4\==0 then return 0 /* not ≈ by 4? Not a leapyear.*/
return y//100\==0 | y//400==0 /*apply 100 and 400 year rule. */
 
(define long-months '(1 3 5 7 8 10 12))
(define days #(sun mon tue wed thu fri sat))
 
(define (week-day date)
/*─────────────────────────────────────S subroutine (for plurals)───────*/
(vector-ref days (date-week-day date)))
s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1)
 
</lang>
(define (five-weekends-a-month start end)
Output:
(for*/list ([year (in-range start (+ end 1))]
<pre style="height:30ex;overflow:scroll">
[month long-months]
[date (in-value (make-date 0 0 0 0 31 month year 0))]
#:when (eq? (week-day date) 'sun))
date))
 
(define weekends (five-weekends-a-month 1900 2100))
(define count (length weekends))
 
(displayln (~a "There are " count " months with five weekends."))
(displayln "The first five are: ")
(for ([w (take weekends 5)])
(displayln (date->string w "~b ~Y")))
(displayln "The last five are: ")
(for ([w (drop weekends (- count 5))])
(displayln (date->string w "~b ~Y")))
</syntaxhighlight>
{{out}}
<pre>
There are 201 months with five weekends.
The first five are:
Mar 1901
Aug 1902
May 1903
Jan 1904
Jul 1904
The last five are:
Mar 2097
Aug 2098
May 2099
Jan 2100
Oct 2100
</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015-09-10}}
<syntaxhighlight lang="raku" line># A month has 5 weekends iff it has 31 days and starts on Friday.
 
my @years = 1900 .. 2100;
my @has31 = 1, 3, 5, 7, 8, 10, 12;
my @happy = ($_ when *.day-of-week == 5 for (@years X @has31).map(-> ($y, $m) { Date.new: $y, $m, 1 }));
 
say 'Happy month count: ', +@happy;
say 'First happy months: ' ~ @happy[^5];
say 'Last happy months: ' ~ @happy[*-5 .. *];
say 'Dreary years count: ', @years - @happy».year.squish;</syntaxhighlight>
 
{{out}}
<pre>Happy month count: 201
First happy months: 1901-03-01 1902-08-01 1903-05-01 1904-01-01 1904-07-01
Last happy months: 2097-03-01 2098-08-01 2099-05-01 2100-01-01 2100-10-01
Dreary years count: 29</pre>
 
=={{header|REXX}}==
===version for newer REXXes===
This version uses the latest enhancements to the &nbsp; '''DATE''' &nbsp; built-in function (which some older REXX interpreters don't support).
<br>This version was written in such a way that it counts the number of days-of-the-week for each month, thereby
<br>generalizing the problem without taking shortcuts specific to the task at hand.
<br>Changing the task's requirements to find how many extended weekends (Fr-Sa-Su ''or'' Sa-Su-Mo) there are for
<br>each month would entail changing only a single &nbsp; '''if''' &nbsp; statement.
<syntaxhighlight lang="rexx">/*REXX program finds months that contain five weekends (given a date range). */
month. =31; month.2=0 /*month days; February is skipped. */
month.4=30; month.6=30; month.9=30; month.11=30 /*all the months with thirty-days. */
parse arg yStart yStop . /*get the "start" and "stop" years.*/
if yStart=='' | yStart=="," then yStart= 1900 /*Not specified? Then use the default.*/
if yStop =='' | yStop =="," then yStop = 2100 /* " " " " " " */
years=yStop - yStart + 1 /*calculate the number of yrs in range.*/
haps=0 /*number of five weekends happenings. */
!.=0; @5w= 'five-weekend months' /*flag if a year has any five-weekends.*/
do y=yStart to yStop /*process the years specified. */
do m=1 for 12; wd.=0 /*process each month and also each year*/
do d=1 for month.m; dat_= y"-"right(m,2,0)'-'right(d,2,0)
parse upper value date('W', dat_, "I") with ? 3
wd.?=wd.?+1 /*? is the first two chars of weekday.*/
end /*d*/ /*WD.su = number of Sundays in a month.*/
if wd.su\==5 | wd.fr\==5 | wd.sa\==5 then iterate /*five weekends ?*/
say 'There are five weekends in' y date('M', dat_, "I")
haps=haps+1; !.y=1 /*bump counter; indicate yr has 5 WE's.*/
end /*m*/
end /*y*/
say
say "There were " haps ' occurrence's(haps) "of" @5w 'in year's(years) yStart"──►"yStop
say; #=0
do y=yStart to yStop; if !.y then iterate /*skip if OK.*/
#=#+1; say 'Year ' y " doesn't have any" @5wem'.'
end /*y*/
say
say "There are " # ' year's(#) "that haven't any" @5w 'in year's(years) yStart'──►'yStop
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1) /*pluralizer.*/</syntaxhighlight>
'''output''' &nbsp; when using the default inputs:
<pre style="height:98ex">
There are five weekends in 1901 March
There are five weekends in 1902 August
Line 2,556 ⟶ 6,212:
There are five weekends in 2100 October
 
There were 201 occurances occurrences of five-weekend months in years 1900-->21001900──►2100
 
Year 1900 doesn't have any five-weekend months.
Year 1906 doesn't have any five-weekend months.
Year 1917 doesn't have any five-weekend months.
Year 1923 doesn't have any five-weekend months.
Year 1928 doesn't have any five-weekend months.
Year 1934 doesn't have any five-weekend months.
Year 1945 doesn't have any five-weekend months.
Year 1951 doesn't have any five-weekend months.
Year 1956 doesn't have any five-weekend months.
Year 1962 doesn't have any five-weekend months.
Year 1973 doesn't have any five-weekend months.
Year 1979 doesn't have any five-weekend months.
Year 1984 doesn't have any five-weekend months.
Year 1990 doesn't have any five-weekend months.
Year 2001 doesn't have any five-weekend months.
Year 2007 doesn't have any five-weekend months.
Year 2012 doesn't have any five-weekend months.
Year 2018 doesn't have any five-weekend months.
Year 2029 doesn't have any five-weekend months.
Year 2035 doesn't have any five-weekend months.
Year 2040 doesn't have any five-weekend months.
Year 2046 doesn't have any five-weekend months.
Year 2057 doesn't have any five-weekend months.
Year 2063 doesn't have any five-weekend months.
Year 2068 doesn't have any five-weekend months.
Year 2074 doesn't have any five-weekend months.
Year 2085 doesn't have any five-weekend months.
Year 2091 doesn't have any five-weekend months.
Year 2096 doesn't have any five-weekend months.
 
There are 29 years that haven't any five-weekendfive─weekend months in years 1900-->21001900──►2100
</pre>
===version 2===
This version will work with any version of a REXX interpreter.
<lang rexx>
/*REXX program finds months with 5 weekends in them (given a date range)*/
 
parse arg yStart yStop .
if yStart=='' then yStart=1900
if yStop =='' then yStop =2100
years=ystop-yStart+1
month. =31 /*month days, Feb. is done later.*/
month.4 =30
month.6 =30
month.9 =30
month.11=30
haps=0 /*num of five weekends happenings*/
yr5.=0 /*if a year has any five-weekends*/
@months='January February March April May June July',
'August September October November December'
 
do y=yStart to yStop /*process the years specified. */
do m=1 for 12 /*process each month in each year*/
wd.=0
if m==2 then month.2=28+leapyear(y) /*handle num of days in Feb*/
do d=1 for month.m
_=dow(m,d,y) /*get day-of-week for mm/dd/yyyy.*/
wd._=wd._+1 /*_: 1 (Sunday), 2 (Monday) ...*/
end /*d*/
if wd.1\==5 | wd.6\==5 | wd.7\==5 then iterate /*5 weekends ?*/
haps=haps+1 /*bump counter*/
say 'There are five weekends in' y word(@months,m)
yr5.y=1 /*indicate this year has one. */
end /*m*/
end /*y*/
 
===version for older REXXes===
This version will work with any version of a REXX interpreter.
<syntaxhighlight lang="rexx">/*REXX program finds months that contain five weekends (given a date range). */
month. =31; month,2=0 /*month days; February is skipped. */
month.4=30; month.6=30; month.9=30; month.11=30 /*all the months with thirty-days. */
@months='January February March April May June July August September October November December'
parse arg yStart yStop . /*get the "start" and "stop" years.*/
if yStart=='' | yStart=="," then yStart= 1900 /*Not specified? Then use the default.*/
if yStop =='' | yStop =="," then yStop = 2100 /* " " " " " " */
years=yStop - yStart + 1 /*calculate the number of yrs in range.*/
haps=0 /*number of five weekends happenings. */
!.=0; @5w= 'five-weekend months' /*flag if a year has any five-weekends.*/
do y=yStart to yStop /*process the years specified. */
do m=1 for 12; wd.=0 /*process each month and also each year*/
do d=1 for month.m
?=dow(m,d,y) /*get the day-of-week for mm/dd/yyyy*/
wd.?=wd.?+1 /*?: 1=Sun, 2=Mon, 3=Tue ∙∙∙ 7=Sat.*/
end /*d*/
if wd.1\==5 | wd.6\==5 | wd.7\==5 then iterate /*not a weekend ? */
say 'There are five weekends in' y word(@months, m)
haps=haps+1; !.y=1 /*bump counter; indicate yr has 5 WE's.*/
end /*m*/
end /*y*/
say
say 'There were ' haps "occurance occurrence"s(haps) 'of' five-weekend months@5w "in year"s(years) yStart'──►',yStop
#=0; say
"year"s(years) yStart'-->'yStop
do y=yStart to yStop; if !.y then iterate /*skip if OK.*/
#=#+1
say 'Year ' y " doesn't have any five-weekend months."
end /*y*/
say
say "There are " # ' year's(#) "that haven't any" @5w 'in year's(years) yStart'──►'yStop
no5s=0
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
dow: procedure; parse arg m,d,y; if m<3 then do; m=m+12; y=y-1; end
yL=left(y,2); yr=right(y,2); w=(d+(m+1)*26%10+yr+yr%4+yL%4+5*yL) // 7
if w==0 then w=7; return w /*Sunday=1, Monday=2, ... Saturday=7 */
/*──────────────────────────────────────────────────────────────────────────────────────*/
s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1) /*pluralizer.*/</syntaxhighlight>
'''output''' &nbsp; is identical to the 1<sup>st</sup> REXX version.
<br><br>
 
===version short and focussed at the task description===
do y=yStart to yStop
<syntaxhighlight lang="rexx">/* REXX ***************************************************************
if yr5.y then iterate
* Short(er) solution focussed at the task's description
no5s=no5s+1
* Only 7 months can have 5 full weekends
say y "doesn't have any five-weekend months."
* and it's enough to test if the 1st day of the month is a Friday
end
* 30.08.2012 Walter Pachl
 
**********************************************************************/
say
Numeric digits 20
say "There are" no5s 'year's(no5s),
nr5fwe=0
"that haven't any five-weekend months in year"s(years) yStart'-->'yStop
years_without_5fwe=0
mnl='Jan Mar May Jul Aug Oct Dec'
ml='1 3 5 7 8 10 12'
Do j=1900 to 2100
year_has_5fwe=0
Do mi=1 To words(ml)
m=word(ml,mi)
jd=greg2jul(j m 1)
IF jd//7=4 Then Do /* 1st m j is a Friday */
nr5fwe=nr5fwe+1
year_has_5fwe=1
If j<=1905 | 2095<=j Then
Say word(mnl,mi) j 'has 5 full weekends'
End
End
If j=1905 Then Say '...'
if year_has_5fwe=0 Then years_without_5fwe=years_without_5fwe+1
End
Say ' '
Say nr5fwe 'occurrences of 5 full weekends in a month'
Say years_without_5fwe 'years without 5 full weekends'
exit
 
greg2jul: Procedure
/***********************************************************************
* Converts a Gregorian date to the corresponding Julian day number
* 19891101 Walter Pachl REXXified algorithm published in CACM
* (Fliegel & vanFlandern, CACM Vol.11 No.10 October 1968)
* 19891125 PA copy leapyear test into this to avoid the dependency
***********************************************************************/
numeric digits 12
Parse Arg yy mm d
If mm<1 | 12<mm Then Call err 'month ('mm') not within 1 to 12'
mdl='31' (28+leapyear(yy)) '31 30 31 30 31 31 30 31 30 31'
md=word(mdl,mm)
If d<1 | md<d Then Call err 'day ('d') not within 1 to' md
/***********************************************************************
* The published formula:
* res=d-32075+1461*(yy+4800+(mm-14)%12)%4+,
* 367*(mm-2-((mm-14)%12)*12)%12-3*((yy+4900+(mm-14)%12)%100)%4
***********************************************************************/
mma=(mm-14)%12
yya=yy+4800+mma
result=d-32075+1461*yya%4+367*(mm-2-mma*12)%12-3*((yya+100)%100)%4
Return result /* return the result */
 
leapyear: Return ( (arg(1)//4=0) & (arg(1)//100<>0) ) | (arg(1)//400=0)</syntaxhighlight>
/*─────────────────────────────────────DOW (day of week) subroutine─────*/
{{Out}}
dow: procedure; arg m,d,y; if m<3 then do; m=m+12; y=y-1; end
<pre>
yL=left(y,2); yr=right(y,2); w=(d+(m+1)*26%10+yr+yr%4+yL%4+5*yL)//7
Mar 1901 has 5 full weekends
if w==0 then w=7; return w /*Sunday=1, Monday=2, ... Saturday=7*/
Aug 1902 has 5 full weekends
May 1903 has 5 full weekends
Jan 1904 has 5 full weekends
Jul 1904 has 5 full weekends
Dec 1905 has 5 full weekends
...
Jul 2095 has 5 full weekends
Mar 2097 has 5 full weekends
Aug 2098 has 5 full weekends
May 2099 has 5 full weekends
Jan 2100 has 5 full weekends
Oct 2100 has 5 full weekends
201 occurrences of 5 full weekends in a month
29 years without 5 full weekends
</pre>
 
===shorter version===
<syntaxhighlight lang="rexx">/*REXX program finds months that contain five weekends (given a date range). */
month. =31; month.2=0 /*month days; February is skipped. */
month.4=30; month.6=30; month.9=30; month.11=30 /*all the months with thirty-days. */
parse arg yStart yStop . /*get the "start" and "stop" years.*/
if yStart=='' | yStart=="," then yStart= 1900 /*Not specified? Then use the default.*/
if yStop =='' | yStop =="," then yStop = 2100 /* " " " " " " */
years=yStop - yStart + 1 /*calculate the number of yrs in range.*/
haps=0 /*number of five weekends happenings. */
!.=0; @5w= 'five-weekend months' /*flag if a year has any five-weekends.*/
do y=yStart to yStop /*process the years specified. */
do m=1 for 12; wd.=0 /*process each month and also each year*/
do d=1 for month.m; dat_= y"-"right(m, 2, 0)'-'right(d, 2, 0)
parse upper value date('W', dat_, "I") with ? 3
wd.?=wd.?+1 /*?: 1=Sun, 2=Mon, 3=Tue ∙∙∙ 7=Sat.*/
end /*d*/ /*WD.su=number of Sundays in the month.*/
if wd.su\==5 | wd.fr\==5 | wd.sa\==5 then iterate /*is this a weekend ? */
say 'There are five weekends in' y date('M', dat_, "I")
haps=haps+1; !.y=1 /*bump counter; indicate yr has 5 WE's.*/
end /*m*/
end /*y*/
say
say 'There were ' haps " occurrence"s(haps) 'of' @5w "in year"s(years) yStart'──►'yStop
#=0; say
do y=yStart to yStop; if !.y then iterate /*skip if OK.*/
#=#+1
say 'Year ' y " doesn't have any five-weekend months."
end /*y*/
say
say "There are " # ' year's(#) "that haven't any" @5w 'in year's(years) yStart'──►'yStop
/*stick a fork in it, we're all done. */</syntaxhighlight>
'''output''' &nbsp; is identical to the 1<sup>st</sup> REXX version.
 
===shorter and more focused===
/*─────────────────────────────────────LEAPYEAR subroutine──────────────*/
This REXX version takes advantage that a month with five full weekends must start on a Friday and have 31 days.
leapyear: procedure; arg y /*year could be: Y, YY, YYY, YYYY*/
<syntaxhighlight lang="rexx">/*REXX program finds months that contain five weekends (given a date range). */
if length(y)==2 then y=left(right(date(),4),2)y /*adjust for YY year.*/
ifmonth. y//4\==031 then return 0 /*days in "all" the months. not by 4? Not a leapyear.*/
returnmonth.2=0; y//100\month.4=0; month.6=0; |month.9=0; y//400=month.11=0 /*apply 100 and 400 year rule./*not 31 day months.*/
month.4=30; month.6=30; month.9=30; month.11=30 /*all the months with thirty-days. */
parse arg yStart yStop . /*get the "start" and "stop" years.*/
if yStart=='' | yStart=="," then yStart= 1900 /*Not specified? Then use the default.*/
if yStop =='' | yStop =="," then yStop = 2100 /* " " " " " " */
years=yStop - yStart + 1 /*calculate the number of yrs in range.*/
haps=0 /*number of five weekends happenings. */
!.=0; @5w= 'five-weekend months' /*flag if a year has any five-weekends.*/
do y=yStart to yStop /*process the years specified. */
do m=1 for 12; if month.m==0 then iterate /*only test 31-day months.*/
dat_= y"-"right(m,2,0)'-01' /*get the date in the desired format. */
if left(date('W',dat_,"I"),2)\=='Fr' then iterate /*isn't not a Friday? */
say 'There are five weekends in' y date('M', dat_, "I")
haps=haps+1; !.y=1 /*bump counter; indicate yr has 5 WE's.*/
end /*m*/
end /*y*/
say
say 'There were ' haps " occurrence"s(haps) 'of' @5w "in year"s(years) yStart'──►'yStop
#=0; say
do y=yStart to yStop; if !.y then iterate /*skip if OK.*/
#=#+1
say 'Year ' y " doesn't have any five-weekend months."
end /*y*/
say
say "There are " # ' year's(#) "that haven't any" @5w 'in year's(years) yStart'──►'yStop</syntaxhighlight>
'''output''' &nbsp; is identical to the 1<sup>st</sup> REXX version.
<br><br>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
sum = 0
month = list(12)
mo = [4,0,0,3,5,1,3,6,2,4,0,2]
mon = [31,28,31,30,31,30,31,31,30,31,30,31]
mont = ["January","February","March","April","May","June",
"July","August","September","October","November","December"]
for year = 1900 to 2100
if year < 2100 leap = year - 1900 else leap = year - 1904 ok
m = ((year-1900)%7) + floor(leap/4) % 7
oldsum = sum
for n = 1 to 12
month[n] = (mo[n] + m) % 7
x = (month[n] + 1) % 7
if x = 2 and mon[n] = 31 sum += 1 see "" + year + "-" + mont[n] + nl ok
next
if sum = oldsum see "" + year + "-" + "(none)" + nl ok
next
see "Total : " + sum + nl
</syntaxhighlight>
Output:
<pre>
1900-(none)
1901-March
1902-August
1903-May
1904-July
1905-December
1906-(none)
...
2093-May
2094-January
2094-October
2095-July
2096-(none)
2097-March
2098-August
2099-May
2100-January
2100-October
Total : 201
</pre>
 
=={{header|RPL}}==
/*─────────────────────────────────────S subroutine (for plurals)───────*/
{{works with|Halcyon Calc|4.2.7}}
s: if arg(1)==1 then return arg(3); return word(arg(2) 's',1)
{| class="wikitable"
</lang>
! RPL code
! Comment
|-
|
OVER 3 < -
R→B DUP 4 / OVER 100 / - OVER 400 / + + B→R
{ 0 3 2 5 0 3 5 1 4 6 2 4 } ROT GET + + 7 MOD
≫ ''''DAYoW'''' STO
{} (0,0) 1900 2100 FOR y
1 CF 1 12 '''FOR''' m
'''IF''' { 1 3 5 7 8 10 12 } m POS '''THEN'''
'''IF''' 1 m y '''DAYoW''' 5 == '''THEN'''
'''IF''' DUP RE 5 < OVER RE 195 > OR '''THEN'''
y m R→C ROT SWAP + SWAP '''END'''
1 + 1 SF '''END'''
'''END'''
'''NEXT IF''' 1 FC? '''THEN''' (0,1) + '''END'''
'''NEXT'''
≫ ''''MW5WE'''' STO
|
'''DAYoW''' ''( j mm aaaa -- day )''
if ( m < 3 ) { y -= 1; }
return (y + y/4 - y/100 + y/400
+ t[m-1] + d) % 7 ;
'''MW5WE''' ''( -- {(first)..(last)} (months,years) )''
For each year in range
reset flag
scan long months
if month starts on Fridays
if in first 5 or last 5 ones
store as (yyyy,mm)
increase month counter, set flag
if flag not set, count the year
|}
{{out}}
<pre>
2: { (1901,3) (1902,8) (1903,5) (1904,1) (1904,7) (2097,3) (2098,8) (2099,5) (2100,1) (2100,10) }
1: (201,29)
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'date'
# The only case where the month has 5 weekends is when the last day
# of the month falls on a Sunday and the month has 31 days.
 
LONG_MONTHS = [1,3,5,7,8,10,12]
# if the last day of the month falls on a Sunday and the month has 31 days,
YEARS = (1900..2100).to_a
# this is the only case where the month has 5 weekends.
 
start = Date.parse("1900-01-01")
dates = YEARS.product(LONG_MONTHS).map{|y, m| Date.new(y,m,31)}.select(&:sunday?)
stop = Date.parse("2100-12-31")
years_4w = YEARS - dates.map(&:year)
dates = (start..stop).find_all do |day|
day.mday == 31 and day.wday == 0 # Ruby 1.9: and day.sunday?
end
 
puts "There are #{dates.size} months with 5 weekends from 1900 to 2100:"
puts dates[0, .first(5]).map { |d| d.strftime("%b %Y") }, "...join("\n")
puts dates.last(5).map {|d| d.strftime("%b %Y") }
puts "..."
puts "There are #{years_4w.size} years without months with 5 weekends:"
puts dates[-5, 5].map { |d| d.strftime("%b %Y") }.join("\n")
puts years_4w.join(", ")</syntaxhighlight>
 
years_with_5w = dates.map(&:year)
 
years = (1900..2100).to_a - years_with_5w
 
puts "There are #{years.size} years without months with 5 weekends:"
puts years.join(", ")</lang>
 
'''Output'''
Line 2,701 ⟶ 6,561:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">preYear = 1900
for yyyy = 1900 to 2100
for mm = 1 to 12 ' go thru all 12 months
mmdayOne$ = left$(mm;"0-01-";mm,2)yyyy ' First day of month
n = date$(dayOne$) = mm;"-01-";yyyy ' Days since 1700
ndow = date$1 + (dayOne$n mod 7) ' DaysDay of Week sincemonth 1700begins
dowm1 = 1mm + (n mod 7) ' Day of Week month begins '
m1n1 = mm = n + 27 ' find end of month starting with 27th day
n1while m1 = nmm + 27 ' findif endmonth ofchanges monthwe startinghave withthe 27thend dayof the month
while m1n1 = mmn1 + 1
n1n$ = date$(n1 + 1)
n$m1 = dateval(left$(n1n$,2))
m1 = val(left$(n$,2))
wend
mmDays = n1 - n ' Days in the Month
if dow = 4 and mmDays = 31 then ' test for 5 weeks
count = count + 1
print using("###",count);" ";yyyy;"-";left$("0";mm,2)
Line 2,723 ⟶ 6,582:
next mm
if preCount = count then
noCount = noCount + 1 ' count years that have none
print yyyy;" has none ";noCount
end if
preCount = count
next yyyy</langsyntaxhighlight>
 
{{Out}}
'''Output'''
<pre>1900 has none 1
1 1901-03
Line 2,747 ⟶ 6,606:
200 2100-01
201 2100-01</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">extern crate chrono;
use chrono::prelude::*;
 
/// Months with 31 days
const LONGMONTHS: [u32; 7] = [1, 3, 5, 7, 8, 10, 12];
 
/// Get all the tuples (year, month) in wich there is five Fridays, five Saturdays and five Sundays
/// between the years start and end (inclusive).
fn five_weekends(start: i32, end: i32) -> Vec<(i32, u32)> {
let mut out = vec![];
 
for year in start..=end {
for month in LONGMONTHS.iter() {
// Five weekends if a 31-days month starts with a Friday.
if Local.ymd(year, *month, 1).weekday() == Weekday::Fri {
out.push((year, *month));
}
}
}
 
out
}
 
fn main() {
let out = five_weekends(1900, 2100);
 
let len = out.len();
println!(
"There are {} months of which the first and last five are:",
len
);
for (y, m) in &out[..5] {
println!("\t{} / {}", y, m);
}
println!("...");
for (y, m) in &out[(len - 5..)] {
println!("\t{} / {}", y, m);
}
}
 
#[test]
fn test() {
let out = five_weekends(1900, 2100);
assert_eq!(out.len(), 201);
}</syntaxhighlight>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">import java.util.Calendar._
import java.util.GregorianCalendar
 
import org.scalatest.{FlatSpec, Matchers}
 
class FiveWeekends extends FlatSpec with Matchers {
 
case class YearMonth[T](year: T, month: T)
implicit class CartesianProd[T](val seq: Seq[T]) {
def x(other: Seq[T]) = for(s1 <- seq; s2 <- other) yield YearMonth(year=s1,month=s2)
def -(other: Seq[T]): Seq[T] = seq diff other
}
 
def has5weekends(ym: { val year: Int; val month: Int}) = {
val date = new GregorianCalendar(ym.year, ym.month-1, 1)
date.get(DAY_OF_WEEK) == FRIDAY && date.getActualMaximum(DAY_OF_MONTH) == 31
}
 
val expectedFirstFive = Seq(
YearMonth(1901,3), YearMonth(1902,8), YearMonth(1903,5), YearMonth(1904,1), YearMonth(1904,7))
val expectedFinalFive = Seq(
YearMonth(2097,3), YearMonth(2098,8), YearMonth(2099,5), YearMonth(2100,1), YearMonth(2100,10))
val expectedNon5erYears = Seq(1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962,
1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035,
2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096)
 
"Five Weekend Algorithm" should "match specification" in {
val months = (1900 to 2100) x (1 to 12) filter has5weekends
months.size shouldBe 201
months.take(5) shouldBe expectedFirstFive
months.takeRight(5) shouldBe expectedFinalFive
 
(1900 to 2100) - months.map(_.year) shouldBe expectedNon5erYears
}
}</syntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "time.s7i";
 
Line 2,766 ⟶ 6,709:
end for;
writeln("Number of months:" <& months);
end func;</langsyntaxhighlight>
 
{{Out}}
Output:
<pre>
1901-03
Line 2,785 ⟶ 6,728:
Number of months:201
</pre>
 
=={{header|Sidef}}==
{{trans|Perl}}
<syntaxhighlight lang="ruby">require('DateTime');
 
var happymonths = [];
var workhardyears = [];
var longmonths = [1, 3, 5, 7, 8, 10, 12];
 
range(1900, 2100).each { |year|
var countmonths = 0;
longmonths.each { |month|
var dt = %s'DateTime'.new(
year => year,
month => month,
day => 1
);
 
if (dt.day_of_week == 5) {
countmonths++;
var yearfound = dt.year;
var monthfound = dt.month_name;
happymonths.append(join(" ", yearfound, monthfound));
}
}
 
if (countmonths == 0) {
workhardyears.append(year);
}
}
 
say "There are #{happymonths.len} months with 5 full weekends!";
say "The first 5 and the last 5 of them are:";
say happymonths.first(5).join("\n");
say happymonths.last(5).join("\n");
say "No long weekends in the following #{workhardyears.len} years:";
say workhardyears.join(",");</syntaxhighlight>
{{out}}
<pre>
There are 201 months with 5 full weekends!
The first 5 and the last 5 of them are:
1901 March
1902 August
1903 May
1904 January
1904 July
2097 March
2098 August
2099 May
2100 January
2100 October
No long weekends in the following 29 years:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096
</pre>
 
=={{header|Simula}}==
{{trans|FreeBasic}}
<syntaxhighlight lang="simula">! TRANSLATION OF FREEBASIC VERSION ;
BEGIN
 
INTEGER PROCEDURE WD(M, D, Y); INTEGER M, D, Y;
BEGIN
! ZELLERISH
! 0 = SUNDAY, 1 = MONDAY, 2 = TUESDAY, 3 = WEDNESDAY
! 4 = THURSDAY, 5 = FRIDAY, 6 = SATURDAY
;
 
IF M < 3 THEN ! IF M = 1 OR M = 2 THEN ;
BEGIN
M := M + 12;
Y := Y - 1
END;
WD := MOD(Y + (Y // 4)
- (Y // 100)
+ (Y // 400)
+ D + ((153 * M + 8) // 5), 7)
END WD;
 
! ------=< MAIN >=------
! ONLY MONTHS WITH 31 DAY CAN HAVE FIVE WEEKENDS
! THESE MONTHS ARE: JANUARY, MARCH, MAY, JULY, AUGUST, OCTOBER, DECEMBER
! IN NR: 1, 3, 5, 7, 8, 10, 12
! THE 1E DAY NEEDS TO BE ON A FRIDAY (= 5)
;
 
TEXT PROCEDURE MONTHNAMES(M); INTEGER M;
MONTHNAMES :- IF M = 1 THEN "JANUARY"
ELSE IF M = 2 THEN "FEBRUARY"
ELSE IF M = 3 THEN "MARCH"
ELSE IF M = 4 THEN "APRIL"
ELSE IF M = 5 THEN "MAY"
ELSE IF M = 6 THEN "JUNE"
ELSE IF M = 7 THEN "JULY"
ELSE IF M = 8 THEN "AUGUST"
ELSE IF M = 9 THEN "SEPTEMBER"
ELSE IF M = 10 THEN "OCTOBER"
ELSE IF M = 11 THEN "NOVEMBER"
ELSE IF M = 12 THEN "DECEMBER"
ELSE NOTEXT;
 
INTEGER M, YR, TOTAL, I, J;
INTEGER ARRAY YR_WITHOUT(1:200);
TEXT ANSWER;
 
FOR YR := 1900 STEP 1 UNTIL 2100 DO ! GREGORIAN CALENDAR ;
BEGIN
ANSWER :- NOTEXT;
FOR M := 1 STEP 2 UNTIL 12 DO
BEGIN
IF M = 9 THEN M := 8;
IF WD(M, 1, YR) = 5 THEN
BEGIN
ANSWER :- ANSWER & MONTHNAMES(M) & ", ";
TOTAL := TOTAL + 1
END
END;
IF ANSWER =/= NOTEXT THEN
BEGIN
OUTIMAGE;
OUTINT(YR, 4); OUTTEXT(" | ");
OUTTEXT(ANSWER.SUB(1, ANSWER.LENGTH - 2)) ! GET RID OF EXTRA " ," ;
END
ELSE
BEGIN
I := I + 1;
YR_WITHOUT(I) := YR
END
END;
 
OUTIMAGE;
OUTTEXT("NR OF MONTH FOR 1900 TO 2100 THAT HAS FIVE WEEKENDS ");
OUTINT(TOTAL, 0);
OUTIMAGE;
OUTIMAGE;
OUTINT(I, 0);
OUTTEXT(" YEARS DON'T HAVE MONTHS WITH FIVE WEEKENDS");
OUTIMAGE;
 
FOR J := 1 STEP 1 UNTIL I DO
BEGIN
OUTINT(YR_WITHOUT(J), 0); OUTCHAR(' ');
IF MOD(J, 8) = 0 THEN OUTIMAGE
END;
OUTIMAGE
 
END.
</syntaxhighlight>
{{out}}
<pre>
 
1901 | MARCH
1902 | AUGUST
1903 | MAY
1904 | JANUARY, JULY
1905 | DECEMBER
...
2095 | JULY
2097 | MARCH
2098 | AUGUST
2099 | MAY
2100 | JANUARY, OCTOBER
NR OF MONTH FOR 1900 TO 2100 THAT HAS FIVE WEEKENDS 201
 
29 YEARS DON'T HAVE MONTHS WITH FIVE WEEKENDS
1900 1906 1917 1923 1928 1934 1945 1951
1956 1962 1973 1979 1984 1990 2001 2007
2012 2018 2029 2035 2040 2046 2057 2063
2068 2074 2085 2091 2096
</pre>
 
=={{header|Stata}}==
 
<syntaxhighlight lang="stata">clear
set obs `=tm(2101m1)-tm(1900m1)'
gen month=tm(1900m1)+_n-1
format %tm month
gen day=dofm(month)
keep if dofm(month+1)-day==31 & dow(day)==5
drop day
 
count
201
 
list in f/5, noobs noheader
 
+--------+
| 1901m3 |
| 1902m8 |
| 1903m5 |
| 1904m1 |
| 1904m7 |
+--------+
 
list in -5/l, noobs noheader
 
+---------+
| 2097m3 |
| 2098m8 |
| 2099m5 |
| 2100m1 |
| 2100m10 |
+---------+</syntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
 
set months {}
Line 2,808 ⟶ 6,953:
puts [join [list {*}[lrange $months 0 4] ... {*}[lrange $months end-4 end]] \n]
puts "There are [llength $years] years without any five-weekend months"
puts [join $years ","]</langsyntaxhighlight>
{{Out}}
Output:
<pre>
There are 201 months with five weekends
Line 2,826 ⟶ 6,971:
1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,2040,2046,2057,2063,2068,2074,2085,2091,2096
</pre>
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
LOOP year=1900,2100
Line 2,835 ⟶ 6,981:
ENDLOOP
ENDLOOP
</syntaxhighlight>
</lang>
{{Out}}
Output:
<pre style='height:30ex;overflow:scroll'>
1901-3
Line 3,039 ⟶ 7,185:
2100-1
2100-10
</pre>
 
=={{header|uBasic/4tH}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="text">' ------=< MAIN >=------
' only months with 31 day can have five weekends
' these months are: January, March, May, July, August, October, December
' in nr: 1, 3, 5, 7, 8, 10, 12
' the 1e day needs to be on a friday (= 5)
 
For y = 1900 To 2100 ' Gregorian calendar
a = 0
For m = 1 To 12 Step 2
If m = 9 Then m = 8
If Func(_wd(m , 1 , y)) = 5 Then
If a Then
Print ", ";
Else
Print y; " | ";
a = 1
EndIf
GoSub m*10
t = t + 1
EndIf
Next
If a Then
Print
Else
i = i + 1
@(i) = y
EndIf
Next
 
Print
Print "Number of months from 1900 to 2100 that have five weekends: ";t
Print
Print i;" years don't have months with five weekends:"
Print
 
For j = 1 To i
Print @(j); " ";
If (j % 8) = 0 Then Print
Next
 
Print
End
 
 
_wd Param(3)
' Zellerish
' 0 = Sunday, 1 = Monday, 2 = Tuesday, 3 = Wednesday
' 4 = Thursday, 5 = Friday, 6 = Saturday
 
If a@ < 3 Then ' If a@ = 1 Or a@ = 2 Then
a@ = a@ + 12
c@ = c@ - 1
EndIf
Return ((c@ + (c@ / 4) - (c@ / 100) + (c@ / 400) + b@ + ((153 * a@ + 8) / 5)) % 7)
 
 
10 Print "January"; : Return
20 Print "February"; : Return
30 Print "March"; : Return
40 Print "April"; : Return
50 Print "May"; : Return
60 Print "June"; : Return
70 Print "July"; : Return
80 Print "August"; : Return
90 Print "September"; : Return
100 Print "October"; : Return
110 Print "November"; : Return
120 Print "December"; : Return</syntaxhighlight>
{{out}}
<pre>1901 | March
1902 | August
1903 | May
1904 | January, July
...
2099 | May
2100 | January, October
 
Number of months from 1900 to 2100 that have five weekends: 201
 
29 years don't have months with five weekends:
 
1900 1906 1917 1923 1928 1934 1945 1951
1956 1962 1973 1979 1984 1990 2001 2007
2012 2018 2029 2035 2040 2046 2057 2063
2068 2074 2085 2091 2096
 
0 OK, 0:888</pre>
 
=={{header|UNIX Shell}}==
{{works with|Bourne Again SHell|3}}
{{works with|ksh}}
 
This is a 2-step-solution:
* create a file with 1-month calendars for all the required month and years
* feed this file to an awk-script to look for the months with 5 weekends.
 
<syntaxhighlight lang="bash">echo "Creating cal-file..."
echo > cal.txt
for ((y=1900; y <= 2100; y++)); do
for ((m=1; m <= 12; m++)); do
#echo $m $y
cal -m $m $y >> cal.txt
done
done
ls -la cal.txt
 
echo "Looking for month with 5 weekends:"
awk -f 5weekends.awk cal.txt
</syntaxhighlight>
 
See also: [http://rosettacode.org/wiki/Five_weekends#AWK awk] and [[Calendar]]. <br>
Try it out online: [http://www.compileonline.com/execute_ksh_online.php compileonline.com]
 
=={{header|VBA}}==
<syntaxhighlight lang="vb">
Option Explicit
 
Sub Main()
Dim y As Long, m As Long, t As String, cpt As Long, cptm As Long
For y = 1900 To 2100
t = vbNullString
For m = 1 To 12 Step 2
If m = 9 Then m = 8
If Weekday(DateSerial(y, m, 1)) = vbFriday Then
t = t & ", " & m
cptm = cptm + 1
End If
Next
If t <> "" Then
Debug.Print y & t
Else
cpt = cpt + 1
End If
Next
Debug.Print "There is " & cptm & " months with five full weekends from the year 1900 through 2100"
Debug.Print "There is " & cpt & " years which don't have months with five weekends"
End Sub</syntaxhighlight>
{{out}}
<pre>1901, 3
1902, 8
1903, 5
1904, 1, 7
1905, 12
1907, 3
1908, 5
1909, 1, 10
1910, 7
......
2090, 12
2092, 8
2093, 5
2094, 1, 10
2095, 7
2097, 3
2098, 8
2099, 5
2100, 1, 10
There is 201 months with five full weekends from the year 1900 through 2100
There is 29 years which don't have months with five weekends</pre>
 
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
For y = 1900 To 2100
For m = 1 To 12
d = DateSerial(y, m + 1, 1) - 1
If Day(d) = 31 And Weekday(d) = vbSunday Then
WScript.Echo y & ", " & MonthName(m)
i = i + 1
End If
Next
Next
 
WScript.Echo vbCrLf & "Total = " & i & " months"
</syntaxhighlight>
 
=={{header|Wren}}==
{{libheader|Wren-date}}
{{libheader|Wren-seq}}
<syntaxhighlight lang="wren">import "./date" for Date
import "./seq" for Lst
 
var dates = []
var years = []
for (y in 1900..2100) {
var hasFive = false
for (m in 1..12) {
var fri = 0
var sat = 0
var sun = 0
for (d in 1..Date.monthLength(y, m)) {
var d = Date.new(y, m, d)
var dow = d.dayOfWeek
if (dow == 5) {
fri = fri + 1
} else if (dow == 6) {
sat = sat + 1
} else if (dow == 7) {
sun = sun + 1
}
}
var fd = Date.new(y, m, 1)
if (fri == 5 && sat == 5 && sun == 5) {
dates.add(fd)
hasFive = true
}
}
if (!hasFive) years.add(y)
}
 
Date.default = "mmm|-|yyyy"
System.print("Between 1900 and 2100:-")
System.print(" There are %(dates.count) months that have five full weekends.")
System.print(" The first 5 are:")
for (i in 0..4) System.print(" %(dates[i])")
System.print(" and the last 5 are:")
for (i in -5..-1) System.print(" %(dates[i])")
System.print("\n There are %(years.count) years that do not have at least one five-weekend month, namely:")
var chunks = Lst.chunks(years, 10)
for (i in 0...chunks.count) System.print(" %(chunks[i])")</syntaxhighlight>
 
{{out}}
<pre>
Between 1900 and 2100:-
There are 201 months that have five full weekends.
The first 5 are:
Mar-1901
Aug-1902
May-1903
Jan-1904
Jul-1904
and the last 5 are:
Mar-2097
Aug-2098
May-2099
Jan-2100
Oct-2100
 
There are 29 years that do not have at least one five-weekend month, namely:
[1900, 1906, 1917, 1923, 1928, 1934, 1945, 1951, 1956, 1962]
[1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, 2035]
[2040, 2046, 2057, 2063, 2068, 2074, 2085, 2091, 2096]
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
 
 
func WeekDay(Year, Month, Day); \Return day of week (0=Sat 1=Sun..6=Fri)
int Year, Month, Day;
[if Month<=2 then [Month:= Month+12; Year:= Year-1];
return rem((Day + (Month+1)*26/10 + Year + Year/4 + Year/100*6 + Year/400) / 7);
]; \WeekDay
 
 
int MonthTbl, Year, I, C;
[MonthTbl:= [1, 3, 5, 7, 8, 10, 12]; \months with 31 days
C:= 0;
for Year:= 1900 to 2100 do
for I:= 0 to 6 do \for all the 31-day months...
if WeekDay(Year, MonthTbl(I), 1) = 6 then \first of month is a Friday
[C:= C+1; \count this year
if C<=5 or C>201-5 then \show first 5 and last 5 years
[IntOut(0, Year); ChOut(0, ^ );
IntOut(0, MonthTbl(I)); CrLf(0);
];
];
IntOut(0, C); CrLf(0); \show number of years
 
\Count and show all years that don't have any 5-weekend months
C:= 0;
for Year:= 1900 to 2100 do
[for I:= 0 to 6 do \for all the 31-day months...
if WeekDay(Year, MonthTbl(I), 1) = 6 \Friday\ then
I:= 10; \bail out of 'for' loop
if I<10 then \'for' loop completed
[if (C&$F) = 0 then CrLf(0); \(format 16 years per line)
C:= C+1; \ without finding a 5-weekend
IntOut(0, Year); ChOut(0, ^ ); \ so show the year
];
];
CrLf(0); IntOut(0, C); CrLf(0); \show number of years
]</syntaxhighlight>
 
{{Out}}
<pre>
1901 3
1902 8
1903 5
1904 1
1904 7
2097 3
2098 8
2099 5
2100 1
2100 10
201
 
1900 1906 1917 1923 1928 1934 1945 1951 1956 1962 1973 1979 1984 1990 2001 2007
2012 2018 2029 2035 2040 2046 2057 2063 2068 2074 2085 2091 2096
29
</pre>
 
=={{header|zkl}}==
Months with five weekends:
<syntaxhighlight lang="zkl">var [const] D=Time.Date, r=L();
foreach y,m in ([1900..2100],[1..12]){
if (D.daysInMonth(y,m)==31 and 5==D.weekDay(y,m,1)) r.append(String(y,"-",m))
}</syntaxhighlight>
Alternatively, in a functional style using list comprehensions:
<syntaxhighlight lang="zkl">r:=[[(y,m); [1900..2100];
[1..12],{D.daysInMonth(y,m)==31 and 5==D.weekDay(y,m,1)};
{String(y,"-",m)}]];</syntaxhighlight>
{{out}}
<pre>
r.len() //-->201
r[0,5] //-->L("1901-3","1902-8","1903-5","1904-1","1904-7")
r[-5,*] //-->L("2097-3","2098-8","2099-5","2100-1","2100-10")
</pre>
 
Extra credit: Years with no five day weekends:
<syntaxhighlight lang="zkl">var [const] D=Time.Date, r=L();
foreach y in ([1900..2100]){ yes:=True;
foreach m in ([1..12]){
if (D.daysInMonth(y,m)==31 and 5==D.weekDay(y,m,1)) { yes=False; break; }
}
if (yes) r.append(y)
}</syntaxhighlight>
Alternatively:
<syntaxhighlight lang="zkl">var yes, r=[[(y,m);
[1900..2100];
[1..12],{if(m==1)yes=True; if(D.daysInMonth(y,m)==31 and 5==D.weekDay(y,m,1)) yes=False; True},
{if (m==12) yes else False};
{y}]]</syntaxhighlight>
Bit of a sleaze using a global var (yes) to hold state.
First filter: On the first month, reset global, note if month has five weekends, always pass.
Second filter: fail if any five day weekends and ignore all months other than December.
{{out}}
<pre>
r.len() //-->29
r //-->L(1900,1906,1917,1923,1928,1934,1945,1951,1956,1962,1973,1979,1984,1990,2001,2007,2012,2018,2029,2035,...)
</pre>
2,021

edits