Five weekends: Difference between revisions

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.

FIVEWEEK CSECT

USING FIVEWEEK,R13 base register

XDEC DS CL12 temp for XDECO

YREGS

{{out}}

<pre>

201 occurrences

29 years with no five weekend month

</pre>

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Calendar.Formatting; use Ada.Calendar;

Put_Line ("Number of months:" & Integer'Image (Months));

end Five_Weekends;

{{out|Sample output}}

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

2100 10

Number of months: 201

</pre>

 

===Imperative===

 

set noFiveWeekendYears to {}

 

set y to y + 12

end

 

{{out}} (can always add "display dialog resultText" for GUI output):

 

===Functional===

on run

end script

end if

{{Out}}

{firstFive:{"1901 March", "1902 August", "1903 May", "1904 January", "1904 July"}},

{lastFive:{"2097 March", "2098 August", "2099 May", "2100 January", "2100 October"}},

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

 

=={{header|AutoHotkey}}==

End_Year := 2100

31_Day_Months = 01,03,05,07,08,10,12

Years with no 5 day weekends between 1900 and 2100 : %No_5_Weekend_Count%

%All_Years_Without_5_Weekend%

 

=={{header|AutoIt}}==

2 - Years Without 5 Weekend Months

3 - Year and Month with 5 Weekends

#include <Date.au3>

#include <Array.au3>

EndIf

EndFunc ;==>Five_weekends

 

=={{header|AWK}}==

 

# usage: awk -f 5weekends.awk cal.txt

 

print(bY)

}

 

See also: [http://rosettacode.org/wiki/Five_weekends#UNIX_Shell unix-shell] and [http://rosettacode.org/wiki/Calendar#AWK Calendar].

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

{{works with|BBC BASIC for Windows}}

DIM Month$(12)

Month$() = "","January","February","March","April","May","June", \

IF num% = oldnum% PRINT "(none)" ELSE PRINT

NEXT year%

{{out}}

<pre>

 

=={{header|C}}==

#include <time.h>

 

printf("%d total\n", n);

return 0;

{{out}} (note that the C library may not be able to handle all dates; the output may vary across systems):

<pre>

 

Not your typical method. Requires <code>ncal</code>.

#include <string.h>

 

 

return 0;

{{out}}

<pre>

Total: 201

</pre>

 

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

{{libheader|Boost}}

#include <boost/date_time/gregorian/gregorian.hpp>

#include <algorithm>

std::cout << std::endl ;

return 0 ;

{{out|Sample output}}

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

</pre>

 

 

 

 

<pre>

</pre>

 

=={{header|Ceylon}}==

<b>module.ceylon</b>

module rosetta.fiveweekends "1.0.0" {

import ceylon.time "1.2.2";

}

<b>run.ceylon</b>

import ceylon.time {

date,

}

 

{{out}}

<pre>

 

</pre>

 

=={{header|Clojure}}==

java.text.DateFormatSymbols)

 

(println month "-" year))

count

 

=={{header|COBOL}}==

program-id. five-we.

data division.

.

end program five-we.

{{out}}

<pre>

 

=={{header|CoffeeScript}}==

startsOnFriday = (month, year) ->

# 0 is Sunday, 1 is Monday, ... 5 is Friday, 6 is Saturday

fiveWeekends()

 

{{out}}

1901 2

1902 7

 

Years with no five-weekend months: 29

 

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

;; http://lispcookbook.github.io/cl-cookbook/dates_and_times.html

 

(format t "Last 5 months: ~A~%" (subseq good-months 0 5))

(format t "Years without a five-weekend month: ~A~%" bad-years))))

 

{{out}}

 

=={{header|D}}==

 

Date[] m5w(in Date start, in Date end) pure /*nothrow*/ {

writefln("\nThere are %d years in the range that do not have " ~

"months with five weekends.", n);

{{out}}

<pre>There are 201 months of which the first and last five are:

There are 29 years in the range that do not have months with five weekends.</pre>

===Simpler Version===

import std.stdio, std.datetime, std.traits;

 

writeln("\nTotal number of years with no 5-weekend months: ",

totalNo5Weekends);

{{out}}

<pre>Total 5-weekend months between 1900 and 2100: 201

 

Total number of years with no 5-weekend months: 29</pre>

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(Format('Months with 5 weekends: %d', [lFiveWeekendCount]));

Writeln(Format('Years with no 5 weekend months: %d', [lYearsWithout]));

 

=={{header|Elixir}}==

@months { "January", "February", "March", "April", "May", "June",

"July", "August", "September", "October", "November", "December" }

IO.puts "Found #{count} month with 5 weekends."

IO.puts "\nFound #{length(none)} years with no month having 5 weekends:"

 

{{out}}

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>:

#!/usr/bin/env escript

%%

has_five({_Year, _Month}, _DaysNot31) ->

false.

Second, a more verbose Erlang module:

-module(five_weekends).

 

find_years_without_5w_months(List) ->

[Y || {[{Y,_M}|_], 0} <- List].

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM FIVE_WEEKENDS

 

PRINT("Total =";CNT%)

END PROGRAM

{{out}}

<pre>

 

=={{header|Euphoria}}==

--Five Weekend task from Rosetta Code wiki

--User:Lnettnay

puts(1, "Number of years that have no months with five full weekends = ")

? none

{{out}}

<pre>

 

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

 

[<EntryPoint>]

(List.take 5 allMonthsWith5we)

(List.take 5 (List.skip ((List.length allMonthsWith5we) - 5) allMonthsWith5we))

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

 

Using Zeller's congruence

implicit none

 

end function Day_of_week

{{out}}

<pre>Mar 1901

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

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>1901 | March

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=fbeb1b7a06fff3da3f8b262ee5d71390 Click this link to run this code]'''

Dim aMonth As Short[] = [1, 3, 5, 7, 8, 10, 12] 'All 31 day months

Dim aMMStore As New String[] 'To store results

" 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

Output:

<pre>

 

=={{header|GAP}}==

# 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

# [ "Mar-1901", "Aug-1902", "May-1903", "Jan-1904", "Jul-1904" ]

r[1]{[n-4 .. n]};

=={{header|Go}}==

Using second algorithm suggestion:

 

import (

}

fmt.Println(len(haveNone), "total")

{{out}}

<pre>

29 total

</pre>

=={{header|Groovy}}==

Solution:

Sun, Mon, Tue, Wed, Thu, Fri, Sat

static Day valueOf(Date d) { Day.valueOf(d.format('EEE')) }

}

}.flatten()

 

Test:

def years = 1900..2100

def fiveWeekendMonths = fiveWeekends(years)

println "Number of five weekend months: ${fiveWeekendMonths.size()}"

 

{{out}}

 

Test:

def yearsWithout = (years as Set) - yearsWith

println "\nNumber of years without a five weekend month: ${yearsWithout.size()}"

 

{{out}}

2091

2096</pre>

 

=={{header|Harbour}}==

PROCEDURE Main()

LOCAL y, m, d, nFound, cNames, nTot := 0, nNotFives := 0

? "Years with no five weekends months: " + hb_NtoS( nNotFives )

 

 

{{out}}

 

Now it is easy to get all months with 31 days that start on Friday.

 

data DayOfWeek = Monday | Tuesday | Wednesday | Thursday | Friday |

formatMonth :: (Year, [Month]) -> String

{{out}}

<pre>

 

====Using Data.Time====

import Data.List.Split (chunksOf)

 

 

fiveFridayMonths :: Integer -> [(Integer, Int)]

fiveFridayMonths y =

 

isFriday :: Day -> Bool

 

main :: IO ()

main = do

lean =

concat $

n = (length . concat) xs

(putStrLn . intercalate "\n\n")

{{Out}}

<pre>How many five-weekend months 1900-2100 ?

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.

 

 

When play begins:

repeat with M running through months:

if M of Y is a happy month, decide no;

 

{{out}}

October 2100.

Found 201 months with five weekends and 29 years with no such months.</pre>

 

=={{header|J}}==

find5wkdMonths=: verb define

years=. range 2{. y

m5w=. (#~ 0 = weekday) >,{years;months;31 NB. 5 full weekends iff 31st is Sunday(0)

>'MMM YYYY' fmtDate toDayNo m5w

'''Usage:'''

201

(5&{. , '...' , _5&{.) find5wkdMonths 1900 2100 NB. First and last 5 months found

Oct 2100

# (range -. {:"1@(_ ". find5wkdMonths)) 1900 2100 NB. number of years without 5 weekend months

 

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

import java.util.GregorianCalendar;

 

}

}

{{out}} (middle results cut out):

<pre style="height:30ex;overflow:scroll"> There are 201 months with five weekends from 1900 through 2100:

2091

2096</pre>

 

=={{header|JavaScript}}==

===ES5===

====Imperative====

{

// 0 is Sunday, 1 is Monday, ... 5 is Friday, 6 is Saturday

document.write('Years with no five-weekend months: ' + yearsWithoutFiveWeekends.length + '<br>');

}

 

{{out|Sample output}}

 

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.

'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',

'Jul', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec'

 

console.log('Number of months that have five full weekends from 1900 to 2100: ' + total);

{{out}}

<pre>1901-Mar

 

====Functional====

'use strict';

 

null, 2

);

{{Out}}

<pre>{

 

===ES6===

// longMonthsStartingFriday :: Int -> [Int]

const longMonthsStartingFriday = y =>

leanYearCount: lstLeanYears.length

});

{{Out}}

<pre>{

 

'''Foundations: Zeller's Congruence'''

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

# Emit 0 for Saturday, 1 for Sunday, etc.

+ (.[1]/400|floor) - 2*(.[1]/100|floor)

| . % 7

'''Nuts and Bolts''':

def day_before(day): (6+day) % 7;

 

["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][.-1];

"\(.[1] | month) \(.[0])"

'''The Task''':

| "There are \(length) months with 5 weekends from 1900 to 2100 inclusive;",

"the first and last five are as follows:",

"...",

( .[length-5: ][] | pp),

{{out}}

There are 201 months with 5 weekends from 1900 to 2100 inclusive;

the first and last five are as follows:

Jan 2100

Oct 2100

 

=={{header|Julia}}==

 

 

end

 

 

 

 

 

{{out}}

 

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

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"

{{out}}

<pre>

 

=={{header|Kotlin}}==

 

import java.util.*

println("There are ${yearsWithNone.size} years with no months which have 5 weekends, namely:")

println(yearsWithNone)

 

{{out}}

 

=={{header|Lasso}}==

months = array(1, 3, 5, 7, 8, 10, 12),

fivemonths = array,

}

 

{{out|Result}}

<pre>Total number of months 201

 

=={{header|Lua}}==

local months={"JAN","MAR","MAY","JUL","AUG","OCT","DEC"}

local daysPerMonth={31+28,31+30,31+30,31,31+30,31+30,0}

print("Months with 5 weekends: ",cnt_months)

print("Years without 5 weekends in the same month:",cnt_no5we)

{{out}}

<pre>1900 0:

Months with 5 weekends: 201

Years without 5 weekends in the same month: 29</pre>

 

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

result = Select[Tuples[{Range@@years, months}], (DateString[# ~ Join ~ 1, "DayNameShort"] == "Fri")&];

 

Print["Last months: " , DateString[#,{"MonthName"," ","Year"}]& /@ result[[-5 ;; All]]];

Print[# // Length, " years without 5 weekend months:\n", #] &@

{{out}}

<pre>201 months with 5 weekends

=={{header|MATLAB}} / {{header|Octave}}==

 

 

i = 1;

for j = length(x)-4:length(x)

fprintf('\t %s \n',x(j,:))

{{out}}

<pre>There are 201 months with 5 weekends between 1900 and 2100.

 

=={{header|Maxima}}==

right(a, n) := block([m: length(a)], makelist(a[i], i, m - n + 1, m))$

 

 

right(a, 5);

 

=={{header|MUMPS}}==

{{libheader|VA Kernel|22.0}}

FIVE

;List and count the months between 1/1900 and 12/2100 that have 5 full weekends

. 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

USER>d ^FIVE

 

=={{header|NetRexx}}==

 

/* NetRexx ************************************************************

* 30.08.2012 Walter Pachl derived from Rexx version 3

yya=yy+4800+mma

result=d-32075+1461*yya%4+367*(mm-2-mma*12)%12-3*((yya+100)%100)%4

Output: see Rexx version 3

 

=={{header|NewLISP}}==

#!/usr/local/bin/newlisp

 

(println "Years with no five weekends months: " NotFives)

(exit)

{{out}}

<pre>

 

=={{header|Nim}}==

 

const LongMonths = {mJan, mMar, mMay, mJul, mAug, mOct, mDec}

 

var sumNone = 0

var none = true

for month in LongMonths:

none = false

if none: inc sumNone

{{out}}

<pre>March 1901

January 2100

October 2100

Years without a 5 weekend month: 29</pre>

 

{{libheader|OCaml Calendar Library}}

 

 

let list_first_five = function

List.iter print_month (list_first_five (List.rev !months));

List.iter print_month (List.rev (list_first_five !months));

 

{{out}}

2100-01

2100-10</pre>

 

=={{header|Oforth}}==

 

| y m |

 

]

]

 

{{out}}

 

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

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

);

s

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

use DateTime ;

 

}

print "No long weekends in the following " . @workhardyears . " years:\n" ;

{{out}}

<pre>There are 201 months with 5 full weekends!

2096

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

{1900,1906,1917,1923,1928,"..",2068,2074,2085,2091,2096}

</pre>

 

=={{header|PicoLisp}}==

(make

(for Y (range 1900 2100)

(setq Lst (diff (range 1900 2100) (uniq (mapcar cadr Lst))))

(prinl "There are " (length Lst) " years with no five-weekend months:")

{{out}}

<pre>There are 201 months with five weekends:

 

=={{header|Pike}}==

{

return (<5,6,7>)[day->week_day()];

 

array rest = range->years() - have5->year();

 

{{out}}

 

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

weekends: procedure options (main); /* 28/11/2011 */

declare tally fixed initial (0);

 

end weekends;

{{out}}

<pre>

=={{header|PowerShell}}==

 

$yearsWithout = @()

foreach ($y in 1900..2100) {

Write-Output ""

Write-Output "Extra Credit: these $($yearsWithout.count) years have no such month:"

 

{{Output}}

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

;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

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out|Sample output}}

<pre>1901 3

 

=={{header|Python}}==

 

START, STOP = date(1900, 1, 1), date(2101, 1, 1)

 

 

indent = ' '

 

 

'''Alternate Algorithm'''

 

The condition is equivalent to having a thirty-one day month in which the last day of the month is a Sunday.

 

 

{{out|Sample output}}

 

There are 29 years in the range that do not have months with five weekends</pre>

 

=={{header|R}}==

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 = ", "))

 

=={{header|Racket}}==

#lang racket

(require srfi/19)

(define count (length weekends))

 

(displayln "The first five are: ")

(for ([w (take weekends 5)])

(for ([w (drop weekends (- count 5))])

(displayln (date->string w "~b ~Y")))

{{out}}

<pre>

The first five are:

Mar 1901

Oct 2100

</pre>

 

=={{header|REXX}}==

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

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. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when using the default inputs:

<pre style="height:98ex">

===version for older REXXes===

This version will work with any version of a REXX interpreter.

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. */

if w==0 then w=7; return w /*Sunday=1, Monday=2, ... Saturday=7 */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; is identical to the 1^st REXX version.

<br><br>

 

===version short and focussed at the task description===

* Short(er) solution focussed at the task's description

* Only 7 months can have 5 full weekends

Return result /* return the result */

 

{{Out}}

<pre>

 

===shorter version===

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. */

say

say "There are " # ' year's(#) "that haven't any" @5w 'in year's(years) yStart'──►'yStop

'''output''' &nbsp; is identical to the 1^st REXX version.

 

===shorter and more focused===

This REXX version takes advantage that a month with five full weekends must start on a Friday and have 31 days.

month. =31 /*days in "all" the months. */

month.2=0; month.4=0; month.6=0; month.9=0; month.11=0 /*not 31 day months.*/

end /*y*/

say

'''output''' &nbsp; is identical to the 1^st REXX version.

<br><br>

 

=={{header|Ring}}==

sum = 0

month = list(12)

next

see "Total : " + sum + nl

Output:

<pre>

2100-October

Total : 201

</pre>

 

=={{header|Ruby}}==

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

 

 

puts "There are #{dates.size} months with 5 weekends from 1900 to 2100:"

 

'''Output'''

 

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

for yyyy = 1900 to 2100

for mm = 1 to 12 ' go thru all 12 months

end if

preCount = count

 

{{Out}}

200 2100-01

201 2100-01</pre>

 

=={{header|Scala}}==

import java.util.GregorianCalendar

 

(1900 to 2100) - months.map(_.year) shouldBe expectedNon5erYears

}

 

=={{header|Seed7}}==

include "time.s7i";

 

end for;

writeln("Number of months:" <& months);

 

{{Out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var happymonths = [];

say happymonths.last(5).join("\n");

say "No long weekends in the following #{workhardyears.len} years:";

{{out}}

<pre>

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

BEGIN

 

 

END.

{{out}}

<pre>

=={{header|Stata}}==

 

set obs `=tm(2101m1)-tm(1900m1)'

gen month=tm(1900m1)+_n-1

| 2100m1 |

| 2100m10 |

 

=={{header|Tcl}}==

 

set months {}

puts [join [list {*}[lrange $months 0 4] ... {*}[lrange $months end-4 end]] \n]

puts "There are [llength $years] years without any five-weekend months"

{{Out}}

<pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP year=1900,2100

ENDLOOP

ENDLOOP

{{Out}}

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

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

{{trans|FreeBASIC}}

' only months with 31 day can have five weekends

' these months are: January, March, May, July, August, October, December

100 Print "October"; : Return

110 Print "November"; : Return

{{out}}

<pre>1901 | March

* feed this file to an awk-script to look for the months with 5 weekends.

 

echo > cal.txt

for ((y=1900; y <= 2100; y++)); do

echo "Looking for month with 5 weekends:"

awk -f 5weekends.awk cal.txt

 

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

{{works with|Windows Script Host|*}}

For y = 1900 To 2100

For m = 1 To 12

 

WScript.Echo vbCrLf & "Total = " & i & " months"

 

=={{header|XPL0}}==

 

 

];

CrLf(0); IntOut(0, C); CrLf(0); \show number of years

 

{{Out}}

=={{header|zkl}}==

Months with five weekends:

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

Alternatively, in a functional style using list comprehensions:

[1..12],{D.daysInMonth(y,m)==31 and 5==D.weekDay(y,m,1)};

{{out}}

<pre>

 

Extra credit: Years with no five day weekends:

foreach y in ([1900..2100]){ yes:=True;

foreach m in ([1..12]){

}

if (yes) r.append(y)

Alternatively:

[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};

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.