Мне действительно нравятся времена, которые следуют определенным образцам. В частности, мне нравятся времена, когда все цифры одинаковы или все цифры увеличиваются арифметически на единицу слева направо. Кроме того, я внутренне ненавижу, когда люди пишут письма в мое время, поэтому вся эта чепуха 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. Не обращайте внимания на возможность високосной секунды.

Выход

Ваша программа должна предоставить (функции возврата 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Ạ

Попробуйте онлайн!

Некоторые части точно такие же, как в ответе Джонатана Аллана , но я публикую его, так как считаю, что он достаточно отличается от него и независимо написан на основе моего ответа Пифа (и короче: 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 байта

Сохранено 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.
                              B60 | Конвертировать из базы 60.
                : | Добавьте вышеизложенное к ↓ ([15, 83, 588, 83, 588, 83]).
                       с588 83 | Создайте список из двух элементов [588, 83].
                     * 3 | Повторите три раза.
                    т | Удалить первый элемент.
                 : 15 | Prepend 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")
        }
    }
}

TIO

TryItOnline