我真的很喜欢遵循特定模式的时代。特别是，我喜欢所有数字都相同的时间，或者所有数字从左到右算术增加一个的时间。此外，当人们在我的时代写信时，我会感到内心的憎恨，因此所有AM / PM的废话对我来说都是死的。因此，我最喜欢的时间是：

0000 0123 1111 1234 2222 2345

为了让我省心，我需要您编写一个程序，以当前时间作为输入，两个程序都必须：（A）如果现在不是我最喜欢的时间之一，请告诉我两个程序（i）这是多少分钟从我上次最喜欢的时间开始算起，以及（ii）从现在开始我下一个最喜欢的时间发生了多少分钟；和（B）如果是现在我最喜欢的一个时代，提供了一个单一的“信号值”。

输入值

您的程序应采用以下任何一种stdin格式接受（通过任何方法：函数参数，命令行参数等）当前时间。

• 四位数的时间作为字符串

• 可以在左边补零的整数，以字符串形式表示四位数的时间

• 四个（或更少）整数的序列，其顺序使得该序列中的第一个整数是时间输入中最左边的（有效）数字（例如，0951可以有效地表示为[0, 9, 5, 1]或[9, 5, 1]）

  • 表示0000为零长度序列是可以接受的

对于字符串输入，它只能包含数字，不能包含冒号或其他标点符号。 可以假定输入始终是24小时有效时间： HHMM，0 <= HH <= 23和0 <= MM <= 59。忽略of秒的可能性。

输出量

您的程序必须根据输入的值是否是目标时间stdout来提供（A）或（B）（功能返回等都可以）。

为一个）：

提供任何合理格式的两个数值，例如：

• 具有合适分隔符的单字符串输出

• 顺序整数/字符串输出，例如，将bash两行打印到stdout：

  49
  34
  

• 长度为2的有序返回值，例如Python列表，C数组等： [49, 34]

值可以以任何顺序出现。例如，以下两个都是输入的有效输出1200：

49 34
34 49

但是，所有输入值的顺序和分隔符必须相同！

对于（B）：

产生任何其他无法达到的结果。但是，必须为所有六个目标时间产生相同的结果。排除无限循环。

样例输入/输出

YAY!!! 在此用作说明性示例，而不是说明性的。

Input      Output
------    --------
 0000      YAY!!!
 0020      20 63
 0105      65 18
 0122      82 1
 0123      YAY!!!
 0124      1 587
 0852      449 139
 1111      YAY!!!
 1113      2 81
 1200      49 34
 1234      YAY!!!
 1357      83 505
 1759      325 263
 1800      326 262
 1801      327 261
 2222      YAY!!!
 2244      22 61
 2345      YAY!!!
 2351      6 9

这是代码高尔夫球，因此以字节为单位的最短代码获胜。不允许出现标准漏洞。

果冻，34 33 32 31 28字节

3字节感谢Xcoder的先生.ị和³技巧。

d³ḅ60;15j83,588ṁ5¤_\ṠÞAµ.ịxẠ

在线尝试！

有些部分与Jonathan Allan的答案完全相同，但是我发布它是因为我认为它与它完全不同，并且是根据我的Pyth答案（以及更短的：D）独立编写的。还应该有改进的空间。

输入是整数，输出是前一次和下一次的数组，或者是特殊时间的空数组。

说明

使用示例输入1200。

• d³将以100为基础的时间转换为小时和分钟：[12,0]。
• ḅ60从60转换为总分钟数：720。
• ;15与15：配对[720, 15]。
• 83,588创建数组[83, 588]。
• ṁ5使其长度5： [83, 588, 83, 588, 83]。
• ¤结合了以上两个动作。只是技术问题。
• j将配对与数组连接：[720, 83, 588, 83, 588, 83, 15]。
• _\从第一个数组中减去每个数组值，然后得到中间结果：[720, 637, 49, -34, -622, -705, -720]。
• ṠÞ 稳定地按信号进行排序：[-34, -622, -705, -720, 720, 637, 49]。
• A取绝对值：[34, 622, 705, 720, 720, 637, 49]。
• µ开始一条新的单子链。再次，技术性。
• .ị接受最后一项和第一项：[49, 34]。
• ×Ạ如果没有零，则重复一次，否则，则重复零次：[49, 34]。

JavaScript（ES6），87 83字节

@ l4m2节省了4个字节

将输入作为字符串。返回0一个2元素数组。

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

测试用例

let f =

t=>[i=0,83,588,83,588,83,15].every(d=>(k=t-(t/25>>2)*40)>(j=i,i+=d))|i-k&&[k-j,i-k]

console.log(f('0000')) // YAY!!!
console.log(f('0020')) // 20 63
console.log(f('0105')) // 65 18
console.log(f('0122')) // 82 1
console.log(f('0123')) // YAY!!!
console.log(f('0124')) // 1 587
console.log(f('0852')) // 449 139
console.log(f('1111')) // YAY!!!
console.log(f('1113')) // 2 81
console.log(f('1200')) // 49 34
console.log(f('1234')) // YAY!!!
console.log(f('1357')) // 83 505
console.log(f('1759')) // 325 263
console.log(f('1800')) // 326 262
console.log(f('1801')) // 327 261
console.log(f('2222')) // YAY!!!
console.log(f('2244')) // 22 61
console.log(f('2345')) // YAY!!!
console.log(f('2351')) // 6 9

怎么样？

我们不在乎.every()循环的结果。只要输入有效，它将永远是虚假的。我们真正感兴趣的是何时退出此循环。

找到最喜欢的时间i（以分钟表示）会立即退出，该时间大于或等于参考时间k（t以分钟为单位的输入时间）。然后我们返回0if i == k或2个延迟。

Befunge-93，88个 85 86 80 74字节

&:"d"/58**-:"S"-:"b"6*-:"S"v
@._v#!:<\-*53:-"S":-*6"b":-<
:$#<$$\^@.._\#`0

在线尝试！

输出自上一个收藏夹时间以来的分钟数，然后输出直至下一个收藏夹时间的分钟数（由两个字符序列分隔：空格，连字符）。如果已经是最喜欢的时间，则返回一个零。

C，121字节

*p,l[]={0,83,671,754,1342,1425,1440};f(t){t=t%100+t/100*60;for(p=l;t>*p;++p);*p-t?printf("%d %d",t-p[-1],*p-t):puts("");}

如果时间是收藏时间，则输出换行符。

在线尝试！

干净，126字节

import StdEnv
f=[1440,1425,1342,754,671,83,0]
?t#t=t rem 100+t/100*60
=(\(a,b)=(t-hd b,last a-t))(span(\a=t<a||isMember t f)f)

定义函数?，获取Int并返回(Int, Int)。
当参数是最喜欢的时间时，它将使调用程序崩溃hd of []。

在线尝试！

Pyth，48 45 42字节

&*FJ.u-NY+P*3,83 588 15isMcz2 60,eK._DJ_hK

在线尝试。 测试套件。

该代码接收一个时间字符串，并将前一次和下一次作为数组输出，或者 0如果时间特殊。

有趣的是，命令式方法也是42个字节：

V+_isMcz2 60+P*3,83 588 15KZIg0=-ZNIZK)_ZB

说明

• cz2将输入（z）分成两个字符。
• sM 将它们评估为整数。
• i… 60将所得的两个项目数组解析为以60为底的数组。
• ,83 588表示数组[83, 588]。
• *3将重复三次[83, 588, 83, 588, 83, 588]。
• P删除最后一个588。
• +… 15添加15到最后。
• .u-NY从已解析的数字开始，从中减去数组中的每个数字，然后返回中间值。这些是每个特殊时间的区别。
• J 将这些差异分配给 J。
• *F计算差异的乘积。如果时间特殊，则该值为0。
• & 在此处停止评估，如果时间特殊则返回0。
• ._DJ 稳定按符号对差异进行排序。
• K将该数组保存到中K。
• e 接受数组中的最后一项。
• _hK 将数组中的第一项取反。
• , 返回两个数组。

果冻， 33 32  34 字节

 +3  +2个字节可修复，因此所有喜欢的时间输出都相等。

^{一定要更短一些！}

s2Ḍḅ60
83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\

一个单调链接，它获取四个数字的列表，并返回包含两个整数的列表
-如果喜欢的时间，则两个条目的结果均为零。

在线尝试！或见测试人员。

怎么样？

s2Ḍḅ60 - helper link, getMinuteOfDay: list of digits, D   e.g. [1,2,3,3]
 2     - literal two                                           2
s      - split into chunks of length                           [[1,2],[3,3]]
  Ḍ    - un-decimal (convert from base 10) (vectorises)        [12,33]
    60 - literal sixty                                         60
   ḅ   - un-base (convert from base)                           753

83,588ṁ5“¡Ð‘j+\ṡ2>E¥ÞÇḢạÇa\ - Link: list of digits        e.g. [1,2,3,3]
83,588                      - literal list of integers         [83,588]
       5                    - literal five                     5
      ṁ                     - mould like (implicit range of) [83,588,83,588,83]
        “¡Ð‘                - code-page index list             [0,15]
            j               - join                           [0,83,588,83,588,83,15]
              \             - cumulative reduce with:
             +              -   addition                     [0,83,671,754,1342,1425,1440]
                2           - literal two                      2
               ṡ            - overlapping slices of length     [[0,83],[83,671],[671,754],[754,1342],[1342,1425],[1425,1440]]
                     Ç      - last link (1) as a monad f(D)    753
                    Þ       - sort by:
                   ¥        -   last two links as a dyad:
                 >          -     greater than? (vectorises)    [0, 0] [ 0,  0] [  0,  1] [  1,   1] [   1,   1] [   1,   1]
                  E         -     equal?                          1       1         0         1           1           1
                            -                             -->  [[671,754],[0,83],[83,671],[754,1342],[1342,1425],[1425,1440]]
                      Ḣ     - head                             [671,754]
                        Ç   - last link (1) as a monad f(D)    753
                       ạ    - absolute difference (vectorises) [ 82,  1]
                          \ - cumulative reduce with:
                         a  -   AND                            [ 82,  1]
                            -   -- such that if "liked" then the [0,x] result becomes [0,0] so they are all equal

外壳，36字节

?↑2↑0Πṙ_1†aÖ±↔Ġ-::15t*3e588 83B60†d½

在线尝试！

谢谢 Zgarb向我解释了三元如何在聊天中工作。尝试打高尔夫球↑0，但由于某种原因，我没有使它工作。这是我第一个不重要的Husk答案，撇开上述内容，我对此感到非常满意。代替的值YAY!!!是[]（但我希望出于高尔夫目的而改变）。

说明

？↑2↑0Πṙ_1†aÖ±↔Ġ-:: 15t * 3e588 83B60†d½| 从CLA作为数字列表输入，输出到STDOUT。

                                   ½| 将列表分为两半。
                                 †d | 将每一半变成以10为底的整数。
                              B60 | 从60开始转换。
                ：| 将以上内容附加到↓（[15，83，588，83，588，83]）。
                       e588 83 | 创建两个元素列表[588，83]。
                     * 3 | 重复三遍。
                    t | 删除第一个元素。
                 ：15 | 加上15。
              Ġ-| 从右侧应用累积减法。
             ↔| 相反。
           Ö±| 稳定排序的符号（-1，0或1）。
         †a | 地图绝对值。
      ṙ_1| 向右旋转。
？Π| 如果产品是真实的，则：
 ↑2 | 拿前两个元素。
   ↑0 | 否则返回一个空列表。

科特林，293字节

{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

美化

{
    fun i(l:List<Int>)=l.all { it ==l[0] } || l.mapIndexed { a, b -> b - a }.all { it ==l[0] }
    val a = (0..1439 + 0).map {
        val h = it/60
        val m = it%60
        listOf(h/10,h%10,m/10,m%10)
    } + listOf(listOf(0,0,0,0))
    val s = a.indexOf(it)
    if (i(it)) 0 to 0 else
        s - a.subList(0, s).indexOfLast {i(it)} to a.subList(s, a.size).indexOfFirst {i(it)}
}

测试

var t:(i:List<Int>)-> Pair<Int, Int> =
{fun i(l:List<Int>)=l.all{it==l[0]}|| l.mapIndexed{a,b->b-a}.all{it==l[0]}
val a=(0..1439+0).map{val h=it/60
val m=it%60
listOf(h/10,h%10,m/10,m%10)}+listOf(listOf(0,0,0,0))
val s=a.indexOf(it)
if(i(it))0 to 0 else
s-a.subList(0,s).indexOfLast{i(it)}to a.subList(s,a.size).indexOfFirst{i(it)}}

data class Test(val input: List<Int>, val output: Pair<Int, Int>)

val TEST = listOf(
    Test(listOf(0,0,0,0), 0 to 0),
    Test(listOf(0,0,2,0), 20 to 63),
    Test(listOf(0,1,0,5), 65 to 18),
    Test(listOf(0,1,2,2), 82 to 1),
    Test(listOf(0,1,2,3), 0 to 0),
    Test(listOf(0,1,2,4), 1 to 587),
    Test(listOf(0,8,5,2), 449 to 139),
    Test(listOf(1,1,1,1), 0 to 0),
    Test(listOf(1,1,1,3), 2 to 81),
    Test(listOf(1,2,0,0), 49 to 34),
    Test(listOf(1,2,3,4), 0 to 0),
    Test(listOf(1,3,5,7), 83 to 505),
    Test(listOf(1,7,5,9), 325 to 263),
    Test(listOf(1,8,0,0), 326 to 262),
    Test(listOf(1,8,0,1), 327 to 261),
    Test(listOf(2,2,2,2), 0 to 0),
    Test(listOf(2,2,4,4), 22 to 61),
    Test(listOf(2,3,4,5), 0 to 0),
    Test(listOf(2,3,5,1), 6 to 9)
)

fun main(args: Array<String>) {
    for (t in TEST) {
        val v = t(t.input)
        if (v != t.output) {
            throw AssertionError("$t $v")
        }
    }
}

蒂奥

在线试用