Las fechas palindrómicas son fechas que aparecen como palíndromos: la cadena de dígitos se puede leer de la misma manera hacia atrás que hacia adelante. Para el formato de fecha norteamericano (MM / DD / AAAA), las siguientes fechas palindrómicas son:

02/02/2020

12/02/2021

03/02/2030

El reto

Cree una función que devuelva todas las fechas palindrómicas en un formato de fecha común y consistente (de su elección) que se encuentre dentro de un rango de fechas ( edición: incluido el rango en sí ).

Reglas

• Para calificar como palíndromo, solo se deben verificar los caracteres numéricos de la fecha.
• La fecha puede estar en cualquier formato común ( MM/DD/YYYY, DD-MM-YYYY), siempre que use dos dígitos para el mes y el día y cuatro para el año, y use un carácter para separar partes de la fecha. La salida debe preservar caracteres seperating ( /, -, etc.). Su función solo necesita manejar un formato de fecha distinto. Incluya el formato en su respuesta.
• Si hay más de una fecha devuelta, deben estar separadas por comas o líneas nuevas.
• ¡La respuesta más corta gana!

Ejemplo

date_palindrome('05/02/2050', '12/12/2060')
>>>['05/02/2050', '06/02/2060']

MATL, 24 23 bytes

YOZ}&:"@23XOtt47>)tP=?8M

Acepta entradas en forma de una matriz de cadenas {lower, upper}donde está el formato de fecha 'MM/DD/YYYY'. La salida también está en el formato MM/DD/YYYY.

Pruébalo en línea

Explicación

        % Implicitly grab the two inputs
YO      % Convert to serial date format
Z}      % Push them onto the stack separately
&:      % Create an array from [lower...upper] incrementing 1 day
"       % For each day
  @23XO % Get the string version of the date (mm/dd/yyyy)
  tt    % Duplicate twice
  47>)  % Get the numeric parts
  tP=   % Compare numeric part with the flipped version of the numeric part
  ?8M   % If they are the same push it to the stack
        % Implicitly display stack contents

Bash + GNU utilidades, 116 84

Requiere una versión de fecha de 64 bits para el caso de prueba dado.

set date -uf- +%
jot -w@ - `$@s` 86400|$@F|sed -r 'h
:
s/-|^(.)(.*)\1$/\2/
t
/./d
g'

I / O está en YYYY-MM-DDformato. La entrada se toma de dos líneas de stdin, p. Ej.

printf "%s\n" 2050-05-02 2060-12-12 | ./palindate.sh

Explicación

• setguarda la plantilla de comando de fecha para poder acceder a ella utilizando el $@parámetro
• date -uf- +%s convierte fechas de punto final en número de segundos desde la época de Unix
• jot interpola esto para dar una lista de segundos de la época, uno por día, cada uno con el prefijo @
• date -uf- +%F formatea cada entrada de la lista como YYYY-MM-DD
• sed comprueba si hay palíndromos:
  • h guardar la línea de entrada en el búfer de retención
  • : definir etiqueta "sin nombre"
  • s/-|^(.)(.*)\1$/\2/ Si se encuentra un guión, elimínelo o si el primer y el último carácter coinciden, elimínelos
  • t si hubo una coincidencia arriba, regrese a la etiqueta sin nombre
  • /./d si quedan caracteres, la línea no es un palíndromo: elimínelo y continúe con la línea siguiente
  • gsi llegamos aquí, entonces no se eliminó la línea, por lo que la línea debe haber sido un palíndromo. Recupere la línea del búfer de retención e implíquela.

Python 2, 197 bytes

¡Un byte guardado gracias a @cat!

from datetime import*
def g(a,b):
 for s in"ab":exec"%s=date(*[int(x)for x in %s.split('-')])"%(s,s)
 for d in range((b-a).days+1):
    x=str(a+timedelta(d));y=x.replace("-","")
    if y==y[::-1]:print x

Pruébalo aquí!

El formato de entrada y salida es YYYY-MM-DD. El primer nivel de intención es espacios, el segundo es pestañas.
No pasa nada especial aquí. Utiliza algunos execabusos para convertir la entrada en dateobjetos dividiendo la cadena de fecha -y salpicando la lista en el dateconstructor. Luego, iteramos sobre todas las fechas en su rango inclusivo e imprimimos las que son palindrómicas.

PowerShell v2 +, 127 bytes

for($a,$b=[datetime[]]$args;$a-le$b){if(($c="{0:yyyyMMdd}"-f$a)-eq-join$c[$c.length..0]){"{0:MM/dd/yyyy}"-f$a}$a=$a.AddDays(1)}

Toma la entrada como argumentos de la línea de comandos $argsen MM/DD/YYYYformato (o similar) y la refundye como una [datetime]matriz, los almacena en $ay $b. Ese es el paso de configuración del forbucle. El condicional es tan largo como $asea ​​menor o igual que $b.

Cada iteración, establecemos $cigual a una -fcadena de yyyyMMddestilo ormatizada , basada en $a. Luego comparamos si eso es -equal a $cinvertido (usando un truco de combinación de matrices). Si es así, sacamos $aen el formato adecuado. De cualquier manera, incrementamos $acon .AddDays(1)para pasar al día siguiente.

Ejemplo

PS C:\Tools\Scripts\golfing> .\forecast-palindromic-dates.ps1 '06/23/2016' '12/12/2020'
02/02/2020

Julia, 132 bytes

f(a,b,t=s->DateTime(s,"mm/dd/y"),g=d->Dates.format(d,"mm/dd/yyyy"))=map(g,filter(d->(r=replace(g(d),"/",""))==reverse(r),t(a):t(b)))

Esta es una función que acepta dos cadenas y devuelve una matriz de cadenas.

Sin golf:

function f(a, b)
    # Define a function to create a DateTime object from a string
    t = s -> DateTime(s, "mm/dd/y")

    # Define a function to create a string from a DateTime object
    g = d -> Dates.format(d, "mm/dd/yyyy")

    # Filter the range a:b to palindromic dates
    p = filter(d -> (r = replace(g(d), "/", "")) == reverse(r), t(a):t(b))

    # Format all dates in the array
    m = map(g, p)

    return m
end

Pruébalo en línea!

JavaScript (ES6), 159154 bytes

(s,e)=>{for(r=[],s=Date.parse(s),e=Date.parse(e);s<=e;s+=864e5){d=new Date(s).toJSON().slice(0,10);`${a=d.match(/\d/g)}`==a.reverse()&&r.push(d)}return r}

E / S en formato ISO. Sin golf:

function date_palindrome(start, end) {
    start = Date.parse(start);
    end = Date.parse(end);
    var result = [];
    while (start <= end) {
        var date = new Date(start).toISOString().slice(0, 10);
        var digits = date.match(/d/g);
        if (digits.join() == digits.reverse.join()) {
            result.push(date);
        }
        start += 24 * 60 * 60 * 1000; // ms
    }
    return result;
}

TSQL, 88 bytes

Usando el formato ISO8601 para la fecha (aaaa-mm-dd)

DECLARE @ date='2050-05-02',@t date='2060-12-12'

a:IF stuff(reverse(@),3,1,'')=stuff(@,8,1,'')PRINT @
SET @=dateadd(d,1,@)IF @<=@t GOTO a

Violín

Java 7, 436 435 416 bytes * suspiro .. *

import java.text.*;import java.util.*;void c(String...a)throws Exception{DateFormat f=new SimpleDateFormat("dd-MM-yyyy");Calendar s=Calendar.getInstance(),e=Calendar.getInstance();s.setTime(f.parse(a[0]));e.setTime(f.parse(a[1]));for(Date d=s.getTime();s.before(e);s.add(5,1),d=s.getTime()){String o=f.format(d),x=o.replaceAll("\\W|_",""),w="";for(char c:x.toCharArray())w=c+w;if(x.equals(w))System.out.println(o);}}

Formato de entrada y salida: dd-MM-yyyy

Ungolfed y código de prueba:

Pruébalo aquí

import java.text.*;
import java.util.*;

class Main{
  static void c(String... a) throws Exception{
    DateFormat f = new SimpleDateFormat("dd-MM-yyyy");
    Calendar s = Calendar.getInstance(),
             e = Calendar.getInstance();
    s.setTime(f.parse(a[0]));
    e.setTime(f.parse(a[1]));
    for(Date d = s.getTime(); s.before(e); s.add(Calendar.DATE, 1), d = s.getTime()){
      String o = f.format(d),
             x = o.replaceAll("\\W|_", ""),
             w = "";
      for(char c : x.toCharArray()){
        w = c + w;
      }
      if(x.equals(w)){
        System.out.println(o);
      }
    }
  }

  public static void main(String[] a){
    try{
      c("05-02-2050", "12-12-2060");
    } catch (Exception e){}
  }
}

Salida:

05-02-2050
15-02-2051
25-02-2052
06-02-2060

Oracle 11: SQL: 246 bytes (hey, al menos vencí a Java: P lol)

with d as(select to_date('&1','yyyy-mm-dd')s,to_date('&2','yyyy-mm-dd')e from dual),r as(select level-1 l from d connect by level<=e-s+1),x as(select s+l y,to_char(s+l,'yyyymmdd')w from d,r)select to_char(y,'yyyy-mm-dd')from x where w=reverse(w);

Salida:

  SQL> with d as(select to_date('&1','yyyy-mm-dd')s,to_date('&2','yyyy-mm-dd')e from dual),r as(select level-1 l from d connect by level<=e-s+1),x as(select s+l y,to_char(s+l,'yyyymmdd')w from d,r)select to_char(y,'yyyy-mm-dd')from x where w=reverse(w);
  Enter value for 1: 2000-01-01
  Enter value for 2: 2021-01-01

  TO_CHAR(Y,
  ----------
  2001-10-02
  2010-01-02
  2011-11-02
  2020-02-02

  SQL>

En formato legible:

  with d as (select to_date('&1','yyyy-mm-dd') s,
                    to_date('&2','yyyy-mm-dd') e
              from dual),
        r as (select level-1 l 
                from d connect by level <= e-s+1),
        x as (select s+l y, to_char(s+l,'yyyymmdd') w 
                from d,r)
  select to_char(y,'yyyy-mm-dd')
    from x 
   where w=reverse(w);

Explicado:

d: get input for start/end
r: generate rows needed, 1 per day.
x: calculate the actual dates, and convert them to a minimal string.
final: use REVERSE function to verify the palindroms, return in proper format.

Aprendí sobre la función REVERSE hoy :)

C #, 97 94 bytes

(a,b)=>{for(;a<b;a=a.AddDays(1))if($"{a:yyy}".SequenceEqual($"{a:MMdd}".Reverse()))a.Dump();};

C # lambda ( Action) donde están las entradas DateTimey la salida se imprime utilizando el .Dump()método ( truco de @ EvilFonti ).

C #, 115 112 bytes

(a,b)=>{var r="";for(;a<b;a=a.AddDays(1))if($"{a:yyy}".SequenceEqual($"{a:MMdd}".Reverse()))r+=a+",";return r;};

C # lambda ( Func) donde las entradas son DateTimey la salida es a string.

Código:

(a,b)=> {
    var r="";
    for(;a<b;a=a.AddDays(1)) {
        if($"{a:yyy}".SequenceEqual($"{a:MMdd}".Reverse()))
            r+=a+",";
    }
    return r;
};

¡Pruébalos en línea!

VBA, 240 193 bytes

Function f(a, b)
Dim j, g()
For i = CDate(a) To CDate(b)
    If Format(i, "yyyy") = StrReverse(Format(i, "mmdd")) Then
        ReDim Preserve g(j)
        g(j) = Format(i, "yyyy-mm-dd")
        j = j + 1
    End If
Next
f = g()
End Function

Eso es en un formato comprensible. Caso de prueba:

Sub e()
MsgBox Join(f("5/2/2050", "6/2/2060"), ", ")
End Sub

Sin tanta redundancia:

Function f(a,b)
Dim j, g()
For i=CDate(a) To CDate(b)
If Format(i,"yyyy")=StrReverse(Format(i,"mmdd")) Then
ReDim Preserve g(j)
g(j)=Format(i,"yyyy-mm-dd")
j=j+1
End If
Next
f=g()
End Function

Javascript (usando una biblioteca externa) (158 bytes)

(a,b)=>_.RangeTo(a%1e20,b%1e20,864e5).Select(y=>new Date(y)).Where(x=>z=(_.From(x.toJSON()).Where(y=>!isNaN(y)).Take(8)).SequenceEqual(z.Reverse())).ToArray()

Enlace a lib: https://github.com/mvegh1/Enumerable

Explicación del código: Ok, finalmente utilicé algunos códigos reales de golf aquí por una vez. Entonces las entradas a, b son objetos de fecha. Cree un rango de enteros de a a b, donde ayb se convierten en enteros, y la distancia entre los valores en el rango es 86400000, es decir, la cantidad de tics en un día. Asigne cada valor en el rango a un objeto de fecha. Filtre ese rango por el predicado que representa fechas palindrómicas. La lógica para determinar que es simple ... convierte la representación de cadena JSON del objeto de fecha actual en una matriz de caracteres usando la biblioteca y filtra las entradas no numéricas, y solo toma los primeros 8 valores (porque eso sería aaaaMMdd ) y almacénelo en la variable z, luego verifique si z es equivalente a z Invertido. Finalmente, vuelva a la matriz nativa de JS

Editar: Afeitó 2 bytes eliminando parens innecesarios.

Java, 269 bytes

import java.time.LocalDate;void q(String...a)throws Exception{LocalDate s=LocalDate.parse(a[0]);while(!s.isAfter(LocalDate.parse(a[1]))){String d=s.toString().replace("-","");if(d.equals(new StringBuffer(d).reverse().toString()))System.out.println(d);s=s.plusDays(1);}}

Sin golf:

import java.io.IOException;
import java.time.LocalDate;

public class UnGolfedPalindromicDates {
    public static void main(String...a) throws IOException {
        LocalDate start = LocalDate.parse(a[0]), end = LocalDate.parse(a[1]);
        while (!start.isAfter(end)) {
            String d = start.toString().replace("-","");
            if (palindrome(d)) System.out.println(d);
            start = start.plusDays(1);
        }
    }

    public static boolean palindrome(String s) {
        return s.equals(new StringBuffer(s).reverse().toString());
    }
}