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>

2016-11-25

2016-12-30

</pre>

 

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

2012-11-30

2012-12-28</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}}==

 

 

 

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

2012-12-28

</pre>

 

=={{header|Befunge}}==

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

2012-Nov-30

2012-Dec-28

</pre>

 

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

29.11.2019

27.12.2019</pre>

 

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

 

December 26, 2003

</pre>

 

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

24 November

29 December</pre>

 

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

2012 Dec 28</pre>

 

===ES5===

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

Fri Nov 27 2015

Fri Dec 25 2015</pre>

 

====Functional composition====

'use strict';

 

})

.join('\n');

 

{{Out}}

 

===ES6===

 

 

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

 

const days = {

};

 

 

 

// isoDateString :: Date -> String

.substr(0, 10);

 

 

// transpose :: [[a]] -> [[a]]

 

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

 

></pre>

 

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

2012-12-28</pre>

 

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

 

2012-01-27

2012-02-24

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>

[2012, 11, 30]

[2012, 12, 28]</pre>

 

=={{header|Perl}}==

use strict ;

use DateTime ;

}

say $dt->ymd ;

{{out}}

<pre>2012-01-27

 

=={{header|Phix}}==

{{out}}

<pre>

2012-01-27

2012-02-24

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

2012-12-28

</pre>

 

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

<pre>

Friday 27 Jan 2012

 

=={{header|Ring}}==

see "What year to calculate (yyyy) : "

give year

next

 

Output:

<pre>

2012-11-30

2012-12-28

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

 

=={{header|Stata}}==

args year

clear

| 30nov2012 |

| 28dec2012 |

 

=={{header|Swift}}==

import Foundation

 

 

print(lastFridays(of: 2013).map(dateFormatter.string).joined(separator: "\n"))

<pre>

1/27/12

 

=={{header|Tcl}}==

set year [lindex $argv 0]

foreach dm {02/1 03/1 04/1 05/1 06/1 07/1 08/1 09/1 10/1 11/1 12/1 12/32} {

# Print the interesting part

puts [clock format $t -format "%Y-%m-%d" -gmt 1]

Sample execution:

<pre>

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

year=2012

ENDLOOP

ENDLOOP

{{out}}

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

=={{header|UNIX Shell}}==

Using <code>ncal</code>. Will switch to Julian calender as ncal sees fit, and will not calculate past year 9999 (chances are you'll be too dead by then to worry about weekends anyway).

 

if [ -z $1 ]; then exit 1; fi

for m in 01 02 03 04 05 06 07 08 09 10 11 12; do

echo $1-$m-`ncal $m $1 | grep Fr | sed 's/.* \([0-9]\)/\1/'`

 

 

For systems without ncal:

 

# usage: last_fridays [ year]

# Strip leading zeros to avoid octal interpretation

month=$(( 1 + ${month#0} ))

 

 

Using <code>date --date</code> from GNU date??? This code is not portable.

 

 

# Free code, no limit work

 

# main

 

Sample execution:

 

=={{header|Visual FoxPro}}==

*!* OOP implementaion

LOCAL lnYear As Integer, oCalc As fricalc

 

ENDDEFINE

 

=={{header|XPL0}}==

 

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

IntOut(0, LastDay); CrLf(0);

];

 

{{out}}

=={{header|zkl}}==

Gregorian calendar

fcn lastDay(y,d){

[1..12].pump(List,'wrap(m){ // 12 months, closure for y & d

})

}

For each month in year y, count back from the last day in the month

until a Friday is found and print that date.