Last Friday of each month: Difference between revisions
Added Easylang
No edit summary |
(Added Easylang) |
||
| (22 intermediate revisions by 13 users not shown) | |||
Line 33:
=={{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
Line 111:
DW DS D packed (PL8) 15num
YREGS
END LASTFRI</
{{out}}
<pre>
Line 129:
=={{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]
Line 193:
PrintB2(last) PutE()
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Last_Friday_of_each_month.png Screenshot from Atari 8-bit computer]
Line 216:
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;
Line 245:
Put_Line(Selected);
end loop;
end Last_Weekday_In_Month;</
{{out}}
<pre>>./last_weekday_in_month friday 2012
Line 264:
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 #
Line 314:
)
OD
END</
{{out}}
<pre>
Line 333:
=={{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 %
Line 390:
for mPos := 1 until 12 do write( year, if mPos < 10 then "-0" else "-1", mPos rem 10, "-", last( mPos ) )
end
end.</
{{out}}
<pre>
Line 410:
{{Trans|JavaScript}}
<
-- lastFridaysOfYear :: Int -> [Date]
Line 605:
map(column, item 1 of xss)
end transpose</
{{Out}}
<pre>2014-01-31 2015-01-30 2016-01-29 2017-01-27 2018-01-26
Line 626:
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}
Line 648:
end lastFridayOfEachMonthInYear
lastFridayOfEachMonthInYear(2020)</
{{Out}}
Line 667:
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}
Line 691:
end lastWeekdayWOfEachMonthInYear
lastWeekdayWOfEachMonthInYear(Friday, 2020)</
{{Out}}
<pre>"./last_Fridays 2020
Line 709:
=={{header|Arturo}}==
<
ensure -> in? m 1..12
Line 721:
loop 1..12 'month [
print to :string.format:"yyyy-MM-dd" lastFridayForMonth month
]</
{{out}}
Line 739:
=={{header|AutoHotkey}}==
<
{
InputBox, 1, Last Fridays of year, Enter a year:, , , , , , , , %A_YYYY%
Line 767:
stmp += 1, days
}
MsgBox % res</
{{out}} for 2012:
<pre>2012-01-27
Line 784:
=={{header|AutoIt}}==
<syntaxhighlight lang="autoit">
#include <Date.au3>
Line 807:
ConsoleWrite($sResult)
EndFunc ;==>_GetFridays
</syntaxhighlight>
{{out}}
<pre>
Line 827:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f LAST_FRIDAY_OF_EACH_MONTH.AWK year
# converted from Fortran
Line 845:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 861:
2012-12-28
</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> INSTALL @lib$ + "DATELIB"
INPUT "What year to calculate (YYYY)? " Year%
PRINT '"Last Fridays in ";Year% " are on:"
FOR Month%=1 TO 12
PRINT Year% "-" RIGHT$("0" + STR$Month%, 2) "-"; \
\ FN_dim(Month%, Year%) - (FN_dow(FN_mjd(FN_dim(Month%, Year%), Month%, Year%)) + 2) MOD 7
NEXT</syntaxhighlight>
{{out}}
<pre>What year to calculate (YYYY)? 2023
Last Fridays in 2023 are on:
2023-01-27
2023-02-24
2023-03-31
2023-04-28
2023-05-26
2023-06-30
2023-07-28
2023-08-25
2023-09-29
2023-10-27
2023-11-24
2023-12-29</pre>
=={{header|Befunge}}==
Line 866 ⟶ 894:
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
^<# #"#"##"#"##!` +76:+1g00,+55,+*<</
{{out}}
Line 892 ⟶ 920:
Doesn't work with Julian calendar (then again, you probably don't need to plan your weekends for middle ages).
<
#include <stdlib.h>
Line 911 ⟶ 939:
return 0;
}</
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Globalization;
Line 951 ⟶ 979:
}
}
}</
{{out}}
<pre>01/27/2012
Line 969 ⟶ 997:
{{libheader|Boost}}
called with <code>./last_fridays 2012</code>
<
#include <iostream>
#include <cstdlib>
Line 985 ⟶ 1,013:
}
return 0 ;
}</
{{out}}
<pre>2012-Jan-27
Line 999 ⟶ 1,027:
2012-Nov-30
2012-Dec-28
</pre>
===Using C++20===
Using C++20 this task can be completed without external libraries.
<syntaxhighlight lang="c++">
#include <chrono>
#include <iostream>
int main() {
std::cout << "The dates of the last Friday in each month of 2023:" << std::endl;
for ( unsigned int m = 1; m <= 12; ++m ) {
std::chrono::days days_in_month = std::chrono::sys_days{std::chrono::year{2023}/m/std::chrono::last}
- std::chrono::sys_days{std::chrono::year{2023}/m/1} + std::chrono::days{1};
const unsigned int last_day = days_in_month / std::chrono::days{1};
std::chrono::year_month_day ymd{std::chrono::year{2023}, std::chrono::month{m}, std::chrono::day{last_day}};
while ( std::chrono::weekday{ymd} != std::chrono::Friday ) {
ymd = std::chrono::sys_days{ymd} - std::chrono::days{1};
}
std::cout << ymd << std::endl;
}
}
</syntaxhighlight>
{{ out }}
<pre>
The dates of the last Friday in each month of 2023:
2023-01-27
2023-02-24
2023-03-31
2023-04-28
2023-05-26
2023-06-30
2023-07-28
2023-08-25
2023-09-29
2023-10-27
2023-11-24
2023-12-29
</pre>
Line 1,004 ⟶ 1,073:
{{libheader|clj-time}}
<
'[clj-time.format :only [unparse formatters]])
Line 1,014 ⟶ 1,083:
(defn last-fridays-formatted [year]
(sort (map #(unparse (formatters :year-month-day) %) (last-fridays year))))</
{{out}}
Line 1,032 ⟶ 1,101:
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
program-id. last-fri.
data division.
Line 1,081 ⟶ 1,150:
.
end program last-fri.
</syntaxhighlight>
{{out}}
Line 1,100 ⟶ 1,169:
=={{header|CoffeeScript}}==
<
last_friday_of_month = (year, month) ->
# month is 1-based, JS API is 0-based, then we use
Line 1,119 ⟶ 1,188:
year = parseInt process.argv[2]
print_last_fridays_of_month year
</syntaxhighlight>
{{out}}
<syntaxhighlight lang="text">
> coffee last_friday.coffee 2012
Fri Jan 27 2012
Line 1,135 ⟶ 1,204:
Fri Nov 30 2012
Fri Dec 28 2012
</syntaxhighlight>
=={{header|Common Lisp}}==
Line 1,141 ⟶ 1,210:
The command-line argument processing is the only CLISP-specific code.
<
(let*
((timestamp (encode-universal-time 0 0 12 day month year))
Line 1,154 ⟶ 1,223:
(let* ((year (read-from-string (car *args*))))
(format t "~{~{~a-~2,'0d-~2,'0d~}~%~}" (last-fridays year)))</
Sample run for the year 2015:
Line 1,172 ⟶ 1,241:
=={{header|D}}==
<
void lastFridays(in uint year) {
Line 1,186 ⟶ 1,255:
void main() {
lastFridays(2012);
}</
<pre>2012-Jan-27
2012-Feb-24
Line 1,202 ⟶ 1,271:
=={{header|Delphi}}==
Uses the standard Delphi library.
<
{$APPTYPE CONSOLE}
Line 1,228 ⟶ 1,297:
WriteLn(DateToStr(D1));
end;
end.</
{{out}}
<pre>Enter year: 2019
Line 1,243 ⟶ 1,312:
29.11.2019
27.12.2019</pre>
=={{header|EasyLang}}==
<syntaxhighlight>
func leap year .
return if year mod 4 = 0 and (year mod 100 <> 0 or year mod 400 = 0)
.
func weekday year month day .
normdoom[] = [ 3 7 7 4 2 6 4 1 5 3 7 5 ]
c = year div 100
r = year mod 100
s = r div 12
t = r mod 12
c_anchor = (5 * (c mod 4) + 2) mod 7
doom = (s + t + (t div 4) + c_anchor) mod 7
anchor = normdoom[month]
if leap year = 1 and month <= 2
anchor = (anchor + 1) mod1 7
.
return (doom + day - anchor + 7) mod 7 + 1
.
mdays[] = [ 31 28 31 30 31 30 31 31 30 31 30 31 ]
proc last_fridays year . .
for m to 12
d = mdays[m]
if m = 2 and leap year = 1
d = 29
.
d -= (weekday year m d - 6) mod 7
m$ = m
if m < 10
m$ = "0" & m
.
print year & "-" & m$ & "-" & d
.
.
last_fridays 2023
</syntaxhighlight>
=={{header|Elixir}}==
<
def lastFriday(year) do
Enum.map(1..12, fn month ->
Line 1,259 ⟶ 1,365:
Enum.each(RC.lastFriday(y), fn {year, month, day} ->
:io.format "~4b-~2..0w-~2..0w~n", [year, month, day]
end)</
{{out}}
Line 1,278 ⟶ 1,384:
=={{header|Elm}}==
<
import Html.App exposing (beginnerProgram)
import Html.Attributes exposing (placeholder, value, style)
Line 1,344 ⟶ 1,450:
, view = view
, update = update
}</
Link to live demo: http://dc25.github.io/lastFridayOfMonthElm/
Line 1,362 ⟶ 1,468:
December 26, 2003
</pre>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(require 'calendar)
(defun last-friday (year)
"Print the last Friday in each month of year"
(mapcar (lambda (month)
(let*
((days (number-sequence 1 (calendar-last-day-of-month month year)))
(mdy (mapcar (lambda (x) (list month x year)) days))
(weekdays (mapcar #'calendar-day-of-week mdy))
(lastfriday (1+ (cl-position 5 weekdays :from-end t))))
(insert (format "%i-%02i-%02i \n" year month lastfriday))))
(number-sequence 1 12)))
(last-friday 2012)</syntaxhighlight>
{{output}}
<pre>2012-01-27
2012-02-24
2012-03-30
2012-04-27
2012-05-25
2012-06-29
2012-07-27
2012-08-31
2012-09-28
2012-10-26
2012-11-30
2012-12-28 </pre>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( last_date_each_month ).
Line 1,383 ⟶ 1,518:
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].
</syntaxhighlight>
{{out}}
<pre>
Line 1,404 ⟶ 1,539:
{{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
[ timestamp>ymd print ] each</
{{out}}
<pre>
Line 1,430 ⟶ 1,565:
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/)
Line 1,443 ⟶ 1,578:
end do
end program
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' compile with: fbc -s console
Line 1,530 ⟶ 1,665:
Loop
End</
{{out}}
<pre>For what year do you want to find the last Friday of the month
Line 1,550 ⟶ 1,685:
=={{header|Frink}}==
<
for m = 1 to 12
{
Line 1,556 ⟶ 1,691:
n = d - (((parseInt[d -> ### u ###] + 1) mod 7) + 1) days
println[n -> ### yyyy-MM-dd ###]
}</
{{out}}
Line 1,575 ⟶ 1,710:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Last_day_of_each_month_of_a_year%2C_being_a_given_weekday}}
'''Solution'''
The following function retrieves the last day of each month of a year, being a given weekday:
[[File:Fōrmulæ - Last day of each month of a year, being a given weekday 01.png]]
'''Test case'''
[[File:Fōrmulæ - Last day of each month of a year, being a given weekday 04.png]]
[[File:Fōrmulæ - Last day of each month of a year, being a given weekday 05.png]]
=={{header|Gambas}}==
<
Dim siYear As Short = InputBox("Please input a year", "Last Friday of each month")
Dim siMonth, siDay As Short
Line 1,601 ⟶ 1,744:
Me.Close
End</
Output:
<pre>
Line 1,619 ⟶ 1,762:
=={{header|Go}}==
<
import (
Line 1,640 ⟶ 1,783:
fmt.Println(d.Format("2006-01-02"))
}
}</
{{out}}
<pre>
Line 1,662 ⟶ 1,805:
Test:
<
def lastFridays = lastWeekDays.curry(Day.Fri)
lastFridays(args[0] as int).each { println (ymd(it)) }</
Execution (Cygwin on Windows 7):
Line 1,684 ⟶ 1,827:
=={{header|Haskell}}==
<
(Day, addDays, showGregorian, fromGregorian, gregorianMonthLength)
import Data.Time.Calendar.WeekDate (toWeekDate)
Line 1,709 ⟶ 1,852:
mapM_
putStrLn
(intercalate " " <$> transpose (weekDayDates 5 <$> [2012 .. 2017]))</
{{Out}}
<pre>2012-01-27 2013-01-25 2014-01-31 2015-01-30 2016-01-29 2017-01-27
Line 1,726 ⟶ 1,869:
=={{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
Line 1,745 ⟶ 1,888:
end
link datetime, printf</
{{libheader|Icon Programming Library}}
Line 1,768 ⟶ 1,911:
=={{header|J}}==
<
last_fridays=: 12 {. [: ({:/.~ }:"1)@(#~ 5 = weekday)@todate (i.366) + todayno@,&1 1</
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).
Line 1,775 ⟶ 1,918:
Example use:
<
2012 1 27
2012 2 24
Line 1,787 ⟶ 1,930:
2012 10 26
2012 11 30
2012 12 28</
=={{header|Java}}==
{{works with|Java|1.5+}}
<
import java.util.*;
Line 1,816 ⟶ 1,959:
}
}
}</
{{out}} (for <code>java LastFridays 2012</code>):
<pre>2012 Jan 27
Line 1,835 ⟶ 1,978:
====Iteration====
{{works with|Nodejs}}
<
last_friday_of_month = function(year, month) {
Line 1,862 ⟶ 2,005:
year = parseInt(process.argv[2]);
return print_last_fridays_of_month(year);
})();</
{{Out}}
<pre>>node lastfriday.js 2015
Line 1,879 ⟶ 2,022:
====Functional composition====
<
'use strict';
Line 1,949 ⟶ 2,092:
})
.join('\n');
})();</
{{Out}}
Line 1,966 ⟶ 2,109:
===ES6===
<
"use strict";
Line 2,045 ⟶ 2,188:
// MAIN ---
return main();
})();</
{{Out}}
<pre>2015-01-30 2016-01-29 2017-01-27 2018-01-26 2019-01-25
Line 2,063 ⟶ 2,206:
{{ works with|jq|1.4}}
'''Foundations'''
<
def until(cond; next):
Line 2,089 ⟶ 2,232:
| if iso == "iso" or iso == "ISO" then 1 + ((. + 5) % 7)
else . % 7
end ;</
'''findLastFridays'''
<
def findLastFriday(year; month):
def isLeapYear:
Line 2,112 ⟶ 2,255:
(range(0;12) | "\(months[.]) \(findLastFriday($year; .+1))") ;
$year|tonumber|findLastFridays</
{{out}}
<
YEAR: 2012
January 27
Line 2,127 ⟶ 2,270:
October 26
November 30
December 28</
=={{header|Julia}}==
<
const wday = Dates.Fri
Line 2,155 ⟶ 2,298:
end
end
</
<pre>
This script will print the last Fridays of each month of the year given.
Line 2,182 ⟶ 2,325:
=={{header|K}}==
<syntaxhighlight lang="k">
/ List the dates of last Fridays of each month of
/ a given year
Line 2,196 ⟶ 2,339:
main: {[y]; lfd1[y];`0: ,"Dates of last Fridays of ",($y);12 10#arr}
</syntaxhighlight>
The output of a session is given below:
Line 2,222 ⟶ 2,365:
=={{header|Kotlin}}==
<
import java.util.*
Line 2,244 ⟶ 2,387:
}
}
}</
{{out}}
Line 2,265 ⟶ 2,408:
=={{header|Lasso}}==
<
#y % 400 == 0 ? return true
#y % 100 == 0 ? return false
Line 2,288 ⟶ 2,431:
with f in fridays(2012) do => {^
#f->format('%Q') + '\r'
^}</
{{out}}
Line 2,305 ⟶ 2,448:
=={{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
Line 2,327 ⟶ 2,470:
sort fridays ascending numeric
return fridays
end lastFriday</
Example<
2 24
3 30
Line 2,339 ⟶ 2,482:
10 26
11 30
12 28</
=={{header|Logo}}==
<
to leap? :year
output (and
Line 2,386 ⟶ 2,529:
print reduce [(word ?1 "- ?2)] (list :year :month :day)
]
bye</
{{out}}
Line 2,404 ⟶ 2,547:
=={{header|Lua}}==
<
return (y % 4 == 0 and y % 100 ~=0) or y % 400 == 0
end
Line 2,423 ⟶ 2,566:
end
lastWeekdays("Friday", tonumber(arg[1]))</
Command line session:
<pre>>lua lastFridays.lua 2012
Line 2,440 ⟶ 2,583:
></pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
module lastfriday {
string year
integer y%
input "Year (e.g. 2023):", y%
year=str$(y%,"")
date a="1/1/"+year
date a1="31/12/"+year
double i, b=a, c=a1
for i=b to b+6
if val(date$(i, 1033, "d"))=6 then exit for
next
document result$="Last Friday per month for year " + year + {:
}
for i=i+7 to c step 7
if val(date$(i, 1033, "M")) <>val(date$(i+7, 1033, "M")) then
result$=date$(i, 1033, "M"+chr$(9)+"dd") + {
}
end if
next
report result$
clipboard result$
}
lastfriday
</syntaxhighlight>
{{out}}
<pre>
Year (e.g. 2023):2023
Last Friday per month for year 2023:
1 27
2 24
3 31
4 28
5 26
6 30
7 28
8 25
9 29
10 27
11 24
12 29
</pre>
=={{header|Maple}}==
<
local i, dt, change, last_days;
last_days := [31,28,31,30,31,30,31,31,30,31,30,31];
Line 2,459 ⟶ 2,650:
end proc;
fridays(2012);</
{{Out|Output}}
<pre>2012-1-27
Line 2,475 ⟶ 2,666:
=={{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]
Column@FridaysOfYear[2012]</
{{out}}
<pre>{2012,1,27}
Line 2,495 ⟶ 2,686:
=={{header|MATLAB}} / {{header|Octave}}==
<
t1 = datenum([y,1,1,0,0,0]);
t2 = datenum([y,12,31,0,0,0]);
Line 2,504 ⟶ 2,695:
datestr(last_fridays_of_year(2012),'yyyy-mm-dd')
</syntaxhighlight>
{{out}}
Line 2,522 ⟶ 2,713:
=={{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)
Line 2,541 ⟶ 2,732:
lastfridays(2012);
["2012-1-27", "2012-2-24", "2012-3-30", "2012-4-27", "2012-5-25", "2012-6-29",
"2012-7-27","2012-8-31", "2012-9-28", "2012-10-26", "2012-11-30", "2012-12-28"]</
=={{header|Nanoquery}}==
<
// a function to check if a year is a leap year
Line 2,594 ⟶ 2,785:
print form(friday.getMonth()) + "-"
println form(friday.getDay())
end</
=={{header|NetRexx}}==
Line 2,600 ⟶ 2,791:
{{trans|C}}
Implements the algorithms from both the [[#Java|Java]] and [[#C|C]] implementations.
<
options replace format comments java crossref symbols nobinary
Line 2,676 ⟶ 2,867:
end
return
</syntaxhighlight>
{{out}}
<pre>
Line 2,711 ⟶ 2,902:
=={{header|Nim}}==
<
const
Line 2,724 ⟶ 2,915:
var date = initDateTime(lastDay, month, year, 0, 0, 0)
date = date - days(DayDiffs[date.weekday])
echo date.format("yyyy-MM-dd")</
{{out}}
Line 2,746 ⟶ 2,937:
Using the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html Unix] from the standard OCaml library:
<
open Unix
Line 2,781 ⟶ 2,972:
done;
done;
Array.iter print_date fridays</
{{out}}
Line 2,801 ⟶ 2,992:
{{libheader|OCaml Calendar Library}}
<
let usage() =
Line 2,825 ⟶ 3,016:
aux num_days
done;
List.iter print_date (List.rev !fridays)</
Run this script with the command:
Line 2,833 ⟶ 3,024:
=={{header|Oforth}}==
<
: lastFridays(y)
Line 2,841 ⟶ 3,032:
while(dup dayOfWeek Date.FRIDAY <>) [ addDays(-1) ]
println
] ;</
{{out}}
Line 2,861 ⟶ 3,052:
=={{header|PARI/GP}}==
<
njd(D) =
{
Line 2,887 ⟶ 3,078:
}
for (m=1, 12, a=njd([2012,m+1,0]); print(njdate(a-(a+1)%7)))</
Output:<pre>
Line 2,904 ⟶ 3,095:
=={{header|Pascal}}==
{{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.
<syntaxhighlight lang="pascal">
program LastFriday;
Line 2,962 ⟶ 3,154:
end;
{ return the calendar day of the last
{ specified weekday in
function LastWeekday(k : weekdays; m, y : integer) : integer;
var
Line 2,972 ⟶ 3,164:
d := DaysInMonth(m, y);
w := DayOfWeek(m, d, y);
{
if w >= k then
else
end;
Line 2,989 ⟶ 3,180:
begin
d := LastWeekday(Fri, m, y);
writeln(m:5,' ',d:5
end;
end.
</syntaxhighlight>
{{out}}
<pre>
Line 3,010 ⟶ 3,201:
12 25
</pre>
=={{header|Perl}}==
<
use strict ;
use DateTime ;
Line 3,024 ⟶ 3,214:
}
say $dt->ymd ;
}</
{{out}}
<pre>2012-01-27
Line 3,041 ⟶ 3,231:
=={{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>
Line 3,054 ⟶ 3,244:
--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>
Line 3,074 ⟶ 3,264:
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;
Line 3,095 ⟶ 3,285:
$year = 2012;
print_last_fridays_of_month($year);
?></
{{out}}
Line 3,112 ⟶ 3,302:
2012-12-28
</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">% for command line argument
main(ARGV) =>
if ARGV.length > 0 then
Year = ARGV[1].to_integer(),
show_year(Year),
nl
end.
% Without command line argument
main => go.
go =>
show_year(2022),
nl.
% Show the months
show_year(Year) =>
foreach(Date in get_months(Year))
println(format_date(Date))
end,
nl.
% Format date to YYYY-DD-MM
format_date(Date) = to_fstring("%4d-%02d-%02d",Date[1],Date[2],Date[3]).
% Return the last Fridays of each month for year Year
get_months(Year) =
[ [ [Year,Month,Day] : Day in 1..max_days_in_month(Year,Month),
dow(Year, Month, Day) == 5].last() : Month in 1..12].
% Day of week, Sakamoto's method
dow(Y, M, D) = R =>
T = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4],
if M < 3 then
Y := Y - 1
end,
R = (Y + Y // 4 - Y // 100 + Y // 400 + T[M] + D) mod 7.
% Maximum days in month
max_days_in_month(Year,Month) = Days =>
if member(Month, [1,3,5,7,8,10,12]) then
Days = 31
elseif member(Month,[4,6,9,11]) then
Days = 30
else
if leap_year(Year) then
Days = 29
else
Days = 28
end
end.
% Is Year a leap year?
leap_year(Year) =>
(Year mod 4 == 0, Year mod 100 != 0)
;
Year mod 400 == 0. </syntaxhighlight>
===Running the program===
There are several ways to run this program; let's call it "last_friday_of_each_month.pi":
===From Picat's shell===
<pre>$ picat
Picat> cl(last_friday_of_each_month)
Picat> show_year(2022)
2022-01-28
2022-02-25
2022-03-25
2022-04-29
2022-05-27
2022-06-24
2022-07-29
2022-08-26
2022-09-30
2022-10-28
2022-11-25
2022-12-30</pre>
===From the command line, year as parameter===
Via <code>main(ARGV)</code>.
<pre>$ picat last_friday_of_each_month.pi 2022</pre>
===From the command line, as a goal===
<pre>$ picat -g "show_year(2022)" last_friday_of_each_month.pi</pre>
===Run the default goal (go/0))===
<pre>$ picat last_friday_of_each_month.pi</pre>
=={{header|PicoLisp}}==
<
(for M 12
(prinl
Line 3,120 ⟶ 3,401:
(find '((D) (= "Friday" (day D)))
(mapcar '((D) (date Y M D)) `(range 31 22)) )
"-" ) ) ) )</
Test:
<
2012-01-27
2012-02-24
Line 3,134 ⟶ 3,415:
2012-10-26
2012-11-30
2012-12-28</
=={{header|Pike}}==
<
{
return day->week_day() == 5 &&
Line 3,148 ⟶ 3,429:
write("%{%s\n%}", days->format_ymd());
return 0;
}</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
Fridays: procedure (year) options (main); /* 8 January 2013 */
declare year character (4) varying;
Line 3,174 ⟶ 3,455:
end;
end Fridays;
</syntaxhighlight>
The command: FRIDAYS /2008 produces:
<pre>
Line 3,209 ⟶ 3,490:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function last-dayofweek {
param(
Line 3,223 ⟶ 3,504:
}
last-dayofweek 2012 "Friday"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 3,243 ⟶ 3,524:
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.
<syntaxhighlight lang="powershell">
function Get-Date0fDayOfWeek
{
Line 3,341 ⟶ 3,622:
}
}
</syntaxhighlight>
The default is to return <code>[DateTime]</code> objects:
<syntaxhighlight lang="powershell">
1..12 | Get-Date0fDayOfWeek -Year 2012 -Last -Friday
</syntaxhighlight>
{{Out}}
<pre>
Line 3,362 ⟶ 3,643:
</pre>
Return the <code>[DateTime]</code> objects as strings (using the default string format):
<syntaxhighlight lang="powershell">
1..12 | Get-Date0fDayOfWeek -Year 2012 -Last -Friday -AsString
</syntaxhighlight>
{{Out}}
<pre>
Line 3,381 ⟶ 3,662:
</pre>
Return the <code>[DateTime]</code> objects as strings (specifying the string format):
<syntaxhighlight lang="powershell">
1..12 | Get-Date0fDayOfWeek -Year 2012 -Last -Friday -AsString -Format yyyy-MM-dd
</syntaxhighlight>
{{Out}}
<pre>
Line 3,401 ⟶ 3,682:
=={{header|PureBasic}}==
<
Define dv.i=ParseDate("%yyyy",Str(yyyy)), mv.i=1
NewList d.i()
Line 3,434 ⟶ 3,715:
EndIf
Print("...End")
Input()</
{{out}}
<pre>Input Year [ 1971 < y < 2038 ]: 2017
Line 3,453 ⟶ 3,734:
=={{header|Python}}==
<
def last_fridays(year):
Line 3,459 ⟶ 3,740:
last_friday = max(week[calendar.FRIDAY]
for week in calendar.monthcalendar(year, month))
print('{:4d}-{:02d}-{:02d}'.format(year, month, last_friday))</
{{out}}
Line 3,476 ⟶ 3,757:
2012-12-28</pre>
Another solution
<
c=calendar.Calendar()
fridays={}
Line 3,490 ⟶ 3,771:
for item in sorted((month+"-"+day for month,day in fridays.items()),
key=lambda x:int(x.split("-")[1])):
print item</
Using reduce
<
c=calendar.Calendar()
fridays={}
Line 3,507 ⟶ 3,788:
for item in sorted((month+"-"+day for month,day in fridays.items()),
key=lambda x:int(x.split("-")[1])):
print item</
using itertools
<
from itertools import chain
f=chain.from_iterable
Line 3,527 ⟶ 3,808:
for item in sorted((month+"-"+day for month,day in fridays.items()),
key=lambda x:int(x.split("-")[1])):
print item</
=={{header|Quackery}}==
<
dup 4 / over +
over 100 / -
Line 3,578 ⟶ 3,859:
[ 5 lastwkdays ] is lastfridays ( year --> )
2012 lastfridays</
{{out}}
Line 3,596 ⟶ 3,877:
=={{header|R}}==
<
d = as.Date(paste0(year, "-01-01"))
fridays = d + seq(by = 7,
Line 3,602 ⟶ 3,883:
364 + (months(d + 30 + 29) == "February"))
message(paste(collapse = "\n", fridays[tapply(
seq_along(fridays), as.POSIXlt(fridays)$mon, max)]))</
=={{header|Racket}}==
<
#lang racket
(require srfi/19 math)
Line 3,647 ⟶ 3,928:
(for ([d (last-fridays 2012)])
(displayln (~a (date->string d "~a ~d ~b ~Y"))))
</syntaxhighlight>
{{out}}
<pre>
Line 3,666 ⟶ 3,947:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
my @fri;
for Date.new("$year-01-01") .. Date.new("$year-12-31") {
Line 3,672 ⟶ 3,953:
}
.say for @fri[1..12];
}</
Example:
Line 3,691 ⟶ 3,972:
A solution without a result array to store things in:
<syntaxhighlight lang="raku"
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.
Line 3,700 ⟶ 3,981:
Another variation where the data flow can be read left to right using feed operators:
<syntaxhighlight lang="raku"
.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]]
Line 3,729 ⟶ 4,010:
year: to-integer input
repeat month 12 [print last-friday-of-month month year]
</syntaxhighlight>
{{out}}
<pre>rebol last-fridays.reb <<< 2012
Line 3,746 ⟶ 4,027:
</pre>
A shorter version:
<
collect [
repeat month 12 [
Line 3,758 ⟶ 4,039:
foreach friday last-fridays-of-year to-integer input [print friday]
</syntaxhighlight>
NB. See "Find the last Sunday of each month" Rosetta for alternative (even more succinct) solution
Line 3,791 ⟶ 4,072:
║ 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*/
Line 3,840 ⟶ 4,121:
.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.*/
say; exit 13 /*··· then exit. */</
{{out|output|text= when using the following input of: <tt> 2012 </tt> or <tt> 12 </tt>}}
<pre>
Line 3,858 ⟶ 4,139:
=={{header|Ring}}==
<
see "What year to calculate (yyyy) : "
give year
Line 3,880 ⟶ 4,161:
next
</syntaxhighlight>
Output:
<pre>
Line 3,897 ⟶ 4,178:
2012-11-30
2012-12-28
</pre>
=={{header|RPL}}==
With the release of the HP-48, RPL gained some basic functions for calculating the date, but nothing for directly obtaining the day of the week.
{{works with|HP|48}}
≪ { "MON" TUE" "WED" "THU" "FRI" "SAT" "SUN" }
SWAP 0 TSTR 1 3 SUB POS
≫ '<span style="color:blue">WKDAY</span>' STO <span style="color:grey">@ ( dd.mmyyyy → 1..7 )</span>
≪ → year
≪ { }
.02 .13 '''FOR''' month
1 month .13 == DUP .01 month IFTE SWAP year + 1000000 / + +
DUP <span style="color:blue">WKDAY</span> 1 + 7 MOD 1 + NEG DATE+ 2 TRNC +
0.01 '''STEP''' 2 FIX
≫ ≫ '<span style="color:blue">TGIF</span>' STO
2012 <span style="color:blue">TGIF</span>
{{out}}
<pre>
1: {27.01 24.02 30.03 27.04 25.05 29.06 27.07 31.08 28.09 26.10 30.11 28.12 }
</pre>
=={{header|Ruby}}==
<
def last_friday(year, month)
Line 3,909 ⟶ 4,211:
year = Integer(ARGV.shift)
(1..12).each {|month| puts last_friday(year, month)}</
Friday is <code>d.wday == 5</code>; the expression <code>(d.wday - 5) % 7</code> counts days after Friday.
Line 3,929 ⟶ 4,231:
Or get the last day of the month and go to the previous day until it's a Friday.
<
def last_friday(year, month)
Line 3,936 ⟶ 4,238:
d
end
</syntaxhighlight>
=={{header|Run BASIC}}==
<
dayOne$ = "01-01-";yr
n1 = date$(dayOne$)
Line 3,953 ⟶ 4,255:
wend
print date$(n1) ' print last Friday's date
next i</
<pre>Year:?2013
01/25/2013
Line 3,969 ⟶ 4,271:
=={{header|Rust}}==
<
use time::{Date, Duration};
Line 3,982 ⟶ 4,284:
println!("{}", date - days_back);
});
}</
{{out}}
Line 4,001 ⟶ 4,303:
=={{header|Scala}}==
<
import java.text.SimpleDateFormat
Line 4,024 ⟶ 4,326:
}
}
}</
{{out}}
<pre>2012-Jan-27
Line 4,044 ⟶ 4,346:
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";
Line 4,073 ⟶ 4,375:
end for;
end if;
end func;</
{{out}} when called with <tt>s7 rosetta/lastWeekdayInMonth 5 2013</tt>:
Line 4,092 ⟶ 4,394:
=={{header|SenseTalk}}==
<
ask "What year?"
put it into year
Line 4,110 ⟶ 4,412:
add a month to lastDayOfMonth -- advance to last day of next month
end repeat
</syntaxhighlight>
{{out}}
<pre>
Line 4,130 ⟶ 4,432:
=={{header|Sidef}}==
{{trans|Perl}}
<
var (year=2016) = ARGV.map{.to_i}...
Line 4,139 ⟶ 4,441:
}
say dt.ymd
}</
{{out}}
<pre>
Line 4,159 ⟶ 4,461:
=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">
Pharo Smalltalk
Line 4,169 ⟶ 4,471:
thenSelect: [ :each |
(((Date daysInMonth: each monthIndex forYear: yr) - each dayOfMonth) <= 6) and: [ each year = yr ] ] ]
</syntaxhighlight>
{{out}}
<pre>
Line 4,177 ⟶ 4,479:
=={{header|SQL}}==
<syntaxhighlight lang="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;
</syntaxhighlight>
<pre>
LASTFRIDAY
Line 4,203 ⟶ 4,505:
=={{header|Stata}}==
<
args year
clear
Line 4,229 ⟶ 4,531:
| 30nov2012 |
| 28dec2012 |
+-----------+</
=={{header|Swift}}==
<syntaxhighlight lang="swift">
import Foundation
Line 4,281 ⟶ 4,583:
print(lastFridays(of: 2013).map(dateFormatter.string).joined(separator: "\n"))
</syntaxhighlight>
<pre>
1/27/12
Line 4,298 ⟶ 4,600:
=={{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} {
Line 4,305 ⟶ 4,607:
# Print the interesting part
puts [clock format $t -format "%Y-%m-%d" -gmt 1]
}</
Sample execution:
<pre>
Line 4,324 ⟶ 4,626:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
year=2012
Line 4,336 ⟶ 4,638:
ENDLOOP
ENDLOOP
</syntaxhighlight>
{{out}}
<pre style='height:30ex;overflow:scroll'>
Line 4,355 ⟶ 4,657:
=={{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
Line 4,363 ⟶ 4,665:
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/'`
done</
For systems without ncal:
<
# usage: last_fridays [ year]
Line 4,383 ⟶ 4,685:
# Strip leading zeros to avoid octal interpretation
month=$(( 1 + ${month#0} ))
done</
Using <code>date --date</code> from GNU date??? This code is not portable.
<
# Free code, no limit work
Line 4,457 ⟶ 4,759:
# main
last_fridays ${1:-2012}</
Sample execution:
Line 4,477 ⟶ 4,779:
=={{header|Visual FoxPro}}==
<
*!* OOP implementaion
LOCAL lnYear As Integer, oCalc As fricalc
Line 4,512 ⟶ 4,814:
ENDDEFINE
</syntaxhighlight>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import time
import os
fn main() {
mut year := 0
mut t := time.now()
year = os.input("Please select a year: ").int()
println("Last Fridays of each month of $year")
println("==================================")
for i in 1..13 {
mut j := time.month_days[i-1]
if i == 2 {
if time.is_leap_year(year) {j = 29}
}
for {
t = time.parse('$year-${i:02}-$j 12:30:00')!
if t.weekday_str() == 'Fri' {
println("${time.long_months[i-1]}: $j")
break
}
j--
}
}
}</syntaxhighlight>
{{out}}
<pre>Please select a year: 2012
Last Fridays of each month of 2012
==================================
January: 27
February: 24
March: 30
April: 27
May: 25
June: 29
July: 27
August: 31
September: 28
October: 26
November: 30
December: 28
</pre>
=={{header|Wren}}==
{{libheader|Wren-date}}
<
import "./date" for Date
var args = Process.arguments
Line 4,538 ⟶ 4,883:
System.print(dt.addDays(-wd - 2))
}
}</
{{out}}
Line 4,574 ⟶ 4,919:
=={{header|XPL0}}==
<
func WeekDay(Year, Month, Day); \Return day of week (0=Sun, 1=Mon ... 6=Sat)
Line 4,596 ⟶ 4,941:
IntOut(0, LastDay); CrLf(0);
];
]</
{{out}}
Line 4,616 ⟶ 4,961:
=={{header|zkl}}==
Gregorian calendar
<
fcn lastDay(y,d){
[1..12].pump(List,'wrap(m){ // 12 months, closure for y & d
Line 4,625 ⟶ 4,970:
})
}
lastDay(2012,D.Friday).concat("\n").println();</
For each month in year y, count back from the last day in the month
until a Friday is found and print that date.
| |||