Calendar: Difference between revisions

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

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:

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

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

 

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

 

 

=={{header|AutoIt}}==

#include <Date.au3>

 

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

EndFunc ;==>_PrintLine

Output

<pre>

 

=={{header|AWK}}==

 

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

 

Output:

<pre>

=={{header|BaCon}}==

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>

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

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>

Written by Kyuvi.<br>

 

 

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

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

(println)

 

 

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>

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

 

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

 

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

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

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

'Print : Print "hit any key to end program

Sleep

{{out}}

<pre> 1969

=={{header|FutureBasic}}==

Legacy version:

 

Str255 a

close 1

 

 

Modern version:

 

local fn RunCommand( command as CFStringRef ) as CFStringRef

NSLog( @"%@", fn RunCommand( @"cal 1969" ) )

 

 

Output of either version:

 

=={{header|Gambas}}==

 

Shell "cal 1969"

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println()

}

Output:

<pre> [SNOOPY]

 

=={{header|Haskell}}==

import Data.Time

import Data.Time.Calendar

calcol' = calColFromCol columns

 

<pre>*Main> printCalendar 1969 80

[Maybe Snoopy]

 

=={{header|Huginn}}==

import Algorithms as algo;

import Text as text;

cols

);

 

Output: <pre> 1969

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

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

 

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

 

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

 

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

 

=={{header|Lua}}==

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

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

end

 

{{out}}

<pre>

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>

=={{header|OCaml}}==

 

 

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

| _ ->

 

{{out}}

 

=={{header|Perl}}==

 

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

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

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

{{out}}

<pre>

=={{header|Phix}}==

Gregorian calender only.

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

<span style="color: #008080;">constant</span> <span style="color: #000000;">year</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1969</span>

<span style="color: #000000;">print_calendar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">year</span><span style="color: #0000FF;">,</span><span style="color: #000000;">132</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1234567890"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">13</span><span style="color: #0000FF;">),</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)&</span><span style="color: #008000;">"12\n"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

{{trans|Lua}}

 

32 var space

enddef

 

{{out}}

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

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>

 

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

calendar: procedure (year) options (main);

declare year character (4) varying;

 

end calendar;

Output:

<pre>

 

=={{header|PowerShell}}==

Param([int]$Year = 1969)

Begin {

}

}

 

=={{header|Prolog}}==

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

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

 

=={{header|Ring}}==

# Project : Calendar

 

next

next

Output image:

 

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

 

[[Category:Scala examples needing attention]]

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:

 

=={{header|Seed7}}==

include "time.s7i";

 

begin

printCalendar(1969, 3);

 

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

=={{header|Sidef}}==

{{trans|Raku}}

 

define months_per_col = 3

}

 

{{out}}

<pre>

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>

 

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>

 

=={{header|SPL}}==

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

> row, 0..3

<

<= lines

{{out}}

<pre>

 

=={{header|Swift}}==

 

let monthWidth = 20

}

 

 

{{out}}

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

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

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

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:

 

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

VBScript has a good set of time-date functions and can easily get the names of weekdays and months from the OS. The program sends its output line by line to stdout so it can be redirected to a file or to a printer. By default the code will print the calendar in the locale set in your Windows, you can select another one if required. It should be called from cscript.

 

'call it with year, number of months per row (1,2,3,4,6) and locale ("" for default)

docal 1969,6,""

print string(ncols,"=")

end sub

output

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-seq}}

import "/fmt" for Fmt

import "/seq" for Lst

}

 

 

{{out}}

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

 

=={{header|XPL0}}==

 

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

];

 

 

{{out}}

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