Враховуючи дорогу 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 333 333 ... (10/3).

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

Підсумовуючи результати в 3,483333333 ... я перетнув його в 3,2, тому мені довелося кудись швидше.

Примітки:

• Ви повинні вивести одне чітке значення, якщо я, безперечно, швидкість, і інше інше значення, якщо я не можу бути.
• Ваша програма або функція може вимагати введення або виводу, щоб мати зворотний новий рядок, але, будь ласка, скажіть це у поданні
• Вашим першим входом буде моя швидкість. Це буде позитивний поплавок або ціле число або рядок.
• Вашим другим входом стане дорога. Він завжди буде відповідати регулярному вираженню ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Тут ви можете перевірити потенційні вклади, якщо вам це цікаво.
• Ви можете взяти вхід у двох параметрах функції або програми, у двох окремих файлах, 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), де, якщо 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

Використання

Призначте цю функцію змінній та викликайте її за допомогою синтаксису currying. Перший аргумент - час, другий - дорога.

Пояснення

Збігається з усіма послідовними пробіжками символів, які не є рівними знаками з подальшим пробігом знаків рівності. Кожна відповідність замінюється результатом внутрішньої функції, яка використовує два аргументи: запуск рівних знаків (у змінній 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(істинним) або нічого (помилковим).

Математика, 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порожню послідовність, aна "3", bдо "","","","","","","","",""(найдовший пробіг "", який він міг знайти), і cна "20","","","\n"; команда (Length@{b}+1)/ToExpression@aоцінює до (9+1)/3, тому результатом заміни є список{10/3, "20","","","\n"} .

Далі правило заміни встановлюється zна 10/3, aдо "20", bдо "",""та cдо "\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===")

Повертає істину, якщо ви були обмеженими швидкістю, інакше помилково

Діалог APL, 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 байт

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

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

Тестовий сценарій:

$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"
}

Вихід:

True: False
True: True

Пояснення:

1. Сценарій отримує елементи дороги 5=====10=====, замінює елементи, додає дужки та оператори+(=====)/5+(=====)/10
2. Тоді сценарій замінює кожного =на +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Нарешті, скрипт оцінює рядок як вираз Powershell і порівнює його з першим аргументом.