[Question]
  [
Think of a road as a number line, starting at `0` and continuing indefinitely:
```
.................................................................
```
There are two cars on the road: `C` and `R`. `C` is the cop who is trying to catch `R`, the robber. `C` starts at `0`, and `R` starts somewhere on the road:
```
C.............................R..................................
```
The cop is already moving - he's chasing the robber. He has a constant speed. The robber just hopped into his car. He's accelerating. Each tick, the robber's speed increases by his acceleration.
Say the cop's speed is `7` and the robber's acceleration is `1`. If the robber starts at `30`, this is what the road would look like each tick:
```
C.............................R..................................
.......C.......................R.................................
..............C..................R...............................
.....................C..............R............................
............................C...........R........................
...................................C.........R...................
..........................................C........R.............
.................................................C........R......
```
After the last tick above, the robber's speed is equal to the cop's, and he's still ahead. Since the cop is moving at a constant speed and the robber is still speeding up, the robber escapes, so you output a truthy value. However, if the cop's speed had been `9`...
```
C.............................R..................................
.........C.....................R.................................
..................C..............R...............................
...........................C........R............................
....................................C...R........................
.............................................X...................
```
... then the cop catches up to the robber before the robber can get away (marked by the `X`), so you output a falsey value.
# Your Task
Given three inputs - the cop's speed, the robber's position, and the robber's acceleration - determine whether or not the robber will get away.
# Rules
* The cop always starts at `0`.
* All inputs will be positive integers.
* The cop catches the robber if, after any tick, the cop's position is greater than or equal to the robber's position.
* The robber gets away when he hasn't been caught yet and his speed is greater than the cop's.
* Your program must terminate after output.
* The robber accelerates before he moves each tick.
# Test Cases
```
Cop Speed, Robber Position, Robber Acceleration -> Output
```
```
7, 30, 1 -> truthy
9, 30, 1 -> falsey
2, 1, 3 -> truthy
100, 100, 50 -> truthy
60, 60, 20 -> falsey
10, 1, 1 -> falsey
10, 50, 2 -> truthy
11, 50, 2 -> truthy
12, 50, 2 -> truthy
13, 50, 2 -> truthy
14, 50, 2 -> truthy
15, 50, 2 -> truthy
16, 50, 2 -> falsey
17, 50, 2 -> falsey
18, 50, 2 -> falsey
100, 451, 10 -> truthy
```
Reference Python 3 implementation that creates a visual also: [Try it online!](https://tio.run/##bVBNS8QwEL3PrxhySlwpXaUXoXsR/AHiQShliTW7rWaTkqZ@/Po600RhFw@ByZs3772Z8Tv23t0uS7cf/YQ1ltDtT/7DUDm4KAc3zlEqBSH3L8BMLanUXWfsJcPPkaCmhc9@sAafwmzuAJPZpsbkBZiFCMk6DGVO6gEgaRV6HI17lXJVuE4ksgEcDll1VyeUbDCYabYc4EHbiWzwJRj9Dmgs0bPn7jfF2QAH/eODNe4Ye4JP@kvyoyhK4QYrgIMPaHTX096ckFTs4PgmjShEi1eYhteEzGvKlj3XctuyKfOb/G9pUDwLjjiZ82aZmvfiv5FHQsfApxeiePODk0yhyyRwikGm3ZRalm0FVQk3Pw "Python 3 – Try It Online")
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
  
[Answer]
# [Python 3](https://docs.python.org/3/), 29 bytes
```
lambda s,p,a:(a-2*s)**2<8*a*p
```
[Try it online!](https://tio.run/##PchNDsIgEAXgPadgSQkm/Iitjd7CpZsx0pQEKWmpxtMjbcxMMm@@N@mbxymaMlzvJcDr8QS6iCSgZ3DQfGk415eOA0/lM/rg6G1eXU9omn3MbGDcvSEwH9OaWVOntMJIochZ0HqpIrpGNVFyq1tYWcv@VTtsXU2UQmmUQR1RFnVCtajurx8 "Python 3 – Try It Online")
### Explanation
The cop's position at time `t` is `st`.
The robber's position at time `t` is `a(t)(t+1)/2 + p`.
The signed distance from the cop to the robber is `(a/2)t^2 + (a/2-s)t + p`.
It never reaches zero if the discriminant is negative, the discriminant being `(a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4`, which has the same sign as `(a-2s)^2-8ap`.
[Answer]
# [Cubically](https://github.com/aaronryank/cubically), 61 bytes
```
$:7(U1R3U1F3D2*1-1/1)6+7$-77*6$(-77777777D2F1U3R1U3!0{<0%6&})
```
[Try it online!](https://tio.run/##Sy5NykxOzMmp/P9fxcpcI9QwyDjU0M3YxUjLUNdQ31DTTNtcRdfcXMtMRQNIQYCLkZthqHEQECsaVNsYqJqp1Wr@/2@oYK5gbAAA) For this to work in TIO, you may need to replace `&` with `&1` due to a bug in the interpreter.
This is a shameless port of [Leaky Nun's answer](https://codegolf.stackexchange.com/a/138645/72489).
Input is in the form `a s p`, where `a` is robber's acceleration, `s` is cop's speed, and `p` is robber's position.
If the acceleration is too high, this will fail. I don't know how high of an acceleration this program will support, [but I know it isn't any higher than 1260](https://www.reddit.com/r/askscience/comments/3w23fk/on_a_rubiks_cube_can_any_sequence_of_moves_if/cxtucf1/). The limiting factor is that it stores the acceleration in the cube and checks if the cube is solved by checking only if the top face's sum is 0 (an incomplete check). It seems to work for acceleration = 50, but I haven't tested to see how high it can get.
### How it works
```
$:7(U1R3U1F3D2*1-1/1)6
$:7                             Store the first number in the notepad
   (                )6          Loop until notepad is 0
    U1R3U1F3D2                  Rotate the cube a certain way
              *1-1/1            Subtract 1 from the notepad
+7$-77*6                
+7                              Add first input to the notepad
  $-77                          Subtract second input from the notepad twice
      *6                        Multiply the notepad by itself (square it)
$(-77777777D2F1U3R1U3!0{<0%6&})
$                               Get next input
 (                            ) Loop indefinitely
  -77777777                     Subtract third input 8 times
           D2F1U3R1U3           "Unrotate" the cube
                     !0{     }  If the top face is 0
                        <0        Check if notepad < 0, store in notepad
                          %6      Output notepad as number
                            &     End the program
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 13 bytes
```
²/W-V-U<o0W x
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=si9XLVYtVTxvMFcgeA==&input=MTYsIDUwLCAy)
### Explanation
`U`, `V`, and `W` are the implicit inputs. First, with `Uo0W` we create the range **[0, W, 2\*W, ...]** until it reaches `U`. `x` then sums this, which gives how far the robber travels before reaching cop speed. We'll call this **r**.
Now, how far does the cop travel in this time? We can calculate this using **U \* (U // W - 1)**, which can be rearranged to **(U \* U) // W - U**. We'll call this **c**.
Now for the final step: does the robber get away? All we need to do here is check if **c < r + V**, or rearranged, **c - V < r**.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 11 bytes
This takes them in this order: `Robber Acceleration, Cop Speed, Robber Position` separated by a newline (as shown in the test suite).
```
<^-QyE2*8*E
```
**[Test Suite](http://pyth.herokuapp.com/?code=%3C%5E-QyE2%2a8%2aE&input=1%0A7%0A30&test_suite=1&test_suite_input=1%0A7%0A30%0A%0A1%0A9%0A30%0A%0A3%0A2%0A1%0A%0A50%0A100%0A100%0A%0A1%0A10%0A1%0A%0A2%0A10%0A50%0A%0A2%0A11%0A50%0A%0A2%0A12%0A50%0A%0A2%0A13%0A50%0A%0A2%0A14%0A50%0A%0A2%0A15%0A50%0A%0A2%0A16%0A50%0A%0A2%0A17%0A50%0A%0A2%0A18%0A50%0A&debug=0&input_size=4)** or **[Try it online!](http://pyth.herokuapp.com/?code=%3C%5E-QyE2%2a8%2aE&input=1%0A7%0A30&test_suite_input=1%0A7%0A30%0A%0A1%0A9%0A30%0A%0A3%0A2%0A1%0A%0A50%0A100%0A100%0A%0A1%0A10%0A1%0A%0A2%0A10%0A50%0A%0A2%0A11%0A50%0A%0A2%0A12%0A50%0A%0A2%0A13%0A50%0A%0A2%0A14%0A50%0A%0A2%0A15%0A50%0A%0A2%0A16%0A50%0A%0A2%0A17%0A50%0A%0A2%0A18%0A50%0A&debug=0&input_size=4)**
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 14 bytes
Port of [totallyhuman's Python answer](https://codegolf.stackexchange.com/a/138647/59487). Returns `1` for truthy and `0` for falsy.
```
hQee-XQ1@Qe*}<
```
**[Try it here!](http://pyke.catbus.co.uk/?code=hQee-XQ1%40Qe%2a%7D%3C&input=2%2C+1%2C+3&warnings=0)**
---
# Explanation
```
hQee-XQ1@Qe*}< - Full program with implicit input added in the beginning (which automatically splits the components)
h              - First input
 Qee           - Last Input halved (through integer division)
    -          - Subtact the above
     X         - Square.
             < - Is smaller than?
      Q1@      - The second input
         Qe*   - Multiplied by the last input
            }  - Doubled
```
# [Pyke](https://github.com/muddyfish/PYKE), 15 bytes
My very first Pyke answer! Port of [my Pyth solution](https://codegolf.stackexchange.com/a/138649/59487), which is inspired by [Leaky's Python submission](https://codegolf.stackexchange.com/a/138645/59487). Returns `1` for truthy and `0` for falsy. 
```
eQh}-XQe8*Q1@*<
```
**[Try it here!](http://pyke.catbus.co.uk/?code=eQh%7D-XQe8%2aQ1%40%2a%3C&input=7%2C+30%2C+1&warnings=0)**
---
# Explanation
```
eQh}-XQe8*Q1@*< - Full program with implicit input added in the beginning (which automatically splits the components)
e               - End; last input in this case
 Qh             - The first input
   }            - Double
    -           - Subtact the above
     X          - Square.
              < - Is less than?
      Qe        - Last Input
        8*      - Times 8 
             *  - Multiplied by
          Q1@   - The second input.
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
_⁵Ḥ¤²÷÷8<
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//X@KBteG4pMKkwrLDt8O3ODz///8x/zMw/zk "Jelly – Try It Online")
Port of Leaky Nun's Python 3 answer.
(full program) Takes arguments in order `acceleration, position, speed`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 29 27 25 bytes
```
->c,p,a{(a-c-c)**2<8*p*a}
```
[Try it online!](https://tio.run/##Rco9D4IwEAbgnV9xcYKmNKXIh4k6ubi46EhiaiWBBLWBkmCA315bDXa4u@fu3ra/vXW1K3S4F1hiPvo8FKEIEGLbHEnEZ32@HI4n0pb8TjrZ1MpfFc9VQEouKhhhaiaQveqgIj5qlgQ2gQeX9j9MMJBOtbUk6nWtYQ5g1hmGmGKIwNv8xUw3C3gRtQfbEgpeaqYtRu3nm4l@SuzVMHJkjrHj2jFxTB0zx3zhBw "Ruby – Try It Online")
Got from 29 to 27 by stealing the idea of multipliying both sides by 4. (Leaky Nun's python answer)
Got from 27 to 25 by removing parens around lambda parameters (thanks totallyhuman)
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 33 bytes
```
(v,p,a)=>v/a*v<p+v/a*(1+v/a)*.5*a
```
[Try it online!](https://tio.run/##fZFNT8QgEIbv/Io5QsXa7tpdTT8um@hlPXnwjIhK0gVSWIxp9rdXaK3hZMjwvg8zmWQGbq@5HsR0tlJ9wPO3deJUo5Tyg@57wZ3UyuaPQolB8hopdhLWMC5AjYj3zFowI7KOOcnh4ax4I5Wja7xq3XfAQyNpQ592wp4aykjb@RuW@cZcRcVlFJLlVcamem3mtXyDJyYVJiM6SusaHFqCpxDFLMJIB05YZ6EFJb7gvzo0IrynsC0olIQifJ/4TdCA0ZZFfIxXVUTeBRdjUyzZubJcfRUzM5QpbFLYpnCbQpXCLoV9CncroEuN0Hv4N8Y/sWfDPHsYcNlB2NMhfJbuRf4ySCeOUgn8t3wca/KwllnNrzJCanRZzvQD "C# (.NET Core) – Try It Online")
I feel like this is off by one somewhere, but it passes for all test cases so it's possible that there simply aren't any test cases where the cop overtakes the robber for a single tick, or it might just work despite my reservations.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 25 bytes
```
(c,r,a)=>(a-c*2)**2<8*r*a
```
[Try it Online!](https://tio.run/##fc/BCsMgDAbg@57Co4oFtbN1MPcuQSZ0jFGs6@s7HQxkczkkh3z8CbnBDpuPy5qG3ebgMvUiCmDuQmHwXDPO9dnyyCGvcXkkGugsyCgFUYw4R1J8XtnhQ6eWAty3xnSZF@6klKyZ2ozs8FSglpa9tUq@96p/Zmqyd1QhphEbETsiZhCbWvt@YsbQ/mJ@AQ)
[Answer]
# [Python 2](https://docs.python.org/2/), 62 bytes
```
P=s=0;S,p,a=input()
while(s<S)*(P<p):s+=a;p+=s;P+=S
print s>=S
```
[Try it online!](https://tio.run/##PczBDoIwDAbge59i4QSywzZEFKjPQDJfgOASSAgsDKI@/Rxoemj7tWl@@1n7eVK@m58GoyjyDToUleaWtzhMdlvjBF79MJrY1To5xU1tk9Kl2FY2RVc1KWqwyzCtzN1R@xABv3/2WDZTAjNv07E93hc8E1zCjbMwmQQVWjBIsa97y0VYjqs8kIdSICVJkTLSmZSTLqSCdP3rCw "Python 2 – Try It Online")
[Answer]
# [Swift 3](https://www.swift.org), 55 bytes
Note that I declared the variable `t` because the expression would be too complex to be solved in reasonable time otherwise (Swift's fault!).
```
func f(a:Int,b:Int,c:Int){let t=c-2*a;print(t*t<8*c*b)}
```
**[Test Suite.](http://swift.sandbox.bluemix.net/#/repl/598e29d7cb3d25200b1533ad)**
**or 55 bytes**, exact closure equivalent (I need the last part because it is a complex construct):
```
{let t=$2-2*$0;return t*t<8*$2*$1}as(Int,Int,Int)->Bool
```
**[Test Suite.](http://swift.sandbox.bluemix.net/#/repl/598e2ba1cb3d25200b1533af)**
# [Swift 3](https://www.swift.org), 57 bytes
```
func f(a:[Int]){let t=a[2]-2*a[0];print(t*t<8*a[2]*a[1])}
```
**[Test Suite.](http://swift.sandbox.bluemix.net/#/repl/598e2877cb3d25200b1533ab)**
[Answer]
# [Python 2](https://docs.python.org/2/), 30 bytes
```
lambda c,p,a:c/a*(c-a+c%a)/2<p
```
[Try it online!](https://tio.run/##Rcq9DoIwEADgvU9xiwlgDW0VUKIjri6OLrWWQILQlBLl6Wsr0V5yd9/9qNk0Q89sfbrZjj/vDw4CK8xLkfIkEhu@Fisep@yorNFzicDFq2k7CVc9yWX2oXTbG6ijpO3VZKI4RvItpDJQXc6V1oNeXhUfR1tg2BIMFNDhL@aqGwBR4he@ZARQ7rpPRvzl@0MXZX7rSANZ4DZwF5gF5oFF4P7HDw "Python 2 – Try It Online") The cop has `c/a` ticks in which to catch the robber, after which it has out-accelerated the cop. At the first tick the cop gains `c-a` on the robber while on the last tick he only gains `c%a`. Thus the total that the cop can gain is the product of the number of ticks and the average distance per tick. This is simply compared to the initial lead the robber has.
[Answer]
# TI BASIC (TI-83/84 series), 18 [bytes](http://tibasicdev.wikidot.com/tokens)
```
Prompt C,R,A
(A-2C)²<8RA
```
Yet another port of *itdoesntwork*'s influential [Ruby solution](https://codegolf.stackexchange.com/a/138646/44945).
## Execution
Input order is cop speed, robber position, robber acceleration.
```
C=?7
R=?30
A=?1
               1
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 79 bytes
```
\d+
$*
$
;
{`(1+);
$1;$1
,(1+;(1+))
$2,$1
1`(1+),\1
$1,
.*,,.*
^(1+),.*;\1.*
1
```
[Try it online!](https://tio.run/##LcxBCsIwEAXQ/T9HhDYdSn7StEoO4CWCVNCFGxfiroeP0zqQ8PL/hPk8v6/3vZ2669rqY4DzcCjY1o5DX@BYHCEayl70cFG04DGWSv0gGL3I6IHbUY6@VGpka4ukIMTlTxRKAoO@9eaAOYieGLTTEXeyZpBmNJM5mdmczcU8m7p@yrox/AA "Retina – Try It Online") Explanation:
```
\d+
$*
```
Convert input to unary.
```
$
;
```
Make room for the robber's speed.
```
{`(1+);
$1;$1
```
Accelerate the robber on each pass.
```
,(1+;(1+))
$2,$1
```
Move the robber away from the cop.
```
1`(1+),\1
$1,
```
Move the cop towards the robber.
```
.*,,.*
```
Has the cop caught the robber?
```
^(1+),.*;\1.*
1
```
Does the robber out-speed the cop?
[Answer]
# [Recursiva](https://github.com/officialaimm/recursiva), ~~19~~ 16 bytes
```
>b*I/acIH+-ac%ac
```
[Try it online!](https://tio.run/##K0pNLi0qzixL/P/fLknLUz8x2dNDWzcxWTUx@f9/QwMDBRNTQwVDAwA "Recursiva – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~31~~ ~~30~~ 29 bytes
*-1 byte thanks to Mr. Xcoder.*
Started off as a port of the [Ruby answer](https://codegolf.stackexchange.com/a/138646).
```
lambda c,p,a:(c-a/2)**2<2*p*a
```
[Try it online!](https://tio.run/##Rcq9DoIwEADgvU9xIzQ1tkVAiY64uji6VCyhCUJTSpSnr61Ee8ndffejF9uNA3ft6eZ68bw/BDREE1ElzUZseYoxP3KssXDWLBUCH69O9RKuZpbrHEIbNVhoE6wGPdskTZF8N1JbqC/n2pjRrK9aTJMrCWSUAAN0@Iv76gdAjIZFKDkFVPgektNw@f6wVXnYerJIHplF7iLzyCKyjNz/@AE "Python 2 – Try It Online")
]