Учитывая дорогу ascii-art и время, которое потребовалось мне, чтобы пересечь ее, скажите мне, ускоряюсь ли я.

Единицы

Расстояние в произвольной единице d. Время в произвольной единице t.

Дорога

Вот простая дорога:

10=====

Эти 10средства 10 dв t. Это ограничение скорости на дороге. Дорога имеет 5 =с, так что его d5. Таким образом, если пересечь эту дорогу в 0,5 t, я пошел 10 dза t, потому что 5 / 0,5 = 10. предел скорости этой дороги 10, так что я остался в пределах ограничения скорости.

Но если я пересечь эту дорогу в 0.25 t , я пошел 20 dза t, потому что 5 / 0,25 = 20. Ограничение скорости этой дороги 10, так что я пошел 10 за ограничение скорости.

Примеры и расчеты

Обратите внимание, что ввод 1 - это время, которое я потратил на дорогу, а ввод 2 - сама дорога.

Вот сложная дорога:

Input 1: 1.5
Input 2: 5=====10=====

Самый быстрый я мог бы ( по закону) пошли на первой дороге (первые 5 =сек) составляет 5 dв t. Поскольку 5 (расстояние), деленное на 5 (ограничение скорости), равно 1, самое быстрое, что я мог бы сделать на этой дороге, - 1 t.

На следующей дороге ограничение скорости составляет 10, а расстояние также равно 5, самое быстрое, что я мог преодолеть, это 0,5 (5/10). Суммируя минимальное количество раз, мы получим 1,5, что означает, что я ехал именно с ограничением скорости.

Примечание: я знаю, что, возможно, я ехал очень быстро на одной дороге и очень медленно на другой, и все еще проезжал 1.5, но примите здесь лучшее.

Последний пример:

Input 1: 3.2
Input 2: 3.0==========20===

Длина первой дороги 10 и ограничение скорости 3, поэтому минимальное время составляет 3,33333 ... (10/3).

Длина второй дороги 3 и ограничение скорости 20, поэтому минимальное время составляет 0,15 (3/20).

Суммируя время, мы получаем результат в 3.483333333 ... Я пересек его в 3.2, поэтому мне пришлось куда-то ускоряться.

Заметки:

• Вы должны вывести одно отдельное значение, если я, несомненно, ускоряюсь, и другое, если это не так.
• Ваша программа или функция может требовать ввода или вывода для завершения новой строки, но, пожалуйста, укажите это в своем представлении.
• Ваш первый вход будет моей скоростью. Это будет положительное число с плавающей точкой или целое число или строка.
• Ваш второй вход будет дорога. Это всегда будет соответствовать регулярному выражению ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Вы можете проверить потенциальные входы здесь, если вы заинтересованы.
• Вы можете получить входные данные в 2 параметрах функции или программы, в 2 отдельных файлах, из STDIN дважды или из строки через пробел, переданной в STDIN, функцию, файл или параметр командной строки.
• Если вы хотите, вы можете изменить порядок ввода.
• Любые вопросы? Спросите ниже в комментариях и счастливого кода для игры в гольф !

05AB1E , 24 22 байта

Возвращает 1, когда несомненно ускоряется и 0 в противном случае.

Сохранено 2 байта благодаря carusocomputing .

'=¡õK¹S'=Q.¡O0K/O-§'-å

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

-§'-åне должно быть больше, чем простое сравнение, но по какой-то причине ни кажется, ›ни ‹работает между вычисленным значением и вторым вводом

объяснение

Используя в 3.0==========20===, 3.2качестве примера

'=¡                        # split first input on "="
   õK                      # remove empty strings
                           # STACK: ['3.0', '20']
     ¹S                    # split first input into a list of chars
       '=Q                 # compare each to "="
          .¡O              # split into chunks of consecutive equal elements and sum
                           # STACK: ['3.0', '20'], [0, 10, 0, 3]
             0K            # remove zeroes
                           # STACK: ['3.0', '20'], [10, 3]
               /           # element-wise division
                           # STACK: [3.3333333333333335, 0.15]
                O          # sum
                           # STACK: 3.4833333333333334
                 -         # subtract from second input
                           # STACK: -0.2833333333333332
                  §        # implicitly convert to string
                   '-å     # check if negative
                           # OUTPUT: 1

Python 2 , 71 байт

m,s=input()
for c in s.split('=')[:-1]:s=float(c or s);m-=1/s
print m<0

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

Динамическая система типов Python может потребовать некоторых злоупотреблений.

Разделение входной строки s.split('=')превращает kзнаки равенства в k-1элементы списка с пустой строкой (кроме конца, где он должен быть обрезан). Например,

"3.0===20====".split('=')[:-1] == ['3.0', '', '', '20', '', '', '']

Код перебирает эти элементы, обновляя текущую скорость sкаждый раз, когда видит число. Обновление выполняется следующим образом s=float(c or s): где if c- непустая строка, мы получаем float(c), а в противном случае c or sоцениваем s, где float(s)просто сохраняем s. Обратите внимание, что cэто строка и sчисло, но Python не требует, не требует согласованных типов ввода и также floatпринимает.

Также обратите внимание, что переменная, sхранящая скорость, такая же, как и входная строка. Строка оценивается, когда начинается цикл, и изменение ее внутри цикла не меняет то, что повторяется. Таким образом, одну и ту же переменную можно использовать повторно, чтобы сэкономить на инициализации. Первый цикл всегда имеет cчисло, поэтому s=float(c or s)его не волнует sначальная роль строки.

Каждая итерация вычитает текущую скорость из допустимого значения, которое начинается как ограничение скорости. В конце, ограничение скорости было нарушено, если оно падает ниже 0.

Python 3 , 79 байт

import re;g=re.sub
lambda m,s:eval(g('=','-~',g('([^=]+)',r'0+1/\1*',s))+'0')>m

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

Например, ввод 3.0==========20===преобразуется в строку

0+1/3.0*-~-~-~-~-~-~-~-~-~-~0+1/20*-~-~-~0 

и оценивается, и результат сравнивается с входной скоростью. Каждый -~увеличивается на 1. Я новичок в регулярных выражениях, так что, возможно, есть лучший способ, как сделать обе замены одновременно. Спасибо Джонатану Аллану за то, что он указал, как соответствовать на всех, кроме =персонажа.

Javascript (ES6), 63 байта

a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

использование

Присвойте эту функцию переменной и вызовите ее, используя синтаксис каррирования. Первый аргумент - время, второй - дорога.

объяснение

Совпадает со всеми последовательными сериями символов, которые не являются знаками равенства, после которых следует серия знаков равенства. Каждое совпадение заменяется результатом внутренней функции, которая использует два аргумента: набор знаков равенства (в переменной d) и число (переменная c). Функция возвращает длину дороги, разделенную на число, с добавлением +.

Затем полученная строка оценивается и сравнивается с первым вводом.

Фрагмент стека

let f=
a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

<input id="time" placeholder="time" type="number">
<input id="road" placeholder="road">
<button onclick="output.innerHTML=f(time.value)(road.value)">Process</button>
<div id="output"></div>

GNU C, 128 байт

#import<stdlib.h>
f(float t,char*r){float l,s=0;for(;*r;){for(l=atof(r);*(++r)-61;);for(;*r++==61;)s+=1/l;--r;}return t<s-.001;}

Обрабатывает также нецелые ограничения скорости. #import<stdlib.h>необходимо, чтобы компилятор не предполагал, что atof()возвращает int.

t<s-.001необходим для того, чтобы тестовый случай с точным ограничением скорости работал, иначе ошибки округления заставят его думать, что вы ускорялись. Конечно, теперь, если время 1.4999вместо 1.5, оно не учитывает это ускорение. Я надеюсь, что все в порядке.

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

Perl 5 , 43 байта

42 байта кода + -pфлаг.

s%[^=]+(=+)%$t+=(length$1)/$&%ge;$_=$t<=<>

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

Для каждой группы цифр, за которой следуют некоторые знаки равенства ( [^=]+(=+)), мы рассчитываем, сколько времени требуется, чтобы пересечь ее (количество равных, деленное на скорость:) (length$1)/$&и суммировать эти времена внутри $t. В конце нам просто нужно проверить, что $tэто меньше времени, которое вы потратили на его пересечение ( $_=$t < <>). Результат будет 1(true) или ничего (false).

Mathematica, 98 байт

Tr[#2~StringSplit~"="//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}]-"
"<=#&

Чистая функция, принимающая два аргумента, число (которое может быть целым числом, дробью, десятичной дробью πили даже числом в научной нотации) и строка, оканчивающаяся новой строкой, и возвращающая Trueили False. Объяснение в качестве примера с использованием входных данных 3.2и "3==========20===\n":

#2~StringSplit~"="производит {"3","","","","","","","","","","20","","","\n"}. Обратите внимание, что число последовательных ""s на единицу меньше количества последовательных =s в каждом прогоне.

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}является повторяющимся правилом замены. Сначала он устанавливает zпустую последовательность ato "3", bto "","","","","","","","",""(самая длинная последовательность ""s, которую он может найти) и cto "20","","","\n"; команда (Length@{b}+1)/ToExpression@aоценивает (9+1)/3, и поэтому результатом замены является список {10/3, "20","","","\n"}.

Далее правила замены устанавливаются zв 10/3, ato "20", bto "",""и cto "\n". Теперь (Length@{b}+1)/ToExpression@aоценивает (2+1)/20, и поэтому результат замены есть {10/3, 3/20, "\n"}. Правило замены не может найти другое совпадение, поэтому оно останавливается.

Наконец, Tr[...]-"\n"(он сохраняет байт для использования фактической новой строки между кавычками вместо "\n") добавляет элементы списка, получая 10/3 + 3/20 + "\n", а затем вычитает из того "\n", что Mathematica совершенно рад сделать. Наконец, <=#сравнивает результат с первым вводом ( 3.2в данном случае), который дает False.

Желе , 27 байт

ṣ”=V€ḟ0
Œr”=e$ÐfṪ€ż⁸Ǥ÷/€S>

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

Примечание: предполагается , что регулярное выражение дано в вопросе должно быть таким , что ограничение скорости не может быть 0.0, 0.00и т.д. - так же , как это может не быть 0( подтверждено в качестве непреднамеренной собственности).

Как?

ṣ”=V€ḟ0 - Link 1, speed limits: road          e.g. "4.0===22=="
ṣ”=     - split by '='                             [['4','.','0'],[],[],['2','2'],[],[]]
   V€   - evaluate €ach as Jelly code              [4.0,0,0,22,0,0]
     ḟ0 - filter discard zero                      [4.0,22]

Œr”=e$ÐfṪ€ż⁸Ǥ÷/€S> - Main link: road, time   e.g. "4.0===22==", 0.84
Œr                  - run-length encode            [['4',1],['.',1],['0',1],['=',3],['2',2],['=',2]]
      Ðf            - filter keep:
     $              -     last two links as a monad:
  ”=                -         "="
    e               -         is an element of?    [['=',3],['=',2]]
        Ṫ€          - tail €ach                    [3,2]
             ¤      - nilad followed by link(s) as a nilad:
           ⁸        -     left argument (road)
            Ç       -     last link (1) as a monad [4.0,22]
          ż         - zip                          [[3,4.0],[2,22]]
              ÷/€   - reduce €ach by division      [0.75, 0.09090909090909091]
                 S  - sum                          0.8409090909090909
                  > - greater than time?           1 (would be 0 if maybe not speeding)

Python 3, 90 байт

import re
lambda t,r:sum(x.count("=")/eval(x.strip("="))for x in re.findall("\d+\D+",r))>t

Выходы, Trueесли вы превышаете скорость, Falseесли вы не можете быть. Не требует (но будет работать с) трейлингом новой строки.

Несмотря на то, что он не выглядит так, как он есть, он корректно обрабатывает поплавки как по времени ввода, так и по ограничениям скорости, поскольку регулярное выражение используется только для разделения сегментов дороги.

MATL , 31 30 байт

t61=TwFhhdfd1wY{1L&)o!oswcU!/s<

Входные данные: строка (ограничения скорости и дороги), затем число (используемая скорость). Выход, 1если несомненно ускоряется, 0если нет.

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

Пояснение с примером

Рассмотрим входы '3.0==========20==='и 3.2.

1       % Push 1
        % STACK: 1
y       % Implicitly input string. Duplicate from below
        % STACK: '3.0==========20===', 1, '3.0==========20==='
61=     % Compare with 61 (ASCII for '=')
        % STACK: '3.0==========20===', 1, [0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1]
TwFhh   % Prepend true (1) and append false (0)
        % STACK: '3.0==========20===', 1, [1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 0]
d       % Consecutive differences
        % STACK: '3.0==========20===', 1, [-1 0 0 1 0 0 0 0 0 0 0 0 0 -1 0 1 0 0 -1]
f       % Find: indices of nonzeros
        % STACK: '3.0==========20===', 1, [1  4 14 16 19]
d       % Consecutive differences. Gives length of substrings of numbers or roads
        % STACK: '3.0==========20===', 1, [3 10 2 3]
Y{      % Split string according to those lenghts. Gives a cell array of strings
        % STACK: {'3.0', '==========', '20', '==='}
1L&)    % Split into odd- and even-indexed subarrays
        % STACK: {'3.0', '20'}, {'==========', '==='}
o       % Convert to 2D numeric array. Right-pads with zeros
        % STACK: {'3.0', '20'}, [61 61 61 61 61 61 61 61 61 61; 61 61 61 0 0 0 0 0 0 0]
!gs     % Number of nonzeros in each row
        % STACK: {'3.0', '20'}, [10 3]
w       % Swap
        % STACK: [10 3], {'3.0', '20'}
c       % Convert to 2D char array. Right-pads with spaces
        % STACK: [10 3], ['3.0'; '20 ']
U       % Convert each row to a number
        % STACK: [10 3], [3.0; 20]
!       % Transpose
        % STACK: [10 3], [3.0 20]
/       % Divide, element-wise
        % STACK: [3.3333 0.15]
s       % Sum of array
        % STACK: 3.4833
<       % Implicitly input number. Less than? Implicitly display (true: 1; false: 0)
        % STACK: true

APL, 41 байт

{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}

Это принимает дорогу в качестве строки в качестве правого аргумента, а время - в качестве левого аргумента и возвращает, 1если вы превышали скорость, а 0если нет, вот так:

      3.2{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}'3.0==========20==='
1

Объяснение:

• X←⍵='=': сохранить в Xбитовом векторе все позиции, ⍵которые являются частью дороги.
• X≠¯1⌽X: отметьте каждую позицию, Xкоторая не равна его правому соседу (обтекание), давая позиции, где начинаются номера и дороги
• Y←⍵⊂⍨: разделить ⍵на эти позиции (давая массив чередующихся номеров и дорожных строк) и сохранить его в Y.
• Y⊂⍨2|⍳⍴Y: разделить Yна последовательные пары.
• {(≢⍵)÷⍎⍺}/¨: для каждой пары разделите длину части дороги ( ≢⍵) на результат вычисления номера части ( ⍎⍺). Это дает минимальное время для каждого сегмента.
• +/: Суммируйте время для всех сегментов, чтобы получить общее минимальное время.
• ⍺<: Проверьте, меньше ли заданное время, чем минимум, или нет.

TI-Basic, 168 165 байтов

Prompt Str0,T
Str0+"0→Str0
0→I
1→A
While inString(Str0,"=",A
I+1→I
I→dim(L1
I→dim(L2
0→L
inString(Str0,"=",A→B
expr(sub(Str0,A,B–A→L1(I
While 1=expr("9"+sub(Str0,B,1)+"9
L+1→L
B+1→B
If B>length(Str0
Return
End
B→A
L→L2(I
End
T≥sum(seq(L2(X)/L1(X),X,1,I

Вход - это дорога как Str0и время как T. Убедитесь, что перед дорогой стоит цитата, например Str0=?"14========3===.

Выход составляет 0, если ускоряется, 1, если возможно, не ускоряется.

Prompt Str0,T                      # 6 bytes
Str0+"0→Str0                       # 9 bytes
0→I                                # 4 bytes
1→A                                # 4 bytes
While inString(Str0,"=",A          # 12 bytes
I+1→I                              # 6 bytes
I→dim(L1                           # 6 bytes
I→dim(L2                           # 6 bytes
0→L                                # 4 bytes
inString(Str0,"=",A→B              # 13 bytes
expr(sub(Str0,A,B–A→L1(I           # 16 bytes
While 1=expr("9"+sub(Str0,B,1)+"9  # 21 bytes
L+1→L                              # 6 bytes
B+1→B                              # 6 bytes
If B>length(Str0                   # 8 bytes
Return                             # 2 bytes
End                                # 2 bytes
B→A                                # 4 bytes
L→L2(I                             # 7 bytes
End                                # 2 bytes
T≥sum(seq(L2(X)/L1(X),X,1,I        # 21 bytes

Баш, 151 байт

Запуск как (например) $ bash golf.sh .5 10=====:

shopt -s extglob
r=$2
while [ -n "$r" ];do
f=${r%%+(=)}
s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`
r=${f%%+([0-9.])}
done
[[ `dc<<<"$1 $s-p"` != -* ]]

объяснение

shopt -s extglob
r=$2

Включите расширенные операторы сопоставления с образцом в bash и назначьте дорогу переменной r.

while [ -n "$r" ];do
f=${r%%+(=)}

Петля пока rне пуста. Установить , fчтобы rсо всеми равноправными признаками удалены с конца, используя %% расширение параметра и +()расширенный оператор подстановки.

s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`

Присвойте sпромежуточную сумму минимального времени для каждого сегмента дороги. Это может быть переписано (возможно, немного) более читабельно, как:

s=$(dc <<< "9k $s $[${#r}-${#f}] ${f##*=} / + p")

В основном, здесь происходит то, что мы используем здесь-строку, чтобы заставить dcкоманду делать математику за нас, так как bash не может выполнять арифметику с плавающей точкой сама по себе. 9kустанавливает точность, поэтому наше деление с плавающей точкой, и pвыводит результат, когда мы закончим. Это калькулятор обратной польской обработки, поэтому то, что мы действительно вычисляем, ${f##*=}делится на $[${#r}-${#f}]плюс нашу текущую сумму (или, когда мы впервые пробежались и sеще не были установлены, ничего, что заставляет нас предупредить сообщение о stderr о dc' стек пустой, но он все равно печатает правильное число, потому что мы все равно добавляем ноль).

Что касается фактических значений, которые мы делим: ${f##*=}это fс наибольшим сопоставлением *=с шаблоном, удаленным спереди. Поскольку fнаша текущая дорога со всеми знаками равенства удалена с конца, это означает ${f##*=}ограничение скорости на данном участке дороги. Например, если бы наша дорога rбыла «10 ===== 5 ===», то fбыла бы «10 ===== 5», и поэтому ${f##*=}«5».

$[${#r}-${#f}]количество знаков равенства в конце нашего отрезка дороги. ${#r}длина r; так fпросто rсо всеми знаками равенства в конце удален, можно просто вычесть длину от такового , rчтобы получить длину этого участка дороги.

r=${f%%+([0-9.])}
done

Снимите ограничение скорости этого участка дороги с конца f, оставив все остальные участки дороги, и установите rего, продолжая цикл для обработки следующего участка дороги.

[[ `dc<<<"$1 $s-p"` != -* ]]

Проверьте, $1не меньше ли времени, которое мы потратили на дорогу (при условии как ), меньше минимума, разрешенного ограничением скорости. Этот минимум sможет быть плавающим, поэтому мы dcснова обращаемся к нему для сравнения. dcдействительно имеет оператор сравнения, но на самом деле его использование оказалось на 9 байтов больше, чем этот, поэтому вместо этого я вычитаю наше время в пути из минимума и проверяю, отрицательно ли оно, проверяя, начинается ли оно с тире. Возможно, не элегантный, но все по-честному в любви и кодегольфе.

Поскольку эта проверка является последней командой в сценарии, ее возвращаемое значение будет также возвращено сценарием: 0, если возможно, ускорение, 1, если определенно ускорение:

$ bash golf.sh .5 10===== 2>/dev/null && echo maybe || echo definitely
maybe
$ bash golf.sh .4 10===== 2>/dev/null && echo maybe || echo definitely
definitely

Python 3.6, 111 байт

Мой первый код гольф!

import re
def f(a,b):
 t=0
 for c in re.split('(=+)',b)[:-1]:
  try:s=float(c)
  except:t+=len(c)/s
 return a<t

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

re.split('(=+)',b)[:-1] Разбивает дорогу кусками =.

Затем он перебирает результат, используя try:s=float(c)для установки текущего ограничения скорости, если текущим элементом является число, или except:t+=len(c)/sдля добавления времени для прохождения этого отрезка дороги к совокупному итогу.

Наконец, он возвращает время, затраченное на максимально быстрое время.

PHP5 207 202 байта

Сначала попытайтесь ответить на кодовый гольф, пожалуйста, будьте осторожны со мной. Я уверен, что один из вас, гениев, сможет значительно сократить это, любые советы по игре в гольф приветствуются.

function s($c,$d){foreach(array_filter(split("[{$d}/=]",$c)) as $e){$f[]=$e;};return $f;}function x($a,$b){$c=s($b,"^");$d=s($b,"");for($i=0;$i<sizeof($c);$i++){$z+=strlen($c[$i])/$d[$i];}return $a<$b;}

Вызвать с

x("1.5","3.0==========20===")

Возвращает истину, если вы были ниже ограничения скорости, ложь в противном случае

Дьялог АПЛ, 27 байт

<∘(+/(⍎'='⎕r' ')÷⍨'=+'⎕s 1)

'=+'⎕s 1является функцией, которая идентифицирует отрезки '='с помощью регулярного выражения и возвращает вектор их длин ( ⎕sправый операнд 0 будет означать смещения; 1 - длины; 2 - индексы совпадающих регулярных выражений)

'='⎕r' 'заменяет '='s пробелами

⍎'='⎕r' ' выполняет его - возвращает вектор скоростей

÷⍨в середине делит два вектора ( ⍨меняет местами аргументы, поэтому расстояние делится на скорость)

+/ это сумма

все до сих пор - 4 поезда - функция без явного аргумента

<∘сочиняет «меньше чем» перед этой функцией; поэтому функция будет действовать только для правого аргумента, а ее результат будет сравниваться с левым аргументом

F # (165 байт)

let rec c t p l=
 match l with
 |[]->t<0.0
 |x::xs->
  match x with
  |""->c(t-p)p xs
  |_->c(t-p)(1.0/float x)xs
let s t (r:string)=r.Split '='|>Seq.toList|>c t 0.0

Я все еще новичок в F #, поэтому, если я сделал что-то странное или глупое, дайте мне знать.

Метод C # ( 137 122 байта)

Требуется using System.Linqдобавить 19 байтов, включенных в 122:

bool C(float t,string r,float p=0)=>r.Split('=').Aggregate(t,(f,s)=>f-(s==""?p:p=1/float.Parse(s)))<-p;

Расширенная версия:

bool Check(float time, string road, float pace=0) => 
    road.Split('=')
        .Aggregate(time, (f, s) => f - (
            s == "" 
            ? pace 
            : pace = 1 / float.Parse(s))) 
        < -pace;

roadСтрока разбивается на =характер. В зависимости от того, является ли строка результирующим массивом пустым, агрегатная функция устанавливает paceпеременную для сегмента (обозначая время, необходимое для прохождения одного =) и вычитает ее из предоставленного времени. Это приведет к слишком большому количеству вычитаний (для конечного сегмента дороги), поэтому вместо сравнения 0мы сравниваем с-pace

R , 100 байт

function(S,R){s=strsplit(R,"=")[[1]]
s[s==""]=0
S<sum((1+(a=rle(as.double(s)))$l[!a$v])/a$v[a$v>0])}

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

Возвращает TRUEдля однозначно ускоряющихся значений, FALSEдля, возможно, не быстрых.

PowerShell, 71 bytes

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

Try it online!

Test script:

$f = {

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

}

@(
    ,(1.5, "5=====10=====", $false)
    ,(3.2, "3.0==========20===", $true)
) | % {
    $time,$road,$expected = $_
    $result = &$f $time $road
    "$($result-eq$expected): $result"
}

Output:

True: False
True: True

Explanation:

1. The script gets the elements of the road 5=====10=====, swaps elements, adds brackets and operators +(=====)/5+(=====)/10
2. Then the script replaces each = with +1: +(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Finally, the script evaluates the string as a Powershell expression and compare it with the first argument.