Entrada:

Una fecha (que contiene dd, MMy yyyy). Un objeto de fecha, o tres enteros separados también son válidos como entrada.

Salida:

Cada parte ( dd, MMy yyyy) se revierte individualmente y se redondea a la fecha válida más cercana.

Por ejemplo (en el formato dd-MM-yyyy): se
21-10-2016convierte12-01-6102

Reglas de desafío:

• Sólo dd, MM, yyyyes válida, pero el orden y que separan-símbolos que se utiliza es su propia elección.
  Así que estos son algunos ejemplos de formato válidos: dd-MM-yyyy; MM/dd/yyyy; yyyy MM dd; ddMMyyyy, Etc.
  Y estos son algunos ejemplos de formato no válidos: dd MMM yyyy; dd-MM-'yy; etc.
• También puede elegir simplemente ingresar un objeto Fecha si su idioma lo admite o tres parámetros enteros separados, en lugar de la cadena que representa una fecha.
• ¡Indique qué formato de fecha ha utilizado! (Y la entrada y la salida deben estar en el mismo formato). También se permite la salida de un objeto Fecha, siempre que pueda manejar todos los casos de prueba y la regla de desafío a continuación.
• La transición del calendario juliano al gregoriano se ignora para este desafío. Por 1582lo tanto, es solo un año inverso válido para 2851.
  Vea la información / consejos del desafío para todos los años, meses y días válidos.
• Como no puede tener febrero como revertido de cualquier otro mes, no tiene que preocuparse por los años bisiestos.

Todos los años, meses y días invertidos:

• El año siempre se puede revertir sin problemas, llegando de 0001 (revertido 1000) a 9999 (restos 9999). (Por 0000lo tanto, no es una entrada válida, y tampoco hay casos de prueba para ello).
• Los únicos meses que habrá revertido son: enero (revertido desde octubre / 10); Octubre (invertido desde enero / 01); Noviembre (sigue siendo noviembre / 11); y diciembre (revertido de cada dos meses / 02- 09, 12).
• Los únicos días que habrá invertido son: 01 (invertido desde 10), 02 (invertido desde 20), 03 (invertido desde 30), 10 (invertido desde 01), 11 (restos 11), 12 (invertido desde 21), 13 (invertido desde 31) , 20 (invertido desde 02), 21 (invertido desde 12), 22 (restos 22), 30 (¡invertido 03o igual que 31 para noviembre!), 31 (invertido desde 04- 09/ 13-19/ 23- 29).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede utilizar STDIN / STDOUT, funciones / método con los parámetros adecuados y declaraciones / resultados de retorno, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba ( dd-MM-yyyycomo 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

Convexo , 23 bytes

El recuento de bytes asume la codificación CP-1252.

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

El formato de E / S es dd mm yyyy.

Pruébalo en línea!

Este es un puerto directo de mi respuesta CJam . Convex se basa en gran medida en CJam y, por lo tanto, la única diferencia es el uso del ¶operador de Convex que envuelve los dos elementos principales de la pila en una lista, ahorrando un byte [...].

CJam, 24 bytes

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

El formato de E / S es dd mm yyyy.

Pruébalo en línea!

Mismo recuento de bytes, formato de E / S mm dd yyyy:

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

Pruébalo en línea!

Explicación

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.

La otra versión funciona de manera similar, excepto que comenzamos desde el entero 1230o 1231antes de convertirlo a ["12" "30"] o ["12" "31"].

Pyth, 55 53 46 43 41 bytes

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

dónde ❤❤ había dos no imprimibles, respectivamente U + 001C y U + 001F.

Banco de pruebas.

Python 3, 82 bytes

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

Una función anónima que toma la entrada, a través del argumento, de la fecha como una lista de cadenas del formulario ['dd', 'mm', 'yyyy'] y devuelve la fecha inversa validada en el mismo formato.

Cómo funciona

Python compara caracteres y cadenas por sus puntos de código Unicode. Esto significa que cualquier comparación en dos o más enteros devuelve lo mismo que esa comparación en esos enteros como cadenas. Por lo tanto, invocar mindos enteros como cadenas devuelve el entero más pequeño como una cadena; Al tomar la parte de fecha invertida como un argumento y el valor máximo como otro, el día y el mes se sujetan al rango deseado. Las partes de fecha se invierten indexando con pasos de -1( [::-1]), y el valor máximo para el mes cambia de '31'a '30'si el mes es noviembre indexando en una lista con el resultado booleano de un condicional.

Pruébalo en Ideone

Dyalog APL , 32 33 bytes

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

I / O es una lista de tres cadenas ( 'dd' 'mm' 'yyyy').

TryAPL , pero tenga en cuenta que ⎕(solicitud de entrada) se ha reemplazado ⍵y toda la línea encerrada en {... }para habilitar las pruebas en línea, y ⍎(ejecutar expresión) se ha reemplazado con 2⊃⎕VFI(verificar y corregir entrada) porque la ejecución de código arbitrario está bloqueada .

C # 314 305 299 249 232 223 Bytes

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

Gracias a @KevinCruijssen por señalar que podría acortar mi declaración de variable, lo que también hizo que la cadena de alias pudiera guardar algunos bytes.

Se guardaron 50 bytes almacenando la función de inversión para su reutilización y otros 13 haciendo lo mismo para el redondeo y eliminando las declaraciones de variables.

La última actualización hace que la cadena de alias ya no sea un protector de bytes.

Versión sin golf:

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

Pruébalo aquí

Javascript, 106 105 94 bytes

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))+''

Conjunto de pruebas (rev. 3)

Explicación

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)

Gracias @KevinCruijssen para el ahorro de 1 byte para b==1a b<2. Gracias @Neil por guardar 11 bytes sugiriendo plantilla ES6 literal y ,separador.

Ruby, 92 84 + 1 ( -pbandera) = 93 85 bytes

Usos -como separador.

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

Pyke, 29 bytes

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

Pruébalo aquí!

Definitivamente puedo ver que esto es golfable

Python 2, 154 bytes

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)

Toma la entrada como una cadena, por lo que las comillas deben especificarse en la entrada, por ejemplo, "11-04-2016".

05AB1E , 24 bytes

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

Puerto de @MartinEnder respuesta Cjam 's , por lo que también entradas y salidas como una cadena en el formato dd MM yyyy.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

#                         # 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"