Pour les calendriers grégoriens, le format de la date varie d'un pays à l'autre. Il existe trois principaux formats reconnus:

1. YY-MM-DD (big-endian)
2. DD-MM-YY (petit endian)
3. MM-DD-YY (moyen-endien)

Votre tâche consiste à écrire un programme qui, étant donné une chaîne d'entrée représentant une date, génère tous les formats de date possibles par lesquels cette chaîne peut être interprétée comme une date.

Règles

• La date d'entrée est au format xx-xx-xx, où chaque champ est composé de deux chiffres et complété par un zéro.
• La date est toujours valide (vous ne pouvez donc pas obtenir des choses comme 14-13-17)
• La date est toujours au moins l'un des formats ci-dessus (donc vous ne pouvez pas obtenir des choses comme 17-14-11)
• Parce que nous sommes en fait dans un monde parallèle, il y a 31 jours pour chaque mois de l'année , et par conséquent aucune année bissextile
• La date est comprise entre le 01 janvier 2001 et le 31 décembre 2099
• S'il n'y a qu'un seul format pour la date, le code doit l'imprimer uniquement (seuls les retours à la ligne sont autorisés)
• S'il existe plusieurs formats pour la date, ils doivent être séparés par une virgule, un espace, une nouvelle ligne ou une combinaison de ceux-ci.
• Vous devez afficher le ou les noms exacts du ou des formats. L'utilisation de valeurs arbitraires distinctes n'est pas autorisée.
• Aucun caractère de début ou de fin autre qu'un espace de fin n'est autorisé
• La sortie doit être en minuscules
• Vous n'êtes pas autorisé à utiliser les fonctions de date ou de calendrier intégrées
• Les formats de sortie ne doivent pas être triés

Exemples

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

Il s'agit de code-golf, donc le code le plus court en octets l'emporte. Des explications sont encouragées.

05AB1E , 40 octets

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

Essayez-le en ligne!

Explication

'-¡©                                      # 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 octets

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),

Essayez-le en ligne!

Python 2 , moins l'analyse en entrée, 123 octets

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),

Essayez-le en ligne!

JavaScript (ES6), 121 119 118 112 octets

Renvoie une chaîne délimitée par des espaces avec un espace de fin.

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``

Comment?

Nous divisons l'entrée en a , b et c . Parce que la date est garantie d'être valide, nous savons avec certitude que b est inférieur à 32. Par conséquent, il suffit de tester si a est inférieur à 13 pour valider le format moyen-endien. Les formats little-endian et big-endian nécessitent que b soit inférieur à 13 et un autre test sur a et c respectivement pour valider la journée.

D'où les 3 tests:

• Big-endian: b <13 & c <32
• Little-endian: b <13 et a <32
• Moyen-endian: a <13

Cas de test

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 octets

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

Golfé.

Merci à manatwork pour quelques conseils

Enregistré 9 octets supprimant la vérification pour moins de 32 dans la réponse Arnauld follwing milieu-endian

4 octets enregistrés en utilisant différentes variables au lieu d'un tableau

Essaye-le!

C #, 180 octets

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":"")}";};

Les sorties avec uniquement des valeurs séparées par des espaces peuvent également avoir des espaces de début et de fin. S'actualisera lorsque l'OP aura clarifié ce point si nécessaire.

Version complète / formatée:

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 octets

[$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:"";

Cas de test

Lot, 138 octets

@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

Vaguement basé sur la réponse de @ ovs.

Java 232 octets

(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);}

Voici une version plus agréable

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

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

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

Je ne savais pas vraiment comment formater cette partie ...

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 octets

[$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 ":"";