アスキーアートの道とそれを横断するのにかかった時間を考えると、スピードを出しているかどうかを教えてください。

単位

距離はの任意の単位ですd。時間はの任意の単位ですt。

道

簡単な道は次のとおりです。

10=====

10手段10 dあたりt。それが道路の制限速度です。道路は5 =秒なので、d5です。したがって、0.5 tでその道路を横断する場合、5 / 0.5 = 10なので10 dあたりに行きましたt。その道路の制限速度は10なので、制限速度内にとどまりました。

しかし、0.25 tでその道路を横断する場合、5 / 0.25 = 20 なので20 dあたり20になりました。その道路の制限速度は10なので、制限速度を10超えました。t

例と計算

入力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）です。

2番目の道路は3本の長さで、速度制限は20なので、最小時間は0.15（3/20）です。

時間を合計すると3.483333333になります... 3.2でそれを超えたため、どこかでスピードを上げる必要がありました。

ノート：

• 間違いなくスピードを上げている場合は、1つの異なる値を出力し、そうでない場合は、別の異なる値を出力する必要があります。
• プログラムまたは関数では、末尾に改行を入れるために入力または出力が必要になる場合がありますが、提出時にその旨を伝えてください。
• 最初の入力は私の速度です。正の浮動小数点数または整数または文字列になります。
• 2番目の入力は道路です。常に正規表現に一致し^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$ます。興味がある場合は、ここで潜在的な入力をテストできます。
• 関数またはプログラムの2つのパラメーター、2つの別個のファイル、STDINから2回、またはSTDINに渡されるスペース区切り文字列、関数、ファイル、またはコマンドラインパラメーターで入力を受け取ることができます。
• 必要に応じて、入力の順序を変更できます。
• 質問は？以下のコメントと幸せなコードゴルフで質問してください！

05AB1E、24 22バイト

間違いなく高速化する場合は1を返し、そうでない場合は0を返します。

carusocomputingのおかげで2バイト節約されました。

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

オンラインでお試しください！

-§'-å単純な比較以上のものである必要はありませんが、何らかの理由で、計算値と2番目の入力の間で機能し›ない‹ようです。

説明

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('=')変わります（最後の要素は切り捨てる必要がある場合を除く）。例えば、kk-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ます。私は正規表現に慣れていないので、両方の置換を一度に行うなど、もっと良い方法があるかもしれません。=キャラクター以外のすべてで一致する方法を指摘してくれたJonathan Allanに感謝します。

Javascript（ES6）、63バイト

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

使用法

この関数を変数に割り当て、カリー化構文を使用して呼び出します。最初の引数は時間であり、2番目の引数は道路です。

説明

等号ではない連続したすべての文字に一致し、その後に等号が続きます。各一致は、2つの引数を使用する内部関数の結果に置き換えられます。2つの引数：等号の実行（変数内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バイト

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の数より1少ないことに注意してください。=、各実行 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、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"ます。最後に<=#、結果を最初の入力（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が浮動小数点演算を単独で実行できないため、here-stringを使用してコマンドを実行して数学を実行していることです。9k除算が浮動小数点になるように精度を設定し、p完了時に結果を出力します。これは逆ポーランド計算機であるため、実際に計算しているものは、に現在の合計を加えたもので${f##*=}除算され$[${#r}-${#f}]ます（または、最初に実行してsまだ設定されていない場合は、stderrに警告メッセージを表示します）dc "スタックは空ですが、とにかくゼロに追加するため、正しい数値が出力されます）。

実際の値については、分割しています：${f##*=}はf、最大のパターンマッチング*=が前面から削除されています。以来f端から除去全て等号との現在の道路であり、この手段は、${f##*=}道路のこの特定のストレッチのための制限速度です。たとえば、道路rが「10 ===== 5 ===」の場合、「f10 ===== 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' ' 実行-速度のベクトルを返します

÷⍨中央で2つのベクトルを分割し⍨ます（引数を交換するため、距離を速度で除算します）

+/ 合計です

これまでのものはすべて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.Linq122バイトに含まれる19バイトを追加する必要があります。

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はセグメントの変数を設定し（単一の移動にかかる時間を示す=）、指定された時間からそれを減算します。これにより、1つの非常に多くの減算（最終的な道路セグメント）が実行されるため、と比較する代わりに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式として評価し、最初の引数と比較します。