Dada uma estrada artística e o tempo que levei para atravessá-la, diga-me se eu estava acelerando.

Unidades

A distância está na unidade arbitrária de d. O tempo está na unidade arbitrária de t.

A estrada

Aqui está um caminho simples:

10=====

As 10médias 10 dpor t. Esse é o limite de velocidade para a estrada. A estrada tem 5 =s, então dé 5. Portanto, se eu atravessar essa estrada em 0,5 t, fui 10 dport , porque 5 / 0,5 = 10. O limite de velocidade dessa estrada é 10, então fiquei dentro do limite de velocidade.

Mas se eu atravessar essa estrada em 0,25 t , fui 20 dpor t, porque 5 / 0,25 = 20. O limite de velocidade dessa estrada é 10, então fui 10 acima do limite de velocidade.

Exemplos e cálculos

Observe que a entrada 1 é o tempo que levei para percorrer a estrada e a entrada 2 é a própria estrada.

Aqui está uma estrada complexa:

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

O mais rápido que eu poderia ter (legalmente) percorrido a primeira estrada (os primeiros 5 =s) é 5 dpor t. Como 5 (distância) dividido por 5 (limite de velocidade) é 1, o mais rápido que eu poderia ter percorrido nessa estrada é 1t .

Na próxima estrada, o limite de velocidade é 10 e a distância também é 5, o mais rápido que pude atravessar é 0,5 (5/10). Totalizar o tempo mínimo resulta em 1,5, o que significa que fui exatamente ao limite de velocidade.

Nota: Eu sei, eu poderia estar indo muito rápido em uma estrada e muito lento em outra e ainda atravessar em 1,5, mas assuma o melhor aqui.

Um exemplo final:

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

A primeira estrada tem 10 longos e um limite de velocidade de 3, portanto o tempo mínimo é 3,33333 ... (10 / 3.)

A segunda estrada é de 3 metros e tem um limite de velocidade de 20, portanto o tempo mínimo é de 0,15 (3 / 20.)

Totalizar os tempos resulta em 3,483333333 ... Eu o atravessei em 3,2, então eu precisava estar acelerando em algum lugar.

Notas:

• Você deve gerar um valor distinto, se eu estiver indubitavelmente acelerando, e outro valor diferente, se eu não estiver.
• Seu programa ou função pode exigir entrada ou saída para ter uma nova linha à direita, mas por favor diga isso no seu envio.
• Sua primeira entrada será a minha velocidade. Será um número positivo ou número inteiro ou sequência.
• Sua segunda entrada será a estrada. Sempre corresponderá ao regex ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Você pode testar possíveis entradas aqui se estiver interessado.
• Você pode inserir 2 parâmetros de uma função ou programa, em 2 arquivos separados, do STDIN duas vezes ou de uma sequência separada por espaço passada para o STDIN, uma função, um arquivo ou um parâmetro da linha de comando.
• Se desejar, você pode alterar a ordem das entradas.
• Alguma pergunta? Pergunte abaixo nos comentários e feliz código-golfe ing!

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!

-§'-å 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

Python 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!

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.

Python 3, 79 bytes

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

Try it online!

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.

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>

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!

Perl 5, 43 bytes

42 bytes of code + -p flag.

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

Try it online!

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).

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.

Jelly, 27 bytes

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

Try it online!

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 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)

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.

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!

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

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.

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

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 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 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

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!

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.

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

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

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.

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

R, 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!

Returns TRUE for unambiguously speeding values, FALSE for possibly unspeedy ones.

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.