Ingresso:

Una data (che contiene dd, MMe yyyy). Un oggetto data o tre numeri interi separati sono validi anche come input.

Produzione:

Ciascuna parte ( dd, MMe yyyy) ritornato individualmente e poi arrotondato alla data valida più vicina.

Ad esempio (nel formato dd-MM-yyyy):
21-10-2016diventa12-01-6102

Regole della sfida:

• Solo dd, MM, yyyyè valido, ma l'ordine e quali-simboli separati si utilizza è la vostra scelta.
  Quindi questi sono alcuni esempi di formato validi: dd-MM-yyyy; MM/dd/yyyy; yyyy MM dd; ddMMyyyy, Ecc
  E questi sono alcuni esempi formato non valido: dd MMM yyyy; dd-MM-'yy; eccetera.
• Puoi anche scegliere di inserire un oggetto Date se la tua lingua lo supporta o tre parametri interi separati, invece della stringa che rappresenta una data.
• Si prega di indicare quale formato data hai usato! (E l'input e l'output devono essere nello stesso formato.) È anche consentito l'output di un oggetto Date, purché sia ​​in grado di gestire tutti i casi di test e la seguente regola di verifica.
• La transizione dal calendario giuliano a quello gregoriano viene ignorata per questa sfida. Quindi 1582è solo un anno inverso valido per 2851.
  Consulta le informazioni / i suggerimenti della sfida per tutti gli anni, i mesi e i giorni validi.
• Dal momento che non puoi avere febbraio al contrario di qualsiasi altro mese, non devi preoccuparti degli anni bisestili.

Tutti gli anni, i mesi e i giorni invertiti:

• L'anno può sempre essere invertito senza problemi, passando da 0001 (invertito di 1000) a 9999 (rimane 9999). (Quindi 0000non è un input valido e non ci sono anche casi di test per questo.)
• Gli unici mesi che hai invertito sono: gennaio (invertito da ottobre / 10); Ottobre (invertito da gennaio / 01); Novembre (rimane novembre / 11); e dicembre (invertito da ogni altro mese / 02- 09, 12).
• Gli unici giorni che hai invertito sono: 01 (invertito da 10), 02 (invertito da 20), 03 (invertito da 30), 10 (invertito da 01), 11 (rimane 11), 12 (invertito da 21), 13 (invertito da 31) , 20 (invertito da 02), 21 (invertito da 12), 22 (rimane 22), 30 (invertito 03o uguale a 31 di novembre!), 31 (invertito da 04- 09/ 13-19/ 23- 29).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e dichiarazioni / output di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi di prova ( dd-MM-yyyycome formato):

21-07-2016   ->   12-12-6102
12-11-1991   ->   21-11-1991
01-01-2000   ->   10-10-0002
27-08-1875   ->   31-12-5781
18-12-2010   ->   31-12-0102
13-01-1981   ->   31-10-1891
04-11-1671   ->   30-11-1761  // Semi-tricky case, since November has 30 days
28-11-2036   ->   30-11-6302  // Semi-tricky case, since November has 30 days
14-06-1855   ->   31-12-5581
30-10-9999   ->   03-01-9999
01-01-2851   ->   10-10-1582

Convesso , 23 byte

Il conteggio dei byte presuppone la codifica CP-1252.

qS/Wf%_1=:=31^sCs¶.e<S*

Il formato I / O è dd mm yyyy.

Provalo online!

Questa è una porta diretta della mia risposta CJam . Convex è fortemente basato su CJam, e quindi l'unica differenza è l'uso dell'operatore Convex ¶che avvolge i primi due elementi dello stack in un elenco, salvando un byte [...].

CJam, 24 byte

qS/Wf%[_1=:=31^sCs].e<S*

Il formato I / O è dd mm yyyy.

Provalo online!

Stesso conteggio byte, formato I / O mm dd yyyy:

qS/Wf%_0=:=1231^s2/.e<S*

Provalo online!

Spiegazione

qS/     e# Read input, split around spaces.
Wf%     e# Reverse each component.
[       e# Set marker for new list.
  _1=   e#   Duplicate reversed strings, extract reversed month.
  :=    e#   Check for equality of the characters. This gives 1 for
        e#   November (11) and 0 for everything else.
  31^   e#   XOR the result with 31, giving 30 for November and 31
        e#   for everything else.
  s     e#   Convert the result to a string, "30"/"31".
  Cs    e#   Push 12, convert to string, "12".
]       e# Wrap "30"/"31" and "12" in a list.
.e<     e# Element-wise minimum. This clamps the day and month to their
        e# respective maxima.
S*      e# Join the result with spaces.

L'altra versione funziona in modo simile, tranne per il fatto che iniziamo dall'intero 1230o 1231prima di convertirlo in ["12" "30"] o ["12" "31"].

Pyth, 55 53 46 43 41 byte

APJ_Mczd = HhS, 12sH = GhS, sGC @. "❤❤ó» î "H%"% 02d% 02d% s "[GHeJ 
APJ_Mczd = hS, 12sH = hS, sGC @." ❤❤ó »î" H% "% 02d% 02d% s" [GHeJ 
APJ_Mcz \ -% "% 02d% 02d% s" [hS, sGx31q11sHhS, 12sHeJ
 APJ_Mczdjd [> 2+ \ 0hS, sGx31q11sH> 2+ \ 0hS, 12sHeJ
APJ_Mczdjd. [L \ 02 [ `HS sGx31q11sH`hS, 12sHeJ

dove ❤❤c'erano due non stampabili, rispettivamente U + 001C e U + 001F.

Suite di test.

Python 3, 82 byte

lambda x:[min(x[0][::-1],['31','30'][x[1]=='11']),min(x[1][::-1],'12'),x[2][::-1]]

Una funzione anonima che accetta, tramite argomento, la data come un elenco di stringhe del modulo ['dd', 'mm', 'yyyy']e restituisce la data inversa convalidata nello stesso formato.

Come funziona

Python confronta i caratteri e le stringhe con i loro punti di codice Unicode. Ciò significa che qualsiasi confronto su due o più numeri interi restituisce lo stesso di quel confronto su tali numeri interi come stringhe. Quindi, chiamando mindue numeri interi come stringhe restituisce il numero intero più piccolo come stringa; prendendo la parte di data invertita come argomento e il valore massimo come altro, il giorno e il mese vengono fissati all'intervallo desiderato. Le parti della data vengono invertite indicizzando con i passaggi di -1( [::-1]) e il valore massimo per il mese viene modificato da '31'a '30'se il mese è novembre indicizzandolo in un elenco con il risultato booleano di un condizionale.

Provalo su Ideone

Dyalog APL , 32 33 byte

⍕¨{⍵-3↑31 11≡2↑⍵}31 12 1E4⌊⍎∊⍕⌽¨⎕

L'I / O è un elenco di tre stringhe ( 'dd' 'mm' 'yyyy').

TryAPL , ma nota che ⎕(richiesta di input) è stato sostituito ⍵e l'intera riga racchiusa in {... }per abilitare il test online e ⍎(esegui espressione) è stato sostituito con 2⊃⎕VFI(verifica e correggi input) perché l'esecuzione di codice arbitrario è bloccata .

C # 314 305 299 249 232 223 byte

using System.Linq;string f(int d,int m,int y){Func<int,string>r=i=>string.Concat((""+i).PadLeft(2,'0').Reverse());Func<string,int,string>x=(j,k)=>int.Parse(j)>k?""+k:j;return x(r(d),m==11?30:31)+"-"+x(r(m),12)+"-"+r(y);}

Grazie a @KevinCruijssen per aver sottolineato che ho potuto abbreviare la mia dichiarazione delle variabili, il che ha anche reso la stringa di aliasing in grado di salvare alcuni byte.

50 byte salvati che memorizzano la funzione di inversione per il riutilizzo e altri 13 facendo lo stesso per l'arrotondamento e rimuovendo le dichiarazioni delle variabili.

L'ultimo aggiornamento rende la stringa di alias non più un risparmio di byte.

Versione Ungolfed:

using System.Linq;
    string dateReverse(int day, int month, int year)
{
    //setup a resuable function to reverse
    Func<int, string> reverse = intToReverse => string.Concat((""+intToReverse).PadLeft(2, '0').Reverse());

    //another function for rounding
    Func<string, int, string> round = (strToRound, maxVal) => int.Parse(strToRound) > maxVal ? "" + maxVal : strToRound;

    //Join the strings into the "dd-mm-yyyy" date format
    return 
        //Round down the day value, if november cap to 30 otherwise cap to 31
        round(reverse(day), month == 11 ? 30 : 31) + "-" +

        //Round the month down
        round(reverse(month), 12) + "-" +

        //we can use the reverse function here too and pad left just won't do anything
        reverse(year);
}

Provalo qui

Javascript, 106 105 94 byte

d=>d.split`,`.map((a,b,r)=>(e=[...a].reverse().join``,f=!b?r[1]==11^31:b<2&&12,f&&f<e?f:e))+''

Suite di test (rev.3)

Spiegazione

d=>d.split`,`                 // split into sections by `,`

.map((a,b,r)=>(               // map each section

e=[...a].reverse().join``,    // spread a date section into array and reverse and 
                              // join with `` to get string result

f=!b?r[1]==11^31              // if section being mapped is day (section 0), 
                              // then max (f) is 30 for November(month 11) or else 31

:b<2&&12,                     // if part being mapped is month (section 1), then max (f) is 12

f&&f<e?f:e))                  // if there is a max (f)
                              // and the max (f) is less than the reversed string (e),
                              // then return the max (f), 
                              // else return the reversed string (e)

+''                           // join all the sections back together with `,` 
                              // (concatenating [] with a string will do this)

Grazie @KevinCruijssen per il salvataggio di 1 byte per b==1a b<2. Grazie a @Neil per aver salvato 11 byte suggerendo il modello ES6 letterale e ,separatore.

Rubino, 92 84 + 1 ( -pbandiera) = 93 85 byte

Utilizza -come separatore.

d,m,y=chomp.split(?-).map &:reverse
$_=[[d,m=="11"?"30":"31"].min,[m,"12"].min,y]*?-

Pyke, 29 byte

F_bw-o^tDI]SX(mhj_Xjth~%R@]Sh

Provalo qui!

Posso sicuramente vedere che questo è golfabile

Python 2, 154 byte

z=input().split("-");r=[x[::-1]for x in z];z[1]=r[1]if r[1]<'12'else '12';z[0]=r[0]if r[0]<'31'else '30'if z[1]=='11'else '31';z[2]=r[2];print "-".join(z)

Prende l'input come una stringa, quindi le virgolette devono essere specificate nell'input, ad es. "11-04-2016".

05AB1E , 24 byte

#íÐÅsË31^12‚øεßт+¦}sθªðý

Porto di @MartinEnder risposta CJam s' , quindi anche gli ingressi e le uscite come una stringa nel formato dd MM yyyy.

Provalo online o verifica tutti i casi di test .

Spiegazione:

#                         # Split the (implicit) input by spaces
                          #  i.e. "04 11 1671" → ["04","11","1671"]
                          #  i.e. "20 01 2000" → ["20","01","2000"]
 í                        # Reverse each string
                          #  i.e. ["04","11","1671"] → ["40","11","1761"]
                          #  i.e. ["20","01","2000"] → ["02","10","0002"]
  Ð                       # Triplicate this list
   Ås                     # Pop one of them, and push it's middle element (the months)
                          #  i.e. ["40","11","1761"] → "11"
                          #  i.e. ["02","10","0002"] → "10"
     Ë                    # Check if the digits are the same (1 for 11; 0 otherwise)
                          #  i.e. "11" → 1 (truthy)
                          #  i.e. "10" → 0 (falsey)
      31^                 # Bitwise-XOR with 31 (30 for November, 31 for other months)
                          #  i.e. 1 → 30
                          #  i.e. 0 → 31
         12‚              # Pair it with 12
                          #  i.e. 30 → [30,12]
                          #  i.e. 31 → [31,12]
            ø             # Zip/transpose; swapping rows and columns
                          # (implicitly removes year)
                          #  i.e. ["40","11","1761"] and [30,12] → [["40",30],["11",12]]
                          #  i.e. ["02","10","0002"] and [31,12] → [["02",31],["10",12]]
             ε    }       # Map each pair to:
              ß           # Get the minimum (implicitly converts to integer unfortunately)
                          #  i.e. [["40",30],["11",12]] → [30,11]
                          #  i.e. [["02",31],["10",12]] → [2,10]
               т+         # Add 100
                          #  i.e. [30,11] → [130,111]
                          #  i.e. [2,10] → [102,110]
                 ¦        # Remove the first character
                          #  i.e. [130,111] → ["30","11"]
                          #  i.e. [102,110] → ["02","10"]
                   s      # Swap so the triplicated list is at the top of the stack again
                    θ     # Pop and only leave it's last element (the year)
                          #  i.e. ["40","11","1761"] → "1761"
                          #  i.e. ["02","10","0002"] → "0002"
                     ª    # Append it to the list
                          #  i.e. ["30","11"] and "1761" → ["30","11","1761"]
                          #  i.e. ["02","10"] and "0002" → ["02","10","0002"]
                      ðý  # Join the list by spaces (and output implicitly)
                          #  i.e. ["30","11","1761"] → "30 11 1761"
                          #  i.e. ["02","10","0002"] → "02 10 0002"