[Question]
  [
Given an [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") road and the time it took me to cross it, tell me if I was speeding.
## Units
Distance is in the arbitrary unit of `d`. Time is in the arbitrary unit of `t`.
## The road
Here is a simple road:
```
10=====
```
The `10` means 10 `d` per `t`. That is the speed limit for the road. The road has 5 `=`s, so its `d` is 5. Therefore, if I cross that road in 0.5 `t`, I went 10 `d` per `t`, because 5/0.5 = 10. The speed limit of that road is 10, so I stayed within the speed limit.
But if I cross that road in **0.25** `t`, I went 20 `d` per `t`, because 5/**0.25** = 20. The speed limit of that road is 10, so I went 10 over the speed limit.
## Examples and calculations
Note that input 1 is the time I took to travel the road, and input 2 is the road itself.
Here is a complex road:
```
Input 1: 1.5
Input 2: 5=====10=====
```
The fastest I could have (legally) gone on the first road (the first 5 `=`s) is 5 `d` per `t`. Since 5 (distance) divided by 5 (speed limit) is 1, the fastest I could have gone on that road is 1 `t`. 
On the next road, the speed limit is 10 and the distance is also 5, the fastest I could cross that is 0.5 (5/10). Totaling the minimum times results in 1.5, meaning I went at *exactly the speed limit.*
*Note: I know, I might have been going really fast on one road and really slow on another and still cross in 1.5, but assume the best here.*
A final example:
```
Input 1: 3.2
Input 2: 3.0==========20===
```
The first road is 10 long and has a speed limit of 3, so the minimum time is 3.33333... (10 / 3.)
The second road is 3 long and has a speed limit of 20, so the minimum time is 0.15 (3 / 20.)
Totaling the times results in 3.483333333... I crossed it in 3.2, so I had to be speeding somewhere.
## Notes:
* You must output one distinct value if I am undoubtedly speeding, and another different value if I might not be.
* Your program or function may require input or output to have a trailing newline, but please say so in your submission.
* Your first input will be my speed. It will be a positive float or integer or string.
* Your second input will be the road. It will always match the regex `^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$`. [You may test out potential inputs here if you are interested.](https://regex101.com/r/Iq04Ph/4)
* You may take input in 2 parameters of a function or program, in 2 separate files, from STDIN twice, or from a space-separated string passed to STDIN, a function, a file or a command-line parameter.
* If you would like to, you can change the order of the inputs.
* Any questions? Ask below in comments and **happy [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")ing!**
  
[Answer]
# [Python 2](https://docs.python.org/2/), 71 bytes
```
m,s=input()
for c in s.split('=')[:-1]:s=float(c or s);m-=1/s
print m<0
```
[Try it online!](https://tio.run/nexus/python2#@5@rU2ybmVdQWqKhyZWWX6SQrJCZp1CsV1yQk1mioW6rrhltpWsYa1Vsm5aTn1iikawAVFOsaZ2ra2uoX8xVUJSZV6KQa2Pw/7@xnomOgpKxnoEtHBiB2EoA "Python 2 – TIO Nexus")
Python's dynamic type system can take quite some abuse.
Splitting the input string `s.split('=')` turns `k` equal signs into `k-1` empty-string list elements (except at the end, where one must be cut off). For example,
```
"3.0===20====".split('=')[:-1] == ['3.0', '', '', '20', '', '', '']
```
The code iterates over these elements, updating the current speed `s` each time it sees a number. The update is done as `s=float(c or s)`, where if `c` is a nonempty string, we get `float(c)`, and otherwise `c or s` evaluates to `s`, where `float(s)` just keeps `s`. Note that `c` is a string and `s` is a number, but Python doesn't require doesn't require consistent input types, and `float` accepts either.
Note also that the variable `s` storing the speed is the same one as taking the input string. The string is evaluated when the loop begins, and changing it within the loop doesn't change what is iterated over. So, the same variable can be reused to save on an initialization. The first loop always has `c` as a number, so `s=float(c or s)` doesn't care about `s`'s initial role as a string.
Each iteration subtracts the current speed from the allowance, which starts as the speed limit. At the end, the speed limit has been violated if this falls below `0`.
[Answer]
# [Python 3](https://docs.python.org/3/), 79 bytes
```
import re;g=re.sub
lambda m,s:eval(g('=','-~',g('([^=]+)',r'0+1/\1*',s))+'0')>m
```
[Try it online!](https://tio.run/nexus/python3#PcZLDsIgEADQvafobmZkRGrTjQYv4iehkTYkpZKBuvTqqBvf6tUQ01NKI/40WfE6r8NmtLOLw8M1kfPRv9yME4IFht0b@Fu83O1NEbCAUe3@2m6BM5ECA3SONUlYCo7Y6Z7DktaCRFQ7bezf4fcP "Python 3 – TIO Nexus")
For example, the input `3.0==========20===` is converted to the string 
```
0+1/3.0*-~-~-~-~-~-~-~-~-~-~0+1/20*-~-~-~0 
```
and evaluated, and the result is compared to the input speed. Each `-~` increments by `1`. I'm new to regexes, so perhaps there's a better way, like making both substitutions at once. Thanks to Jonathan Allan for pointing out how to match on all but the `=` character.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~24~~ 22 bytes
Returns **1** when undoubtedly speeding and **0** otherwise.
Saved 2 bytes thanks to *carusocomputing*.
```
'=¡õK¹S'=Q.¡O0K/O-§'-å
```
[Try it online!](https://tio.run/nexus/05ab1e#@69ue2jh4a3eh3YGq9sG6h1a6G/gre@ve2i5uu7hpf//G@sZ2MKBEYjNZaxnBAA "05AB1E – TIO Nexus")
`-§'-å` shouldn't have to be more than a simple comparison, but for some reason neither `›` nor `‹` seem to work between the calculated value and the second input.
**Explanation**
Using `3.0==========20===, 3.2` as example
```
'=¡                        # 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
```
[Answer]
# Javascript (ES6), 63 bytes
```
a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a
```
# Usage
Assign this function to a variable and call it using the currying syntax. The first argument is the time, the second is the road.
# Explanation
Matches all consecutive runs of characters that are not equal signs followed by a run of equal signs. Each match is replaced by the result of the inner function, which uses two arguments: the run of equal signs (in variable `d`) and the number (variable `c`). The function returns the length of the road devided by the number, prepended by a +.
The resulting string is then evaluated, and compared against the first input.
# Stack Snippet
```
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>
```
[Answer]
# GNU C, 128 bytes
```
#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;}
```
Handles non-integer speed limits also. `#import<stdlib.h>` is needed for the compiler not to assume that `atof()` returns an `int`.
`t<s-.001` is needed to make the exact speed limit test case to work, otherwise rounding errors cause it to think you were speeding. Of course, now if the time is `1.4999` instead of `1.5`, it doesn't consider that speeding. I hope that's okay.
[Try it online!](https://tio.run/nexus/c-gcc#PY3NDoIwEITvPEVTQ9LSgi0EL2t9Ei8oNjQpP1nqifDsWDA6h92dbybZ7eT6acRwnUPr3aPoboll1o9NIEE@uwYz5MvXezkbBXZEBhlCpPHypgmjZcghY0Igzy8a@K8jhDG7n4XRZw95jrDiK7xxIPFfXiilYd3cEEjfuIHxZElI1IQRWUbT9j6kLZXEsqooJa3MX6WKg/I90kUtaX1QrY5FOYdk3T4)
[Answer]
# [Perl 5](https://www.perl.org/), 43 bytes
42 bytes of code + `-p` flag.
```
s%[^=]+(=+)%$t+=(length$1)/$&%ge;$_=$t<=<>
```
[Try it online!](https://tio.run/nexus/perl5#Pc3NDoIwEATge59ihWIgKPITTrA@CQmpsSJJC01ZjCS8O1oSnctM5vL5ByOtgrNhnDCtwAcrJ0n90MFjtKBnRb1REuRb6G9P2xQ09zjEOAo4xRgqOXT05Fl04cegkxVvkVON9XWrgLewrgjpvhIErxk8J/Ta2PHliHEmM5OTtCCHnnbVSnEXt14tMA5q2bIUXVia5CUr9/27sqRkBf6Tu5sVSf4B "Perl 5 – TIO Nexus")
For each group of digit followed by some equal signs (`[^=]+(=+)`), we calculate how much time is needed to cross it (number of equals divided by the speed: `(length$1)/$&`) and sum those times inside `$t`. At the end, we just need to check that `$t` is less than the time you took to cross it (`$_=$t < <>`). The result will be `1` (true) or *nothing* (false).
[Answer]
# Mathematica, 98 bytes
```
Tr[#2~StringSplit~"="//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}]-"
"<=#&
```
Pure function taking two arguments, a number (which can be an integer, fraction, decimal, even `π` or a number in scientific notation) and a newline-terminated string, and returning `True` or `False`. Explanation by way of example, using the inputs `3.2` and `"3==========20===\n"`:
`#2~StringSplit~"="` produces `{"3","","","","","","","","","","20","","","\n"}`. Notice that the number of consecutive `""`s is one fewer than the number of consecutive `=`s in each run.
`//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}` is a repeating replacement rule. First it sets `z` to the empty sequence, `a` to `"3"`, `b` to `"","","","","","","","",""` (the longest run of `""`s it could find), and `c` to `"20","","","\n"`; the command `(Length@{b}+1)/ToExpression@a` evaluates to `(9+1)/3`, and so the result of the replacement is the list `{10/3, "20","","","\n"}`.
Next the replacement rule sets `z` to `10/3`, `a` to `"20"`, `b` to `"",""`, and `c` to `"\n"`. Now `(Length@{b}+1)/ToExpression@a` evaluates to `(2+1)/20`, and so the result of the replacement is `{10/3, 3/20, "\n"}`. The replacement rule can't find another match, so it halts.
Finally, `Tr[...]-"\n"` (it saves a byte to use an actual newline between the quotes instead of `"\n"`) adds the elements of the list, obtaining `10/3 + 3/20 + "\n"`, and then subtracts off the `"\n"`, which Mathematica is perfectly happy to do. Finally, `<=#` compares the result to the first input (`3.2` in this case), which yields `False`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 27 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṣ”=V€ḟ0
Œr”=e$ÐfṪ€ż⁸Ç¤÷/€S>
```
**[Try it online!](https://tio.run/nexus/jelly#@/9w5@JHDXNtwx41rXm4Y74B19FJRSB@qsrhCWkPd64CCh/d86hxx@H2Q0sOb9cHcoPt/v//b6xnYAsHRiA2UMgEAA "Jelly – TIO Nexus")**
Note: assumes that the regex given in the question should be such that a speed limit cannot be `0.0`, `0.00`, etc. - just like it cannot be `0` ([confirmed](https://codegolf.stackexchange.com/questions/116050/am-i-over-the-speed-limit/116063#comment283408_116050) as an unintentional property).
### How?
```
ṣ”=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)
```
[Answer]
# Python 3, 90 bytes
```
import re
lambda t,r:sum(x.count("=")/eval(x.strip("="))for x in re.findall("\d+\D+",r))>t
```
Outputs `True` if you're speeding, `False` if you might not be. Does not require (but will work with) trailing newline.
Despite it not looking like it would, it correctly handles floats in both input time and speed limits, because the regex is just used to seperate the road segments.
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~31~~ 30 bytes
```
t61=TwFhhdfd1wY{1L&)o!oswcU!/s<
```
Inputs are: a string (speed limits and roads), then a number (used speed). Output is `1` if undoubtedly speeding, `0` if not.
[Try it online!](https://tio.run/nexus/matl#@29YaWZoG1LulpGRkpYSWW3oo6aZr5hfXJ4cqqhfbPP/v7qxnoEtHBiB2OpcxnpGAA "MATL – TIO Nexus")
### Explanation with example
Consider inputs `'3.0==========20==='` and `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
```
[Answer]
# APL, 41 bytes
```
{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}
```
This takes the road as a string as its right argument, and the time taken as its left argument, and returns `1` if you were speeding and `0` if not, like so:
```
      3.2{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}'3.0==========20==='
1
```
Explanation:
* `X←⍵='='`: store in `X` a bit vector of all positions in `⍵` that are part of the road.
* `X≠¯1⌽X`: mark each position of `X` that is not equal to its right neighbour (wrapping around), giving the positions where numbers and roads start
* `Y←⍵⊂⍨`: split `⍵` at these positions (giving an array of alternating number and road strings), and store it in `Y`.
* `Y⊂⍨2|⍳⍴Y`: split up `Y` in consecutive pairs.
* `{(≢⍵)÷⍎⍺}/¨`: for each pair, divide the length of the road part (`≢⍵`) by the result of evaluating the number part (`⍎⍺`). This gives the minimum time for each segment.
* `+/`: Sum the times for all segments to get the total minimum time.
* `⍺<`: Check whether the given time is less than the minimum or not.
[Answer]
# TI-Basic, ~~168~~ 165 bytes
```
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
```
Input is the road as `Str0` and the time as `T`. Make sure to precede the road with a quote, eg `Str0=?"14========3===`.
Output is 0 if speeding, 1 if possibly not speeding.
```
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
```
[Answer]
# Bash, 151 bytes
Running as (for example) `$ 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"` != -* ]]
```
## Explanation
```
shopt -s extglob
r=$2
```
Enable bash's [extended pattern-matching operators](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) and assign the road to a variable `r`.
```
while [ -n "$r" ];do
f=${r%%+(=)}
```
Loop until `r` is empty. Set `f` to `r` with all equal signs removed from the end, using the `%%` [parameter expansion](https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html#Shell-Parameter-Expansion) and the `+()` extended globbing operator.
```
s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`
```
Assign to `s` a running sum of the minimum times for each road segment. This can be re-written (perhaps slightly) more readably as:
```
s=$(dc <<< "9k $s $[${#r}-${#f}] ${f##*=} / + p")
```
Basically what's going on here is we're using a here-string to get the `dc` command to do math for us, since bash can't do floating-point arithmetic by itself. `9k` sets the precision so our division is floating-point, and `p` prints the result when we're done. It's a reverse-polish calculator, so what we're really calculating is `${f##*=}` divided by `$[${#r}-${#f}]`, plus our current sum (or, when we first run through and `s` hasn't been set yet, nothing, which gets us a warning message on stderr about `dc`'s stack being empty, but it still prints the right number because we'd be adding to zero anyway).
As for the actual values we're dividing: `${f##*=}` is `f` with the largest pattern matching `*=` removed from the front. Since `f` is our current road with all the equal signs removed from the end, this means `${f##*=}` is the speed limit for this particular stretch of road. For example, if our road `r` were '10=====5===', then `f` would be '10=====5', and so `${f##*=}` would be '5'.
`$[${#r}-${#f}]` is the number of equal signs at the end of our stretch of road. `${#r}` is the length of `r`; since `f` is just `r` with all the equal signs at the end removed, we can just subtract its length from that of `r` to get the length of this road section.
```
r=${f%%+([0-9.])}
done
```
Remove this section of road's speed limit from the end of `f`, leaving all the other sections of road, and set `r` to that, continuing the loop to process the next bit of road.
```
[[ `dc<<<"$1 $s-p"` != -* ]]
```
Test to see if the time we took to travel the road (provided as `$1`) is less than the minimum allowed by the speed limit. This minimum, `s`, can be a float, so we turn to `dc` again to do the comparison. `dc` does have a comparison operator, but actually using it ended up being 9 more bytes than this, so instead I subtract our travel time from the minimum and check to see if it's negative by checking if it starts with a dash. Perhaps inelegant, but all's fair in love and codegolf.
Since this check is the last command in the script, its return value will be returned by the script as well: 0 if possibly speeding, 1 if definitely speeding:
```
$ 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
```
[Answer]
# Python 3.6, 111 bytes
My first code golf!
```
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
```
[Try it online!](https://tio.run/nexus/python3#PYvBDsIgEETvfMXeWNKKtb2R8iXGAyIkJEgJrIl@Pa4X5zR582akZz0aQQviESJEdPNdGQFkFwHxaOAhFV51rzkRSrSTkqxczelyYw@ofUy3MR@O0CsG4e1DJUOTzaEwOnfBf3q1Am6nUVsqhBE3vc5y04v9Z/11qdT4Ag)
`re.split('(=+)',b)[:-1]`
Splits the road by chunks of `=`.
It then iterates over the result, using `try:s=float(c)` to set the current speed limit if the current item is a number or `except:t+=len(c)/s` to add the time to traverse this section of road to the cumulative total.
Finally it returns the time taken to the fastest possible time.
[Answer]
# PHP5 ~~207~~ 202 bytes
First effort at a code golf answer, please go easy on me. I'm sure one of you geniuses will be able to shorten this significantly, any golfing tips are welcome.
```
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;}
```
Invoke with
```
x("1.5","3.0==========20===")
```
Returns true if you have been under the speed limit, false otherwise
[Answer]
# Dyalog APL, 27 bytes
`<∘(+/(⍎'='⎕r' ')÷⍨'=+'⎕s 1)`
`'=+'⎕s 1` is a function that identifies stretches of `'='` with a regex and returns a vector of their lengths (`⎕s`'s right operand 0 would mean offsets; 1 - lengths; 2 - indices of regexes that matched)
`'='⎕r' '` replaces `'='`s with spaces
`⍎'='⎕r' '` executes it - returns a vector of speeds
`÷⍨` in the middle divides the two vectors (`⍨` swaps the arguments, so it's distance divided by speed)
`+/` is sum
everything so far is a 4-train - a function without an explicit argument
`<∘` composes "less than" in front of that function; so, the function will act only on the right argument and its result will be compared against the left argument
[Answer]
# F# (165 bytes)
```
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
```
I'm still new to F#, so if I did anything weird or stupid, let me know.
[Answer]
# C# method (137 122 bytes)
Requires `using System.Linq` adding 19 bytes, included in the 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;
```
Expanded version:
```
bool Check(float time, string road, float pace=0) => 
    road.Split('=')
        .Aggregate(time, (f, s) => f - (
            s == "" 
            ? pace 
            : pace = 1 / float.Parse(s))) 
        < -pace;
```
The `road` string is split on the `=` character. Depending on whether a string is the resulting array is empty, the aggregate function sets the `pace` variable for the segment (denoting the time it takes to travel a single `=`) and subtracts it from the time supplied. This will do one too many substractions (for the final road segment), so instead of comparing to `0`, we compare to `-pace`
[Answer]
# [R](https://www.r-project.org/), 100 bytes
```
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])}
```
[Try it online!](https://tio.run/##JYnLDoIwEEX3fAVOWMzEWlsIO8aPgGXTBT6akPAwDLgxfntFPMl95N45hrQ6pTGs423pphEbVdNbWJZZnn23YK2AgZyz3ifihBnAs0maStYB0R6x5bl/YCv6Pq3XrQkRZb07tNnL03lzt@liPH1iQKtLBSX/sGYPoCRgoXMFhf4vO7nZv/gF "R – Try It Online")
Returns `TRUE` for unambiguously speeding values, `FALSE` for possibly unspeedy ones.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 71 bytes
```
param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)
```
[Try it online!](https://tio.run/##PY9RC4IwFIXf/RUXubUNpzmjl0Dqn8TQKwmTbC4Kqt9uc5rn5cI534Fz@9uT7HAlY0ZsoIT32GurO45OohXoUuM42tRSb3RFjGfJSfAyEUyyhGMhdqjYmpaTq9inpZcYv1F05hF4Sa6yg4T4UE5SeTixBGy0GUgszD4rPLPP5jioyBfQ2YfnBHxgA@/Ao2s78hNvupZIr54qR7Xfj5c5tjQ8jPPG1r8VYAhwSGPkC5DSfW2L478WR9/xBw "PowerShell – 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.
]