Calendar: Difference between revisions

{{task|Date and time}}

Create a routine that will generate a text calendar for any year.

:*   [[Five weekends]]

<br><br>

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

{{trans|Free Basic}}

This program uses no external functions but two ASSIST macros (XDECO, XPRNT) to keep the code as short as possible.

CALENDAR CSECT

USING CALENDAR,R13 base register

DA DS 12CL144

YREG

{{out}}

<pre>

31

</pre>

=={{header|Ada}}==

 

the [[Calendar_-_for_"real"_programmers#Ada]] task.

 

 

package Printable_Calendar is

end record;

 

 

We continue with the implementation (printable_calendar.ads):

 

 

package body Printable_Calendar is

end Init_132;

 

 

Now, the main program is really simple:

 

 

procedure Cal is

C.New_Line;

C.Print(1969, "Nineteen-Sixty-Nine");

 

Here is the output:

 

To get a 132-character-wide output, you just have to replace "Init_80" by "Init_132" in the main program.

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

PROC print calendar = (INT year, page width)VOID: (

line printer width = 80; # as at 1969! #

print calendar(mankind stepped on the moon, line printer width)

Output:

<pre>

30

</pre>

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

{{trans|Simula}} which is a {{trans|C}}

<br>In Algol W, the condition of a "while" loop can be a block and the boolean "and" operator short circuits, which allow us to avoid the goto statements.

<br>Also, the Algol W string type is fixed length, unlike the Simula text type.

INTEGER WIDTH, YEAR;

INTEGER COLS, LEAD, GAP;

PRINT_YEAR

END

{{out}}

<pre>

 

 

</pre>

 

=={{header|AutoHotkey}}==

LastDay := [], Day := []

Titles =

Res:=RegExReplace(Res,"`am)(^|\s)\K0", " ")

return res

Gui, add, edit, vYr w40 r1 Limit4 Number, 1969

Gui, add, edit, vEdit2 w580 r38

GuiClose:

ExitApp

Outputs:<pre> 1969

 

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30 </pre>

=={{header|AutoIt}}==

#include <Date.au3>

 

ConsoleWrite($sLeft & $_sLine & $_sLF & @LF)

EndFunc ;==>_PrintLine

Output

<pre>

</pre>

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 00:40, 15 November 2013 (UTC)

=={{header|AWK}}==

 

Works with Gnu awk version 3.1.5 and with BusyBox v1.20.0.git awk

 

Output:

<pre>

 

</pre>

Choosing 132 character output.

DECLARE month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

year$ = "1969"

PRINT day;

NEXT

 

{{out}}

 

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

::Batch File Implementation

 

echo.

pause

{{Out}}

<pre>

 

Press any key to continue . . .</pre>

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

{{works with|BBC BASIC for Windows}}

The day and month names are in the language for which the PC is configured.

VDU 23,22,640;570;8,15,16,128

PRINT

NEXT

Output:

<pre> 1969

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Befunge}}==

This is quite closely based on the [[Calendar#C|C]] sample, although the centering calculation has been adjusted to fix an off-by-one error, and the months have been made a constant height, regardless of how much space they require, to try and produce a more balanced layout.

The year is read from stdin, and the width is specified by the first value on the stack (set to 80 - <tt>"P"</tt> - in the current implementation).

 

J!F?M!A M!J J!A!S O!N D!SaFrThWeTuMoSuvp01:_1#!-#%:#\>#+6<v-2g1+1g01p1p01:<

January February March April >:45**00g\-\1-:v:<<6>+7%:10g2+:38*\`|

> > $$55+,6>>40p:10g30g>:#,1#*-#8\#4_$>\:2*:1+1g2-50p1g640g-7*1+\-7v v@,<6

2:+g01$_55+,^ > > > > #^>#g>#0>#2_v v*2!!\%+55:\/+55:**`0\!`g05:::\< >2-^^

=={{header|C}}==

With arbitrary display width (>= 20 though) and auto spacing.

#include <stdlib.h>

#include <string.h>

bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);

exit(1);

 

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

An attempt to abuse the DateTime class for all static information. In the event that the number of days and months changes, so long as the DateTime class is updated accordingly, this should still print properly. It also abuses iterators to allow for a concise month printing method, but with the ability to still print x months per line.

 

 

using System;

}

 

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

#include <windows.h>

#include <iostream>

}

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

Output:

<pre>

+----------------------+----------------------+----------------------+

</pre>

 

=={{header|COBOL}}==

the program calls subroutine DATE2DOW to convert any YYYY-MM-DD to Day of Week (1=Sunday). the group names WS-CFGN

and WS-CFGW may be moved to WS-CFG to use narrow or wide print line size respectively.

IDENTIFICATION DIVISION.

PROGRAM-ID. CALEND.

.

END PROGRAM DATE2DOW.

Output (based on 80 character wide display)

<pre>

30

</pre>

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

Depends on quicklisp.

 

(defparameter *day-row* "Su Mo Tu We Th Fr Sa")

(lambda (&rest heads)

(format t format-string heads))

{{out}}

<pre>CL-USER> (print-calendar 1969)

30

NIL</pre>

=={{header|D}}==

 

void printCalendar(in uint year, in uint nCols)

void main() {

printCalendar(1969, 3);

 

<pre> [Snoopy Picture]

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

 

let day_of_week month year =

let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]

sb.ToString()

 

 

{{out}}

 

=={{header|Factor}}==

math.ranges prettyprint sequences sequences.interleaved ;

IN: rosetta-code.calendar

: calendar-demo ( -- ) 1969 calendar ;

 

{{out}}

<pre>

30

</pre>

 

=={{header|Fortran}}==

Already having a routine to produce a calendar simplified matters. However, it added to each row of days a row of annotations for those days (Xmas, etc. and also +2hh and -2hh for the days with two half-hour changes in length due to daylight saving: NZ also had daylight saving with changes of one half-hour) which meant that the field allowance was always four. With the annotations abandoned, this could be reduced to three, and, the first day column on a line does not need a leading space. Since the method employed variables for the layout, it could easily be twiddled to have three months per line (thus fitting into a line length of 80) or six (using most of a line length of 132) and so it became a matter of pulling together the needed routines from various places.

MODULE DATEGNASH !Assorted vexations. Time and calendar games, with local flavourings added.

 

END DO

END

Selected output, lacking alas the outbursts from Snoopy: three months /line

<pre>

31 30

</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

'Print : Print "hit any key to end program

Sleep

{{out}}

<pre> 1969

21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

28 29 30 31 25 26 27 28 29 30 31 29 30 27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 </pre>

=={{header|FutureBasic}}==

 

 

open "UNIX", 1,"cal 1969"

close 1

 

<pre>

1969

30

</pre>

=={{header|Gambas}}==

 

Shell "cal 1969"

 

Output:

<pre>

30

</pre>

=={{header|Go}}==

 

import (

fmt.Println()

}

Output:

<pre> [SNOOPY]

30

</pre>

=={{header|Haskell}}==

import Data.Time

import Data.Time.Calendar

calcol' = calColFromCol columns

 

<pre>*Main> printCalendar 1969 80

[Maybe Snoopy]

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Huginn}}==

import Algorithms as algo;

import Text as text;

cols

);

 

Output: <pre> 1969

20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31</pre>

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

The procedures ''printCalendar'' handles formatting of large components and uses co-expressions to keep the formatting of week elements in each column synchronized. The procedure ''CalendarFormatWeek'' is a generator that returns heading elements, alignment spacing, and individual days.

printCalendar(\A[1]|1969)

end

if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29) # LY adjustment

every d to (6*7) do suspend "" # trailer alignment

 

{{libheader|Icon Programming Library}}

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|J}}==

'''Solution:'''

require 'dates general/misc/format' NB. J7.x

calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])

calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]

'''Example use:'''

[Insert Snoopy here]

1969

19 20 21 22 23 24 25│ 16 17 18 19 20 21 22│ 21 22 23 24 25 26 27

26 27 28 29 30 31 │ 23 24 25 26 27 28 29│ 28 29 30 31

=={{header|Java}}==

{{trans|D}}

import java.util.*;

 

}

}

 

{{out}}

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30 </pre>

 

=={{header|Julia}}==

using Dates

lineprintcalendar(1969)

 

=={{header|Kotlin}}==

{{trans|D}}

import java.text.DateFormatSymbols

import java.text.MessageFormat

fun main(args: Array<String>) {

System.out.printCalendar(1969, 3, Locale.US)

{{out}}

See D output.

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

rem Adapted from LB examples included with software

[start]

monthname$=word$("January February March April May June July August September October November December",month)

end function

 

{{out}}

 

</pre>

=={{header|Lingo}}==

-- @desc Class "Calendar"

-- @file parent script "Calendar"

on _write (me, str, x, y)

put str into char x to x+str.length-1 of line y of _calStr

 

Usage:

calStr = calObj.make(1969)

 

{{out}}

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Lua}}==

local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",

"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}

end

 

{{out}}

<pre>

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|M2000 Interpreter}}==

Set console to 80 character by 43 lines. Produce calendar line by line, three columns of months.

Module Calendar get the Year and the Language Id (1033 for English, 1032 for Greek and any other which support the Window OS).

 

Module Calendar (Year, LocaleId) {

Function GetMax(Year, Month) {

For i=1 to 3 {

Month=i+j*3

}

Print

k=Key$ ' wait key

Calendar 2018, 1032 ' Greek

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Nim}}==

{{trans|D}}

import strformat

 

echo ""

 

{{out}}

<pre>

 

</pre>

=={{header|OCaml}}==

 

 

let lang = "en" (* language: English *)

| _ ->

 

{{out}}

</pre>

=={{header|Perl}}==

 

use warnings;

use Time::Local;

 

 

 

 

=={{header|Phix}}==

Gregorian calender only.

function centre(string s, integer width)

end function

for d=1 to lastday do

line[p..p+1] = sprintf("%2d",d)

return res

end function

printf(1,centre("[Spot Reserved For Snoopy]",width)&"\n")

printf(1,centre(sprintf("%d",year),width)&"\n")

for month=1 to 12 do

end for

for month=1 to 12 by wide do

for k=1 to 9 do -- (more than enough)

integer any = 0

for j=0 to wide-1 do

if length(line) then

end for

end procedure

printf(1,join(repeat("1234567890",8),"")&"\n")

{{out}}

[Spot Reserved For Snoopy]

1969

January February March

April May June

July August September

October November December

12345678901234567890123456789012345678901234567890123456789012345678901234567890

[Spot Reserved For Snoopy]

</pre>

 

=={{header|PicoLisp}}==

This "calendar" is nicely formatted, and fits into 20 columns ;-)

(prinl "====== " Year " ======")

(for Dat (range (date Year 1 1) (date Year 12 31))

(pack "Week " (week Dat)) ) ) ) ) )

 

Output:

<pre>====== 1969 ======

30 Tue

31 Wed</pre>

=={{header|Pike}}==

 

this script also highlights holidays by region. regions may be chosen by 2-letter country name, as well as some special 'regions': christianity, orthodox, bahai, islamic, among others.

 

 

int main(int argc, array(string) argv)

return dayname;

}

Output: (holidays lost in copy-paste)

<pre>

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

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

calendar: procedure (year) options (main);

declare year character (4) varying;

 

end calendar;

Output:

<pre>

28 29 30 31 25 26 27 28 25 26 27 28 29 30 31

</pre>

=={{header|PowerShell}}==

Param([int]$Year = 1969)

Begin {

}

}

=={{header|Prolog}}==

Call the write_calendar(Year) predicate to print a calendar for a year.

Works with swi-prolog and requires the day_of_the_week library call.

 

% to write out the static parts in place and insert the generated parts into that format.

write_calendar(Year) :-

is_leap_year(Year) :-

0 is Year mod 100 -> 0 is Year mod 400

=={{header|Python}}==

The Python [https://docs.python.org/3/library/calendar.html calendar].prcal function prints calendars with the following formatting options: optional parameters w, l, and c are for date column width, lines per week, and number of spaces between month columns, respectively.

 

>>> help(calendar.prcal)

Help on method pryear in module calendar:

13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21

20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28

 

=={{header|Racket}}==

(require racket/date net/base64 file/gunzip)

(define (calendar yr)

(λ(s) (equal? "" s)))))

 

 

{{out}}

26 27 28 29 30 31 23 24 25 26 27 28 29 28 29 30 31

30</pre>

=={{header|Raku}}==

(formerly Perl 6)

 

say fmt-year($year);

 

sub fmt-year ($year) {

}

}

sub fmt-month ($year, $month) {

=={{header|Rebol}}==

do [if "" = y: ask "Year (ENTER for current):^/^/" [prin y: now/year]

foreach m system/locale/months [

]

] ask "^/^/Press [ENTER] to Continue..."]

 

=={{header|REXX}}==

<br>specified. &nbsp; The choice could've been performed programmatically, but I never believe that a program

<br>could best choose over what the user wants, as it depends on esthetics and looks (fashion).

 

@abc='abcdefghijklmnopqrstuvwxyz'; @abcU=@abc; upper @abcU

put:_=arg(1);_=translate(_,,'_'chk);if \grid then _=ungrid(_);if lowerCase then _=lower(_);if upperCase then upper _;if shortest&_=' ' then return;call tell _;return

tell:say arg(1);return

'''output''' when using the input of: <tt> 1/1/1969 (noGrid smallest narrowest) </tt>

<pre>

Output when using the input of: <tt> 1/1/1969 (smallest narrowest width 156 calSpaces 5) </tt>

<br>A width of 156 was used to illustrate showing a grid, otherwise it would fit in 132 columns.

┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐

│ January 1969 │ │ February 1969 │ │ March 1969 │ │ April 1969 │ │ May 1969 │ │ June 1969 │

| |

</pre>

=={{header|Ring}}==

# Project : Calendar

 

next

next

Output image:

 

[https://www.dropbox.com/s/sj37yypiq45o5cd/CalmoSoftCalendar.jpg?dl=0 Calendar]

 

=={{header|Ruby}}==

<code>Date</code> class, from the standard library, knows how many days in a month, and which day is Sunday, for both Julian and Gregorian calendars. This program uses <code>Date</code> class, plus its own assumptions, to create the calendar. This program assumes that every year has 12 months and starts with January 1, and every month fits in 6 weeks starting with Sunday.

 

 

# Creates a calendar of _year_. Returns this calendar as a multi-line

80; end; end; end

 

 

Here is 1969 in 132 columns.

 

=={{header|Rust}}==

// Command line:

// >>$ calendar 2019 150

}

}

=={{header|Scala}}==

{{libheader|Scala}}

=== Scala Version 1 ===

 

import language.postfixOps

import collection.mutable.ListBuffer

printCalendar(getGregCal(1969), List("[Snoopy Picture]", "1969"))

printCalendar(getGregCal(1582), List("[Snoopy Picture]", "1582"), printerWidth = 132)

 

{{out}}

{{works with|Scala|2.10.1}}

 

* Loosely based on the Ruby implementation.

*

}

 

 

* This provides extra classes needed for the main

* algorithm.

}

 

 

Sample output for 1792:

31

</pre>

=={{header|Seed7}}==

include "time.s7i";

 

begin

printCalendar(1969, 3);

 

Original source: [http://seed7.sourceforge.net/algorith/date.htm#calendar]

</pre>

=={{header|Sidef}}==

 

define months_per_col = 3

}

 

{{out}}

<pre>

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Simula}}==

{{trans|C}}

The subtleties of the post-increment logic which is used in the c program took me some time to detect.

For symmetry I also implemented the pre-increment.

INTEGER WIDTH, YEAR;

INTEGER COLS, LEAD, GAP;

PRINT_YEAR;

END;

{{out}}

<pre>

 

</pre>

=={{header|Smalltalk}}==

 

This implementation has been developed using '''Cuis Smalltalk''' [https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev] with '''Aconcagua''' loaded.

"Instance Variables:

- yearToPrint: The year to print the calendar of

"Returns the number of character per month"

^20

{{out}}

<pre>

30

</pre>

=={{header|SPL}}==

#.output(#.str(year,">68<"))

> row, 0..3

<

<= lines

{{out}}

<pre>

</pre>

 

=={{header|Tcl}}==

Due to the prevalence of 80 column devices instead of 132 column ones, this code produces 3 months at a time instead of 4.

 

# Produce information about the days in a month, without any assumptions about

 

snoopy

Which produces this output:

<pre>

</pre>

If a different year is chosen, it's printed…

<pre>

[Snoopy Picture]

</pre>

The code also handles Julian/Gregorian switch dates correctly, but ''must'' be told what locale to format the switch as and for what timezone in that case. For example, Spain was one of the first countries to make the change:

<pre>

[Snoopy Picture]

</pre>

As can be seen, a Real Programmer has many intricacies to deal with!

=={{header|uBasic/4tH}}==

The required "Snoopy" code is here. Use it when you feel like it.

Print " X XX"

Print " X *** X XXXXX"

Print " =====********** * X ) \\ )"

Print " ====* * X \\ \\ )XXXXX"

This is the code that generates the calendar:

 

Push 63 : Gosub _Space ' center year

010 Print " October "; : Return

011 Print " November"; : Return

Output (missing Snoopy):

<pre>Year to print: 1969

 

0 OK, 0:2753</pre>

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

All Unix variations come with the cal command which makes the task very easy.

#!/bin/sh

echo "Snoopy goes here"

cal 1969

 

Output produced:

30

</pre>

 

=={{header|Vedit macro language}}==

This implementation uses the '''calendar.vdm''' macro that comes with Vedit. (So it serves as an example of how to call other macros from a macro.)

Calendar.vdm draws one month calendar. That is then copied as columnar block and pasted to the 1969 calendar.

 

Config_Tab(5,30,55)

#9 = 1 // first day of week: 0=Su, 1=Mo

EOF

Ins_Newline(2)

 

The code above creates calendar for 80x43 display. For 132 column display, change #3 (number of months per line) to 4 or 6, and adjust the tab positions if required.

The following would work with all widhts, but the left/right margin would not be balanced.

 

Output:

27 28 29 30 31 24 25 26 27 28 29 30 29 30 31

</pre>

=={{header|Visual Basic .NET}}==

'''Compiler:''' Roslyn Visual Basic (language version >= 15.8)

 

Options and imports statements (all parts must be in one file):

Option Explicit On

Option Infer On

Imports System.Text

Imports System.Runtime.InteropServices

 

Helper to parse command-line arguments.

ReadOnly _ArgDict As New Dictionary(Of String, String)()

 

End If

End Sub

 

Program:

Sub Main(args As String())

Dim dt As Date

End Function

End Module

 

====Command-line arguments:====

</pre>

 

=={{header|XLISP}}==

Targets the 132-column imaginary line printer. The day of the week on 1 January of a given year is found using Gauss's algorithm; <tt>LEAP-YEARP</tt> is taken from the Rosetta Code task on leap years.

(define months-list '(("JANUARY" 31) ("FEBRUARY" 28) ("MARCH" 31) ("APRIL" 30) ("MAY" 31) ("JUNE" 30) ("JULY" 31) ("AUGUST" 31) ("SEPTEMBER" 30) ("OCTOBER" 31) ("NOVEMBER" 30) ("DECEMBER" 31)))

(define days #(" Sunday " "Monday " "Tuesday " "Wednesday " "Thursday " "Friday " "Saturday"))

(print-calendar months-list (gauss-algorithm year)))

 

{{out}}

<pre> ******** SNOOPY CALENDAR 1969 ********

21 22 23 24 25 26 27

28 29 30 31 </pre>

=={{header|XPL0}}==

 

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

];

 

 

{{out}}

30

</pre>

=={{header|Yabasic}}==

{{trans|Lua}}

clear screen

 

 

print_cal(2018)

=={{header|zkl}}==

Gregorian calender only. Hard coded to a fit on a 80x43 terminal (somewhat half assed).

 

fcn center(text,m) { String(" "*((m-text.len())/2),text) }

 

if(vm.numArgs){ y:=vm.nthArg(0).toInt(); oneYear(y,"").println(); }

oneMonth produces a list of strings that make up a one month calender. Each day is three characters, the first line is padded with blanks to line it up with the 1st day of the week. The entire month is one long list of "days" that is then chunked into a list of weeks (one line per week). oneYear takes 3 months and builds the page line by line.

{{out}}