Apakah saya melebihi batas kecepatan?


Diberi jalan dan waktu yang saya perlukan untuk melewatinya, beri tahu saya jika saya melaju kencang.


Jarak adalah dalam unit arbitrer dari d. Waktu dalam unit sewenang-wenang t.


Ini jalan sederhana:


The 10berarti 10 dper t. Itu adalah batas kecepatan untuk jalan. Jalan memiliki 5 =s, jadi ini dadalah 5. Oleh karena itu, jika saya menyeberang jalan itu dalam 0,5 t, saya pergi 10 dper t, karena 5 / 0,5 = 10. Batas kecepatan jalan itu adalah 10, jadi saya tetap dalam batas kecepatan.

Tetapi jika saya menyeberang jalan itu di 0,25 t , saya pergi 20 dper t, karena 5 / 0,25 = 20. Batas kecepatan jalan itu adalah 10, jadi saya pergi 10 di atas batas kecepatan.

Contoh dan perhitungan

Perhatikan bahwa input 1 adalah waktu yang saya ambil untuk menempuh jalan, dan input 2 adalah jalan itu sendiri.

Inilah jalan yang kompleks:

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

Yang tercepat yang saya bisa (secara hukum) pergi di jalan pertama (5 pertama =) adalah 5 dper t. Karena 5 (jarak) dibagi 5 (batas kecepatan) adalah 1, tercepat saya bisa pergi di jalan itu adalah 1 t.

Di jalan berikutnya, batas kecepatan adalah 10 dan jaraknya juga 5, tercepat yang bisa saya lewati yaitu 0,5 (5/10). Total hasil kali minimum dalam 1,5, berarti saya pergi tepat pada batas kecepatan.

Catatan: Saya tahu, saya mungkin sudah sangat cepat di satu jalan dan sangat lambat di jalan lain dan masih menyeberang 1,5, tetapi anggap yang terbaik di sini.

Contoh terakhir:

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

Jalan pertama adalah 10 panjang dan memiliki batas kecepatan 3, sehingga waktu minimum adalah 3,33333 ... (10 / 3.)

Jalan kedua adalah 3 panjang dan memiliki batas kecepatan 20, sehingga waktu minimum adalah 0,15 (3 / 20.)

Total hasil kali dalam 3,483333333 ... Saya melewati dalam 3,2, jadi saya harus melaju di suatu tempat.


  • Anda harus menampilkan satu nilai berbeda jika saya tidak diragukan lagi ngebut, dan nilai lain yang berbeda jika saya mungkin tidak.
  • Program atau fungsi Anda mungkin memerlukan input atau output untuk memiliki baris tambahan, tapi tolong katakan demikian dalam kiriman Anda.
  • Input pertama Anda adalah kecepatan saya. Ini akan menjadi float atau integer atau string yang positif.
  • Input kedua Anda akan menjadi jalan. Itu akan selalu cocok dengan regex ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Anda dapat menguji input potensial di sini jika Anda tertarik.
  • Anda dapat mengambil input dalam 2 parameter fungsi atau program, dalam 2 file terpisah, dari STDIN dua kali, atau dari string yang dipisahkan ruang yang diteruskan ke STDIN, sebuah fungsi, file, atau parameter baris perintah.
  • Jika Anda ingin, Anda dapat mengubah urutan input.
  • Ada pertanyaan? Tanyakan di bawah ini di komentar dan selamat !

Saya pikir pertanyaan ini akan mendapat manfaat dari beberapa input → contoh output.

Sepertinya tidak ada yang benar menangani titik desimal yang bisa hadir dalam batas kecepatan jalan.
Jonathan Allan

Coba lihat speedometer?

@ programmer5000 Lalu, jangan ragu untuk menggunakan regex ini sebagai gantinya ^(([1-9]+[0-9]*|(?!0\.0+\b)[0-9]+\.[0-9]+)=+)+\n?$. (Akan lebih bersih dengan tampilan di belakang, tetapi kemudian akan membutuhkan mesin Net.)



05AB1E , 24 22 byte

Mengembalikan 1 ketika tidak diragukan lagi ngebut dan 0 sebaliknya.

Disimpan 2 byte berkat carusocomputing .


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


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

'=¡õK¹S'=QJ0¡õK€g/O-0.S for 23 bytes

@ovs: So .S works, OK. That doesn't return 2 unique values though as it will return 0 when you've done exactly the speed limit.

@Emigna gahh... I keep posting the wrong one; the a > b operator is casting to integer before the comparison between a float and an int. It's very odd indeed... I did get it down to 22 bytes though: '=¡€Þ¹S'=Q.¡O0K/O-§'-å.
Magic Octopus Urn

@carusocomputing: Nice! Chunkifying with summation was a good idea.

@carusocomputing: The final version you had before deleting could be shortened to ¨'=¡.¡2ôvyg>s/}O-§'-å at 23 with 2 return values. Maybe there is some improvement to be made there still? I Don't see what though. That last comparison really screws us up.


Python 2, 71 bytes

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.

I must point out that this is a property of Python's dynamic typing (performing type checking at runtime rather than compile time), not weak typing. Python's types are actually pretty strong (it's not usually possible to convert values between types without an explicit instruction).

@Muzer My mistake, fixed it.


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


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.

It still doesn't seem to be able to handle floats.

@L3viathan Could you give an example where it goes wrong?

For example when the road is "0.5=20===", the output will be None regardless of the time input.

Ah, divide by zero...
Jonathan Allan

I think ([\d|.]+) may fix it.
Jonathan Allan


Javascript (ES6), 63 bytes



Assign this function to a variable and call it using the currying syntax. The first argument is the time, the second is the road.


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

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.


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

Doesn't seem to handle decimal numbers.

@L3viathan right, thanks for pointing it out. (There wasn't any test case with decimal numbers and I read the specs a bit too fast)


Mathematica, 98 bytes


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.

Does it work with floating point speeds?

Yes, anything that Mathematica recognizes as a number. The input could be "1+2====3.456====π=====\n" even.
Greg Martin


Jelly, 27 bytes


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


ṣ”=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)

Yes, I explicitly stated about 0.0 since I filter out values that evaluate as 0 in the code to pull out the speed limits.
Jonathan Allan


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


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


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:



  • 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
While inString(Str0,"=",A
While 1=expr("9"+sub(Str0,B,1)+"9
If B>length(Str0

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
while [ -n "$r" ];do
s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`
[[ `dc<<<"$1 $s-p"` != -* ]]


shopt -s extglob

Enable bash's extended pattern-matching operators and assign the road to a variable r.

while [ -n "$r" ];do

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.


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
$ bash golf.sh .4 10===== 2>/dev/null && echo maybe || echo definitely


Python 3.6, 111 bytes

My first code golf!

import re
def f(a,b):
 for c in re.split('(=+)',b)[:-1]:
 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.

Congratulations on your first code golf! Nicely done!


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


Returns true if you have been under the speed limit, false otherwise

Nice first submission!

Cut 5 chars by realising I didn't need to declare $z before accessing it in the loop
Darren H


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


Try it online!

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


PowerShell, 71 bytes


Try it online!

Test script:

$f = {



    ,(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. 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.
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.