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

{{trans|Common Lisp}}Java interop version.<br>

Written by Kyuvi.<br>

 

 

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

 

(defn month-to-word

[month]

((vec (.getMonths (new java.text.DateFormatSymbols))) month))

(defn normal-date-string

[date]

(map #(join " " %)

(defn oct-1582-string

[date]

(map #(join " " %)

 

(defn center-string

[string width]

(let [pad (- width (count string))

 

(defn calc-columns

[characters margin-size]

(loop [cols 0 excess characters ]

 

(defn month-vector

[date]

(vec (concat

 

(defn year-vector [date]

(loop [m [] c (month date)]

(if (= c 11 )

 

(defn print-months

[ v ncols margin]

(doseq [r (range (Math/ceil (/ 12 ncols)))]

(defn print-cal

"(print-cal [year [width [margin]]])

([]

(print-cal 1969 80 2))

(print-cal year width 2))

([year width margin]

(let [date (new java.util.GregorianCalendar year 0 1)

column-count (calc-columns width margin)

(println (center-string (str year) total-size))

(println)

 

 

 

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

{{libheader| System.DateUtils}}

{{Trans|D}}

program Calendar;

 

printCalendar(1969, 4);

readln;

{{out}}

<pre> [Snoopy Picture]

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

30</pre>

 

=={{header|F Sharp|F#}}==

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

* Given a width, return a function that takes a string, and

* pads it at both ends to the given width

 

cal(1969, 'en-US', 3);

{{out}}

<pre>

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

k=Key$ ' wait key

Calendar 2018, 1032 ' Greek

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

 

Therefore, I've chosen to implement "raw" textual grids from scratch with a function called DataGrid. There are two versions of DataGrid. The first version allows you to specify exactly the height and width of each row and column in terms of number of string characters. The second version allows you to specify just the "macro" grid dimensions, and the actual size of each cell will be determined by calculating the width among cells in the same column and max height among cells in the same row. With those max values, it calls the first GridData function. The cell dimensions do not account for spacing and borders, which are added after the cell is scaled to the correct character dimensions. A variety of decoration options can also be supplied. The effect of these will be demonstrated in the examples below. Each version acts on a list of cells that are already rectangular arrays of data (though their dimensions obviously don't already need to be identical--that's part of the job of DataGrid, and it's why DataGrid can be composed/nested). Also, the list of cells is "flat", and its length does not need to conform to an exact rectangle (again, this is a job of DataGrid).

 

rowHeights:{__Integer},

colWidths:{__Integer},

 

(*While the grid functions make no assumptions about the format of the data, we will be using them with string/character data, and we will eventually want to output a calendar as a single large string. AsString gives us a standard method for transforming a matrix of characters into a string with rows delimited by newlines.*)

 

To illustrate how DataGrid works, I'll create some sample data-grids and assemble them together into a larger data-grid, and then I'll use DataGrid itself to present all of these results. Notice the options for alignment, borders, spacings, etc.

 

GridA = DataGrid[{2},{5},{0,0},{{1,1},{1,1}},<|"border"->"*","alignment"->{1,-1}|>,{DataA}];

DataB = {{"B"},{"B"}};

DataGrid[{2,3},{2,3},{{0,1},{2,3}},<|"border"->"@","alignment"->{0,0},"dividers"->{"/","/","/"}|>,{GridA,GridB,GridA,GridB,GridA}];

 

 

{{out}}

HeaderGrid is a helper that defers the "gridding" of the individual header cells and data cells to functions that get passed in. There are some assumptions about presentation that feed into this design, but if your requirements differ, it's fairly easy to follow this same basic pattern of accepting functions that do the lower level work--you would just need to organize that work differently.

 

finalSpacings:{_Integer,_Integer},

finalBorderWidths:{{_Integer,_Integer},{_Integer,_Integer}},

{"Su","Mo","Tu","We","Th","Fr","Sa"},

DataGrid[{3},{4},{0,0},{{0,0},{0,0}},<|"alignment"->{-1,1}|>,#]&,

 

{{out}}

MonthGrid will use HeadedGrid for the main part of the month, and it will take another gridding function to handle the title (month name). I could have simplified the method signature by having the caller pass in a HeadedGrid function directly, but I liked exposing more control with this function. MonthGrid offers the convenience of specifying a leading offset for the month (month and week boundaries don't typically align, so this allows for starting on the correct day of the week without requiring the caller to munge the data).

 

finalSpacings:{_Integer,_Integer},

finalBorderWidths:{{_Integer,_Integer},{_Integer,_Integer}},

{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"},

DataGrid[{1}, {2}, {0, 0}, {{0, 0}, {0, 0}}, <|"alignment" -> {-1, 1}|>, #] &,

 

{{out}}

FractalChars takes a string and rasterizes each character and then replaces each black pixel with the original character. The output is a matrix of characters suitable as a datum in the argument to DataGrid.

 

ReplaceAll[ImageData[ImageCrop[Binarize[Rasterize[Style[char,FontFamily->font],RasterSize->rasterSize]]]],{1->" ",0->char}];

FractalChars[rasterSize_,font_,word_String]:=FractalChars[rasterSize,font,#]&/@Characters[word];

 

(*An example banner.*)

 

{{out}}

Fortunately, Mathematica has many powerful calendar-related functions. Unfortunately, the semantics of calendars is sufficiently complicated that there is no practical way to create just a few standard data generators that will cover all of the implied cases. For example, the seemingly simple concept of "first day of the year" is ambiguous. The Jewish year uses one start day for religious holidays and another day for civil/secular purposes. The task definition referenced the switch-over from the Julian calendar to the Gregorian calendar, but this did not happen simultaneously around the globe, and many regions adopted the Gregorian calendar surprisingly recently. Assigning a number to a year is not standardized across calendars (e.g. consider the Chinese and Jewish calendars). The Cotsworth Calendar (effectively the International Fixed Calendar) has days that aren't assigned to any month or week--they're just dangling special days. So, we can provide some simple, general helper functions, but we assume that the calendar maker will be responsible for dealing with special cases.

 

MonthNames[]:=MonthNames["Gregorian"];

MonthNames[calType_]:=Lookup[CalendarData[calType,"PropertyAssociation"],"MonthNames"];

 

(*Since month boundaries don't align with week boundaries on most calendars, we need to pad month data with empty cells. I was tempted to create a function that would generate offsets for a given year on a given calendar, but even that required too many decisions on the part of the calendar maker to be feasible. So, I removed all of the calendar semantics. If you provide the fixed small group length (week length), the initial offset, and the list of the large group lengths (month lengths), this function will give you the offsets you need for each large group (month).*)

 

For the year 1969 on the Gregorian calendar, Mathematica can give us all of the data we need.

 

InitialOffset1969=QuantityMagnitude[DateDifference[PreviousDate[DateObject[{1969,1,1}],Sunday],DateObject[{1969,1,1}]]];

MonthLengths1969=Length/@Values[Data1969];

MonthsGrid1969=DataGrid[{3,4},{1,4},{{0,0},{0,0}},<||>,MonthGrids1969];

 

 

{{out}}

It's a bit more involved to create the data for a calendar that displays the switch from Julian to Gregorian. A few major European Catholic countries made the switch in 1582, so I'll generate data for that scenario. The switch happened in October, with Thursday Oct 4 being followed by Friday Oct 15. Mathematica provides tools to both fetch the calendar data and then fiddle with the structures so that I can highlight the relevant month and dates.

 

Join[

DateRange[DateObject[{1582,1,1},CalendarType->"Julian"],DateObject[{1582,10,4},CalendarType->"Julian"],CalendarType->"Julian"],

{monthNameGridder[{{Characters[MonthNames1582France[[10]]]}}],

DataGrid[{1+Ceiling[Length@octoberCells/7],7},{0,1},{{0,0},{0,0}},<|"alignment"->{0,0}|>,octoberCells]}]},

 

{{out}}

WidestFitDimensions will output data about the best fit it found, including the dimensions (which could be used in DataGrid) and the width of the best fit grid. There is no guarantee that a strict fit can be found, so it also provides the actual width of the best fit, and the user can determine what to do with the results. One could create another helper gridding function that uses WidestFitDimensions to automatically generate the grid, but I've already demonstrated such helper functions, so I'll just focus on computing the grid dimensions here.

 

targetWidth_Integer,

columnSpacings_Integer,

{widths},isTooLarge[#]&,1,-1+Length@widths]},

<|"dimensions"->Dimensions@bestFitGrid,"width"->fullWidthOfGrid@bestFitGrid|>]]]];

 

Checking best fit for our 1969 calendar for a few widths.

{{out}}

<pre><|dimensions->{4,3},width->68|></pre>

{{out}}

<pre><|dimensions->{3,5},width->116|></pre>

{{out}}

<pre><|dimensions->{12,1},width->20|></pre>

=={{header|Nim}}==

{{trans|D}}

import strformat

 

echo ""

 

{{out}}

<pre>

 

</pre>

=={{header|OCaml}}==

 

 

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

| _ ->

 

{{out}}

</pre>

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Calendar

my ($string, $w) = @_;

sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);

{{out}}

<pre>

31 30

</pre>

=={{header|Phix}}==

Gregorian calender only.

{{out}}

[Spot Reserved For Snoopy]

1969

=={{header|Phixmonti}}==

{{trans|Lua}}

 

32 var space

enddef

 

{{out}}

<pre>

 

=== Press any key to exit ===</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)

my @weekday-names = <Mo Tu We Th Fr Sa Su>;

my @month-names = <Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec>;

((' ' xx $date.day-of-week - 1), (1..$date.days-in-month)».fmt('%2d')).flat.rotor(7, :partial).join("\n") ~

(' ' if $_ < 7) ~ (' ' xx 7-$_).join(' ') given Date.new($year, $month, $date.days-in-month).day-of-week;

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

| |

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

{{trans|Raku}}

 

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

 

let monthWidth = 20

}

 

 

{{out}}

30

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

{{libheader|Wren-date}}

{{libheader|Wren-fmt}}

{{libheader|Wren-seq}}

 

var calendar = Fn.new { |year|

}

 

 

{{out}}

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