Мені дуже подобаються часи, які слідують певним зразкам. Зокрема, мені подобаються часи, коли всі цифри однакові, або всі цифри збільшуються арифметично на одну зліва направо. Крім того, я ненавиджу, коли люди пишуть листи в мої часи, тому вся ця дурниця AM / PM для мене мертва. Таким чином, мої улюблені часи:

0000 0123 1111 1234 2222 2345

Для душевного спокою мені потрібно, щоб ви написали мені єдину програму, яка, враховуючи поточний час як вхідний, обидва: (А) якщо це зараз не один з моїх улюблених часів, говорить мені обом (i) скільки хвилин це з мого останнього улюбленого часу, а також (ii) скільки хвилин відбудеться наступний мій улюблений час; і (В) якщо є в даний час один з моїх улюблених часів, поставляє один "значення сигналу.

Вхідні дані

Ваша програма повинна приймати (будь-яким способом: аргументом функції, аргументом stdinкомандного рядка тощо) поточний час у будь-якому з наступних форматів:

• Чотиризначний час у вигляді рядка

• Ціле число, яке може бути з нульовим написом зліва, щоб зробити чотиризначний час у вигляді рядка

• Послідовність чотирьох (або менших) цілих чисел, упорядкована таким чином, що перше ціле число у послідовності є лівою лівою (значущою) цифрою у введенні часу (наприклад, 0951може бути дійсно представлена ​​як [0, 9, 5, 1]або [9, 5, 1])

  • Представлення 0000у вигляді послідовності нульової довжини є прийнятним

У разі введення рядка він повинен містити лише цифри, без крапки та інших розділових знаків. Можна вважати, що введення завжди дійсні 24-годинний час:, HHMM де 0 <= HH <= 23і 0 <= MM <= 59. Нехтуйте можливістю високосної секунди.

Вихідні дані

Ваша програма повинна подавати (функція повертається, stdoutі т. Д. Все добре) або (A) або (B) , залежно від того, вхідне значення є цільовим часом.

Для):

Введіть два числових значення у будь-якому розумному форматі, наприклад:

• Однорядний вихід з відповідним роздільником

• Послідовні цілі / рядкові виходи, наприклад, bashдрук двох рядків для stdout:

  49
  34
  

• Дві дві упорядковані значення повернення, такі як список 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Ạ

Спробуйте в Інтернеті!

Деякі частини точно так само, як і у відповіді Джонатана Аллана , але я розміщую її, як вважаю, що достатньо відрізняється від неї і незалежно написана на основі моєї відповіді 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].
• ṠÞ стабільно сортує їх по Signum: [-34, -622, -705, -720, 720, 637, 49].
• Aприймає абсолютні значення: [34, 622, 705, 720, 720, 637, 49].
• µзапускає новий монастирський ланцюг. Знову ж таки, технічність.
• .ịбере останні і перші пункти: [49, 34].
• ×Ạповтори , що коли - то , якщо немає нулів, або нуль раз інакше: [49, 34].

JavaScript (ES6), 87 83 байти

Збережено 4 байти завдяки @ l4m2

Вводиться як рядок. Повертає 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перетворений у хвилини). Потім ми повертаємось, 0якщо 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розбиває input ( 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½

Спробуйте в Інтернеті!

Дякую Згарбу за те, що він мені пояснив, як тернари працюють у чаті. Намагаюся займатися гольфом ↑0, але я чомусь не змусив його працювати інакше (?). Це моя перша нетривіальна відповідь Хука, і відпускаючи вищезгадане, я цілком задоволений цим. Значення, яке використовується замість, YAY!!!є [](але я сподіваюся, що це зміниться для цілей гольфу).

Пояснення

? ↑ 2 ↑ 0Πṙ_1 † aÖ ± ↔Ġ - :: 15t * 3e588 83B60 † d½ | Введіть як список знаків від CLA, виведіть в STDOUT.

                                   ½ | Розділіть список на дві половини.
                                 † d | Перетворіть кожну половину в ціле число бази-10.
                              В60 | Перетворення з бази 60.
                : | Додайте вище до ↓ ([15, 83, 588, 83, 588, 83]).
                       e588 83 | Створіть список двох елементів [588, 83].
                     * 3 | Повторіть три рази.
                    т | Видаліть перший елемент.
                 : 15 | Додайте 15.
              Ġ- | Застосовуйте сукупне віднімання праворуч.
             ↔ | Зворотний.
           Ö ± | Стабільне сортування за знаком (-1, 0 або 1).
         † а | Абсолютне значення карти.
      ṙ_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")
        }
    }
}

ТІО

TryItOnline