给定一个ASCII艺术道路，我花了时间去跨过它，告诉我，如果我是超速行驶。

单位

距离以的任意单位表示d。时间以的任意单位表示t。

马路

这是一条简单的路：

10=====

的10装置10 d每t。那是道路的速度极限。这条路有5 =s，所以它d是5。因此，如果我以0.5越过那条路t，我d每10条走10条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?$。如果您有兴趣，可以在这里测试潜在的输入。
• 您可以从STDIN两次，或者从传递给STDIN的以空格分隔的字符串，函数，文件或命令行参数中，在2个单独的文件中，输入函数或程序的2个参数中的输入。
• 如果需要，可以更改输入的顺序。
• 任何问题？在下面的注释和快乐的代码打扰中询问！

05AB1E，24 22字节

毫无疑问，当超速时返回1，否则返回0。

由于使用了carusocomputing，节省了2个字节。

'=¡õ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)keeps为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。我是正则表达式的新手，所以也许有更好的方法，例如一次替换两个。感谢乔纳森·艾伦（Jonathan Allan）指出了除=角色以外的所有角色的搭配方法。

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（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为空序列，分别a为to "3"，bto "","","","","","","","",""（""它可以找到的最长的s）和cto "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

Bash，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为空。使用参数扩展和扩展的globlob运算符将其设置f为r从结尾删除所有等号。%% +()

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

s为每个路段分配最短时间的总和。可以更可读地将其重写为（也许稍微）为：

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

基本上，这里发生的是我们使用here字符串来获取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===")

如果您已达到速度限制，则返回true，否则返回false

Dyalog 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＃方法（137122字节）

需要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表达式，并将其与第一个参数进行比较。