Find the last Sunday of each month: Difference between revisions

* [[Last Friday of each month]]

<br><br>

=={{header|Ada}}==

 

2013-12-29</pre>

 

 

 

{{Trans|JavaScript}}

 

on lastSundaysOfYear(y)

-- lastWeekDaysOfYear :: Int -> Int -> [Date]

script lastWeekDaysOfYear

-- lastWeekDay :: Int -> Int -> Date

script lastWeekDay

set iYear to intYear

(((weekday of calendarDate(iYear, iMonth, iLastDay)) as integer) + ¬

(7 - (iWeekday))) mod 7)

end script

map(lastWeekDay, lastDaysOfMonths(intYear))

-- isLeapYear :: Int -> Bool

end script

end lastSundaysOfYear

 

 

on run argv

end run

 

 

-- Up to two optional command line arguments: [yearFrom], [yearTo]

on fiveCurrentYears(_)

set intThisYear to year of (current date)

end fiveCurrentYears

 

 

 

 

 

-- calendarDate :: Int -> Int -> Int -> Date

end calendarDate

 

 

 

-- intercalate :: Text -> [Text] -> Text

return strJoined

end intercalate

 

-- isoRow :: [Date] -> String

intercalate(tab, map(my isoDateString, lstDate))

end isoRow

 

-- map :: (a -> b) -> [a] -> [b]

set lst to {}

repeat with i from 1 to lng

end repeat

return lst

else

script

end script

end if

end mReturn

 

 

 

{{Out}}

 

=={{header|AutoHotkey}}==

Date := Year . "0101"

 

 

Gui, Show

{{out}}

<pre>Last Sundays of 2013:

November 24

December 29</pre>

=={{header|AWK}}==

# syntax: GAWK -f FIND_THE_LAST_SUNDAY_OF_EACH_MONTH.AWK [year]

BEGIN {

exit(0)

}

<p>Output:</p>

<pre>

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

Uses day of week, last day of month and leapyear routines

@echo off

setlocal enabledelayedexpansion

set /a "%2=^!(%1%%4)+(^!^!(%1%%100)-^!^!(%1%%400))"

exit /b

{{out}}

 

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

INSTALL @lib$+"DATELIB"

 

NEXT

END

{{out}}

<pre>

=={{header|Befunge}}==

This is essentially identical to [[Last_Friday_of_each_month#Befunge|Last Friday of each month]] except for the initial day offset.

v2++6**"I"5\+/*:*54\-/"d"\/4::-1::p53+g5<

>:00p5g4-+7%\:0\v>,"-",5g+:55+/68*+,55+%v

^<<_$$vv*86%+55:<^+*86%+55,+*86/+55:-1:<6

>$$^@$<>+\55+/:#^_$>:#,_$"-",\:04-\-00g^8

 

{{out}}

 

=={{header|C}}==

 

#include <stdio.h>

#include <stdlib.h>

for(m = 0; m < 12; m++) {

w = (w + days[m]) % 7;

}

 

return 0;

}

 

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

#include <windows.h>

#include <iostream>

}

//--------------------------------------------------------------------------------------------------

{{out}}

<pre>

</pre>

Other solution, based on the Boost DateTime library:

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

#include <cstdlib>

}

return 0 ;

{{out}}

<pre>2013-Jan-27

2013-Dec-29

</pre>

 

 

 

 

}

</pre>

 

=={{header|Clojure}}==

 

(:require [clj-time.core :as time]

[clj-time.periodic :refer [periodic-seq]]

(defn -main [& args]

(println (last-sundays-of-months (Integer. (first args)))))

{{out}}

<pre>2013-01-27

 

=={{header|COBOL}}==

program-id. last-sun.

data division.

.

end program last-sun.

 

{{out}}

2016-12-25

</pre>

 

=={{header|D}}==

import std.stdio, std.datetime;

 

void main() {

lastSundays(2013);

{{out}}

<pre>2013-Jan-27

2013-Nov-24

2013-Dec-29</pre>

 

=={{header|Elixir}}==

def lastSunday(year) do

Enum.map(1..12, fn month ->

Enum.each(RC.lastSunday(y), fn {year, month, day} ->

:io.format "~4b-~2..0w-~2..0w~n", [year, month, day]

 

{{out}}

</pre>

 

 

 

 

 

 

{{out}}

<pre>

2013-01-27

2013-02-24

</pre>

 

 

 

 

 

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

<p>We use a transformation from and to the Julian Day Number, see also PARI/GP or Fortran.</p>

<p>The formulars used here come from [http://calendars.wikia.com/wiki/Julian_day_number] (section "Calculation").</p>

let a = (14 - month) / 12

let y = year + 4800 - a

|> List.map (fun x -> date_from_jdn (x - (x+1)%7))

|> List.iter (printfn "%A")

{{out}}

<pre>RosettaCode 2016

(2016, 11, 27)

(2016, 12, 25)</pre>

 

=={{header|Fortran}}==

Their routine is not only fast, but flexible, in particular allowing Month + 1 so that DAYNUM(Y,M + 1,0) gives the last day of month M for M = 1 to 12, with no agony over which month has what last day and leap years or not. If W is the day of week desired, all that remains is to use MOD(D - W,7) to determine the offset back to the desired day of the week and make that shift. There is a problem with the MOD function when negative numbers are involved: it may or may not (depending on computer, compiler, language) return a negative result; by adding 7 and taking a MOD again, this variation is suppressed.

 

But alas, only pl/i offers palindromic functions, and only for SUBSTR.

 

MODULE DATEGNASH

C Calculate conforming to complex calendarical contortions.

GO TO 10

END

And after all that, results:

<pre>

29/12/2013 : Sunday

What year (non-positive to quit):0

</pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

 

Loop

{{out}}

<pre>For what year do you want to find the last Sunday of the month

26 November

31 December</pre>

 

=={{header|Go}}==

This is different from the Go code for [[Last Friday of each month]]. It uses the fact that time functions in Go correct for dates: if you enter 32nd of october, Go corrects to 1st of November. So that if 29th of February is corrected to 1st of March, chosen year is not a leap year.

 

 

import (

}

}

 

<pre>

=={{header|Groovy}}==

Solution:

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

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

!months[monthStr] ? months + [(monthStr):sunday] : months

}.values().sort()

 

Test:

def lastSundays = lastWeekDays.curry(Day.Sun)

 

Execution (Cygwin on Windows 7):

 

=={{header|Haskell}}==

import Data.Time.Calendar

 

 

where

 

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

This is a trivial adaptation of the solution to the "Last Friday of each month" task

and works in both languages:

every write(lastsundays(!A))

end

end

 

Sample run:

=={{header|J}}==

Same solution as for [[Last_Friday_of_each_month#J]]

 

Example use:

2013 1 27

2013 2 24

2013 10 27

2013 11 24

 

=={{header|Java}}==

 

public class LastSunday

s.close();

}

 

{{out}}

</pre>

===Java 8===

import java.util.stream.*;

import static java.time.temporal.TemporalAdjusters.*;

}

 

 

=={{header|JavaScript}}==

 

{{output}}

<pre>2013-01-27

2013-12-29</pre>

 

'use strict';

 

.join('\n');

 

 

{{Out}}

2013-11-24 2014-11-30 2015-11-29 2016-11-27 2017-11-26

2013-12-29 2014-12-28 2015-12-27 2016-12-25 2017-12-31</pre>

 

=={{header|jq}}==

{{works with|jq|1.4}}

'''Foundations'''

def until(cond; next):

def _until:

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

else . % 7

'''findLastSundays'''

def findLastSunday(year; month):

def isLeapYear:

 

$year|tonumber|findLastSundays

'''Example:'''

YEAR: 2013

January 27

October 27

November 24

 

=={{header|Julia}}==

isdefined(:Date) || using Dates

 

end

end

 

This code uses the <code>Dates</code> module, which is being incorporated into Julian's standard library with the current development version (<tt>0.4</tt>). I've used <code>isdefined</code> to make this code good for the current stable version (<tt>0.3</tt>) as well as for future releases. If <code>Dates</code> is not installed on your instance of Julian try <code>Pkg.add("Dates")</code> from the <tt>REPL</tt>.

 

Year>

</pre>

 

=={{header|Lasso}}==

year = integer(web_request -> param('year') || 2013),

date = date(#year + '-1-1'),

}

}

<pre>27 January

24 February

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

This program goes a step further and provides a function definition, NthDayOfMonth(), that returns the date of any occurrence of a day in any given month and year. For example: The third Monday in February, the last Monday in May, the fourth Thursday in November, etc.

yyyy=2013: if yyyy<1901 or yyyy>2099 then end

nda$="Lsu"

end select

end function

{{out}}

<pre>

=={{header|LiveCode}}==

Abstracted version of "last friday of each month". LiveCode dateItem item 7 is day of week. It is numbered 1 (Sunday) to 7 (Saturday).

-- year,month num,day of month,hour in 24-hour time,minute,second,numeric day of week.

convert the long date to dateitems

sort mydays ascending numeric

return mydays

2 24

3 31

 

=={{header|Lua}}==

return (y % 4 == 0 and y % 100 ~=0) or y % 400 == 0

end

end

 

Command line session:

<pre>>lua lastSundays.lua 2013

 

></pre>

 

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

Table[Last@

DayRange[{year, i},

DatePlus[{year, i}, {{1, "Month"}, {-1, "Day"}}], Sunday], {i,

12}]

{{out}}

<pre>{{2013, 1, 27}, {2013, 2, 24}, {2013, 3, 31}, {2013, 4, 28}, {2013, 5,

 

=={{header|Nim}}==

 

Sample usage:

<pre>./lastsunday 2013

 

=={{header|OCaml}}==

let is_leap_year y =

(* See OCaml solution on Rosetta Code for

2 -> print_last_sundays( int_of_string (Sys.argv.(1)));

|_ -> invalid_arg "Please enter a year";

Sample usage:

<pre> ocaml sundays.ml 2013

 

=={{header|Oforth}}==

 

: lastSunday(y)

Date newDate(y, m, Date.DaysInMonth(y, m))

while(dup dayOfWeek Date.SUNDAY <>) [ addDays(-1) ] println

 

{{out}}

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

 

njd(D) =

{

}

 

 

Output:<pre>

 

=={{header|Perl}}==

use strict ;

use warnings ;

my $ymd = $date->ymd ;

print "$ymd\n" ;

{{out}}

<pre>2013-01-27

2013-12-29

</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

// Created with PHP 7.0

 

 

printLastSundayOfAllMonth($argv[1]);

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(for M 12

(prinl

(find '((D) (= "Sunday" (day D)))

(mapcar '((D) (date Y M D)) `(range 31 22)) )

Test:

2013-01-27

2013-02-24

2013-10-27

2013-11-24

 

=={{header|PowerShell}}==

function last-dayofweek {

param(

}

last-dayofweek 2013 "Sunday"

<b>Output:</b>

<pre>

This script finds the first and/or last or all dates of any of the days of week; accepts <code>[Int32]</code> and <code>[DateTime]</code> values for Month and Year parameters; outputs <code>[DateTime]</code> objects by default but has an option to output time strings in various formats. This script also allows for pipeline input based mainly upon the Month parameter.

This script has a syntax as complex as any PowerShell Cmdlet because it attempts to do everything.

function Get-Date0fDayOfWeek

{

}

}

The default is to return <code>[DateTime]</code> objects:

1..12 | Get-Date0fDayOfWeek -Year 2013 -Last -Sunday

{{Out}}

<pre>

</pre>

Return the <code>[DateTime]</code> objects as strings (using the default string format):

1..12 | Get-Date0fDayOfWeek -Year 2013 -Last -Sunday -AsString

{{Out}}

<pre>

</pre>

Return the <code>[DateTime]</code> objects as strings (specifying the string format):

1..12 | Get-Date0fDayOfWeek -Year 2013 -Last -Sunday -AsString -Format yyyy-MM-dd

{{Out}}

<pre>

2013-12-29

</pre>

 

=={{header|Python}}==

import sys

import calendar

last_sunday = max(week[-1] for week in calendar.monthcalendar(year, month))

print('{}-{}-{:2}'.format(year, calendar.month_abbr[month], last_sunday))

 

<b>Output</b>:

2013-Jan-27

2013-Feb-24

2013-Nov-24

2013-Dec-29

 

=={{header|Racket}}==

#lang racket

(require srfi/19 math)

(for ([d (last-sundays 2013)])

(displayln (~a (date->string d "~a ~d ~b ~Y"))))

{{out}}

<pre>

Sun 29 Dec 2013

</pre>

 

=={{header|REBOL}}==

 

last-sundays-of-year: function [

 

foreach sunday last-sundays-of-year to-integer system/script/args [print sunday]

{{out}}

<pre>./last-sundays.reb 2013

except for the innards of the first '''DO''' loop. <br><br>

The &nbsp; '''lastDOW''' &nbsp; subroutine can be used for any day-of-the-week for any month for any year.

parse arg yyyy

do j=1 for 12

.er: arg ,_;say; say '***error!*** (in LASTDOW)';say /*tell error, and */

say word('day-of-week month year excess',arg(2)) arg(1) a._

2013-01-27

2013-02-24

 

=={{header|Ring}}==

see "What year to calculate (yyyy) : "

give year

next

next

Output:

<pre>

2013-11-24

2013-12-29

</pre>

 

=={{header|Ruby}}==

 

def last_sundays_of_year(year = Date.today.year)

end

 

 

{{out}}

</pre>

Results before the year 1581 may differ from other languages - the Date library takes the Julian reform into account.

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

print "Last Sundays in ";year;" are:"

dim month(12)

if x = 4 then print year ; "-";right$("0"+str$(n),2);"-" ; i

next

<pre>

What year to calculate (yyyy) : ?2013

2013-11-24

2013-12-29</pre>

 

=={{header|Scala}}==

import java.util.Calendar._

val cal = getInstance

val fmt = new java.text.SimpleDateFormat("yyyy-MM-dd")

println(lastSundaysOf(year).map(fmt.format) mkString "\n")

===Java 8===

def lastSundaysOf(year: Int) = (1 to 12).map{month =>

import java.time._; import java.time.temporal.TemporalAdjusters._

val year = args.headOption.map(_.toInt).getOrElse(java.time.LocalDate.now.getYear)

println(lastSundaysOf(year) mkString "\n")

 

=={{header|Seed7}}==

Applicable to any day of the week, cf. [[http://rosettacode.org/wiki/Last_Friday_of_each_month#Seed7]].

 

include "time.s7i";

include "duration.s7i";

end for;

end if;

 

{{out}} when called with <tt>s7 rosetta/lastWeekdayInMonth 7 2013</tt>:

 

=={{header|Sidef}}==

var (year=2016) = ARGV.map{.to_i}...

 

 

say date.ymd;

{{out}}

<pre>

 

=={{header|Smalltalk}}==

Pharo Smalltalk

 

thenSelect: [ :each |

(((Date daysInMonth: each monthIndex forYear: yr) - each dayOfMonth) <= 6) and: [ each year = yr ] ] ]

{{out}}

<pre>

(27 January 2013 24 February 2013 31 March 2013 28 April 2013 26 May 2013 30 June 2013 28 July 2013 25 August 2013 29 September 2013 27 October 2013 24 November 2013 29 December 2013)

</pre>

 

=={{header|Swift}}==

 

func lastSundays(of year: Int) -> [Date] {

dateFormatter.dateStyle = .short

 

{{out}}

<pre>

 

=={{header|Tcl}}==

if {$year eq ""} {

set year [clock format [clock seconds] -gmt 1 -format "%Y"]

return $result

}

{{out}}

When called as: “<code>tclsh lastSundays.tcl 2013</code>” (or with the year argument omitted during 2013)

2013-12-29

</pre>

 

=={{header|VBScript}}==

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

strYear = WScript.StdIn.ReadLine

 

WScript.Echo d - Weekday(d) + 1

Next

 

=={{header|zkl}}==