# Am I over the speed limit?

Given an 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.

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.

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. • 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 ing! • I think this question would benefit from a couple of input→output examples. Apr 10, 2017 at 21:21 • Looks like no one is correctly handling the decimal points that could be present in the road speed limits. Apr 10, 2017 at 21:54 • Try looking at the speedometer? Apr 11, 2017 at 1:47 • @programmer5000 Then, feel free to use this regex instead ^(([1-9]+[0-9]*|(?!0\.0+\b)[0-9]+\.[0-9]+)=+)+\n?$. (It would have been cleaner with a lookbehind, but then it would need .Net engine)
Apr 11, 2017 at 6:59

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

• 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). Apr 11, 2017 at 9:17
• @Muzer My mistake, fixed it.
– xnor
Apr 11, 2017 at 20:32

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

• It still doesn't seem to be able to handle floats. Apr 10, 2017 at 22:03
• @L3viathan Could you give an example where it goes wrong?
– xnor
Apr 10, 2017 at 22:05
• For example when the road is "0.5=20===", the output will be None regardless of the time input. Apr 10, 2017 at 22:06
• Ah, divide by zero... Apr 10, 2017 at 22:07
• I think ([\d|.]+) may fix it. Apr 10, 2017 at 22:10

# 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

• '=¡õK¹S'=QJ0¡õK€g/O-0.S for 23 bytes
– ovs
Apr 11, 2017 at 13:54
• @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. Apr 11, 2017 at 15:54
• @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-§'-å. Apr 11, 2017 at 17:49
• @carusocomputing: Nice! Chunkifying with summation was a good idea. Apr 11, 2017 at 20:04
• @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. Apr 11, 2017 at 20:10

# 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">
<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). • Doesn't seem to handle decimal numbers. Apr 10, 2017 at 21:57 • @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) – Dada Apr 10, 2017 at 22:03 # 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. • Does it work with floating point speeds? Apr 10, 2017 at 22:08 • Yes, anything that Mathematica recognizes as a number. The input could be "1+2====3.456====π=====\n" even. Apr 10, 2017 at 23:30 # 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]
ż         - 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. Apr 10, 2017 at 23:22

# 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. • Congratulations on your first code golf! Nicely done! – user58826 Apr 12, 2017 at 14:14 # 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

• Nice first submission!
– user58826
Apr 12, 2017 at 20:33
• Cut 5 chars by realising I didn't need to declare $z before accessing it in the loop Apr 12, 2017 at 20:41 # 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,"=")[] 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.