Last Friday of each month: Difference between revisions

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

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

LASTFRI CSECT

USING LASTFRI,R13 base register

DW DS D packed (PL8) 15num

YREGS

{{out}}

<pre>

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

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]

PrintB2(last) PutE()

OD

{{out}}

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

Uses GNAT. Applicable to any day of the week, cf. [[http://rosettacode.org/wiki/Find_last_sunday_of_each_month#Ada]].

Ada.Calendar.Formatting, Ada.Calendar.Arithmetic;

Put_Line(Selected);

end loop;

{{out}}

<pre>>./last_weekday_in_month friday 2012

Basically the same as the "Find the Last Sunday Of Each Month" task solution.

{{Trans|ALGOL W}}

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

# assumes year is in the Gregorian Calendar #

)

OD

{{out}}

<pre>

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

Basically the same as the "Find the Last Sunday Of Each Month" task solution, uses the Day_of_week and isLeapYear procedures from the 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}}

-- lastFridaysOfYear :: Int -> [Date]

map(column, item 1 of xss)

{{Out}}

<pre>2014-01-31 2015-01-30 2016-01-29 2017-01-27 2018-01-26

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 lastFridayOfEachMonthInYear

{{Out}}

The above is of course hard-coded for Fridays. It can be made more flexible by taking an AppleScript weekday constant as a parameter:

-- 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_Fridays 2020

=={{header|Arturo}}==

ensure -> in? m 1..12

loop 1..12 'month [

print to :string.format:"yyyy-MM-dd" lastFridayForMonth month

{{out}}

=={{header|AutoHotkey}}==

{

InputBox, 1, Last Fridays of year, Enter a year:, , , , , , , , %A_YYYY%

stmp += 1, days

}

{{out}} for 2012:

<pre>2012-01-27

=={{header|AutoIt}}==

#include <Date.au3>

ConsoleWrite($sResult)

EndFunc ;==>_GetFridays

{{out}}

<pre>

=={{header|AWK}}==

# syntax: GAWK -f LAST_FRIDAY_OF_EACH_MONTH.AWK year

# converted from Fortran

exit(0)

}

{{out}}

<pre>

The algorithm has been slightly simplified to avoid the additional day adjustment inside the loop, and the year is obtained from stdin rather than via the command line.

v2++1**"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}}

Doesn't work with Julian calendar (then again, you probably don't need to plan your weekends for middle ages).

#include <stdlib.h>

return 0;

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

using System.Collections.Generic;

using System.Globalization;

}

}

{{out}}

<pre>01/27/2012

{{libheader|Boost}}

called with <code>./last_fridays 2012</code>

#include <iostream>

#include <cstdlib>

}

return 0 ;

{{out}}

<pre>2012-Jan-27

{{libheader|clj-time}}

'[clj-time.format :only [unparse formatters]])

(defn last-fridays-formatted [year]

{{out}}

=={{header|COBOL}}==

program-id. last-fri.

data division.

.

end program last-fri.

{{out}}

=={{header|CoffeeScript}}==

last_friday_of_month = (year, month) ->

# month is 1-based, JS API is 0-based, then we use

year = parseInt process.argv[2]

print_last_fridays_of_month year

{{out}}

> coffee last_friday.coffee 2012

Fri Jan 27 2012

Fri Nov 30 2012

Fri Dec 28 2012

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

The command-line argument processing is the only CLISP-specific code.

(let*

((timestamp (encode-universal-time 0 0 12 day month year))

(let* ((year (read-from-string (car *args*))))

Sample run for the year 2015:

=={{header|D}}==

void lastFridays(in uint year) {

void main() {

lastFridays(2012);

<pre>2012-Jan-27

2012-Feb-24

=={{header|Delphi}}==

Uses the standard Delphi library.

{$APPTYPE CONSOLE}

WriteLn(DateToStr(D1));

end;

{{out}}

<pre>Enter year: 2019

=={{header|Elixir}}==

def lastFriday(year) do

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

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

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

{{out}}

=={{header|Elm}}==

import Html.App exposing (beginnerProgram)

import Html.Attributes exposing (placeholder, value, style)

, view = view

, update = update

Link to live demo: http://dc25.github.io/lastFridayOfMonthElm/

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

(defun last-friday (year)

(number-sequence 1 12)))

{{output}}

<pre>2012-01-27

=={{header|Erlang}}==

-module( last_date_each_month ).

Months_days = [{X, Y} || X <- Months, Y <- lists:seq(calendar:last_day_of_the_month(Year, X), calendar:last_day_of_the_month(Year, X) - 7, -1), calendar:valid_date(Year, X, Y), calendar:day_of_the_week(Year, X, Y) =:= Week_day],

[{Year, X, proplists:get_value(X, Months_days)} || X <- Months].

{{out}}

<pre>

{{works with|Factor|0.98}}

The <code>last-friday-of-month</code> word in the <code>calendar</code> vocabulary does most of the work. This program expects the year as a command line argument.

IN: rosetta-code.last-fridays

(command-line) second string>number <year> 12 <iota>

[ months time+ last-friday-of-month ] with map

{{out}}

<pre>

Algorithm: compute day of week for last day of month, then subtract just enough to get to the preceding friday. Do this for each month. To simplify computations further, we only need to compute day of week of january 1st (the others are found by adding month lengths). Since day of week need only be known modulo 7, we do not compute modulo at all except once when subtracting.

implicit none

integer :: days(1:12) = (/31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31/)

end do

end program

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Loop

{{out}}

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

=={{header|Frink}}==

for m = 1 to 12

{

n = d - (((parseInt[d -> ### u ###] + 1) mod 7) + 1) days

println[n -> ### yyyy-MM-dd ###]

{{out}}

=={{header|Gambas}}==

Dim siYear As Short = InputBox("Please input a year", "Last Friday of each month")

Dim siMonth, siDay As Short

Me.Close

Output:

<pre>

=={{header|Go}}==

import (

fmt.Println(d.Format("2006-01-02"))

}

{{out}}

<pre>

Test:

def lastFridays = lastWeekDays.curry(Day.Fri)

Execution (Cygwin on Windows 7):

=={{header|Haskell}}==

(Day, addDays, showGregorian, fromGregorian, gregorianMonthLength)

import Data.Time.Calendar.WeekDate (toWeekDate)

mapM_

putStrLn

{{Out}}

<pre>2012-01-27 2013-01-25 2014-01-31 2015-01-30 2016-01-29 2017-01-27

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

This will write the last fridays for every year given as an argument. There is no error checking on the year.

every write(lastfridays(!A))

end

end

{{libheader|Icon Programming Library}}

=={{header|J}}==

In other words, start from January 1 of the given year, and count forward for 366 days, keeping the Fridays. Then pick the last remaining day within each represented month (which will be a Friday because we only kept the Fridays). Then pick the first 12 (since on a non-leap year which ends on a Thursday we would get an extra Friday).

Example use:

2012 1 27

2012 2 24

2012 10 26

2012 11 30

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.*;

}

}

{{out}} (for <code>java LastFridays 2012</code>):

<pre>2012 Jan 27

====Iteration====

{{works with|Nodejs}}

last_friday_of_month = function(year, month) {

year = parseInt(process.argv[2]);

return print_last_fridays_of_month(year);

{{Out}}

<pre>>node lastfriday.js 2015

====Functional composition====

'use strict';

})

.join('\n');

{{Out}}

===ES6===

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>2015-01-30 2016-01-29 2017-01-27 2018-01-26 2019-01-25

{{ works with|jq|1.4}}

'''Foundations'''

def until(cond; next):

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

else . % 7

'''findLastFridays'''

def findLastFriday(year; month):

def isLeapYear:

(range(0;12) | "\(months[.]) \(findLastFriday($year; .+1))") ;

{{out}}

YEAR: 2012

January 27

October 26

November 30

=={{header|Julia}}==

const wday = Dates.Fri

end

end

<pre>

This script will print the last Fridays of each month of the year given.

=={{header|K}}==

/ List the dates of last Fridays of each month of

/ a given year

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

The output of a session is given below:

=={{header|Kotlin}}==

import java.util.*

}

}

{{out}}

=={{header|Lasso}}==

#y % 400 == 0 ? return true

#y % 100 == 0 ? return false

with f in fridays(2012) do => {^

#f->format('%Q') + '\r'

{{out}}

=={{header|LiveCode}}==

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

convert the long date to dateitems

sort fridays ascending numeric

return fridays

2 24

3 30

10 26

11 30

=={{header|Logo}}==

to leap? :year

output (and

print reduce [(word ?1 "- ?2)] (list :year :month :day)

]

{{out}}

=={{header|Lua}}==

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

end

end

Command line session:

<pre>>lua lastFridays.lua 2012

=={{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>2012-1-27

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

NestWhile[(DaysPlus[#, - 1]) &, #, (DateString[#, "DayName"] != "Friday") &] & /@

Most@Reverse@NestList [DaysPlus[# /. {x_, y_, X_} -> {x, y, 1}, - 1] &, {Y + 1, 1, 1}, 12]

{{out}}

<pre>{2012,1,27}

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

t1 = datenum([y,1,1,0,0,0]);

t2 = datenum([y,12,31,0,0,0]);

datestr(last_fridays_of_year(2012),'yyyy-mm-dd')

{{out}}

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

lastfridays(2012);

["2012-1-27", "2012-2-24", "2012-3-30", "2012-4-27", "2012-5-25", "2012-6-29",

=={{header|Nanoquery}}==

// a function to check if a year is a leap year

print form(friday.getMonth()) + "-"

println form(friday.getDay())

=={{header|NetRexx}}==

{{trans|C}}

Implements the algorithms from both the [[#Java|Java]] and [[#C|C]] implementations.

options replace format comments java crossref symbols nobinary

end

return

{{out}}

<pre>

=={{header|Nim}}==

const

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

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

{{out}}

Using the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html Unix] from the standard OCaml library:

open Unix

done;

done;

{{out}}

{{libheader|OCaml Calendar Library}}

let usage() =

aux num_days

done;

Run this script with the command:

=={{header|Oforth}}==

: lastFridays(y)

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

println

{{out}}

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

njd(D) =

{

}

Output:<pre>

{{works with|Free Pascal}}

Using Free Pascal's DateUtils library would dramatically simplify the coding (see the Delphi example) but for older Pascal implementations the needed routines are the programmer's responsibility.

program LastFriday;

end;

end.

{{out}}

<pre>

=={{header|Perl}}==

use strict ;

use DateTime ;

}

say $dt->ymd ;

{{out}}

<pre>2012-01-27

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">last_day_of_month</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dow</span><span style="color: #0000FF;">)</span>

--last_day_of_month(prompt_number("Year:",{1752,9999}),FRIDAY)</span>

<span style="color: #000000;">last_day_of_month</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2012</span><span style="color: #0000FF;">,</span><span style="color: #000000;">FRIDAY</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

PHP is generally used for web apps, so I am not implementing the command-line component of this task.

function last_friday_of_month($year, $month) {

$day = 0;

$year = 2012;

print_last_fridays_of_month($year);

{{out}}

=={{header|Picat}}==

main(ARGV) =>

if ARGV.length > 0 then

(Year mod 4 == 0, Year mod 100 != 0)

;

===Running the program===

=={{header|PicoLisp}}==

(for M 12

(prinl

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

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

Test:

2012-01-27

2012-02-24

2012-10-26

2012-11-30

=={{header|Pike}}==

{

return day->week_day() == 5 &&

write("%{%s\n%}", days->format_ymd());

return 0;

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

Fridays: procedure (year) options (main); /* 8 January 2013 */

declare year character (4) varying;

end;

end Fridays;

The command: FRIDAYS /2008 produces:

<pre>

=={{header|PowerShell}}==

function last-dayofweek {

param(

}

last-dayofweek 2012 "Friday"

<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 2012 -Last -Friday

{{Out}}

<pre>

</pre>

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

1..12 | Get-Date0fDayOfWeek -Year 2012 -Last -Friday -AsString

{{Out}}

<pre>

</pre>

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

1..12 | Get-Date0fDayOfWeek -Year 2012 -Last -Friday -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 ]: 2017

=={{header|Python}}==

def last_fridays(year):

last_friday = max(week[calendar.FRIDAY]

for week in calendar.monthcalendar(year, month))

{{out}}

2012-12-28</pre>

Another solution

c=calendar.Calendar()

fridays={}

for item in sorted((month+"-"+day for month,day in fridays.items()),

key=lambda x:int(x.split("-")[1])):

Using reduce

c=calendar.Calendar()

fridays={}

for item in sorted((month+"-"+day for month,day in fridays.items()),

key=lambda x:int(x.split("-")[1])):

using itertools

from itertools import chain

f=chain.from_iterable

for item in sorted((month+"-"+day for month,day in fridays.items()),

key=lambda x:int(x.split("-")[1])):

=={{header|Quackery}}==

dup 4 / over +

over 100 / -

[ 5 lastwkdays ] is lastfridays ( year --> )

{{out}}

=={{header|R}}==

d = as.Date(paste0(year, "-01-01"))

fridays = d + seq(by = 7,

364 + (months(d + 30 + 29) == "February"))

message(paste(collapse = "\n", fridays[tapply(

=={{header|Racket}}==

#lang racket

(require srfi/19 math)

(for ([d (last-fridays 2012)])

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

{{out}}

<pre>

=={{header|Raku}}==

(formerly Perl 6)

my @fri;

for Date.new("$year-01-01") .. Date.new("$year-12-31") {

}

.say for @fri[1..12];

Example:

A solution without a result array to store things in:

say ~.value.reverse.first: *.day-of-week == 5

for classify *.month, Date.new("$year-01-01") .. Date.new("$year-12-31");

Here, <code>classify</code> sorts the dates into one bin per month (but preserves the order in each bin). We then take the list inside each bin (<code>.value</code>) and find the last (<code>.reverse.first</code>) date which is a Friday.

Another variation where the data flow can be read left to right using feed operators:

.say for Date.new("$year-01-01") .. Date.new("$year-12-31") ==> classify *.month ==>

map *.value.reverse.first: *.day-of-week == 5

=={{header|REBOL}}==

The longer version:

days-in-feb: function [year] [either leap-year? year [29] [28]]

year: to-integer input

repeat month 12 [print last-friday-of-month month year]

{{out}}

<pre>rebol last-fridays.reb <<< 2012

</pre>

A shorter version:

collect [

repeat month 12 [

foreach friday last-fridays-of-year to-integer input [print friday]

NB. See "Find the last Sunday of each month" Rosetta for alternative (even more succinct) solution

║ last day─of─week is then obtained straightforwardly, or via subtraction. ║

╚════════════════════════════════════════════════════════════════════════════════════════════════╝

parse arg yyyy /*obtain optional argument from the CL.*/

do j=1 for 12 /*traipse through all the year's months*/

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

say word('day-of-week month year excess', arg(2)) arg(1) a._ /*plug in a choice.*/

{{out|output|text=&nbsp; when using the following input of: &nbsp; &nbsp; <tt> 2012 </tt> &nbsp; &nbsp; or &nbsp; &nbsp; <tt> 12 </tt>}}

<pre>

=={{header|Ring}}==

see "What year to calculate (yyyy) : "

give year

next

Output:

<pre>

=={{header|Ruby}}==

def last_friday(year, month)

year = Integer(ARGV.shift)

Friday is <code>d.wday == 5</code>; the expression <code>(d.wday - 5) % 7</code> counts days after Friday.

Or get the last day of the month and go to the previous day until it's a Friday.

def last_friday(year, month)

d

end

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

dayOne$ = "01-01-";yr

n1 = date$(dayOne$)

wend

print date$(n1) ' print last Friday's date

<pre>Year:?2013

01/25/2013

=={{header|Rust}}==

use time::{Date, Duration};

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

});

{{out}}

=={{header|Scala}}==

import java.text.SimpleDateFormat

}

}

{{out}}

<pre>2012-Jan-27

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

include "time.s7i";

include "duration.s7i";

end for;

end if;

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

=={{header|SenseTalk}}==

ask "What year?"

put it into year

add a month to lastDayOfMonth -- advance to last day of next month

end repeat

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Perl}}

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

 

}

say dt.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|SQL}}==

select to_char( next_day( last_day( add_months( to_date(

:yr||'01','yyyymm' ),level-1))-7,'Fri') ,'yyyy-mm-dd Dy') lastfriday

from dual

connect by level <= 12;

<pre>

LASTFRIDAY