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>

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

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]

PrintI(years(i)) Put('/) PrintBE(months(i))

OD

{{out}}

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

 

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

{{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''.}}

INT m, year, nfives := 0, not5 := 0;

BOOL no5weekend;

END # function day_of_week #;

SKIP

{{out}}

<pre>

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>

 

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

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

===With iteration===

 

namespace _5_Weekends

}

}

{{out}}

<pre>

 

===With LINQ===

using System.Linq;

using System.Collections.Generic;

{

public static IEnumerable<int> To(this int start, int end) => Enumerable.Range(start, end - start + 1);

{{out}}

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

2091

2096

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

 

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

 

=={{header|Dart}}==

main() {

var total = 0;

print('Year with none: $empty');

}

{{out|Sample output}}

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

 

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

 

=={{header|Factor}}==

sequences ;

 

[ length "%d five-weekend months found.\n" printf ]

[ 5 head timestamps>my "..." print ]

{{out}}

<pre>

 

Using Zeller's congruence

implicit none

 

end function Day_of_week

{{out}}

<pre>Mar 1901

 

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

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

 

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

 

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

 

procedure main(A) # five weekends

every insert(F := set(), integer(!fwe ? tab(find("-"))))

return sort(Y--F)

 

{{libheader|Icon Programming Library}}

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

 

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

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

{{works with|Julia|0.6}}

 

 

function hasfiveweekend(month::Integer, year::Integer)

nyrs = 2100 - 1899 - length(unique(yrs))

 

 

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

 

=={{header|Maple}}==

local i, month, count;

#Only months with 31 days can possibly satisfy the condition

printf("%d months have five full weekends.\n", count);

end proc;

{{Out|Output}}

<pre>1901-March

 

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

if none: inc sumNone

 

{{out}}

<pre>March 1901

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

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

 

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

=={{header|Prolog}}==

Works with SWI-Prolog;

weekends(1900, 2100, FiveWeekendList, RemainderWeekendList),

 

length(LastN, N),

append(_, LastN, List).

{{out}}

<pre>?- main.

 

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

=={{header|Quackery}}==

 

dup 4 / over +

over 100 / -

i if say ", "

i^ 8 mod 7 = if

 

{{out}}

 

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

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

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

{{out}}

<pre>

(formerly Perl 6)

{{works with|Rakudo|2015-09-10}}

 

my @years = 1900 .. 2100;

say 'First happy months: ' ~ @happy[^5];

say 'Last happy months: ' ~ @happy[*-5 .. *];

 

{{out}}

<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 dates.last(5).map {|d| d.strftime("%b %Y") }

puts "There are #{years_4w.size} years without months with 5 weekends:"

 

'''Output'''

 

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

for yyyy = 1900 to 2100

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

end if

preCount = count

 

{{Out}}

 

=={{header|Rust}}==

use chrono::prelude::*;

 

let out = five_weekends(1900, 2100);

assert_eq!(out.len(), 201);

 

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

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

 

=={{header|VBA}}==

Option Explicit

 

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"

{{out}}

<pre>1901, 3

=={{header|VBScript}}==

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

For y = 1900 To 2100

For m = 1 To 12

 

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

 

=={{header|Wren}}==

{{libheader|Wren-date}}

{{libheader|Wren-seq}}

 

var dates = []

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)

 

{{out}}

 

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