Para los calendarios gregorianos, el formato de fecha varía de un país a otro. Hay tres formatos principales reconocidos:

1. YY-MM-DD (big-endian)
2. DD-MM-YY (little-endian)
3. MM-DD-YY (endian medio)

Su tarea es escribir un programa que, dada una cadena de entrada que representa una fecha, genere todos los formatos de fecha posibles mediante los cuales esta cadena se puede interpretar como una fecha.

Reglas

• La fecha de entrada está en el formato xx-xx-xx, donde cada campo tiene dos dígitos y está rellenado con ceros.
• La fecha siempre es válida (por lo que no puede obtener cosas como 14-13-17)
• La fecha siempre es al menos uno de los formatos anteriores (por lo que no puede obtener cosas como 17-14-11)
• Debido a que, de hecho, estamos en un mundo paralelo, hay 31 días para cada mes del año y, en consecuencia, no hay años bisiestos.
• La fecha es entre el 1 de enero de 2001 y el 31 de diciembre de 2099.
• Si solo hay un formato para la fecha, el código solo debe imprimirlo (solo se permiten líneas nuevas)
• Si hay varios formatos para la fecha, deben estar separados por una coma, un espacio, una nueva línea o una combinación de esos
• Debe generar los nombres exactos de los formatos. El uso de valores arbitrarios distintos no está permitido.
• No se permiten caracteres iniciales o finales que no sean un espacio final
• La salida debe estar en minúsculas
• No está permitido usar ninguna fecha incorporada o funciones de calendario
• Los formatos de salida no tienen que ser ordenados

Ejemplos

Input      Output
30-05-17   big-endian, little-endian
05-15-11   middle-endian
99-01-02   big-endian
12-11-31   big-endian, little-endian, middle-endian
02-31-33   middle-endian

Este es el código de golf, por lo que gana el código más corto en bytes. Se alientan las explicaciones.

05AB1E , 40 bytes

'-¡©2£13‹`®Á2£32‹*)˜“Œ±„¥„ê“#Ï’-„–ian’«»

Pruébalo en línea!

Explicación

'-¡©                                      # split on "-" and store a copy in register
    2£13‹                                 # compare the first 2 elements to 13
         `                                # split as separate to stack
                                          # the bottom element is true if it is middle endian
                                          # the top value is true if it can be big/little
          ®Á                              # retrieve the list from register and rotate right
            2£32‹                         # compare the first 2 elements to 32
                 *                        # multiply with the result of the comparison to 13
                  )˜                      # wrap in a flattened list
                    “Œ±„¥„ê“#             # push the list ['middle', 'big', 'little']
                             Ï            # index into this with the flattened list
                                          # this leaves the types the date could be
                              ’-„–ian’«   # append "-endian" to each
                                       »  # join on newlines

Python 2 , 123 bytes

a,b,c=map(int,input().split('-'))
for a,b,c in[[b,c,'big'],[b,a,'little'],[a,b,'middle']]:print(c+'-endian')*(a<13)*(b<32),

Pruébalo en línea!

Python 2 , menos análisis de entrada, 123 bytes

d=input()
for a,b,c in[[3,6,'big'],[3,0,'little'],[0,3,'middle']]:print(c+'-endian')*(int(d[a:a+2])<13)*(int(d[b:b+2])<32),

Pruébalo en línea!

JavaScript (ES6), 121 119 118 112 bytes

Devuelve una cadena delimitada por espacios con un espacio final.

s=>['big','little','middle'].map((v,i)=>[b<13&c<32,b<13&a<32,a<13][i]?v+'-endian ':'',[a,b,c]=s.split`-`).join``

¿Cómo?

Dividimos la entrada en una , b y c . Debido a que se garantiza que la fecha es válida, sabemos con certeza que b es menor que 32. Por lo tanto, es suficiente para probar si a es menor que 13 para validar el formato de endian medio. Ascendente hacia la izquierda y formatos big endian requieren b a ser inferior a 13 y otro de prueba en una y C , respectivamente, para validar el día.

De ahí las 3 pruebas:

• Big-endian: b <13 & c <32
• Little-endian: b <13 y a <32
• Endian medio: a <13

Casos de prueba

let f =

s=>['big','little','middle'].map((v,i)=>[b<13&c<32,b<13&a<32,a<13][i]?v+'-endian ':'',[a,b,c]=s.split`-`).join``

console.log(f("30-05-17")) // big-endian, little-endian
console.log(f("05-15-11")) // middle-endian
console.log(f("99-01-02")) // big-endian
console.log(f("12-11-31")) // big-endian, little-endian, middle-endian
console.log(f("02-31-33")) // middle-endian

Bash, 240 125 116 112 bytes

IFS=- read a b c<<<$1
d=-endian
((b<13))&&(((a<32))&&echo little$d;((c<32))&&echo big$d);((a<13))&&echo middle$d

Golfizado

Gracias a manatwork por algunos consejos

Se guardaron 9 bytes eliminando la verificación de menos de 32 en la respuesta de Arnauld que sigue a la respuesta intermedia.

Guardado 4 bytes usando diferentes variables en lugar de una matriz

¡Pruébalo!

C #, 180 bytes

t=(n,m)=>int.Parse(n)<13&int.Parse(m)<32;s=>{var a=s.Split('-');return$"{(t(a[1],a[2])?"big-endian":"")} {(t(a[1],a[0])?"little-endian":"")} {(t(a[0],a[1])?"middle-endian":"")}";};

Las salidas con solo valores separados por espacios, también pueden tener espacios iniciales y finales. Se actualizará cuando el OP haya aclarado ese punto si es necesario.

Versión completa / formateada:

Func<string, string, bool> t = (n, m) => int.Parse(n) < 13 & int.Parse(m) < 32;

Func<string, string> f = s =>
{
    var a = s.Split('-');

    return $"{(t(a[1], a[2]) ? "big-endian" : "")} {(t(a[1], a[0]) ? "little-endian" : "")} {(t(a[0], a[1]) ? "middle-endian" : "")}";
};

PHP, 151 bytes

[$a,$b,$c]=sscanf($argn,"%d-%d-%d");$z="-endian ";echo($m=$b&&$b<13)&&$c&&$c<32?big.$z:"",$m&&$a&&$a<32?little.$z:"",$a&&$a<13&&$b&&$b<32?middle.$z:"";

Casos de prueba

Lote, 138 bytes

@echo off
set/ps=
call:l little %s:-= %
exit/b
:l
call:e big %4 %3
call:e middle %3 %2
:e
if %2 leq 31 if %3 leq 12 echo %1-endian

Vagamente basado en la respuesta de @ ovs.

Java 232 bytes

(String s)=>{String[]i=s.split("-");String e="-endian",b="big"+e,m="middle"+e,l="little"+e;int p=Integer.valueOf(i[0]);System.out.print(p<13?Integer.valueOf(i[1])<13?Integer.valueOf(i[2])<32?b+","+m+","+l:m+","+l:m:p<32?b+","+l:b);}

Aquí hay una versión más bonita

String[] i = s.split("-");

String e = "-endian",
       b = "big" + e,
       m = "middle" + e,
       l = "little" + e;

int p = Integer.valueOf(i[0]);

Realmente no sabía cómo formatear esta parte ...

System.out.print(
        p < 13 ? Integer.valueOf(I[1]) < 13 ? Integer.valueOf(I[2]) < 32 ? b + "," + m + "," + l
                                                                         : m + "," + l
                                            : m 

               : p < 32 ? b + "," + l 
                        : b
);

PHP, 131 bytes

[$a,$b,$c]=explode('-',$argn);foreach([[big,b,c],[little,b,a],[middle,a,b]]as[$t,$x,$y])echo$$x*$$y&&$$x<13&$$y<32?"$t-endian ":"";