Find the last Sunday of each month: Difference between revisions

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

 

[String] sundays

L(month) 1..12

R sundays

 

 

{{out}}

=={{header|360 Assembly}}==

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

LASTSUND CSECT

USING LASTSUND,R13 base register

DW DS D packed (PL8) 15num

YREGS

{{out}}

<pre>

2013-01-27

2013-02-24

2013-11-24

2013-12-29</pre>

 

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

Uses the Day_of_week and isLeapYear procedures from the day-of-the-week and leap-year tasks - included here for convenience.

% returns true if year is a leap year, false otherwise %

% assumes year is in the Gregorian Calendar %

for mPos := 1 until 12 do write( year, if mPos < 10 then "-0" else "-1", mPos rem 10, "-", last( mPos ) )

end

{{out}}

<pre>

{{Trans|JavaScript}}

 

 

-- lastSundaysOfYear :: Int -> [Date]

map(column, item 1 of xss)

{{Out}}

<pre>2015-01-25 2016-01-31 2017-01-29 2018-01-28 2019-01-27

AppleScript's weekday constants can be coerced either to English text or to the integers 1 (for Sunday) to 7 (Saturday).

 

-- Initialise an AppleScript date to the first day of some month in the specified year.

tell (current date) to set {firstDayOfNextMonth, its day, its year} to {it, 1, y}

end lastSundayOfEachMonthInYear

 

 

{{Out}}

The above is hard-coded for Sundays. As with the "Last Friday of each month" task [[https://www.rosettacode.org/wiki/Last_Friday_of_each_month#AppleScript Last Friday of each month]], the handler can be made more flexible with a weekday constant parameter, so that it can be used for any last weekday of the months:

 

-- Initialise an AppleScript date to the first day of some month in the specified year.

tell (current date) to set {firstDayOfNextMonth, its day, its year} to {it, 1, y}

end lastWeekdayWOfEachMonthInYear

 

{{Out}}

<pre>"./last_Sundays 2020

=={{header|Arturo}}==

 

 

 

 

{{out}}

 

=={{header|AutoHotkey}}==

Date := Year . "0101"

 

 

Gui, Show

{{out}}

<pre>Last Sundays of 2013:

 

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

Identical to [[Last_Friday_of_each_month#C|Last Friday of each month]] except for removal of the offset day in the output.

 

#include <stdio.h>

#include <stdlib.h>

return 0;

}

 

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

 

namespace LastSundayOfEachMonth

*/

// The updated code

Console.WriteLine(date.ToString("yyyy-MM-dd"));

}

}

}

{{out}}

<pre>Year to calculate: 2013

 

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

2013-Dec-29

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

First, calculate the day of week of the 1st day of next month. Then figure out how many days you have to go back until the last Sunday of the month.

 

(loop for month from 1 to 12

for last-month-p = (= month 12)

(format t "~D-~2,'0D-~2,'0D~%" year month date))))

 

{{out}}

<pre>2013-01-27

 

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

2013-12-29

</pre>

 

=={{header|Erlang}}==

-module(last_sundays).

 

{Year, Month, Ldm - Diff}.

 

{{out}}

<pre>

2013-12-29

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

=={{header|Factor}}==

This program expects a year passed in via command line argument. In case you are wondering — yes — Factor has a <tt>last-sunday-of-month</tt> word in its calendar vocabulary. This is par for the course when it comes to Factor.

sequences ;

IN: rosetta-code.last-sunday

: main ( -- ) parse-year 12 [ process-month ] times drop ;

 

{{out}}

<pre>

 

=={{header|FBSL}}==

 

DIM date AS INTEGER, dayname AS STRING

 

PAUSE

{{out}}

<pre>2013-1-27

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

Dim sYear As String 'To store the year chosen

Dim siDay, siMonth, siWeekday As Short 'Day, Month and Weekday

Next

 

Output:

<pre>

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.Maybe (fromJust)

 

 

 

main :: IO ()

main =

mapM_

putStrLn

{{Out}}

<pre>2018-01-28 2019-01-27 2020-01-26 2021-01-31 2022-01-30 2023-01-29

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

===ES5===

====Iteration====

var lastDay = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

var sundays = [];

}

 

{{output}}

<pre>2013-01-27

 

====Functional composition====

'use strict';

 

.join('\n');

 

 

{{Out}}

 

===ES6===

'use strict'

 

// MAIN ---

return main();

{{Out}}

<pre>2019-01-27 2020-01-26 2021-01-31 2022-01-30

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

 

=={{header|K}}==

/ List the dates of last Sundays of each month of

/ a given year

main: {[y]; lsd1[y];`0: ,"Dates of last Sundays of ",($y); 12 10#arr}

 

The output of a session with the above script is given below:

{{out}}

 

=={{header|Kotlin}}==

 

import java.util.*

}

}

Sample input/output:

{{out}}

 

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

 

=={{header|Maple}}==

local i, dt, change, last_days;

last_days := [31,28,31,30,31,30,31,31,30,31,30,31];

end proc;

 

{{Out|Output}}

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

 

const

var date = initDateTime(lastDay, month, year, 0, 0, 0)

date = date - days(DayDiffs[date.weekday])

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

=={{header|Phix}}==

Requires 0.8.1 (day_of_week() is now ISO 8601 compliant)

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

 

=={{header|PureBasic}}==

Define dv.i=ParseDate("%yyyy",Str(yyyy)), mv.i=1

NewList d.i()

EndIf

Print("...End")

{{out}}

<pre>Input Year [ 1971 < y < 2038 ]: 2013

 

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

last_sundays <- function(year) {

for (month in 1:12) {

}

last_sundays(2004)

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket

(require srfi/19 math)

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

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

{{out}}

<pre>

 

{{works with|rakudo|2018.03}}

for 1..12 -> $month {

my $month-end = Date.new($year, $month, Date.new($year,$month,1).days-in-month);

say $month-end - $month-end.day-of-week % 7;

}

 

{{out|input=2018}}

 

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

 

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

 

=={{header|Rust}}==

use time::{Date, Duration};

 

println!("{}", date - days_back);

});

{{out}}

<pre>

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>

 

=={{header|Stata}}==

args year

clear

| 24nov2013 |

| 29dec2013 |

 

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

This uses the programs awk and cal, which are usually installed on any POSIXlike system.

 

local y=$1

for (( m=1; m<=12; ++m )); do

cal $m $y | awk -vy=$y -vm=$m '/^.[0-9]/ {d=$1} END {print y"-"m"-"d}'

done

 

{{Out}}

=={{header|VBScript}}==

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

strYear = WScript.StdIn.ReadLine

 

WScript.Echo d - Weekday(d) + 1

Next

 

=={{header|Wren}}==

{{libheader|Wren-date}}

var args = Process.arguments

System.print(dt.addDays(-wd))

}

 

{{out}}

<pre>

The dates of the last Sundays in the month for 2013 are:

2013-01-27

2013-12-29

 

The dates of the last Sundays in the month for 2020 are:

2020-01-26

2020-11-29

2020-12-27

</pre>