Day of the week: Difference between revisions

 

=={{header|11l}}==

{{out}}

<pre>

{{trans|REXX}}

The program uses two ASSIST macro (XDECO,XPRNT) to keep the code as short as possible.

DOW CSECT

USING DOW,R15 base register

PG DS CL12 buffer

YREGS

{{out}}

<pre style="height:16ex"> 2011

 

=={{header|ABAP}}==

data: lv_start type i value 2007,

lv_n type i value 114,

endif.

enddo.

{{out}}

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

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

Action! does not have a standard library providing a day of week function, therefore an adaptation of [https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto.27s_methods Sakamoto's method] to determine the day of week for a given date using integer arithmetic is used.

Byte FUNC DayOfWeek(BYTE day, month CARD year BYTE century)

CARD weekday

OD

RETURN

{{out}}

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

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

end if;

end loop;

{{out}}

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

 

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

INT sun=0 # , mon=1, tue=2, wed=3, thu=4, fri=5, sat=6 #;

 

new line(stand out)

)

{{out}}

<pre>

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

{{Trans|Fortran}}

integer procedure Day_of_week ( integer value d, m, y );

begin

if day = 1 then writeon( I_W := 5, S_W := 0, year );

end for_year

{{out}}

<pre>

 

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

BEGIN

 

 

END

{{out}}

<pre>

</pre>

=={{header|APL}}==

⎕IO ← 0 ⍝ Indices are 0-based

y ← 2008 + ⍳114 ⍝ Years from 2008 to 2121

zeller ← { 7 | +/ (((1↑⍴⍵),6)⍴1 1 1 1 ¯1 1) × ⌊(((⍴⍵)⍴1 13 1)×⍵+(⍴⍵)⍴0 1 0)[;0 1 2 2 2 2]÷((1↑⍴⍵),6)⍴1 5 1 4 100 400 }

result ← (1 = zeller 25,[1]12,[0.5]y) / y

{{out}}

<pre>

 

=={{header|AppleScript}}==

set Christmas to (current date)

set month of Christmas to December

if weekday of Christmas is Sunday then set end of ChristmasSundays to |year|

end repeat

 

 

Or, composing generic functions:

-- xmasIsSunday :: Int -> Bool

on xmasIsSunday(y)

end script

end if

{{Out}}

 

=={{header|Arc}}==

(= day-names '(Sunday Monday Tuesday Wednesday Thursday Friday Saturday))

(= get-weekday-num (fn (year month day)

7)))

(= get-weekday-name (fn (weekday-num) (day-names weekday-num)))

<b>test:</b>

(when (is 0 (get-weekday-num i 12 25))

(prn i)))

2118

 

 

=={{header|Arturo}}==

 

"Sunday" = get to :date.format:"dd-MM-YYYY" ~"25-12-|year|" 'Day

 

{{out}}

 

=={{header|AutoHotkey}}==

stop = 2121

 

year++

}

 

=={{header|AutoIt}}==

Const $iSunday = 1

For $iYear = 2008 To 2121 Step 1

ConsoleWrite(StringFormat($iYear & "\n"))

EndIf

 

=={{header|AWK}}==

 

# syntax: GAWK -f DAY_OF_THE_WEEK.AWK

# runtime does not support years > 2037 on my 32-bit Windows XP O/S

}

}

 

=={{header|BASIC}}==

This program needs the modulo function because there is a bug in the built in modulo function.

 

Declare Function wd(m As Double, d As Double, y As Double) As Integer

 

Dec 25, 2107

Dec 25, 2112

 

==={{header|Applesoft BASIC}}===

{{trans|Commodore BASIC}}

2 DEF FN RD(Y) = 365 * Y + INT (Y / 4) - INT (Y / 100) + INT (Y / 400)

3 PRINT "YEARS WITH CHRISTMAS ON A SUNDAY" CHR$ (13)

4 FOR Y = 2008 TO 2121

5 IF NOT FN D7( FN RD(Y) - 6) THEN PRINT Y,

==={{header|Atari BASIC}}===

{{trans|Commodore BASIC}}

110 PRINT CHR$(125);"SUNDAY CHRISTMASES 2008-2121:":PRINT

120 FOR Y=2008 TO 2121

210 PRINT

220 NEXT Y

 

{{Out}}

 

==={{header|BaCon}}===

PRINT "Years with Christmas on a Sunday"

FOR y = 2008 TO 2121

tv = TIMEVALUE(y, 12, 25, 0, 0, 0)

IF WEEKDAY$(tv) = "Sunday" THEN PRINT y

 

{{out}}

This takes advantage of the dynamic scope of arguments to DEF FN functions to nest definitions and ultimately turn the question "Does Christmas fall on a Sunday in year Y?" into a single Boolean function of the year number. It's easy to run afoul of stack limitations in Microsoft BASICs doing this, especially on older versions that just use the processor's 256-byte stack instead of giving BASIC its own, but this program runs fine even on an unexpanded VIC-20.

 

110 REM MODULO FUNCTION (USES CALLER'S N AS DIVIDEND)

120 DEF FNNM(D) = N - D * INT(N/D)

230 : IF FNXS(Y) THEN PRINT Y,:REM PRINT YEARS IN COLUMNS

240 NEXT Y

 

{{Out}}

 

==={{header|FreeBASIC}}===

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Dec 25 2011

Dec 25 2112

Dec 25 2118</pre>

' Weekday And DateSerial only works with #Include "vbcompat.bi"

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>25-12-2011

 

==={{header|GW-BASIC}}===

20 D = 25

30 FOR Y = 2007 TO 2122

150 Z = Z + D + INT((153*M + 8)/5)

160 Z = Z MOD 7

 

==={{header|IS-BASIC}}===

110 PRINT "The years between 2008 and 2121 will the 25th of December be a Sunday:"

120 FOR Y=2008 TO 2121

170 LET W=D+INT((13*(M+12*A-2)-1)/5)+Y+INT(Y/4)-INT(Y/100)+INT(Y/400)

180 LET DAYWEEK=W-7*INT(W/7)

 

==={{header|Minimal BASIC}}===

10 REM Find years with Sunday Christmas

20 LET F = 2008

130 PRINT

140 END

 

==={{header|Sinclair ZX81 BASIC}}===

{{trans|C}}

Works with 1k of RAM. Follows the C code quite closely: the only factors that perhaps make it less readable are (a) the absence of a modulo operator and (b) the need for continual calls to <code>INT</code> because we don't have an integer type. The performance is pretty acceptable; seconds rather than minutes.

20 LET D=25

30 FOR Y=2008 TO 2121

110 LET W=D+INT ((13*MM-1)/5)+YY+INT (YY/4)-INT (YY/100)+INT (YY/400)

120 LET W=W-7*INT (W/7)

{{out}}

<pre>2011

second, even in SLOW mode, as multiplying by 13 with a division by 5 is slower than by 256 alone, as well as that two divisions by

multiples of 100 are much slower than one by 16 as at the link. N.B. by relying on strings to have 4-digit years, this routine is not y10k-compliant

AUTO 100,10

 

ctrl+space

{{out}}

<pre>2011

 

==={{header|Tiny BASIC}}===

LET Y = 2007

LET M = 12

LET Z = Z + D + (153*M + 8)/5

LET Z = Z - 7*(Z/7)

{{out}}

<pre>2011

 

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

:: Batch File Implementation

:: Question: In what years between 2008 and 2121 will the 25th of December be a Sunday?

)

pause

{{out}}

<pre>Dec 25, 2011 is a Sunday.

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

{{works with|BBC BASIC for Windows}}

FOR year% = 2008 TO 2121

PRINT "Christmas Day is a Sunday in "; year%

ENDIF

 

=={{header|bc}}==

Because ''bc'' has no date library, this program uses [http://mathforum.org/library/drmath/view/62324.html ''Zeller's rule''], also known as [http://www.merlyn.demon.co.uk/zel-like.htm ''Zeller's congruence''], to calculate day of week.

 

 

/*

if (w(y, 12, 25) == 0) y

}

 

=={{header|BCPL}}==

 

let weekday(y, m, d) =

for year = 2008 to 2121

if weekday(year, 12, 25) = 0

{{out}}

<pre>2011

Befunge doesn't have any standard date-handling functionality, so we calculate the day of the week directly using a simple variation of the Zeller rule.

 

@_^#`"y": +1$<_v#%7+1+/*:*<

 

{{out}}

=={{header|Bracmat}}==

{{trans|C}}

( wday

= year month day adjustment mm yy

& 1+!y:?y

)

{{out}}

<pre>2011-12-25

Because of problems with various C libraries (such as ''time_t'' overflowing during 2038, or strptime() or mktime() not filling in ''tm_wday''), this program uses [http://mathforum.org/library/drmath/view/62324.html Zeller's Rule] to calculate day of week.

 

 

/* Calculate day of week in proleptic Gregorian calendar. Sunday == 0. */

 

return 0;

 

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

 

class Program

}

}

 

Using LINQ:

using System.Linq;

 

foreach (string day in days) Console.WriteLine(day);

}

using System.Linq;

 

.ForEach(ent => Console.WriteLine(ent.ToString("dd MMM yyyy")));

}

{{out}}

<pre style="height:20ex;overflow:scroll">25 Dec 2011

 

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

#include <iostream>

 

std::cout << "\n" ;

return 0 ;

{{out}}

<pre>

Utilizing Java interop

 

(import '(java.util GregorianCalendar))

(defn yuletide [start end]

 

(yuletide 2008 2121)

<pre>(2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118)</pre>

 

=={{header|CLU}}==

y: int := d.year

m: int := d.month

end

end

{{out}}

<pre>2011

=={{header|COBOL}}==

Using Date Intrinsic Functions

program-id. dec25.

data division.

.

end program dec25.

{{out}}

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

Without Date Intrinsic Functions

 

identification division.

program-id. dowtest.

.

end program todow.

{{out}}

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

 

=={{header|CoffeeScript}}==

sunday = 0

for year in [2008..2121]

xmas = new Date year, december, 25

{{out}}

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

 

=={{header|ColdFusion}}==

<cfloop from = "2008" to = "2121" index = "i">

<cfset myDate = createDate(i, 12, 25) />

</cfif>

</cfloop>

 

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

when (= 6 (multiple-value-bind

(second minute hour date month year day-of-week dst-p tz)

(declare (ignore second minute hour date month year dst-p tz))

day-of-week))

 

for xmas = (encode-universal-time 0 0 0 25 12 year)

for day = (nth-value 6 (decode-universal-time xmas))

 

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

MODULE DayOfWeek;

IMPORT DevCommanders, TextMappers, Dates, StdLog;

 

END DayOfWeek.

Execute: ^Q DayOfWeek.Do 2008 2121~

{{out}}

 

=={{header|Cowgol}}==

 

sub weekday(year: uint16, month: uint8, day: uint8): (wd: uint8) is

end if;

year := year + 1;

{{out}}

<pre>2011

 

=={{header|D}}==

import std.stdio, std.range, std.algorithm, std.datetime;

 

iota(2008, 2122)

.filter!(y => Date(y, 12, 25).dayOfWeek == DayOfWeek.sun));

{{out}}

<pre>Christmas comes on a Sunday in the years:

=={{header|Delphi}}==

{{libheader|sysutils}} always in uses clause in Delphi

var

i: integer;

//GUI

form1.label1.caption := outputyears;

 

Procedure called with year range to test and outputs a space-delimited array of years to a label. There is no error check that fromyear < toyear, but this is easily added.

 

=={{header|Draco}}==

word c;

if m<3 then

fi

od

{{out}}

<pre>2011

 

=={{header|ECL}}==

 

IMPORT STD;

2118

*/

This code solves a specific task, but can easily be modified as a generic function to return the DayOfWeek for any day after 1 AD.

 

=={{header|Elixir}}==

{{works with|Elixir|1.4}}

wday = Date.from_erl!({year, 12, 25}) |> Date.day_of_week

if wday==7, do: IO.puts "25 December #{year} is sunday"

 

{{out}}

 

=={{header|Emacs Lisp}}==

 

(defun sunday-p (y)

(seq-filter #'sunday-p (number-sequence a b)))

 

{{output}}

<pre>(2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118)</pre>

=={{header|Erlang}}==

 

-module(yuletide).

-export([main/0, sunday_years/2]).

 

is_sunday( 7 ) -> true;

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM DAY_OF_THE_WEEK

 

GET(K$)

END PROGRAM

{{out}}

<pre>Dec 25, 2011

 

=={{header|Euphoria}}==

--Day of the week task from Rosetta Code wiki

--User:Lnettnay

end if

end for

{{out}}

<pre>

 

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

 

[ 2008 .. 2121 ]

|> List.choose (fun y -> if DateTime(y,12,25).DayOfWeek = DayOfWeek.Sunday then Some(y) else None)

{{out}}

<pre>[2011; 2016; 2022; 2033; 2039; 2044; 2050; 2061; 2067; 2072; 2078; 2089; 2095;

 

=={{header|Factor}}==

 

=={{header|FBSL}}==

 

'In what years between 2008 and 2121 will the 25th of December be a Sunday?

next

PAUSE

 

=={{header|Forth}}==

 

Forth has only TIME&DATE, which does not give day of week. Many public Forth Julian date calculators had year-2100 problems, but this algorithm works well.

\ Zeller's Congruence

: weekday ( d m y -- wd) \ 1 mon..7 sun

7 = if i . then

loop cr ;

 

cr yuletide

December 25 is Sunday in 2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118

ok

 

 

To show year-2100 problems with SwiftForth's provided Modified Julian Day support:

 

." December 25 is Sunday in "

2122 2008 do

 

cr yuletide

 

In [[4tH]] a library is available which provides the right answer:

 

 

: yuletide

loop cr ;

 

 

The code is derived from "Collected Algorithms from ACM", Volume 1 Algorithms 1-220.

{{works with|Fortran|90 and later}}

Based on Forth example

IMPLICIT NONE

END FUNCTION Day_of_week

{{out}}

<pre>

 

=={{header|Frink}}==

if (parseDate["$y-12-25"] -> ### u ###) == "7"

 

{{out}}

 

=={{header|FutureBasic}}==

 

long y

next

 

 

 

=={{header|Gambas}}==

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

Dim siCount As Short

 

Next

 

Output:

<pre>

 

=={{header|GAP}}==

# [ 2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118 ]

 

 

Filtered([2008 .. 2121], y -> WeekDayAlt([25, 12, y]) = "Sun");

 

=={{header|Go}}==

 

import "fmt"

}

}

{{out}}

<pre>

 

Solution:

 

Test program:

 

{{out}}

=={{header|Haskell}}==

Using the time library:

import Data.Time.Calendar.WeekDate (toWeekDate)

 

| year <- [2008 .. 2121],

isXmasSunday year

{{out}}

<pre>Sunday 25 December 2011

 

The built-in System.Time module can overflow at the Unix epoch in 2038:

isXmasSunday :: Int -> Bool

[ "25 December " ++ show year ++ " is Sunday"

| year <- [2008 .. 2121]

{{out}} on 32-bit machine:

<pre>

 

=={{header|HicEst}}==

TIME(Year=year, MOnth=12, Day=25, TO, WeekDay=weekday)

IF( weekday == 7) WRITE(StatusBar) year

ENDDO

 

<pre>No anomalies detected for the first million years :-)

Dec 25 = Sunday in

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

 

 

procedure main()

writes("December 25th is a Sunday in: ")

every writes((dayoweek(25,12,y := 2008 to 2122)=="Sunday",y)," ")

 

 

[http://www.cs.arizona.edu/icon/library/src/procs/datetime.icn datetime provides dayoweek]

 

static d_code, c_code, m_code, ml_code, y, C, M, Y

 

return d_code[(C + Y + M + day) % 7 + 1]

 

{{out}}

 

=={{header|J}}==

xmasSunday=: #~ 0 = [: weekday 12 25 ,~"1 0 ] NB. returns years where 25 Dec is a Sunday

xmasSunday 2008 + i.114 NB. check years from 2008 to 2121

 

=={{header|Java}}==

import java.util.Date;

import java.util.GregorianCalendar;

}

}

{{out}}

<pre>Sun Dec 25 00:00:00 CST 2011

===ES5===

====Iteration====

var xmas = new Date(year, 11, 25)

if ( xmas.getDay() === 0 )

console.log(year)

{{out}}

<pre>2011

====Functional composition====

 

'use strict';

 

.filter(isXmasSunday);

 

 

{{Out}}

 

===ES6===

"use strict";

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

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

# If iso == "iso" or "ISO", then emit an integer in 1 -- 7 where

| if iso == "iso" or iso == "ISO" then 1 + ((. + 5) % 7)

else . % 7

'''The task''':

# readily be presented on a single line:

{{out}}

$ jq -n -c -f zeller.jq

Jsi does not yet implement the Javascript ''Date'' object. ''strftime' and ''strptime'' functions are used here instead.

 

for (var year = 2008; year <= 2121; year++) {

var xmas = strptime(year + '/12/25', '%Y/%m/%d');

2118

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

lo, hi = 2008, 2121

 

println("Years from $lo to $hi having Christmas on Sunday: ")

 

{{out}}

 

=={{header|K}}==

y@&6={wd 1225+x*10000}'y:2008+!114

2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118

 

=={{header|Kotlin}}==

 

import java.util.*

calendar.add(Calendar.YEAR, 1)

}

 

{{out}}

 

=={{header|Lasso}}==

local(tDate = date('12/25/' + loop_count))

#tDate->dayOfWeek == 1 ? '\r' + #tDate->format('%D') + ' is a Sunday'

 

{{out}}

 

=={{header|Liberty BASIC}}==

for year = 2008 to 2121

dateString$="12/25/";year

 

print count; " years when Christmas Day falls on a Sunday"

 

=={{header|Lingo}}==

refDateObj = date(1905,1,2)

repeat with year = 2008 to 2121

dayOfWeek = ((dateObj - refDateObj) mod 7)+1 -- 1=Monday..7=Sunday

if dayOfWeek=7 then put year

{{out}}

<pre>

 

=={{header|LiveCode}}==

convert the long date to dateitems

put it into xmasDay

if the last char of xmasYear is comma then delete the last char of xmasYear

return xmasYear

 

=={{header|Logo}}==

to leap? :year

output (and

; Put it all together to answer the question posed in the problem

print filter [sunday? ? 12 25] iseq 2008 2121

 

{{Out}}

'''Library:''' [http://luaforge.net/projects/date/ LuaDate]

 

 

for year=2008,2121 do

print(year)

end

 

{{out}}

=== Without external modules ===

Same output as above

for year = 2008, 2121 do

dTab.year = year

print(year)

end

 

=={{header|M2000 Interpreter}}==

Str$( number, format$) use Visual Basic 6 format

Print "December 25 is a Sunday in:"

For Year=2008 to 2121 {

 

 

{{out}}

<pre>

 

=={{header|M4}}==

 

define(`for',

 

for(`yr',2008,2121,

 

{{out}}

 

=={{header|Maple}}==

local i, dt;

for i from 2008 to 2121 by 1 do

end proc;

 

 

{{Out|Output}}

Or simply:

 

 

{{out}}

 

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

gives back:

 

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

 

t = t(strmatch('Sunday', datestr(t,'dddd')), :);

datestr(t,'yyyy')

 

 

 

=={{header|Maxima}}==

if m < 3 then (m: m + 12, y: y - 1),

k: 1 + remainder(day + quotient((m + 1)*26, 10) + y + quotient(y, 4)

sublist(makelist(i, i, 2008, 2121),

lambda([y], weekday(y, 12, 25) = 'sunday));

 

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

1 0 / [x] П6 ИП9 + 1 8 9

9 - 3 6 5 , 2 5 * [x]

0 , 5 9 * [x] + 2 9 +

ИП7 + П4 ИП4 7 / [x] 7 * -

 

''Input:'' РX: starting year.

Consequently, it suffers from the same problem as C.

 

 

IMPORT IO, Fmt, Date, Time;

END;

END;

 

{{out}}

=={{header|MUMPS}}==

{{libheader|VA Kernel|22.0}}

DOWHOLIDAY

;In what years between 2008 and 2121 will December 25 be a Sunday?

KILL BDT,EDT,CHECK,CHKFOR,LIST,I,X,Y

QUIT

The following years have Christmas on a Sunday: 2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118

 

=={{header|Nanoquery}}==

// loop through the years 2008 through 2121

println "In " + year + ", December 25th is a Sunday."

end if

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

 

return

{{out}}

<pre>

===Comparison of Some Common Day-of-Week Algorithms===

The following program exercises some common &quot;Day-0f-Week&quot; algorithms to confirm they all arrive at the same result.

options replace format comments java crossref savelog symbols nobinary

 

method modulo(N = int, D = int) inheritable static binary returns int

return (D + (N // D)) // D

{{out}}

<pre>

 

=={{header|Nim}}==

 

for year in 2008..2121:

if getDayOfWeek(25, mDec, year) == dSun:

stdout.write year, ' '

 

{{out}}

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

{{works with|oo2c version 2}}

MODULE DayOfWeek;

IMPORT NPCT:Dates, Out;

END

END DayOfWeek.

{{out}}

<pre>

</pre>

{{works with|AOS}}

MODULE DaysOfWeek; (** AUTHOR ""; PURPOSE ""; *)

 

 

END DaysOfWeek.

{{out}}

<pre>

{{works with|Cocoa}}

 

 

int main()

}

return 0;

 

{{out}}

=={{header|OCaml}}==

{{trans|C}}

open Unix

 

raise e

done

 

{{out}} of a run on a 32 bit machine

Unlike the previous example which only uses the OCaml standard library, here with the OCaml Calendar Library we can go until the year 2121:

 

 

let list_make_seq first last =

Date.day_of_week (Date.make year 12 25) = Date.Sun) years in

print_endline "December 25 is a Sunday in:";

 

{{out}}

=={{header|Oforth}}==

 

{{out}}

<pre>

=={{header|ooRexx}}==

===Christmas===

lastdate = .datetime~new(2121, 12, 25)

 

end

 

{{out}}

<pre>Christmas falls on Sunday in the years 2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118</pre>

===Weekday===

Parse Arg yyyymmdd

If arg(1)='' |,

wd=.Array~of('Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday')

dt=.DateTime~new(y,m,d)

{{out}}

<pre>H:\>rexx wd ?

 

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

njd(D) =

{

 

for (y = 2008, 2121, if (njd([y,12,25]) % 7 == 1, print(y)));

 

Output:

 

=={{header|Peloton}}==

<@ ITEFORLI3>2121|2008|

<@ LETVARCAP>Christmas Day|25-Dec-<@ SAYVALFOR>...</@></@>

</@>

</@>

 

English dialect variable-length space-padded opcodes

<# iterate foriteration literalstring3>2121|2008|

<# let variable capture>Christmas Day|25-Dec-<# say value foriteration>...</#></#>

</#>

 

{{out}}

=={{header|Perl}}==

 

 

use Time::Local;

}

 

 

{{out}}

 

Using the DateTime module from CPAN:

 

use DateTime;

}

 

or shorter:

 

use DateTime;

}

 

{{out}}

<pre>

 

Alternatively in one line using grep (read from right to left):

 

use DateTime;

print join " ", grep { DateTime->new(year => $_, month => 12, day => 25)->day_of_week == 7 } (2008 .. 2121);

 

{{out}}

<pre>2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118</pre>

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Day_of_the_week.exw</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #0000FF;">}</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #0000FF;">?<span style="color: #000000;">res

{{out}}

<pre>

=={{header|PHP}}==

 

for($i=2008; $i<2121; $i++)

{

}

}

 

{{out}}

 

=={{header|Picat}}==

L = [Year : Year in 2008..2121, dow(Year, 12, 25) == 0],

println(L),

end,

R = (Y + Y // 4 - Y // 100 + Y // 400 + T[M] + D) mod 7.

 

{{out}}

 

=={{header|PicoLisp}}==

(when (= "Sunday" (day (date Y 12 25)))

{{out}}

<pre>2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118</pre>

 

=={{header|Pike}}==

{{out}}

<pre>

 

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

declare i picture '9999';

do i = 2008 to 2121;

put skip list ('Christmas day ' || i || ' is a Sunday');

end;

 

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

 

sunday_christmas:

 

end sunday_christmas;

{{out}}

<pre>Christmas will fall on Sunday in these years:

 

=={{header|PowerShell}}==

 

===Find Christmas holiday for any day and/or year===

function Get-ChristmasHoliday

{

}

}

Satisfy the task requirement:

2008..2121 | Get-ChristmasHoliday | where DayOfWeek -match Su

{{Out}}

<pre>

</pre>

Get days off for a random year:

Get-ChristmasHoliday -Year (2008..2121 | Get-Random)

{{Out}}

<pre>

</pre>

Get days off for the current year using the '''Year''' property returned by <code>Get-Date</code>:

(Get-Date | Get-ChristmasHoliday).DaysOff

{{Out}}

<pre>

</pre>

Get days off for the current year as <code>[DateTime]</code> objects:

(Get-Date | Get-ChristmasHoliday).DaysOff | Get-Date

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog;

christmas_days_falling_on_sunday(2011, 2121, SundayList),

writeln(SundayList).

day_of_the_week(Date, DayOfTheWeek),

DayOfTheWeek == 7.

{{out}}

<pre>?- main.

=={{header|PureBasic}}==

PureBasic's internal Date() is limited between 1970-01-01 00:00:00 and 2038-01-19 03:14:07

If DayOfWeek(Date(i,12,25,0,0,0))=0

PrintN(Str(i))

EndIf

 

=={{header|Python}}==

 

{{out}}

<pre>[2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]</pre>

Or, in terms of datetime:

{{Works with|Python|3.7}}

 

from datetime import date

# MAIN --

if __name__ == '__main__':

{{Out}}

<pre>Years between 2008 and 2121 with 25 Dec on a Sunday:

Using Tomohiko Sakamoto's algorithm.

 

dup 4 / over +

over 100 / -

2121 1+ 2008 - times

[ 25 12 i^ 2008 + dayofweek

 

{{out}}

 

=={{header|R}}==

xmas <- as.POSIXlt(paste0(years, '/12/25'))

years[xmas$wday==0]

 

# Under MS Windows, write instead

 

=={{header|Racket}}==

 

#lang racket

 

(for ([y (in-range 2008 2121)] #:when (xmas-on-sunday? y))

(displayln y))

 

=={{header|Raku}}==

As Perl 5, except <code>DateTime</code> is built-in, so you don't need to download a module of that name:

 

 

=={{header|REBOL}}==

Title: "Yuletide Holiday"

URL: http://rosettacode.org/wiki/Yuletide_Holiday

d: to-date reduce [y 12 25]

if 7 = d/weekday [prin [y ""]]

 

{{out}}

 

=={{header|Red}}==

repeat yy 114 [

d: to-date reduce [25 12 (2007 + yy )]

d/year: d/year + 1

]

{{out}}<pre>25-Dec-2011

25-Dec-2016

===using DATE weekday===

The extended &nbsp; DATE &nbsp; parameters (arguments 2 and 3) are only supported by the newer REXX interpreters.

if date('w', year"1225", 's') == 'Sunday' then say year

{{out|output}}

<pre>

===using DATE base===

The extended DATE parameters (arguments 2 and 3) are only supported by the newer REXX interpreters.

if date('b', year"1225", 's') // 7 == 6 then say year

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

 

Language note: &nbsp; the DATE &nbsp; built-in function always returns the day-of-week in English, no matter what the native language is in effect.

parse arg start finish . /*get the START and FINISH years. */

if start=='' | start=="," then start=2008 /*Not specified? Then use the default.*/

say 'December 25th,' y "falls on a Sunday."

end /*y*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

===old school DOW ===

This &nbsp; DOW &nbsp; (day-of-week) &nbsp; version will work with any version of a REXX interpreter.

parse arg start finish . /*get the START and FINISH years. */

if start=='' | start=="," then start=2008 /*Not specified? Then use the default.*/

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

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

for n = 2008 to 2121

if n < 2100 leap = n - 1900 else leap = n - 1904 ok

if m = 4 see "25 Dec " + n + nl ok

next

 

=={{header|Ruby}}==

 

{{out}}

<pre>

 

Or using the Time class

{{output}}

<pre>

 

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

if val(date$("12-25-";year)) mod 7 = 5 then print "For ";year;"xmas is Sunday"

For 2011 xmas is Sunday

For 2016 xmas is Sunday

 

=={{header|Rust}}==

 

use chrono::prelude::*;

let years = (2008..2121).filter(|&y| Local.ymd(y, 12, 25).weekday() == Weekday::Sun).collect::<Vec<i32>>();

println!("Years = {:?}", years);

 

Output:

 

=={{header|S-BASIC}}==

$constant SUNDAY = 0

 

next year

end

{{out}}

<pre>Christmas will fall on a Sunday in

 

=={{header|SAS}}==

do y=2008 to 2121;

a=mdy(12,25,y);

 

/* 2011 2016 2022 2033 2039 2044 2050 2061 2067

 

=={{header|Scala}}==

{{libheader|Scala}}

===JDK (discouraged) ===

import Calendar.{ DAY_OF_WEEK, DECEMBER, SUNDAY }

 

s"${yuletide.length} Years between ${years.head} and ${years.last}" +

" including where Christmas is observed on Sunday:\n", ", ", "."))

===JDK >= 8 (recommended)===

====Naive programming====

 

object DayOfTheWeek1 extends App {

s"${yuletide.count(p => true)} Years between ${years.head} and ${years.last}" +

" including where Christmas is observed on Sunday:\n", ", ", "."))

====Idiomatic programming====

 

object DayOfTheWeek1 extends App {

s"${yuletide.length} Years between ${years.head} and ${years.last}" +

" including where Christmas is observed on Sunday:\n", ", ", "."))

====Tail recursion====

import scala.annotation.tailrec

 

s"${yuletide.length} Years between ${years.head} and ${years.last}" +

" including where Christmas is observed on Sunday:\n", ", ", "."))

{{out | Output of all solutions }}

<pre>Years between 2008 and 2121 including when Christmas is observed on Sunday:

 

=={{header|Scheme}}==

(if (< month 3)

(begin (set! month (+ month 12)) (set! year (- year 1))))

 

(task)

 

=={{header|Seed7}}==

the function [http://seed7.sourceforge.net/libraries/time.htm#dayOfWeek%28in_time%29 dayOfWeek],

which returns 1 for monday, 2 for tuesday, and so on up to 7 for sunday.

include "time.s7i";

 

end if;

end for;

{{out}}

<pre>

 

=={{header|SenseTalk}}==

 

repeat with year = 2008 to 2121

put "Christmas in " & year & " falls on a Sunday"

end if

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

 

for year in (2008 .. 2121) {

say "25 Dec #{year} is Sunday"

}

{{out}}

<pre>

=={{header|Simula}}==

{{trans|Sinclair ZX81 BASIC}}

INTEGER M,D,Y;

M := 12;

END;

END;

{{out}}

<pre>2011

 

=={{header|Smalltalk}}==

date := Date newDay: 25 monthIndex: 12 year: year.

date dayName = #Sunday

ifTrue: [ date displayNl ]

 

{{out}}

SQL has good support for date functions; care must be taken with NLS settings (globalization support), in the code below the date format language is passed in as an argument to the relevant function. (Or, see a variation that does not depend on language settings, after the output shown below.)

 

from (

select add_months(date '2008-12-25', 12 * (level - 1)) as dt

where to_char(dt, 'Dy', 'nls_date_language=English') = 'Sun'

order by 1

 

 

Alternatively, the WHERE clause can be written in a way that avoids the complication of language settings. The (overloaded) TRUNC function, as applied to dates, takes a second argument indicating "to what" we must truncate. One option is 'iw' for "ISO week"; this truncates to the most recent Monday (the beginning of the ISO standard week, which is Monday through Sunday by definition). Like so (replace in the query above):

 

 

=={{header|Standard ML}}==

fun yearsOfSundayXmas(fromYear, toYear) =

if fromYear>toYear then

else

yearsOfSundayXmas(fromYear+1, toYear)

 

{{out}}

 

The [https://www.stata.com/help.cgi?dow() <code>dow()</code>] function returns the day of week, where sunday is zero and saturday is 6.

sca n=2121-2008+1

set obs `=n'

| 2112 |

| 2118 |

 

=== Mata ===

 

 

=={{header|Suneido}}==

while (year <= 2121)

{

Print(year)

++year

{{out}}

<pre>2011

 

=={{header|Swift}}==

 

var year=2008

}

year++

{{out}}

<pre>2011

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

for {set y 2008} {$y <= 2121} {incr y} {

puts "xmas $y is a sunday"

}

{{out}}

<pre>xmas 2011 is a sunday

=={{header|TI-83 BASIC}}==

'''Works with''' TI-84+/SE only

:For(A,2008,2121

:If dayofWk(A,12,25)=1

:Disp A

:End

{{out}}

<pre>2011

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

PRINT "25th of December will be a Sunday in the following years: "

IF (dayofweek==7) PRINT year

ENDLOOP

{{out}}

<pre>

== {{header|TypeScript}} ==

{{trans|Minimal BASIC}}

// Find years with Sunday Christmas

var f = 2008;

}

process.stdout.write("\n");

{{out}}

<pre>

 

{{works with|bash}}

 

for (( i=2008; i<=2121; ++i ))

done |grep Sun

 

 

The first lines of output (from a GNU/Linux system with 32bit time_t, date version 6.9) are

 

Sun Dec 25 00:00:00 CET 2016

Sun Dec 25 00:00:00 CET 2022

Sun Dec 25 00:00:00 CET 2033

 

I.e., starting from year 2038, the <tt>date</tt> command (which uses the glibc library, at least on GNU systems), is not able to recognise the date as a valid one!

''Different machine/OS version (64 bit time_t):''

This is the same command run on RedHat Linux.

date (coreutils) 5.2.1

Written by David MacKenzie.

Sun Dec 25 00:00:00 GMT 2112

Sun Dec 25 00:00:00 GMT 2118

 

===With GNU date and GNU seq ({{header|UnixPipes}})===

Like the previous solution, this solution uses date -d, which seems to be a [[GNU]] extension. Output is same as previous solution.

 

 

===With Unix cal===

 

{{works with|Bourne Shell}}

while test $y -lt 2122; do

cal 12 $y | tail +3 | cut -c1-2 | grep -Fq 25 && echo 25 Dec $y

y=`expr $y + 1`

 

Running this script with [[OpenBSD]], the output is identical to the C# program. OpenBSD ''cal'' accepts any year from 1 to 9999, so 2008 to 2122 is well within range.

 

===With zsh===

for (( year = 2010; year <= 2121; year++ ));

 

If the system has 32-bit time, this script will malfunction for years >= 2038; it will print no year from 2038 to 2121 (unless today is Sunday, then it prints every year from 2038 to 2121). This happens because ''strftime -r '%F' $year-12-25'' yields -1 for an out-of-range date, and ''strftime '%A' -1'' yields name of today.

date with the weekday included. The output is then filtered for Sundays.

 

#import nat

#import stt

#show+

 

{{out}}

<pre>2011

 

=={{header|VBA}}==

 

Sub MainDayOfTheWeek()

Next

XmasSunday = Mid(temp, 2)

 

{{Out}}

 

=={{header|VBScript}}==

If Weekday(DateSerial(year, 12, 25)) = 1 Then

WScript.Echo year

End If

 

{{Out}}

 

=={{header|Vedit macro language}}==

for (#3 = 2008; #3 < 2122; #3++) {

Reg_Set(10, "12/25/")

Num_Ins(#3, NOCR)

}

 

{{out}}

 

=={{header|Visual Objects}}==

local i as dword

endif

next i

 

{{out}}

=={{header|Vlang}}==

Updated for Vlang version 0.2.2

 

fn main() {

}

}

 

{{out}}

{{Trans|ALGOL W}}...which is {{Trans|Fortran}}

VTL-2 does not have operator precedence - all expressions are evaluated left-to-right, except for expressions nested in parenthesis, hence the expression at line 1090 differs from that in the Algol W sample.

1010 R=!

1020 N=M

2080 Y=Y+1

2090 #=Y<2121*2040

{{out}}

<pre>

 

=={{header|Wortel}}==

Returns: <pre>[2011 2016 2022 2033 2039 2044 2050 2061 2067 2072 2078 2089 2095 2101 2107 2112 2118]</pre>

 

=={{header|Wren}}==

{{libheader|Wren-date}}

 

System.print("Years between 2008 and 2121 when 25th December falls on Sunday:")

for (year in 2008..2121) {

if (Date.new(year, 12, 25).dayOfWeek == 7) System.print(year)

 

{{out}}

the Gregorian calendar, from 1583 onward. It's based on Zeller's Congruence.

 

 

func WeekDay(Year, Month, Day); \Return day of week (0=Sat 1=Sun..6=Fri)

if WeekDay(Year, 12, 25) = 1 then \25th of December is a Sunday

[IntOut(0, Year); CrLf(0)];

 

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

If m < 3 Then // If m = 1 Or m = 2 Then

m = m + 12

Print "Dec 25 ", yr

EndIf

 

=={{header|zkl}}==

ISO dates, monday is 1, sunday is 7

foreach y in ([2008..2121]){

if (D.Sunday==D.weekDay(y,12,25)) println(y)

Or, in a more functional manner:

{{out}}

<pre>

 

=={{header|zonnon}}==

module Main;

(*Access to Mono System package *)

System.Console.WriteLine(now.DayOfWeek);

end Main.

{{Out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BASIC}}

20 FOR y=2008 TO 2121

30 LET year=y: LET m=12: LET d=25: GO SUB 1000

1020 LET wd=FN m(year+INT (year/4)-INT (year/100)+INT (year/400)+d+INT ((153*m+8)/5),7)

1030 RETURN