Instruction stringlengths 45 106 | input_code stringlengths 1 13.7k | output_code stringlengths 1 13.7k |
|---|---|---|
Translate the given Clojure code snippet into Java without altering its behavior. | (require '[clojure.string :only [join] :refer [join]])
(def day-row "Su Mo Tu We Th Fr Sa")
(def col-width (count day-row))
(defn month-to-word
"Translate a month from 0 to 11 into its word representation."
[month]
((vec (.getMonths (new java.text.DateFormatSymbols))) month))
(defn month [date]
(.get date (java.util.Calendar/MONTH)))
(defn total-days-in-month [date]
(.getActualMaximum date (java.util.Calendar/DAY_OF_MONTH)))
(defn first-weekday [date]
(.get date (java.util.Calendar/DAY_OF_WEEK)))
(defn normal-date-string
"Returns a formatted list of strings of the days of the month."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(range 1 (inc (total-days-in-month date))))
(repeat (- 42 (total-days-in-month date)
(dec (first-weekday date)) ) " ")))))
(defn oct-1582-string
"Returns a formatted list of strings of the days of the month of October 1582."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(concat (range 1 5)
(range 15 (inc (total-days-in-month date)))))
(repeat (- 42
(count (concat (range 1 5)
(range 15
(inc (total-days-in-month date)))))
(dec (first-weekday date)) ) " ")))))
(defn center-string
"Returns a string that is WIDTH long with STRING centered in it."
[string width]
(let [pad (- width (count string))
lpad (quot pad 2)
rpad (- pad (quot pad 2))]
(if (<= pad 0)
string
(str (apply str (repeat lpad " "))
string
(apply str (repeat rpad " "))))))
(defn calc-columns
"Calculates the number of columns given the width in CHARACTERS and the
MARGIN SIZE."
[characters margin-size]
(loop [cols 0 excess characters ]
(if (>= excess col-width)
(recur (inc cols) (- excess (+ margin-size col-width)))
cols)))
(defn month-vector
"Returns a vector with the month name, day-row and days
formatted for printing."
[date]
(vec (concat
(vector (center-string (month-to-word (month date)) col-width))
(vector day-row)
(if (and (= 1582 (.get date (java.util.Calendar/YEAR)))
(= 9 (month date)))
(oct-1582-string date)
(normal-date-string date)))))
(defn year-vector [date]
"Returns a 2d vector of all the months in the year of DATE."
(loop [m [] c (month date)]
(if (= c 11 )
(conj m (month-vector date))
(recur (conj m (month-vector date))
(do (.add date (java.util.Calendar/MONTH ) 1)
(month date))))))
(defn print-months
"Prints the months to standard output with NCOLS and MARGIN."
[ v ncols margin]
(doseq [r (range (Math/ceil (/ 12 ncols)))]
(do (doseq [i (range 8)]
(do (doseq [c (range (* r ncols) (* (+ r 1) ncols))
:while (< c 12)]
(printf (str (apply str (repeat margin " ")) "%s")
(get-in v [c i])))
(println)))
(println))))
(defn print-cal
"(print-cal [year [width [margin]]])
Prints out the calendar for a given YEAR with WIDTH characters wide and
with MARGIN spaces between months."
([]
(print-cal 1969 80 2))
([year]
(print-cal year 80 2))
([year width]
(print-cal year width 2))
([year width margin]
(assert (>= width (count day-row)) "Width should be more than 20.")
(assert (> margin 0) "Margin needs to be more than 0.")
(let [date (new java.util.GregorianCalendar year 0 1)
column-count (calc-columns width margin)
total-size (+ (* column-count (count day-row))
(* (dec column-count) margin))]
(println (center-string "[Snoopy Picture]" total-size))
(println (center-string (str year) total-size))
(println)
(print-months (year-vector date) column-count margin))))
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Convert this Clojure snippet to Python and keep its semantics consistent. | (require '[clojure.string :only [join] :refer [join]])
(def day-row "Su Mo Tu We Th Fr Sa")
(def col-width (count day-row))
(defn month-to-word
"Translate a month from 0 to 11 into its word representation."
[month]
((vec (.getMonths (new java.text.DateFormatSymbols))) month))
(defn month [date]
(.get date (java.util.Calendar/MONTH)))
(defn total-days-in-month [date]
(.getActualMaximum date (java.util.Calendar/DAY_OF_MONTH)))
(defn first-weekday [date]
(.get date (java.util.Calendar/DAY_OF_WEEK)))
(defn normal-date-string
"Returns a formatted list of strings of the days of the month."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(range 1 (inc (total-days-in-month date))))
(repeat (- 42 (total-days-in-month date)
(dec (first-weekday date)) ) " ")))))
(defn oct-1582-string
"Returns a formatted list of strings of the days of the month of October 1582."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(concat (range 1 5)
(range 15 (inc (total-days-in-month date)))))
(repeat (- 42
(count (concat (range 1 5)
(range 15
(inc (total-days-in-month date)))))
(dec (first-weekday date)) ) " ")))))
(defn center-string
"Returns a string that is WIDTH long with STRING centered in it."
[string width]
(let [pad (- width (count string))
lpad (quot pad 2)
rpad (- pad (quot pad 2))]
(if (<= pad 0)
string
(str (apply str (repeat lpad " "))
string
(apply str (repeat rpad " "))))))
(defn calc-columns
"Calculates the number of columns given the width in CHARACTERS and the
MARGIN SIZE."
[characters margin-size]
(loop [cols 0 excess characters ]
(if (>= excess col-width)
(recur (inc cols) (- excess (+ margin-size col-width)))
cols)))
(defn month-vector
"Returns a vector with the month name, day-row and days
formatted for printing."
[date]
(vec (concat
(vector (center-string (month-to-word (month date)) col-width))
(vector day-row)
(if (and (= 1582 (.get date (java.util.Calendar/YEAR)))
(= 9 (month date)))
(oct-1582-string date)
(normal-date-string date)))))
(defn year-vector [date]
"Returns a 2d vector of all the months in the year of DATE."
(loop [m [] c (month date)]
(if (= c 11 )
(conj m (month-vector date))
(recur (conj m (month-vector date))
(do (.add date (java.util.Calendar/MONTH ) 1)
(month date))))))
(defn print-months
"Prints the months to standard output with NCOLS and MARGIN."
[ v ncols margin]
(doseq [r (range (Math/ceil (/ 12 ncols)))]
(do (doseq [i (range 8)]
(do (doseq [c (range (* r ncols) (* (+ r 1) ncols))
:while (< c 12)]
(printf (str (apply str (repeat margin " ")) "%s")
(get-in v [c i])))
(println)))
(println))))
(defn print-cal
"(print-cal [year [width [margin]]])
Prints out the calendar for a given YEAR with WIDTH characters wide and
with MARGIN spaces between months."
([]
(print-cal 1969 80 2))
([year]
(print-cal year 80 2))
([year width]
(print-cal year width 2))
([year width margin]
(assert (>= width (count day-row)) "Width should be more than 20.")
(assert (> margin 0) "Margin needs to be more than 0.")
(let [date (new java.util.GregorianCalendar year 0 1)
column-count (calc-columns width margin)
total-size (+ (* column-count (count day-row))
(* (dec column-count) margin))]
(println (center-string "[Snoopy Picture]" total-size))
(println (center-string (str year) total-size))
(println)
(print-months (year-vector date) column-count margin))))
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Maintain the same structure and functionality when rewriting this code in VB. | (require '[clojure.string :only [join] :refer [join]])
(def day-row "Su Mo Tu We Th Fr Sa")
(def col-width (count day-row))
(defn month-to-word
"Translate a month from 0 to 11 into its word representation."
[month]
((vec (.getMonths (new java.text.DateFormatSymbols))) month))
(defn month [date]
(.get date (java.util.Calendar/MONTH)))
(defn total-days-in-month [date]
(.getActualMaximum date (java.util.Calendar/DAY_OF_MONTH)))
(defn first-weekday [date]
(.get date (java.util.Calendar/DAY_OF_WEEK)))
(defn normal-date-string
"Returns a formatted list of strings of the days of the month."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(range 1 (inc (total-days-in-month date))))
(repeat (- 42 (total-days-in-month date)
(dec (first-weekday date)) ) " ")))))
(defn oct-1582-string
"Returns a formatted list of strings of the days of the month of October 1582."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(concat (range 1 5)
(range 15 (inc (total-days-in-month date)))))
(repeat (- 42
(count (concat (range 1 5)
(range 15
(inc (total-days-in-month date)))))
(dec (first-weekday date)) ) " ")))))
(defn center-string
"Returns a string that is WIDTH long with STRING centered in it."
[string width]
(let [pad (- width (count string))
lpad (quot pad 2)
rpad (- pad (quot pad 2))]
(if (<= pad 0)
string
(str (apply str (repeat lpad " "))
string
(apply str (repeat rpad " "))))))
(defn calc-columns
"Calculates the number of columns given the width in CHARACTERS and the
MARGIN SIZE."
[characters margin-size]
(loop [cols 0 excess characters ]
(if (>= excess col-width)
(recur (inc cols) (- excess (+ margin-size col-width)))
cols)))
(defn month-vector
"Returns a vector with the month name, day-row and days
formatted for printing."
[date]
(vec (concat
(vector (center-string (month-to-word (month date)) col-width))
(vector day-row)
(if (and (= 1582 (.get date (java.util.Calendar/YEAR)))
(= 9 (month date)))
(oct-1582-string date)
(normal-date-string date)))))
(defn year-vector [date]
"Returns a 2d vector of all the months in the year of DATE."
(loop [m [] c (month date)]
(if (= c 11 )
(conj m (month-vector date))
(recur (conj m (month-vector date))
(do (.add date (java.util.Calendar/MONTH ) 1)
(month date))))))
(defn print-months
"Prints the months to standard output with NCOLS and MARGIN."
[ v ncols margin]
(doseq [r (range (Math/ceil (/ 12 ncols)))]
(do (doseq [i (range 8)]
(do (doseq [c (range (* r ncols) (* (+ r 1) ncols))
:while (< c 12)]
(printf (str (apply str (repeat margin " ")) "%s")
(get-in v [c i])))
(println)))
(println))))
(defn print-cal
"(print-cal [year [width [margin]]])
Prints out the calendar for a given YEAR with WIDTH characters wide and
with MARGIN spaces between months."
([]
(print-cal 1969 80 2))
([year]
(print-cal year 80 2))
([year width]
(print-cal year width 2))
([year width margin]
(assert (>= width (count day-row)) "Width should be more than 20.")
(assert (> margin 0) "Margin needs to be more than 0.")
(let [date (new java.util.GregorianCalendar year 0 1)
column-count (calc-columns width margin)
total-size (+ (* column-count (count day-row))
(* (dec column-count) margin))]
(println (center-string "[Snoopy Picture]" total-size))
(println (center-string (str year) total-size))
(println)
(print-months (year-vector date) column-count margin))))
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Can you help me rewrite this code in Go instead of Clojure, keeping it the same logically? | (require '[clojure.string :only [join] :refer [join]])
(def day-row "Su Mo Tu We Th Fr Sa")
(def col-width (count day-row))
(defn month-to-word
"Translate a month from 0 to 11 into its word representation."
[month]
((vec (.getMonths (new java.text.DateFormatSymbols))) month))
(defn month [date]
(.get date (java.util.Calendar/MONTH)))
(defn total-days-in-month [date]
(.getActualMaximum date (java.util.Calendar/DAY_OF_MONTH)))
(defn first-weekday [date]
(.get date (java.util.Calendar/DAY_OF_WEEK)))
(defn normal-date-string
"Returns a formatted list of strings of the days of the month."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(range 1 (inc (total-days-in-month date))))
(repeat (- 42 (total-days-in-month date)
(dec (first-weekday date)) ) " ")))))
(defn oct-1582-string
"Returns a formatted list of strings of the days of the month of October 1582."
[date]
(map #(join " " %)
(partition 7
(concat
(repeat (dec (first-weekday date)) " ")
(map #(format "%2s" %)
(concat (range 1 5)
(range 15 (inc (total-days-in-month date)))))
(repeat (- 42
(count (concat (range 1 5)
(range 15
(inc (total-days-in-month date)))))
(dec (first-weekday date)) ) " ")))))
(defn center-string
"Returns a string that is WIDTH long with STRING centered in it."
[string width]
(let [pad (- width (count string))
lpad (quot pad 2)
rpad (- pad (quot pad 2))]
(if (<= pad 0)
string
(str (apply str (repeat lpad " "))
string
(apply str (repeat rpad " "))))))
(defn calc-columns
"Calculates the number of columns given the width in CHARACTERS and the
MARGIN SIZE."
[characters margin-size]
(loop [cols 0 excess characters ]
(if (>= excess col-width)
(recur (inc cols) (- excess (+ margin-size col-width)))
cols)))
(defn month-vector
"Returns a vector with the month name, day-row and days
formatted for printing."
[date]
(vec (concat
(vector (center-string (month-to-word (month date)) col-width))
(vector day-row)
(if (and (= 1582 (.get date (java.util.Calendar/YEAR)))
(= 9 (month date)))
(oct-1582-string date)
(normal-date-string date)))))
(defn year-vector [date]
"Returns a 2d vector of all the months in the year of DATE."
(loop [m [] c (month date)]
(if (= c 11 )
(conj m (month-vector date))
(recur (conj m (month-vector date))
(do (.add date (java.util.Calendar/MONTH ) 1)
(month date))))))
(defn print-months
"Prints the months to standard output with NCOLS and MARGIN."
[ v ncols margin]
(doseq [r (range (Math/ceil (/ 12 ncols)))]
(do (doseq [i (range 8)]
(do (doseq [c (range (* r ncols) (* (+ r 1) ncols))
:while (< c 12)]
(printf (str (apply str (repeat margin " ")) "%s")
(get-in v [c i])))
(println)))
(println))))
(defn print-cal
"(print-cal [year [width [margin]]])
Prints out the calendar for a given YEAR with WIDTH characters wide and
with MARGIN spaces between months."
([]
(print-cal 1969 80 2))
([year]
(print-cal year 80 2))
([year width]
(print-cal year width 2))
([year width margin]
(assert (>= width (count day-row)) "Width should be more than 20.")
(assert (> margin 0) "Margin needs to be more than 0.")
(let [date (new java.util.GregorianCalendar year 0 1)
column-count (calc-columns width margin)
total-size (+ (* column-count (count day-row))
(* (dec column-count) margin))]
(println (center-string "[Snoopy Picture]" total-size))
(println (center-string (str year) total-size))
(println)
(print-months (year-vector date) column-count margin))))
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Write the same code in C as shown below in Common_Lisp. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Port the following code from Common_Lisp to C# with equivalent syntax and logic. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Produce a functionally identical C++ code for the snippet given in Common_Lisp. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Translate the given Common_Lisp code snippet into Java without altering its behavior. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Translate this program into Python but keep the logic exactly as in Common_Lisp. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Convert this Common_Lisp snippet to VB and keep its semantics consistent. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Produce a functionally identical Go code for the snippet given in Common_Lisp. | (ql:quickload '(date-calc))
(defparameter *day-row* "Su Mo Tu We Th Fr Sa")
(defparameter *calendar-margin* 3)
(defun month-to-word (month)
"Translate a MONTH from 1 to 12 into its word representation."
(svref #("January" "February" "March" "April"
"May" "June" "July" "August"
"September" "October" "November" "December")
(1- month)))
(defun month-strings (year month)
"Collect all of the strings that make up a calendar for a given
MONTH and YEAR."
`(,(date-calc:center (month-to-word month) (length *day-row*))
,*day-row*
,@ (let ((days (make-array (* 7 6) :initial-element nil)))
(loop :for i :from (date-calc:day-of-week year month 1)
:for day :from 1 :to (date-calc:days-in-month year month)
:do (setf (aref days i) day))
(loop :for i :from 0 :to 5
:collect
(format nil "~{~:[ ~
(loop :for day :across (subseq days (* i 7) (+ 7 (* i 7)))
:append (if day (list day day) (list day))))))))
(defun calc-columns (characters margin-size)
"Calculate the number of columns given the number of CHARACTERS per
column and the MARGIN-SIZE between them."
(multiple-value-bind (cols excess)
(truncate characters (+ margin-size (length *day-row*)))
(incf excess margin-size)
(if (>= excess (length *day-row*))
(1+ cols)
cols)))
(defun take (n list)
"Take the first N elements of a LIST."
(loop :repeat n :for x :in list :collect x))
(defun drop (n list)
"Drop the first N elements of a LIST."
(cond ((or (<= n 0) (null list)) list)
(t (drop (1- n) (cdr list)))))
(defun chunks-of (n list)
"Split the LIST into chunks of size N."
(assert (> n 0))
(loop :for x := list :then (drop n x)
:while x
:collect (take n x)))
(defun print-calendar (year &key (characters 80) (margin-size 3))
"Print out the calendar for a given YEAR, optionally specifying
a width limit in CHARACTERS and MARGIN-SIZE between months."
(assert (>= characters (length *day-row*)))
(assert (>= margin-size 0))
(let* ((calendars (loop :for month :from 1 :to 12
:collect (month-strings year month)))
(column-count (calc-columns characters margin-size))
(total-size (+ (* column-count (length *day-row*))
(* (1- column-count) margin-size)))
(format-string (concatenate 'string
"~{~a~^~" (write-to-string margin-size) ",0@T~}~%")))
(format t "~a~%~a~%~%"
(date-calc:center "[Snoopy]" total-size)
(date-calc:center (write-to-string year) total-size))
(loop :for row :in (chunks-of column-count calendars)
:do (apply 'mapcar
(lambda (&rest heads)
(format t format-string heads))
row))))
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Maintain the same structure and functionality when rewriting this code in C. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert the following code from D to C#, ensuring the logic remains intact. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Transform the following D implementation into C++, maintaining the same output and logic. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Rewrite this program in Java while keeping its functionality equivalent to the D version. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Write the same code in Python as shown below in D. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Translate this program into VB but keep the logic exactly as in D. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Convert the following code from D to Go, ensuring the logic remains intact. | import std.stdio, std.datetime, std.string, std.conv;
void printCalendar(in uint year, in uint nCols)
in {
assert(nCols > 0 && nCols <= 12);
} body {
immutable rows = 12 / nCols + (12 % nCols != 0);
auto date = Date(year, 1, 1);
int offs = date.dayOfWeek;
const months = "January February March April May June
July August September October November December".split;
string[8][12] mons;
foreach (immutable m; 0 .. 12) {
mons[m][0] = months[m].center(21);
mons[m][1] = " Su Mo Tu We Th Fr Sa";
immutable dim = date.daysInMonth;
foreach (immutable d; 1 .. 43) {
immutable day = d > offs && d <= offs + dim;
immutable str = day ? format(" %2s", d-offs) : " ";
mons[m][2 + (d - 1) / 7] ~= str;
}
offs = (offs + dim) % 7;
date.add!"months"(1);
}
"[Snoopy Picture]".center(nCols * 24 + 4).writeln;
writeln(year.text.center(nCols * 24 + 4), "\n");
foreach (immutable r; 0 .. rows) {
string[8] s;
foreach (immutable c; 0 .. nCols) {
if (r * nCols + c > 11)
break;
foreach (immutable i, line; mons[r * nCols + c])
s[i] ~= format(" %s", line);
}
writefln("%-(%s\n%)\n", s);
}
}
void main() {
printCalendar(1969, 3);
}
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Maintain the same structure and functionality when rewriting this code in C. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Keep all operations the same but rewrite the snippet in C#. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Keep all operations the same but rewrite the snippet in C++. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Can you help me rewrite this code in Java instead of Delphi, keeping it the same logically? | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Port the following code from Delphi to Python with equivalent syntax and logic. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Generate an equivalent VB version of this Delphi code. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Keep all operations the same but rewrite the snippet in Go. | program Calendar;
uses
System.SysUtils,
System.DateUtils;
function Center(s: string; width: Integer): string;
var
side: Integer;
begin
if s.Length >= width then
exit(s);
side := (width - s.Length) div 2;
Result := s + string.Create(' ', side);
Result := string.Create(' ', width - Result.Length) + Result;
end;
procedure PrintCalendar(year, nCols: word; local: string = 'en-US');
var
fmt: TFormatSettings;
begin
if (nCols <= 0) or (nCols > 12) then
exit;
fmt := TFormatSettings.Create(local);
var rows := 12 div nCols + ord(12 mod nCols <> 0);
var date := EncodeDate(year, 1, 1);
var offs := DayOfTheWeek(date);
var months: TArray<string>;
setlength(months, 12);
for var i := 1 to 12 do
months[i - 1] := fmt.LongMonthNames[i];
var sWeek := '';
for var i := 1 to 7 do
sWeek := sWeek + ' ' + copy(fmt.ShortDayNames[i], 1, 2);
var mons: TArray<TArray<string>>;
SetLength(mons, 12, 8);
for var m := 0 to 11 do
begin
mons[m, 0] := Center(months[m], 21);
mons[m, 1] := sWeek;
var dim := DaysInMonth(date);
for var d := 1 to 43 do
begin
var day := (d > offs) and (d <= offs + dim);
var str := ' ';
if day then
str := format(' %2d', [d - offs]);
mons[m, 2 + (d - 1) div 7] := mons[m, 2 + (d - 1) div 7] + str;
end;
offs := (offs + dim) mod 7;
date := IncMonth(date, 1);
end;
writeln(Center('[Snoopy Picture]', nCols * 24 + 4));
Writeln(Center(year.ToString, nCols * 24 + 4));
writeln;
for var r := 0 to rows - 1 do
begin
var s: TArray<string>;
SetLength(s, 8);
for var c := 0 to nCols - 1 do
begin
if r * nCols + c > 11 then
Break;
for var i := 0 to High(mons[r * nCols + c]) do
begin
var line := mons[r * nCols + c, i];
s[i] := s[i] + ' ' + line;
end;
end;
for var ss in s do
begin
writeln(ss, ' ');
end;
writeln;
end;
end;
begin
printCalendar(1969, 4);
readln;
end.
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Can you help me rewrite this code in C instead of F#, keeping it the same logically? | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert this F# snippet to C# and keep its semantics consistent. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Change the programming language of this snippet from F# to C++ without modifying what it does. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Translate this program into Java but keep the logic exactly as in F#. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Write the same algorithm in Python as shown in this F# implementation. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Rewrite this program in VB while keeping its functionality equivalent to the F# version. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Write the same code in Go as shown below in F#. | let getCalendar year =
let day_of_week month year =
let t = [|0; 3; 2; 5; 0; 3; 5; 1; 4; 6; 2; 4|]
let y = if month < 3 then year - 1 else year
let m = month
let d = 1
(y + y / 4 - y / 100 + y / 400 + t.[m - 1] + d) % 7
let last_day_of_month month year =
match month with
| 2 -> if (0 = year % 4 && (0 = year % 400 || 0 <> year % 100)) then 29 else 28
| 4 | 6 | 9 | 11 -> 30
| _ -> 31
let get_month_calendar year month =
let min (x: int, y: int) = if x < y then x else y
let ld = last_day_of_month month year
let dw = 7 - (day_of_week month year)
[|[|1..dw|];
[|dw + 1..dw + 7|];
[|dw + 8..dw + 14|];
[|dw + 15..dw + 21|];
[|dw + 22..min(ld, dw + 28)|];
[|min(ld + 1, dw + 29)..ld|]|]
let sb_fold (f:System.Text.StringBuilder -> 'a -> System.Text.StringBuilder) (sb:System.Text.StringBuilder) (xs:'a array) =
for x in xs do (f sb x) |> ignore
sb
let sb_append (text:string) (sb:System.Text.StringBuilder) = sb.Append(text)
let sb_appendln sb = sb |> sb_append "\n" |> ignore
let sb_fold_in_range a b f sb = [|a..b|] |> sb_fold f sb |> ignore
let mask_builder mask = Printf.StringFormat<string -> string>(mask)
let center n (s:string) =
let l = (n - s.Length) / 2 + s.Length
let f n s = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
(f l s) + (f (n - l) "")
let left n (s:string) = sprintf (mask_builder ("%-" + (n.ToString()) + "s")) s
let right n (s:string) = sprintf (mask_builder ("%" + (n.ToString()) + "s")) s
let array2string xs =
let ys = xs |> Array.map (fun x -> sprintf "%2d " x)
let sb = ys |> sb_fold (fun sb y -> sb.Append(y)) (new System.Text.StringBuilder())
sb.ToString()
let xsss =
let m = get_month_calendar year
[|1..12|] |> Array.map (fun i -> m i)
let months = [|"January"; "February"; "March"; "April"; "May"; "June"; "July"; "August"; "September"; "October"; "November"; "December"|]
let sb = new System.Text.StringBuilder()
sb |> sb_append "\n" |> sb_append (center 74 (year.ToString())) |> sb_appendln
for i in 0..3..9 do
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (center 21 months.[i]) |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append "Su Mo Tu We Th Fr Sa " |> sb_append " ")
sb |> sb_appendln
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (right 21 (array2string (xsss.[i].[0]))) |> sb_append " ")
sb |> sb_appendln
for j = 1 to 5 do
sb |> sb_fold_in_range i (i + 2) (fun sb i -> sb |> sb_append (left 21 (array2string (xsss.[i].[j]))) |> sb_append " ")
sb |> sb_appendln
sb.ToString()
let printCalendar year = getCalendar year
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Port the provided Factor code into C while preserving the original functionality. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Translate this program into C# but keep the logic exactly as in Factor. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Translate the given Factor code snippet into C++ without altering its behavior. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Port the provided Factor code into Java while preserving the original functionality. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Change the programming language of this snippet from Factor to Python without modifying what it does. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Port the following code from Factor to VB with equivalent syntax and logic. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Write a version of this Factor function in Go with identical behavior. | USING: arrays calendar.format grouping io.streams.string kernel
math.ranges prettyprint sequences sequences.interleaved ;
IN: rosetta-code.calendar
: calendar ( year -- )
12 [1,b] [ 2array [ month. ] with-string-writer ] with map
3 <groups> [ " " <interleaved> ] map 5 " " <repetition>
<interleaved> simple-table. ;
: calendar-demo ( -- ) 1969 calendar ;
MAIN: calendar-demo
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Transform the following Haskell implementation into C, maintaining the same output and logic. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert this Haskell block to C#, preserving its control flow and logic. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Transform the following Haskell implementation into C++, maintaining the same output and logic. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Change the programming language of this snippet from Haskell to Java without modifying what it does. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Preserve the algorithm and functionality while converting the code from Haskell to Python. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Convert this Haskell snippet to VB and keep its semantics consistent. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Transform the following Haskell implementation into Go, maintaining the same output and logic. | import qualified Data.Text as T
import Data.Time
import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.List.Split (chunksOf)
import Data.List
data Day = Su | Mo | Tu | We | Th | Fr | Sa
deriving (Show, Eq, Ord, Enum)
data Month = January | February | March
| April | May | June
| July | August | September
| October | November | December
deriving (Show, Eq, Ord, Enum)
monthToInt :: Month -> Int
monthToInt = (+ 1) . fromEnum
dayFromDate :: Integer -> Month -> Int -> Int
dayFromDate year month day = day' `mod` 7
where (_, _, day') = toWeekDate $ fromGregorian year (monthToInt month) day
nSpaces :: Int -> T.Text
nSpaces n = T.replicate n (T.pack " ")
space :: T.Text
space = nSpaces 1
calMarginWidth = 3
calMargin :: T.Text
calMargin = nSpaces calMarginWidth
calWidth = 20
listMonth :: Integer -> Month -> [T.Text]
listMonth year month = [monthHeader, weekHeader] ++ weeks'
where
monthHeader = (T.center calWidth ' ') . T.pack $ show month
weekHeader = (T.intercalate space) $ map (T.pack . show) [(Su)..]
monthLength = toInteger $
gregorianMonthLength year $
monthToInt month
firstDay = dayFromDate year month 1
days = replicate firstDay (nSpaces 2) ++
map ((T.justifyRight 2 ' ') . T.pack . show) [1..monthLength]
weeks = map (T.justifyLeft calWidth ' ') $
map (T.intercalate space) $
chunksOf 7 days
weeks' = weeks ++ replicate (6 - length weeks) (nSpaces calWidth)
listCalendar :: Integer -> Int -> [[[T.Text]]]
listCalendar year calColumns = (chunksOf calColumns) . (map (listMonth year)) $
enumFrom January
calColFromCol :: Int -> Int
calColFromCol columns = c + if r >= calWidth then 1 else 0
where (c, r) = columns `divMod` (calWidth + calMarginWidth)
colFromCalCol :: Int -> Int
colFromCalCol calCol = calCol * calWidth + ((calCol - 1) * calMarginWidth)
center :: Int -> String -> String
center i a = T.unpack . (T.center i ' ') $ T.pack a
printCal :: [[[T.Text]]] -> IO ()
printCal = mapM_ f where
f c = mapM_ (putStrLn . T.unpack) rows
where rows = map (T.intercalate calMargin) $ transpose c
printCalendar :: Integer -> Int -> IO ()
printCalendar year columns =
if columns < 20
then putStrLn $ "Cannot print less than 20 columns"
else do
putStrLn $ center columns' "[Maybe Snoopy]"
putStrLn $ center columns' $ show year
putStrLn ""
printCal $ listCalendar year calcol'
where
calcol' = calColFromCol columns
columns' = colFromCalCol calcol'
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Translate this program into C but keep the logic exactly as in Icon. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert this Icon block to C#, preserving its control flow and logic. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Translate the given Icon code snippet into C++ without altering its behavior. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Convert this Icon snippet to Java and keep its semantics consistent. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Transform the following Icon implementation into Python, maintaining the same output and logic. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Generate a VB translation of this Icon snippet without changing its computational steps. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Keep all operations the same but rewrite the snippet in Go. | procedure main(A)
printCalendar(\A[1]|1969)
end
procedure printCalendar(year)
cols := 3
mons := []
"January February March April May June " ||
"July August September October November December " ?
while put(mons, tab(find(" "))) do move(1)
write(center("[Snoopy Picture]",cols * 24 + 4))
write(center(year,cols * 24 + 4), "\n")
M := list(cols)
every mon := 0 to 9 by cols do {
writes(" ")
every i := 1 to cols do {
writes(center(mons[mon+i],24))
M[i] := create CalendarFormatWeek(year,mon + i)
}
write()
every 1 to 7 do {
every c := 1 to cols do {
writes(" ")
every 1 to 7 do writes(right(@M[c],3))
}
write()
}
}
return
end
link datetime
procedure CalendarFormatWeek(year,m)
static D
initial D := [31,28,31,30,31,30,31,31,30,31,30,31]
every suspend "Su"|"Mo"|"Tu"|"We"|"Th"|"Fr"|"Sa"
every 1 to (d := (julian(m,1,year)+1)%7) do suspend ""
every suspend 1 to D[m] do d +:= 1
if m = 2 & IsLeapYear(year) then suspend (d +:= 1, 29)
every d to (6*7) do suspend ""
end
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Write a version of this J function in C with identical behavior. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Can you help me rewrite this code in C# instead of J, keeping it the same logically? | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Maintain the same structure and functionality when rewriting this code in C++. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Write the same algorithm in Java as shown in this J implementation. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Write the same algorithm in Python as shown in this J implementation. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Ensure the translated VB code behaves exactly like the original J snippet. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Change the following J code into Go without altering its purpose. | require 'dates format'
require 'dates general/misc/format'
calBody=: (1 1 }. _1 _1 }. ":)@(-@(<.@%&22)@[ ]\ calendar@])
calTitle=: (<: - 22&|)@[ center '[Insert Snoopy here]' , '' ,:~ ":@]
formatCalendar=: calTitle , calBody
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Convert this Julia snippet to C and keep its semantics consistent. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Port the provided Julia code into C# while preserving the original functionality. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Preserve the algorithm and functionality while converting the code from Julia to C++. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Convert this Julia snippet to Java and keep its semantics consistent. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Change the programming language of this snippet from Julia to Python without modifying what it does. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Keep all operations the same but rewrite the snippet in VB. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Write a version of this Julia function in Go with identical behavior. | using Dates
const pagesizes = Dict( "lpr" => [132, 66], "tn3270" => [80, 43])
pagefit(prn) = haskey(pagesizes, prn) ?
[div(pagesizes[prn][1], 22), div(pagesizes[prn][2], 12)] : [1, 1]
pagecols(prn) = haskey(pagesizes, prn) ? pagesizes[prn][1] : 20
function centerobject(x, cols)
content = string(x)
rpad(lpad(content, div(cols + length(content), 2)), cols)
end
function ljustlines(x, cols)
arr = Vector{String}()
for s in split(x, "\n")
push!(arr, rpad(s, cols)[1:cols])
end
join(arr, "\n")
end
function formatmonth(yr, mo)
dt = Date("$yr-$mo-01")
dayofweekfirst = dayofweek(dt)
numweeklines = 1
str = centerobject(monthname(dt), 20) * "\nMo Tu We Th Fr Sa Su\n"
str *= " " ^ (3 * (dayofweekfirst - 1)) * lpad(string(1), 2)
for i = 2:daysinmonth(dt)
if (i + dayofweekfirst + 5) % 7 == 0
str *= "\n" * lpad(i, 2)
numweeklines += 1
else
str *= lpad(string(i), 3)
end
end
str *= numweeklines < 6 ? "\n\n\n" : "\n\n"
ljustlines(str, 20)
end
function formatyear(displayyear, printertype)
calmonths = [formatmonth(displayyear, mo) for mo in 1:12]
columns = pagecols(printertype)
monthsperline = pagefit(printertype)[1]
joinspaces = max( (monthsperline > 1) ?
div(columns - monthsperline * 20, monthsperline - 1) : 1, 1)
str = "\n" * centerobject(displayyear, columns) * "\n"
monthcal = [split(formatmonth(displayyear, i), "\n") for i in 1:12]
for i in 1:monthsperline:length(calmonths) - 1
for j in 1:length(monthcal[1])
monthlines = map(x->monthcal[x][j], i:i + monthsperline - 1)
str *= rpad(join(monthlines, " " ^ joinspaces), columns) * "\n"
end
str *= "\n"
end
str
end
function lineprintcalendar(years)
for year in years, printer in keys(pagesizes)
println(formatyear(year, printer))
end
end
lineprintcalendar(1969)
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Please provide an equivalent version of this Lua code in C. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Maintain the same structure and functionality when rewriting this code in C#. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Port the following code from Lua to C++ with equivalent syntax and logic. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Transform the following Lua implementation into Java, maintaining the same output and logic. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Convert the following code from Lua to Python, ensuring the logic remains intact. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Translate the given Lua code snippet into VB without altering its behavior. | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Can you help me rewrite this code in Go instead of Lua, keeping it the same logically? | function print_cal(year)
local months={"JANUARY","FEBRUARY","MARCH","APRIL","MAY","JUNE",
"JULY","AUGUST","SEPTEMBER","OCTOBER","NOVEMBER","DECEMBER"}
local daysTitle="MO TU WE TH FR SA SU"
local daysPerMonth={31,28,31,30,31,30,31,31,30,31,30,31}
local startday=((year-1)*365+math.floor((year-1)/4)-math.floor((year-1)/100)+math.floor((year-1)/400))%7
if year%4==0 and year%100~=0 or year%400==0 then
daysPerMonth[2]=29
end
local sep=5
local monthwidth=daysTitle:len()
local calwidth=3*monthwidth+2*sep
function center(str, width)
local fill1=math.floor((width-str:len())/2)
local fill2=width-str:len()-fill1
return string.rep(" ",fill1)..str..string.rep(" ",fill2)
end
function makeMonth(name, skip,days)
local cal={
center(name,monthwidth),
daysTitle
}
local curday=1-skip
while #cal<9 do
line={}
for i=1,7 do
if curday<1 or curday>days then
line[i]=" "
else
line[i]=string.format("%2d",curday)
end
curday=curday+1
end
cal[#cal+1]=table.concat(line," ")
end
return cal
end
local calendar={}
for i,month in ipairs(months) do
local dpm=daysPerMonth[i]
calendar[i]=makeMonth(month, startday, dpm)
startday=(startday+dpm)%7
end
print(center("[SNOOPY]",calwidth),"\n")
print(center("
for q=0,3 do
for l=1,9 do
line={}
for m=1,3 do
line[m]=calendar[q*3+m][l]
end
print(table.concat(line,string.rep(" ",sep)))
end
end
end
print_cal(1969)
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Can you help me rewrite this code in C instead of Mathematica, keeping it the same logically? | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Can you help me rewrite this code in C# instead of Mathematica, keeping it the same logically? | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Write the same code in C++ as shown below in Mathematica. | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Produce a functionally identical Java code for the snippet given in Mathematica. | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Preserve the algorithm and functionality while converting the code from Mathematica to Python. | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Generate an equivalent VB version of this Mathematica code. | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Write the same algorithm in Go as shown in this Mathematica implementation. | DataGrid[
rowHeights:{__Integer},
colWidths:{__Integer},
spacings:{_Integer,_Integer},
borderWidths:{{_Integer,_Integer},{_Integer,_Integer}},
options_Association,
data:{__List?MatrixQ}]:=
With[
{alignment=Lookup[options,"alignment",{0,0}],
background=Lookup[options,"background"," "],
dividers=Lookup[options,"dividers",{" "," "," "}],
border=Lookup[options,"border"," "],
dims={Length[rowHeights],Length[colWidths]}},
With[{augmentedData=PadRight[data,Times@@dims,{{{background}}}]},
With[{cellDims=ArrayReshape[Outer[List,rowHeights,colWidths],{Times@@dims,2}]},
With[{undecoratedGrid=Partition[MapThread[MatrixAlign[alignment,#1,background][#2]&, {cellDims,augmentedData}],dims[[2]]]},
With[{dividedRows=MapThread[Transpose[Riffle[#2,{ConstantArray[dividers[[2]],{#1,spacings[[2]]}]},{2,-2,2}]]&, {rowHeights,undecoratedGrid}]},
With[{dividedColumn=Riffle[dividedRows,{Transpose[Riffle[ConstantArray[dividers[[1]],{spacings[[1]],#}]&/@colWidths,{ConstantArray[dividers[[3]],spacings]},{2,-2,2}]]},{2,-2,2}]},
With[{dividedGrid=Catenate[Map[Flatten,dividedColumn,{2}]]},
ArrayPad[dividedGrid,borderWidths,border]]]]]]]];
DataGrid[dims:{_Integer,_Integer},spacings_,borderWidths_,options_,data:{__List?MatrixQ}]:=
With[
{rowHeights=Flatten@BlockMap[Max[Part[#,All,All,1]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{1,dims[[2]]}],
colWidths=Flatten@BlockMap[Max[Part[#,All,All,2]]&,ArrayReshape[Dimensions/@data,Append[dims,2],1],{dims[[1]],1}]},
DataGrid[rowHeights,colWidths,spacings,borderWidths,options,data]];
MatrixAlign[{-1,-1},dims_,pad_]:=PadRight[#,dims,pad]&;
MatrixAlign[{-1,0},dims_,pad_]:=PadRight[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{-1,1},dims_,pad_]:=PadRight[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,-1},dims_,pad_]:=CenterArray[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{0,0},dims_,pad_]:=CenterArray[#,dims,pad]&;
MatrixAlign[{0,1},dims_,pad_]:=CenterArray[PadLeft[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,-1},dims_,pad_]:=PadLeft[PadRight[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,0},dims_,pad_]:=PadLeft[CenterArray[#,{Dimensions[#][[1]],dims[[2]]},pad],dims,pad]&;
MatrixAlign[{1,1},dims_,pad_]:=PadLeft[#,dims,pad]&;
AsString[matrix_List?MatrixQ]:=StringRiffle[matrix,"\n",""];
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Please provide an equivalent version of this Nim code in C. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Translate the given Nim code snippet into C# without altering its behavior. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Convert this Nim block to C++, preserving its control flow and logic. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Maintain the same structure and functionality when rewriting this code in Java. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Preserve the algorithm and functionality while converting the code from Nim to Python. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Generate a VB translation of this Nim snippet without changing its computational steps. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Preserve the algorithm and functionality while converting the code from Nim to Go. | import times
import strformat
proc printCalendar(year, nCols: int) =
var rows = 12 div nCols
var date = initDateTime(1, mJan, year, 0, 0, 0, utc())
if rows mod nCols != 0:
inc rows
var offs = getDayOfWeek(date.monthday, date.month, date.year).int
var mons: array[12, array[8, string]]
for m in 0..11:
mons[m][0] = &"{$date.month:^21}"
mons[m][1] = " Su Mo Tu We Th Fr Sa"
var dim = getDaysInMonth(date.month, date.year)
for d in 1..42:
var day = d > offs and d <= offs + dim
var str = if day: &" {d-offs:2}" else: " "
mons[m][2 + (d - 1) div 7] &= str
offs = (offs + dim) mod 7
date = date + months(1)
var snoopyString, yearString: string
formatValue(snoopyString, "[Snoopy Picture]", "^" & $(nCols * 24 + 4))
formatValue(yearString, $year, "^" & $(nCols * 24 + 4))
echo snoopyString, "\n" , yearString, "\n"
for r in 0..<rows:
var s: array[8, string]
for c in 0..<nCols:
if r * nCols + c > 11:
break
for i, line in mons[r * nCols + c]:
s[i] &= &" {line}"
for line in s:
if line == "":
break
echo line
echo ""
printCalendar(1969, 3)
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Can you help me rewrite this code in C instead of OCaml, keeping it the same logically? | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert the following code from OCaml to C#, ensuring the logic remains intact. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Convert this OCaml block to C++, preserving its control flow and logic. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Preserve the algorithm and functionality while converting the code from OCaml to Java. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Change the following OCaml code into Python without altering its purpose. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Transform the following OCaml implementation into VB, maintaining the same output and logic. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
|
docal 1969,6,""
function center (s,n) x=n-len(s):center=space(x\2+(x and 1))& s & space(x\2):end function
sub print(x) wscript.stdout.writeline x : end sub
function iif(a,b,c) :if a then iif=b else iif =c end if : end function
sub docal (yr,nmonth,sloc)
dim ld(6)
dim d(6)
if nmonth=5 or nmonth>6 or nmonth<1 then wscript.stderr.writeline "Can
if sloc<>"" then Setlocale sloc
wday=""
for i=1 to 7
wday=wday &" "&right(" "& left(weekdayname(i,true,vbUseSystemDayOfWeek),2),2)
next
ncols=nmonth*21+(nmonth-1)*1
print center("[Snoopy]",ncols)
print center(yr,ncols)
print string(ncols,"=")
for i=1 to 12\nmonth
s="": s1="":esp=""
for j=1 to nmonth
s=s & esp & center(monthname(m+j),21)
s1=s1 & esp & wday
d(j)= -weekday(dateserial(yr,m+j,1),vbUseSystemDayOfWeek)+2
ld(j)=day(dateserial(yr,m+j+1,0))
esp=" "
next
print s: print s1
while(d(1)<ld(1)) or (d(2)<ld(2)) or (d(3)<ld(3)) or (d(4)<ld(4))or (d(5)<ld(5)) or (d(6)<ld(6))
s=""
for j=1 to nmonth
for k=1 to 7
s=s& right(space(3)&iif(d(j)<1 or d(j)>ld(j),"",d(j)),3)
d(j)=d(j)+1
next
s=s&" "
next
print s
wend
m=m+nmonth
if i<>12\nmonth then print ""
next
print string(ncols,"=")
end sub
|
Preserve the algorithm and functionality while converting the code from OCaml to Go. | #load "unix.cma"
let lang = "en"
let usage () =
Printf.printf "Usage:\n%s\n" Sys.argv.(0)
let month_pattern =
[
[ 0; 4; 8 ];
[ 1; 5; 9 ];
[ 2; 6; 10 ];
[ 3; 7; 11 ];
]
let month_langs = [
"en", [|
"January"; "February"; "March"; "April";
"May"; "June"; "July"; "August"; "September";
"October"; "November"; "December";
|];
"fr", [|
"janvier"; "février"; "mars"; "avril"; "mai";
"juin"; "juillet"; "août"; "septembre";
"octobre"; "novembre"; "décembre";
|];
]
let days_lang = [
"en", [| "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday"; "Sunday" |];
"fr", [| "lundi"; "mardi"; "mercredi";
"jeudi"; "vendredi"; "samedi"; "dimanche" |];
]
let titles_lang = [
"en", "( Snoopy's best pic )";
"fr", "( Le meilleur profil de Snoopy )";
]
let days = List.assoc lang days_lang
let month = List.assoc lang month_langs
let title = List.assoc lang titles_lang
let monday_first = 6, [| 0; 1; 2; 3; 4; 5; 6 |]
let sunday_first = 0, [| 6; 0; 1; 2; 3; 4; 5 |]
let off, days_order = sunday_first
let off, days_order = monday_first
let shorten n s =
let len = String.length s in
if n >= len then s else
let n = if s.[n-1] = '\xC3' then n+1 else n in
if n >= len then s else
(String.sub s 0 n)
let pad size c s =
let len = String.length s in
let n1 = (size - len) / 2 in
let n2 = size - len - n1 in
String.make n1 c ^ s ^
String.make n2 c
let days = Array.map (shorten 2) days
let indices ofs =
(ofs / 7, ofs mod 7)
let t_same t1 t2 =
( t1.Unix.tm_year = t2.Unix.tm_year &&
t1.Unix.tm_mon = t2.Unix.tm_mon &&
t1.Unix.tm_mday = t2.Unix.tm_mday )
let current_year () =
let t = Unix.localtime (Unix.time ()) in
(t.Unix.tm_year + 1900)
let make_month t year month =
let empty_day = 0 in
let m = Array.make_matrix 6 7 empty_day in
let ofs = ref 0 in
for day = 1 to 31 do
let tm =
{ t with
Unix.tm_year = year - 1900;
Unix.tm_mon = month;
Unix.tm_mday = day;
}
in
let _, this = Unix.mktime tm in
if !ofs = 0 then ofs := (this.Unix.tm_wday + off) mod 7;
if t_same this tm then
let i, j = indices !ofs in
m.(i).(j) <- day;
incr ofs;
done;
(m)
let cal ~year =
let empty = [| [| |] |] in
let months = Array.make 12 empty in
let t = Unix.gmtime 0.0 in
for mon = 0 to 11 do
months.(mon) <- make_month t year mon;
done;
(months)
let print_month_label mp =
List.iter (fun i ->
let mon = pad 20 ' ' month.(i) in
Printf.printf " %s " mon
) mp;
print_newline ()
let print_day_label mp =
List.iter (fun _ ->
Array.iter (fun i ->
Printf.printf " %s" days.(i)
) days_order
; print_string " "
) mp;
print_newline ()
let print_mon m mp =
print_month_label mp;
print_day_label mp;
for w = 0 to pred 6 do
print_string begin
String.concat " " begin
List.map (fun i ->
let b = Buffer.create 132 in
for d = 0 to pred 7 do
match m.(i).(w).(d) with
| 0 -> Buffer.add_string b " "
| d -> Printf.kprintf (Buffer.add_string b) " %2d" d
done;
(Buffer.contents b)
) mp
end
end
; print_string "\n"
done
let print_cal ~y:m =
List.iter (fun mon_row ->
print_mon m mon_row
) month_pattern
let print_header lbl =
let n = List.length (List.hd month_pattern) in
let year_lbl = pad (23*n-7) ' ' lbl in
Printf.printf " %s\n" year_lbl
let print_calendar ~year =
print_header title;
print_header (string_of_int year);
print_cal (cal ~year)
let () =
let args = List.tl (Array.to_list Sys.argv) in
match args with
| [] ->
let year = current_year () in
print_calendar ~year
| ["--year"; _year] ->
let year = int_of_string _year in
print_calendar ~year
| _ ->
usage ()
| package main
import (
"fmt"
"time"
)
const pageWidth = 80
func main() {
printCal(1969)
}
func printCal(year int) {
thisDate := time.Date(year, 1, 1, 1, 1, 1, 1, time.UTC)
var (
dayArr [12][7][6]int
month, lastMonth time.Month
weekInMonth, dayInMonth int
)
for thisDate.Year() == year {
if month = thisDate.Month(); month != lastMonth {
weekInMonth = 0
dayInMonth = 1
}
weekday := thisDate.Weekday()
if weekday == 0 && dayInMonth > 1 {
weekInMonth++
}
dayArr[int(month)-1][weekday][weekInMonth] = thisDate.Day()
lastMonth = month
dayInMonth++
thisDate = thisDate.Add(time.Hour * 24)
}
centre := fmt.Sprintf("%d", pageWidth/2)
fmt.Printf("%"+centre+"s\n\n", "[SNOOPY]")
centre = fmt.Sprintf("%d", pageWidth/2-2)
fmt.Printf("%"+centre+"d\n\n", year)
months := [12]string{
" January ", " February", " March ", " April ",
" May ", " June ", " July ", " August ",
"September", " October ", " November", " December"}
days := [7]string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
for qtr := 0; qtr < 4; qtr++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
fmt.Printf(" %s ", months[qtr*3+monthInQtr])
}
fmt.Println()
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
fmt.Printf(" %s", days[day])
}
fmt.Printf(" ")
}
fmt.Println()
for weekInMonth = 0; weekInMonth < 6; weekInMonth++ {
for monthInQtr := 0; monthInQtr < 3; monthInQtr++ {
for day := 0; day < 7; day++ {
if dayArr[qtr*3+monthInQtr][day][weekInMonth] == 0 {
fmt.Printf(" ")
} else {
fmt.Printf("%3d", dayArr[qtr*3+monthInQtr][day][weekInMonth])
}
}
fmt.Printf(" ")
}
fmt.Println()
}
fmt.Println()
}
}
|
Generate a C translation of this Perl snippet without changing its computational steps. |
use strict;
use warnings;
use Time::Local;
my $year = shift // 1969;
my $width = shift // 80;
my $columns = int +($width + 2) / 22 or die "width too short at $width";
print map { center($_, $width), "\n" } '<reserved for snoopy>', $year;
my @months = qw( January February March April May June
July August September October November December );
my @days = qw( 31 28 31 30 31 30 31 31 30 31 30 31 );
(gmtime 86400 + timegm 1,1,1,28,1,$year)[3] == 29 and $days[1]++;
my @blocks = map
{
my $m = center($months[$_], 20) . "\nSu Mo Tu We Th Fr Sa\n" .
"00 00 00 00 00 00 00\n" x 6;
$m =~ s/00/ / for 1 .. (gmtime timegm 1,1,1,1,$_,$year )[6];
$m =~ s/00/ center($_, 2) /e for 1 .. $days[$_];
$m =~ s/00/ /g;
[ split /\n/, $m ]
} 0 .. 11;
while( my @row = splice @blocks, 0, $columns )
{
print center(join(' ', map shift @$_, @row), $width) for 1 .. @{$row[0]};
}
sub center
{
my ($string, $w) = @_;
sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int width = 80, year = 1969;
int cols, lead, gap;
const char *wdays[] = { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
struct months {
const char *name;
int days, start_wday, at;
} months[12] = {
{ "January", 31, 0, 0 },
{ "February", 28, 0, 0 },
{ "March", 31, 0, 0 },
{ "April", 30, 0, 0 },
{ "May", 31, 0, 0 },
{ "June", 30, 0, 0 },
{ "July", 31, 0, 0 },
{ "August", 31, 0, 0 },
{ "September", 30, 0, 0 },
{ "October", 31, 0, 0 },
{ "November", 30, 0, 0 },
{ "December", 31, 0, 0 }
};
void space(int n) { while (n-- > 0) putchar(' '); }
void init_months()
{
int i;
if ((!(year % 4) && (year % 100)) || !(year % 400))
months[1].days = 29;
year--;
months[0].start_wday
= (year * 365 + year/4 - year/100 + year/400 + 1) % 7;
for (i = 1; i < 12; i++)
months[i].start_wday =
(months[i-1].start_wday + months[i-1].days) % 7;
cols = (width + 2) / 22;
while (12 % cols) cols--;
gap = cols - 1 ? (width - 20 * cols) / (cols - 1) : 0;
if (gap > 4) gap = 4;
lead = (width - (20 + gap) * cols + gap + 1) / 2;
year++;
}
void print_row(int row)
{
int c, i, from = row * cols, to = from + cols;
space(lead);
for (c = from; c < to; c++) {
i = strlen(months[c].name);
space((20 - i)/2);
printf("%s", months[c].name);
space(20 - i - (20 - i)/2 + ((c == to - 1) ? 0 : gap));
}
putchar('\n');
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < 7; i++)
printf("%s%s", wdays[i], i == 6 ? "" : " ");
if (c < to - 1) space(gap);
else putchar('\n');
}
while (1) {
for (c = from; c < to; c++)
if (months[c].at < months[c].days) break;
if (c == to) break;
space(lead);
for (c = from; c < to; c++) {
for (i = 0; i < months[c].start_wday; i++) space(3);
while(i++ < 7 && months[c].at < months[c].days) {
printf("%2d", ++months[c].at);
if (i < 7 || c < to - 1) putchar(' ');
}
while (i++ <= 7 && c < to - 1) space(3);
if (c < to - 1) space(gap - 1);
months[c].start_wday = 0;
}
putchar('\n');
}
putchar('\n');
}
void print_year()
{
int row;
char buf[32];
sprintf(buf, "%d", year);
space((width - strlen(buf)) / 2);
printf("%s\n\n", buf);
for (row = 0; row * cols < 12; row++)
print_row(row);
}
int main(int c, char **v)
{
int i, year_set = 0;
for (i = 1; i < c; i++) {
if (!strcmp(v[i], "-w")) {
if (++i == c || (width = atoi(v[i])) < 20)
goto bail;
} else if (!year_set) {
if (!sscanf(v[i], "%d", &year) || year <= 0)
year = 1969;
year_set = 1;
} else
goto bail;
}
init_months();
print_year();
return 0;
bail: fprintf(stderr, "bad args\nUsage: %s year [-w width (>= 20)]\n", v[0]);
exit(1);
}
|
Convert this Perl snippet to C# and keep its semantics consistent. |
use strict;
use warnings;
use Time::Local;
my $year = shift // 1969;
my $width = shift // 80;
my $columns = int +($width + 2) / 22 or die "width too short at $width";
print map { center($_, $width), "\n" } '<reserved for snoopy>', $year;
my @months = qw( January February March April May June
July August September October November December );
my @days = qw( 31 28 31 30 31 30 31 31 30 31 30 31 );
(gmtime 86400 + timegm 1,1,1,28,1,$year)[3] == 29 and $days[1]++;
my @blocks = map
{
my $m = center($months[$_], 20) . "\nSu Mo Tu We Th Fr Sa\n" .
"00 00 00 00 00 00 00\n" x 6;
$m =~ s/00/ / for 1 .. (gmtime timegm 1,1,1,1,$_,$year )[6];
$m =~ s/00/ center($_, 2) /e for 1 .. $days[$_];
$m =~ s/00/ /g;
[ split /\n/, $m ]
} 0 .. 11;
while( my @row = splice @blocks, 0, $columns )
{
print center(join(' ', map shift @$_, @row), $width) for 1 .. @{$row[0]};
}
sub center
{
my ($string, $w) = @_;
sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);
}
| using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CalendarStuff
{
class Program
{
static void Main(string[] args)
{
Console.WindowHeight = 46;
Console.Write(buildMonths(new DateTime(1969, 1, 1)));
Console.Read();
}
private static string buildMonths(DateTime date)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(center("[Snoop]", 24 * 3));
sb.AppendLine();
sb.AppendLine(center(date.Year.ToString(), 24 * 3));
List<DateTime> dts = new List<DateTime>();
while (true)
{
dts.Add(date);
if (date.Year != ((date = date.AddMonths(1)).Year))
{
break;
}
}
var jd = dts.Select(a => buildMonth(a).GetEnumerator()).ToArray();
int sCur=0;
while (sCur<dts.Count)
{
sb.AppendLine();
int curMonth=0;
var j = jd.Where(a => curMonth++ >= sCur && curMonth - 1 < sCur + 3).ToArray();
sCur += j.Length;
bool breakOut = false;
while (!breakOut)
{
int inj = 1;
foreach (var cd in j)
{
if (cd.MoveNext())
{
sb.Append((cd.Current.Length == 21 ? cd.Current : cd.Current.PadRight(21, ' ')) + " ");
}
else
{
sb.Append("".PadRight(21, ' ') + " ");
breakOut = true;
}
if (inj++ % 3 == 0) sb.AppendLine();
}
}
}
return sb.ToString();
}
private static IEnumerable<string> buildMonth(DateTime date)
{
yield return center(date.ToString("MMMM"),7*3);
var j = DateTime.DaysInMonth(date.Year, date.Month);
yield return Enum.GetNames(typeof(DayOfWeek)).Aggregate("", (current, result) => current + (result.Substring(0, 2).ToUpper() + " "));
string cur = "";
int total = 0;
foreach (var day in Enumerable.Range(-((int)date.DayOfWeek),j + (int)date.DayOfWeek))
{
cur += (day < 0 ? " " : ((day < 9 ? " " : "") + (day + 1))) +" ";
if (total++ > 0 && (total ) % 7 == 0)
{
yield return cur;
cur = "";
}
}
yield return cur;
}
private static string center(string s, int len)
{
return (s.PadLeft((len - s.Length) / 2 + s.Length, ' ').PadRight((len), ' '));
}
}
}
|
Write the same code in C++ as shown below in Perl. |
use strict;
use warnings;
use Time::Local;
my $year = shift // 1969;
my $width = shift // 80;
my $columns = int +($width + 2) / 22 or die "width too short at $width";
print map { center($_, $width), "\n" } '<reserved for snoopy>', $year;
my @months = qw( January February March April May June
July August September October November December );
my @days = qw( 31 28 31 30 31 30 31 31 30 31 30 31 );
(gmtime 86400 + timegm 1,1,1,28,1,$year)[3] == 29 and $days[1]++;
my @blocks = map
{
my $m = center($months[$_], 20) . "\nSu Mo Tu We Th Fr Sa\n" .
"00 00 00 00 00 00 00\n" x 6;
$m =~ s/00/ / for 1 .. (gmtime timegm 1,1,1,1,$_,$year )[6];
$m =~ s/00/ center($_, 2) /e for 1 .. $days[$_];
$m =~ s/00/ /g;
[ split /\n/, $m ]
} 0 .. 11;
while( my @row = splice @blocks, 0, $columns )
{
print center(join(' ', map shift @$_, @row), $width) for 1 .. @{$row[0]};
}
sub center
{
my ($string, $w) = @_;
sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);
}
| #include <windows.h>
#include <iostream>
using namespace std;
class calender
{
public:
void drawCalender( int y )
{
year = y;
for( int i = 0; i < 12; i++ )
firstdays[i] = getfirstday( i );
isleapyear();
build();
}
private:
void isleapyear()
{
isleap = false;
if( !( year % 4 ) )
{
if( year % 100 ) isleap = true;
else if( !( year % 400 ) ) isleap = true;
}
}
int getfirstday( int m )
{
int y = year;
int f = y + 1 + 3 * m - 1;
m++;
if( m < 3 ) y--;
else f -= int( .4 * m + 2.3 );
f += int( y / 4 ) - int( ( y / 100 + 1 ) * 0.75 );
f %= 7;
return f;
}
void build()
{
int days[] = { 31, isleap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int lc = 0, lco = 0, ystr = 7, start = 2, fd = 0, m = 0;
HANDLE h = GetStdHandle( STD_OUTPUT_HANDLE );
COORD pos = { 0, ystr };
draw();
for( int i = 0; i < 4; i++ )
{
for( int j = 0; j < 3; j++ )
{
int d = firstdays[fd++], dm = days[m++];
pos.X = d * 3 + start;
SetConsoleCursorPosition( h, pos );
for( int dd = 0; dd < dm; dd++ )
{
if( dd < 9 ) cout << 0 << dd + 1 << " ";
else cout << dd + 1 << " ";
pos.X += 3;
if( pos.X - start > 20 )
{
pos.X = start; pos.Y++;
SetConsoleCursorPosition( h, pos );
}
}
start += 23;
pos.X = start; pos.Y = ystr;
SetConsoleCursorPosition( h, pos );
}
ystr += 9; start = 2;
pos.Y = ystr;
}
}
void draw()
{
system( "cls" );
cout << "+--------------------------------------------------------------------+" << endl;
cout << "| [SNOOPY] |" << endl;
cout << "| |" << endl;
cout << "| == " << year << " == |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JANUARY | FEBRUARY | MARCH |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| APRIL | MAY | JUNE |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| JULY | AUGUST | SEPTEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
cout << "| OCTOBER | NOVEMBER | DECEMBER |" << endl;
cout << "| SU MO TU WE TH FR SA | SU MO TU WE TH FR SA | SU MO TU WE TH FR SA |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "| | | |" << endl;
cout << "+----------------------+----------------------+----------------------+" << endl;
}
int firstdays[12], year;
bool isleap;
};
int main( int argc, char* argv[] )
{
int y;
calender cal;
while( true )
{
system( "cls" );
cout << "Enter the year( yyyy ) --- ( 0 to quit ): ";
cin >> y;
if( !y ) return 0;
cal.drawCalender( y );
cout << endl << endl << endl << endl << endl << endl << endl << endl;
system( "pause" );
}
return 0;
}
|
Generate a Java translation of this Perl snippet without changing its computational steps. |
use strict;
use warnings;
use Time::Local;
my $year = shift // 1969;
my $width = shift // 80;
my $columns = int +($width + 2) / 22 or die "width too short at $width";
print map { center($_, $width), "\n" } '<reserved for snoopy>', $year;
my @months = qw( January February March April May June
July August September October November December );
my @days = qw( 31 28 31 30 31 30 31 31 30 31 30 31 );
(gmtime 86400 + timegm 1,1,1,28,1,$year)[3] == 29 and $days[1]++;
my @blocks = map
{
my $m = center($months[$_], 20) . "\nSu Mo Tu We Th Fr Sa\n" .
"00 00 00 00 00 00 00\n" x 6;
$m =~ s/00/ / for 1 .. (gmtime timegm 1,1,1,1,$_,$year )[6];
$m =~ s/00/ center($_, 2) /e for 1 .. $days[$_];
$m =~ s/00/ /g;
[ split /\n/, $m ]
} 0 .. 11;
while( my @row = splice @blocks, 0, $columns )
{
print center(join(' ', map shift @$_, @row), $width) for 1 .. @{$row[0]};
}
sub center
{
my ($string, $w) = @_;
sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);
}
| import java.text.*;
import java.util.*;
public class CalendarTask {
public static void main(String[] args) {
printCalendar(1969, 3);
}
static void printCalendar(int year, int nCols) {
if (nCols < 1 || nCols > 12)
throw new IllegalArgumentException("Illegal column width.");
Calendar date = new GregorianCalendar(year, 0, 1);
int nRows = (int) Math.ceil(12.0 / nCols);
int offs = date.get(Calendar.DAY_OF_WEEK) - 1;
int w = nCols * 24;
String[] monthNames = new DateFormatSymbols(Locale.US).getMonths();
String[][] mons = new String[12][8];
for (int m = 0; m < 12; m++) {
String name = monthNames[m];
int len = 11 + name.length() / 2;
String format = MessageFormat.format("%{0}s%{1}s", len, 21 - len);
mons[m][0] = String.format(format, name, "");
mons[m][1] = " Su Mo Tu We Th Fr Sa";
int dim = date.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int d = 1; d < 43; d++) {
boolean isDay = d > offs && d <= offs + dim;
String entry = isDay ? String.format(" %2s", d - offs) : " ";
if (d % 7 == 1)
mons[m][2 + (d - 1) / 7] = entry;
else
mons[m][2 + (d - 1) / 7] += entry;
}
offs = (offs + dim) % 7;
date.add(Calendar.MONTH, 1);
}
System.out.printf("%" + (w / 2 + 10) + "s%n", "[Snoopy Picture]");
System.out.printf("%" + (w / 2 + 4) + "s%n%n", year);
for (int r = 0; r < nRows; r++) {
for (int i = 0; i < 8; i++) {
for (int c = r * nCols; c < (r + 1) * nCols && c < 12; c++)
System.out.printf(" %s", mons[c][i]);
System.out.println();
}
System.out.println();
}
}
}
|
Convert the following code from Perl to Python, ensuring the logic remains intact. |
use strict;
use warnings;
use Time::Local;
my $year = shift // 1969;
my $width = shift // 80;
my $columns = int +($width + 2) / 22 or die "width too short at $width";
print map { center($_, $width), "\n" } '<reserved for snoopy>', $year;
my @months = qw( January February March April May June
July August September October November December );
my @days = qw( 31 28 31 30 31 30 31 31 30 31 30 31 );
(gmtime 86400 + timegm 1,1,1,28,1,$year)[3] == 29 and $days[1]++;
my @blocks = map
{
my $m = center($months[$_], 20) . "\nSu Mo Tu We Th Fr Sa\n" .
"00 00 00 00 00 00 00\n" x 6;
$m =~ s/00/ / for 1 .. (gmtime timegm 1,1,1,1,$_,$year )[6];
$m =~ s/00/ center($_, 2) /e for 1 .. $days[$_];
$m =~ s/00/ /g;
[ split /\n/, $m ]
} 0 .. 11;
while( my @row = splice @blocks, 0, $columns )
{
print center(join(' ', map shift @$_, @row), $width) for 1 .. @{$row[0]};
}
sub center
{
my ($string, $w) = @_;
sprintf "%${w}s", $string . ' ' x ($w - length($string) >> 1);
}
| >>> import calendar
>>> help(calendar.prcal)
Help on method pryear in module calendar:
pryear(self, theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a years calendar.
>>> calendar.prcal(1969)
1969
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2
6 7 8 9 10 11 12 3 4 5 6 7 8 9 3 4 5 6 7 8 9
13 14 15 16 17 18 19 10 11 12 13 14 15 16 10 11 12 13 14 15 16
20 21 22 23 24 25 26 17 18 19 20 21 22 23 17 18 19 20 21 22 23
27 28 29 30 31 24 25 26 27 28 24 25 26 27 28 29 30
31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 4 1
7 8 9 10 11 12 13 5 6 7 8 9 10 11 2 3 4 5 6 7 8
14 15 16 17 18 19 20 12 13 14 15 16 17 18 9 10 11 12 13 14 15
21 22 23 24 25 26 27 19 20 21 22 23 24 25 16 17 18 19 20 21 22
28 29 30 26 27 28 29 30 31 23 24 25 26 27 28 29
30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 29 30 31 29 30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 1 2 1 2 3 4 5 6 7
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14
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
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.