Discordian date: Difference between revisions

This program is written to run under CP/M, and it takes a Gregorian date as an argument on the command line, in <code>DDMMYYYY</code> format.

 

;; has finally come to CP/M.

bdos: equ 5 ; CP/M syscalls

tibsday: db 'Saint Tib',39,'s Day$'

yold: db ' in the YOLD $'

 

{{out}}

This code is written to compile to a <code>.COM</code> file using <code>nasm</code>.

 

bits 16

cpu 8086

xflux: db 'flux!$'

tibsday: db "Saint Tib's Day$"

 

{{out}}

C:\>ddate 01/05/2005

Setting Orange, day 5 of Chaos in the YOLD 3171: celebrate Mungday!

</pre>

 

 

discordian.adb:

with Ada.Text_IO;

with Ada.Integer_Text_IO;

 

end Discordian;

 

{{Out}}

Setting Orange, day 26 of Bureaucracy in the YOLD 3178

Setting Orange, day 73 of The Aftermath in the YOLD 3178</pre>

 

=={{header|AppleScript}}==

 

*)

-- Calculate the input date's day-of-year number.

copy inputDate to startOfYear

end gregorianToDiscordian

 

set discordianDate to gregorianToDiscordian(ASDate)

 

{{output}}

 

=={{header|AWK}}==

# DDATE.AWK - Gregorian to Discordian date contributed by Dan Nielsen

# syntax: GAWK -f DDATE.AWK [YYYYMMDD | YYYY-MM-DD | MM-DD-YYYY | DDMMMYYYY | YYYY] ...

errors++

}

{{Out}}

<pre>

{{trans|PowerBASIC}}

 

 

DECLARE FUNCTION julian(AS DOUBLE) AS INTEGER

NEXT

FUNCTION = tmp + DAY(d)

{{out}}

<pre>"Discordian date.exe" 19-10-2015

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

{{works with|Windows XP Service Pack 3}}

goto Parse

 

 

:End

{{out}}

<pre>

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

{{works with|BBC BASIC for Windows}}

PRINT "01/01/2011 -> " FNdiscordian("01/01/2011")

ENDIF

= Weekday$(day% MOD 5) + ", " + STR$(day% MOD 73 + 1) + " " + \

{{Out}}

<pre>

Reads the date to convert from stdin as three separate numeric inputs (year, month, and day).

 

v"f I".+1%,,,,"Day I":$_:#<0#!4#:p#-4#1g4-#0+#<<_v#!*!-2g40!-<

>"o",,,/:5+*66++:4>g#<:#44#:9#+*#1-#,_$$0 v_v#!< >$ 0 "yaD " v

@,+55.+*+92"j"$_,#!>#:<", in the YOLD"*84 <.>,:^ :"St. Tib's"<

 

{{out}} (multiple runs)

For the source code of <code>ddate</code> in util-linux package, see [[http://jubal.westnet.com/hyperdiscordia/ddate.html]].

 

#include <stdio.h>

#include <time.h>

return 0;

 

Demonstration:

Prickle-Prickle, Chaos 4, YOLD 3182</pre>

 

 

public static class DiscordianDate

}

 

{{out}}

<pre>

 

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

#include <iostream>

#include <algorithm>

return 0;

}

{{out}}<pre>

Enter a date (dd mm yyyy) or 0 to quit: 19 10 2015

 

=={{header|Clojure}}==

 

(def seasons ["Chaos" "Discord" "Confusion" "Bureaucracy" "The Aftermath"])

(let [day-of-year (dec (.getDayOfYear (tc/date-time year month day)))

dday (discordian-day day-of-year (leap-year? year))]

 

{{out}}

"Setting Orange, The Aftermath 73, YOLD 3179"</pre>

 

=={{header|D}}==

 

immutable seasons = ["Chaos", "Discord", "Confusion",

}

}

{{out}}

<pre>$ ./ddate 20100722 20120228 20120229 20120301 20100105 20110503 20151019 00000101 -11660101

Sweetmorn, day 1 of Chaos in the YOLD 1166

Sweetmorn, day 1 of Chaos in the YOLD 0</pre>

 

=={{header|Euphoria}}==

{{trans|D}}

return remainder(year,4)=0 and remainder(year,100)!=0 or remainder(year,400)=0

end function

today = date()

today[YEAR] += 1900

 

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

 

 

let seasons = [| "Chaos"; "Discord"; "Confusion"; "Bureaucracy"; "The Aftermath" |]

|> Seq.iter(fun (s,d) -> printfn "%s is %s" s (ddate d))

0

{{out}}

<pre>2012-02-28 is Chaos 59, 3178 YOLD

2015-10-20 is The Aftermath 1, 3181 YOLD</pre>

 

program discordianDate

implicit none

end if

end function Pleapyear

<pre>

compiled as ddate.

Celebrate for today is St. Tibbs Day in the YOLD 3186

</pre>

 

=={{header|FreeBASIC}}==

{{trans|BASIC}}

 

meses:

cDiscordiano("15/07/2019")

cDiscordiano("19/03/2025")

{{out}}

<pre>

=={{header|Go}}==

A package modeled after the time package in the Go standard library

 

import (

}

return

Example program using above package

 

import (

fmt.Fprintf(os.Stderr, "usage: %s [+format] [day month year]\n", os.Args[0])

os.Exit(1)

{{Out}}

<pre>

 

=={{header|Haskell}}==

import Data.Time.Calendar.MonthDay (monthAndDayToDayOfYear)

import Text.Printf (printf)

weekday = toEnum $ dayOfYear `mod` 5

season = toEnum $ dayOfYear `div` 73

 

Examples:

 

where

display d = putStr (show d ++ " -> ") >> print (fromYMD d)

,(2010,9,2)

,(2010,12,31)

 

<pre>λ> test

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

This version is loosely based on a modified translation of the original ddate.c and like the original the leap year functionality is Julian not Gregorian.

 

procedure main()

ddate.sday || " of " || seasons[ddate.season])) ||

" in the YOLD " || ddate.year

 

{{Out}}

 

=={{header|J}}==

leap=: _1j1 * 0 -/@:= 4 100 400 |/ {.@]

bs=: ((#:{.) + 0 j. *@[ * {:@]) +.

 

Example use:

 

3178 1 59

disc 2012 2 29

3181 4 73

disc 2000 3 13

 

see [[Talk:Discordian_date|talk page]]. But, in essence, this version uses season ordinals with a single imaginary day after the 59th of the first season, on leap years. This is implemented so that that imaginary day has been passed for all remaining days of a leap year.

=={{header|Java}}==

 

import java.util.GregorianCalendar;

 

assert (discordianDate(new GregorianCalendar(y, m, d)).equals(result));

}

 

{{Out}}

=={{header|JavaScript}}==

 

/**

* All Hail Discordia! - this script prints Discordian date using system date.

 

module.exports = discordianDate;

 

Example use:

 

console.log(discordianDate(new Date(Date.now())));

"Boomtime, the 2nd day of Chaos in the YOLD 3183"

 

look at [http://www.cs.cmu.edu/~tilt/principia/body.html#applecorps calendar];

 

=={{header|JotaCode}}==

"Today is ",

@let(1,@add(@switch(@time("mon"),

", YOLD ",

@add(@time("year"),3066))

 

=={{header|Julia}}==

 

function discordiandate(year::Integer, month::Integer, day::Integer)

@show discordiandate(2017, 08, 15)

@show discordiandate(1996, 02, 29)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

import java.util.GregorianCalendar

 

test(2011, 4, 3, "Discoflux, in the YOLD 3177")

test(2015, 9, 19, "Boomtime, day 73 of Bureaucracy in the YOLD 3181")

 

=={{header|Maple}}==

local days31, days30, daysThisYear, i, dYear, dMonth, dDay, seasons, week, dayOfWeek;

days31 := [1, 3, 5, 7, 8, 10, 12];

convertDiscordian (2016, 1, 1);

convertDiscordian (2016, 2, 29);

{{out}}

<pre>

 

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

 

DMONTHS = {"Chaos", "Discord", "Confusion", "Bureaucracy", "The Aftermath"};

Print["Today is ", DDAYS[[Mod[dday,4] + 1]],", ",DMONTHS[[season+1]]," ",dday,", YOLD ",year]

];

{{Out}}

<pre>DiscordianDate[2012,2,28]

DiscordianDate[2012,3,1]

-> Today is Setting Orange, Chaos 60, YOLD 3178</pre>

 

=={{header|Pascal}}==

program ddate;

{

WriteLn(Eris);

end.

{{Out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

use strict;

use warnings;

say "$_ is " . ddate($_) for qw< 2010-07-22 2012-02-28 2012-02-29 2012-03-01 >;

{{out}}

<pre>2010-07-22 is Pungenday, the 57th day of Confusion in the YOLD 3176

 

=={{header|Phix}}==

{{out}}

<pre>

 

 

<?php

$Anerisia = array(31,28,31,30,31,30,31,31,30,31,30,31);

 

?>

 

{{Out}}

=={{header|PicoLisp}}==

{{trans|Python}}

(let? Date (date Year Month Day)

(let (Leap (date Year 2 29) D (- Date (date Year 1 1)))

(inc (% D 73))

", YOLD "

 

=={{header|Pike}}==

Pike includes a Discordian calendar.

dates can be converted from any calendar to any other.

Result: "Pungenday, 59 Bureaucracy 3177"

> Calendar.Discordian.Day(Calendar.Day(2011,11,11))->format_ext_ymd();

Result: "Setting Orange, 23 The Aftermath 3177"

> Calendar.Day((Calendar.Discordian.Month()+1)->day(1));

 

=={{header|PowerBASIC}}==

#DIM ALL

 

 

? result

 

=={{header|PowerShell}}==

{{works with|powershell|2}}

function ConvertTo-Discordian ( [datetime]$GregorianDate )

{

ConvertTo-Discordian ([datetime]'2/29/2016')

ConvertTo-Discordian ([datetime]'12/8/2016')

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

main:-

holy_day(3, 50, 'Bureflux').

holy_day(4, 5, 'Maladay').

 

{{out}}

 

=={{header|PureBasic}}==

Protected DoY=DayOfYear(Date(Y,M,D,0,0,0)), Yold$=Str(Y+1166)

Dim S.s(4)

EndIf

ProcedureReturn S(DoY/73)+" "+Str(DoY%73)+", Yold "+Yold$

 

=={{header|Python}}==

 

DISCORDIAN_SEASONS = ["Chaos", "Discord", "Confusion", "Bureaucracy", "The Aftermath"]

season, dday = divmod(day_of_year, 73)

return "%s %d, YOLD %d" % (DISCORDIAN_SEASONS[season], dday + 1, year + 1166)

 

=={{header|Racket}}==

{{trans|D}}

 

;;;; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

;;;; Derived from 'D' Implementation

(check-equal? (discordian/ymd 2010 1 5) "Mungday, in the YOLD 3176")

(check-equal? (discordian/ymd 2011 5 3) "Discoflux, in the YOLD 3177"))

 

{{Out}}

{{Works with|rakudo|2015-11-04}}

<!-- Hi ‎Grondilu! Keep up the good work! -->

my @days = << Sweetmorn Boomtime Pungenday Prickle-Prickle 'Setting Orange' >>;

sub ordinal ( Int $n ) { $n ~ ( $n % 100 == 11|12|13

 

say "$_ is {.&ddate}" for < 2010-07-22 2012-02-28 2012-02-29 2012-03-01 >;

 

{{out}}

2012-03-01 is Setting Orange, the 60th day of Chaos in the YOLD 3178

</pre>

 

=={{header|REXX}}==

 

If the Gregorian date is omitted or specified as an asterisk &nbsp; ('''*'''), &nbsp; the current date is used.

@day.1= 'Sweetness' /*define the 1st day─of─Discordian─week*/

@day.2= 'Boomtime' /* " " 2nd " " " " */

leapyear: procedure; parse arg y /*obtain a four─digit Gregorian year. */

if y//4 \== 0 then return 0 /*Not ÷ by 4? Then not a leapyear. */

{{out|input|text=&nbsp; when using the (various) following inputs of:}}

<pre>

Boomtime, Bureaucracy 73, 3181

Setting Orange, The Aftermath 73, 3266

</pre>

 

=={{header|Ruby}}==

 

class DiscordianDate

%Q{#{@st_tibs ? "St. Tib's Day" : "%s, %s %d" % [weekday, season, day]}, #{year} YOLD}

end

 

Testing:

dd = DiscordianDate.new(*date)

puts "#{"%4d-%02d-%02d" % date} => #{dd}"

{{Out}}

<pre>2012-02-28 => Prickle-Prickle, Chaos 59, 3178 YOLD

permission of the author.

 

 

use chrono::NaiveDate;

format!("{}{}", s, suffix)

}

 

{{Out}}<pre>$ ./ddate -1166-1-1

 

{{trans|Python}}

 

import java.util.GregorianCalendar

} else

println("usage: DDate [day month year]")

Test:

Confusion 57, 3176 YOLD

scala rosetta.DDate 28 2 2012

scala rosetta.DDate 19 10 2015

Bureaucracy 73, 3181 YOLD

 

=={{header|Seed7}}==

include "time.s7i";

writeln("Discordian date computation works.");

end if;

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var seasons = %w(Chaos Discord Confusion Bureaucracy The\ Aftermath);

%w(2010-07-22 2012-02-28 2012-02-29 2012-03-01).each { |ymd|

say "#{ymd} is #{ddate(ymd)}"

{{out}}

<pre>

 

=={{header|Swift}}==

 

let monthDays = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]

showDiscordianDate(year: 2019, month: 7, day: 15)

showDiscordianDate(year: 2025, month: 3, day: 19)

 

{{out}}

 

=={{header|Tcl}}==

proc disdate {year month day} {

# Get the day of the year

incr year 1166

return "$season $dos, $year YOLD"

Demonstrating:

puts [disdate 2012 2 28]

puts [disdate 2012 2 29]

{{Out}}

<pre>

{{libheader|Wren-date}}

{{libheader|Wren-fmt}}

 

var seasons = ["Chaos", "Discord", "Confusion", "Bureaucracy", "The Aftermath"]

var dt = Date.parse(date)

System.print("%(date) = %(discordian.call(dt))")

 

{{out}}

=={{header|zkl}}==

{{trans|D}}

var [const]

seasons=T("Chaos","Discord","Confusion","Bureaucracy","The Aftermath"),

dWday:=weekday[(doy - 1)%5];

"%s, day %s of %s in the YOLD %s".fmt(dWday,dsDay,dSeas,dYear);

T(2010,1, 5), T(2011,5, 3))){

"%d-%02d-%02d is -->%s".fmt(y,m,d,discordianDate(y,m,d)).println();

{{out}}

<pre>