Palindrome dates: Difference between revisions

Write a program which calculates and shows the next 15 palindromic dates for those countries which express their dates in the   '''yyyy-mm-dd'''   format.

<br><br>

 

=={{header|Ada}}==

with Ada.Calendar.Formatting;

with Ada.Calendar.Arithmetic;

Date := Date + 1;

end loop;

 

=={{header|AppleScript}}==

===Procedural===

script o

property output : {}

end palindromeDates

 

 

{{output}}

===Functional===

 

use framework "Foundation"

use scripting additions

set my text item delimiters to dlm

str

{{Out}}

<pre>Count of palindromic dates [2021..9999]: 284

9280-08-29

9290-09-29</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f PALINDROME_DATES.AWK

BEGIN {

return(rts)

}

{{out}}

<pre>

21211212 92800829

21300312 92900929

</pre>

 

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

{{works with|BBC BASIC for Windows}}

DIM B% 8

TestDate%=FN_today

TestDate%+=1

UNTIL VPOS=15

{{out}}

<pre>

=={{header|C}}==

This only works if time_t is a 64-bit type.

#include <stdio.h>

#include <string.h>

}

return 0;

 

{{out}}

 

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

using System.Linq;

using System.Collections.Generic;

bool IsValidDate(int y, int m, int d, out DateTime date) => DateTime.TryParse($"{y}-{m}-{d}", out date);

}

{{out}}

<pre>

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

{{libheader|Boost}}

#include <string>

#include <boost/date_time/gregorian/gregorian.hpp>

}

return 0;

 

{{out}}

<pre>

Next 15 palindrome dates:

2021-12-02

2030-03-02

 

=={{header|Clojure}}==

(defn valid-date? [[y m d]]

(and (<= 1 m 12)

(map date-str)

(take n)))

 

{{out}}

("2021-12-02" "2030-03-02" "2040-04-02" "2050-05-02" "2060-06-02" "2070-07-02" "2080-08-02" "2090-09-02" "2101-10-12" "2110-01-12" "2111-11-12" "2120-02-12" "2121-12-12" "2130-03-12" "2140-04-12")

</pre>

 

=={{header|F_Sharp|F#}}==

open System

 

|> Seq.take 15

|> Seq.iter print_date

{{out}}

<pre>> dotnet fsi palindrome_dates.fsx

A simple brute force solution that repeatedly increments a timestamp's day by one and checks whether it's a palindrome:

{{works with|Factor|0.99 2020-01-23}}

sequences sets ;

 

[ "-" without dup reverse = ] lfilter ;

 

{{out}}

<pre>

A faster version that directly generates palindromic numbers such as <tt>20200202</tt> and keeps those which are valid dates:

{{works with|Factor|0.99 2020-01-23}}

lists.lazy math math.functions math.parser math.ranges sequences ;

 

 

"10,000th palindrome date after 2020-02-02: " write

{{out}}

<pre>

10,000th palindrome date after 2020-02-02: 1250101-05-21

</pre>

 

=={{header|Go}}==

Simple brute force as speed is not an issue here.

 

import (

}

}

 

{{out}}

</pre>

Or, a more ambitious version.

 

import (

}

fmt.Println()

 

{{out}}

 

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

import Data.Maybe (mapMaybe)

 

palinDates :: [Day]

palinDay y = fromGregorianValid y m d

where

 

 

main :: IO ()

let n = length palinDates

{{Out}}

<pre>Count of palindromic dates [2021..9999]: 284

9280-08-29

9290-09-29</pre>

 

=={{header|Java}}==

import java.time.LocalDate;

import java.time.format.DateTimeFormatter;

 

}

{{Out}}

<pre>

=={{header|Javascript}}==

===Procedural===

* Adds zeros for 1 digit days/months

* @param date: string

}

 

{{Out}}

<pre>2021-12-02 ​

2140-04-12 ​</pre>

===Functional===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Count of palindromic dates [2021..9999]: 284

9280-08-29

9290-09-29</pre>

 

=={{header|Julia}}==

Uses the built-in Dates package to check date validity but not for iteration.

function datepalindromes(nextcount=20)

datepalindromes()

<pre>

Date palindromes:

2190-09-12

</pre>

 

=={{header|Perl}}==

===Date calculation===

The more robust solution, using a date/time module.

my $d = Time::Piece->strptime("2020-02-02", "%Y-%m-%d");

 

print $d->strftime("%Y-%m-%d\n");

}

{{out}}

<pre>

Given the limited look-ahead required by the task, processing date-like strings can also work.

{{libheader|ntheory}}

use warnings;

use feature 'say';

say s/ /-/gr;

last if 15 == ++$cnt;

{{out}}

<pre>2021-12-02

 

=={{header|Phix}}==

{{out}}

<pre>

9180-08-19 9210-01-29 9221-12-29 9250-05-29 9280-08-29

9190-09-19 9211-11-29 9230-03-29 9260-06-29 9290-09-29

</pre>

 

Defined in terms of string reversal:

{{Works with|Python|3.7}}

 

from datetime import datetime

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Count of palindromic dates [2021..9999]:

Or, defined in terms of integer operations, rather than string reversals:

{{Works with|Python|3.7}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Count of palindromic dates [2021..9999]:

9280-08-29

9290-09-29</pre>

 

=={{header|Raku}}==

Pretty basic, but good enough. Could start earlier but 3/2/1 digit years require different handling that isn't necessary for this task. (And would be pretty pointless anyway assuming we need 2 digits for the month and two digits for the day. ISO:8601 anybody?)

 

my @palindate = {

 

say "\nTotal number of five digit year palindrome dates:\n" ~

{{out}}

<pre>2020-02-02

The &nbsp; '''date''' &nbsp; BIF &nbsp; (with the &nbsp; '''base''' &nbsp; argument) &nbsp; converts a date to the number of years since the beginning of

<br>the Gregorian calendar, &nbsp; the date is in the &nbsp; '''ISO''' &nbsp; format &nbsp; (International Standards Organization &nbsp; 8601:2004).

/* ───── */

parse arg n from . /*obtain optional argumets from the CL*/

say 'a palindromic date: ' aDate /*display a palindromic date ──► term. */

#= # + 1 /*bump the counter of palindromic dates*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

a palindromic date: 2130-03-12

a palindromic date: 2140-04-12

</pre>

 

=={{header|Ruby}}==

 

palindate = Enumerator.new do |yielder|

end

 

{{out}}

<pre>

 

=={{header|Rust}}==

// chrono = "0.4"

 

date = date.succ();

}

 

{{out}}

=={{header|Sidef}}==

{{trans|Ruby}}

for y in (2020 .. 9999) {

var (m, d) = Str(y).flip.last(4).split(2)...

]) {

say ("\n#{a}\n", b.slices(5).map { .join(" ") }.join("\n"))

{{out}}

<pre>

9211-11-29 9220-02-29 9221-12-29 9230-03-29 9240-04-29

9250-05-29 9260-06-29 9270-07-29 9280-08-29 9290-09-29

</pre>

 

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

printf format, rev and date commands are the keys :

 

for _H in {2..9}; do

done

done

{{out}}

<pre>

2130-03-12

...

</pre>

 

{{libheader|Wren-fmt}}

{{libheader|Wren-date}}

 

var isPalDate = Fn.new { |date|

count = count + 1

}

 

{{out}}

2140-04-12

</pre>

 

=={{header|zkl}}==

while(n){

ds:=TD.toYMDString(date.xplode()) - "-";

if(ds==ds.reverse()){ n-=1; println(TD.toYMDString(date.xplode())); }

date=TD.addYMD(date,0,0,1);

{{out}}

<pre>