输入：

日期（含dd，MM和yyyy）。日期对象或三个独立的整数也可用作输入。

输出：

每个部分（dd，MM和yyyy）单独恢复，比四舍五入到最接近的有效日期。

例如（格式为dd-MM-yyyy）：
21-10-2016变为12-01-6102

挑战规则：

• 只有dd，MM，yyyy是有效的，但为了和您使用独立的符号是你自己的选择。
  因此，这些都是一些有效的格式例子：dd-MM-yyyy; MM/dd/yyyy; yyyy MM dd; ddMMyyyy等
  是一些无效的格式示例：dd MMM yyyy; dd-MM-'yy; 等等
• 如果您的语言支持日期对象或三个单独的整数参数，也可以选择仅输入日期对象，而不是代表日期的字符串。
• 请说明您使用的日期格式！（并且输入和输出必须采用相同的格式。）还可以输出Date对象，只要它可以处理以下所有测试用例和质询规则即可。
• 从儒略历到公历的过渡对此挑战被忽略了。因此，1582对于只是一个有效的反向年份2851。
  请参阅挑战信息/所有有效年，月和日的提示。
• 由于您无法将2月与其他任何月份相反，因此您不必担心worry年。

所有倒转的年，月和日：

• 年份可以任意倒转，范围从0001（倒数为1000）到9999（剩余数9999）。（因此0000这不是有效的输入，也没有测试用例。）
• 您将要撤消的唯一月份是：一月（从十月/撤消10）；十月（与一月/相反01）；11月（仍为11月/ 11）；和月（从隔月扭转/ 02- ，）。0912
• 您将撤消的唯一日期是：01（从撤消10），02（从撤消20），03（从撤消30），10（从撤消01），11（剩余11），12（从撤消21），13（从撤消31） ，20（从反向02），21（从反向12），22（剩余22），30（03与11月的31反向或相同！），31（从04- 09/ 13- 反向19/ 23- 29）。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法以及return语句/输出，完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如有必要，请添加说明。

测试用例（dd-MM-yyyy格式）：

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

凸，23字节

字节数假定为CP-1252编码。

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

I / O格式为dd mm yyyy。

在线尝试！

这是我的CJam答案的直接入口。Convex很大程度上基于CJam，因此唯一的区别是使用Convex的¶运算符，该运算符将顶部的两个堆栈元素包装在列表中，并在上保存一个字节[...]。

CJam，24个字节

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

I / O格式为dd mm yyyy。

在线尝试！

字节数相同，I / O格式mm dd yyyy：

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

在线尝试！

说明

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.

另一个版本的工作方式类似，除了我们从整数开始1230或1231在将其转换为["12" "30"] or 之前["12" "31"]。

Pyth，55 53 46 43 41字节

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

其中❤❤有两个不可打印的内容，分别是U + 001C和U + 001F。

测试套件。

Python 3，82个字节

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

一个匿名函数，该函数通过参数输入日期作为格式的字符串列表的['dd', 'mm', 'yyyy']日期，并以相同格式返回经过验证的反向日期。

怎么运行的

Python通过Unicode代码点比较字符和字符串。这意味着对两个或多个整数的任何比较返回的结果与对这些整数作为字符串的比较结果相同。因此，min两个整数作为字符串返回最小的整数作为字符串。通过将反向日期部分作为一个参数，将最大值作为另一个参数，可以将日期和月份限制在所需的范围内。通过使用步骤-1（[::-1]）进行索引来反转日期部分，并且通过将条件条件的布尔结果索引到列表中，将月份的最大值从更改为'31'，'30'如果月份是11月。

在Ideone上尝试

Dyalog APL，32 33 字节

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

I / O是三个字符串的列表（'dd' 'mm' 'yyyy'）的。

TryAPL，但请注意，⎕（提示输入）已被替换⍵和整个线路封闭在{... }，以使在线测试，和⍎（执行表达式）已被替换2⊃⎕VFI（验证和修正输入），因为任意代码执行被阻塞。

C＃314 305 299 249 232 223个字节

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

感谢@KevinCruijssen指出我可以缩短变量声明，这也使别名字符串能够节省一些字节。

保存了50个字节，用于存储可重复使用的反向函数；另外的13个字节，用于舍入和删除变量声明，对此进行了同样的处理。

最近的更新使别名字符串不再是字节保护程序。

非高尔夫版本：

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

在这里测试

的Javascript，106个 105 94字节

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

测试套件（版本3）

说明

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)

感谢@KevinCruijssen保存1个字节为b==1至b<2。感谢@Neil通过建议ES6模板文字和,分隔符来节省11个字节。

Ruby，92 84 +1（-p标志）= 93 85字节

使用-作为分隔符。

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

Pyke，29个字节

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

在这里尝试！

我绝对可以看到这是可以打高尔夫球的

Python 2，154字节

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)

将输入作为字符串，因此需要在输入中指定引号，例如“ 11-04-2016”。

05AB1E，24 字节

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

@MartinEnder的CJam答案的端口，因此也以格式的字符串形式输入和输出dd MM yyyy。

在线尝试或验证所有测试用例。

说明：

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