Stellen Sie sich eine Straße als eine Zahlenlinie vor, die auf 0unbestimmte Zeit beginnt und fortgesetzt wird:

.................................................................

Es sind zwei Autos unterwegs: Cund R. Cist der Polizist, der versucht zu fangen R, der Räuber. Cbeginnt um 0und Rbeginnt irgendwo auf der Straße:

C.............................R..................................

Der Cop ist schon in Bewegung - er jagt den Räuber. Er hat eine konstante Geschwindigkeit. Der Räuber sprang gerade in sein Auto. Er beschleunigt. Mit jedem Tick erhöht sich die Geschwindigkeit des Räubers um seine Beschleunigung.

Sagen wir, die Geschwindigkeit des Polizisten ist 7und die Beschleunigung des Räubers ist 1. Wenn der Räuber um beginnt 30, sieht die Straße bei jedem Tick folgendermaßen aus:

C.............................R..................................
.......C.......................R.................................
..............C..................R...............................
.....................C..............R............................
............................C...........R........................
...................................C.........R...................
..........................................C........R.............
.................................................C........R......

Nach dem letzten Tick oben ist die Geschwindigkeit des Räubers gleich der des Polizisten und er ist immer noch vorne. Da sich der Cop mit konstanter Geschwindigkeit bewegt und der Räuber immer noch schneller wird, entkommt der Räuber, sodass Sie einen Wahrheitswert ausgeben. Wenn jedoch die Geschwindigkeit des Polizisten gewesen wäre 9...

C.............................R..................................
.........C.....................R.................................
..................C..............R...............................
...........................C........R............................
....................................C...R........................
.............................................X...................

... dann holt der Polizist den Räuber ein, bevor der Räuber Xentkommen kann (markiert durch ), und Sie geben einen falschen Wert aus.

Deine Aufgabe

Bei drei Eingaben - der Geschwindigkeit des Polizisten, der Position des Räubers und der Beschleunigung des Räubers - wird bestimmt, ob der Räuber davonkommt oder nicht.

Regeln

• Der Bulle beginnt immer um 0.
• Alle Eingaben sind positive ganze Zahlen.
• Der Polizist fängt den Räuber, wenn die Position des Polizisten nach einem Häkchen größer oder gleich der Position des Räubers ist.
• Der Räuber entkommt, wenn er noch nicht erwischt wurde und seine Geschwindigkeit höher ist als die des Polizisten.
• Ihr Programm muss nach der Ausgabe beendet werden.
• Der Räuber beschleunigt, bevor er jede Zecke bewegt.

Testfälle

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

Referenz Python 3-Implementierung, die auch ein visuelles Element erstellt: Probieren Sie es online aus!

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Gelee , 9 Bytes

_⁵Ḥ¤²÷÷8<

Probieren Sie es online!

Port of Leaky Nuns Python 3 Antwort.

(vollständiges Programm) Ordnet die Argumente acceleration, position, speed.

Python 3 , 29 Bytes

lambda s,p,a:(a-2*s)**2<8*a*p

Probieren Sie es online!

Erläuterung

Die Cops Position zur Zeit tist st.

Die Position des Räubers zur Zeit tist a(t)(t+1)/2 + p.

Die vorzeichenbehaftete Entfernung vom Polizisten zum Räuber beträgt (a/2)t^2 + (a/2-s)t + p.

Sie erreicht niemals Null, wenn die Diskriminante negativ ist, wobei die Diskriminante (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4dasselbe Vorzeichen hat wie (a-2s)^2-8ap.

Japt , 13 Bytes

²/W-V-U<o0W x

Online testen!

Erläuterung

U, V Und Wsind die impliziten Eingänge. Zuerst Uo0Werstellen wir den Bereich [0, W, 2 * W, ...], bis er erreicht ist U. xdann summiert sich dies, was angibt, wie weit sich der Räuber bewegt, bevor er die Geschwindigkeit der Polizei erreicht. Wir nennen das r .

Wie weit reist der Cop in dieser Zeit? Wir können dies mit U * (U // W - 1) berechnen , das in (U * U) // W - U umgeordnet werden kann . Wir nennen das c .

Nun zum letzten Schritt: Entkommt der Räuber? Alles, was wir hier tun müssen, ist zu überprüfen, ob c <r + V oder umgeordnet c - V <r ist .

Kubisch 61 Bytes

$:7(U1R3U1F3D2*1-1/1)6+7$-77*6$(-77777777D2F1U3R1U3!0{<0%6&})

Probieren Sie es online!Dazu in TIO zu arbeiten, müssen Sie ersetzen &mit &1aufgrund eines Fehlers im Interpreter.

Dies ist ein schamloser Hafen der Antwort von Leaky Nun . Die Eingabe erfolgt in der Form a s p, woa die Beschleunigung des Räubers, sdie Geschwindigkeit des Polizisten und pdie Position des Räubers angegeben sind.

Wenn die Beschleunigung zu hoch ist, schlägt dies fehl. Ich weiß nicht, wie hoch die Beschleunigung sein wird, die dieses Programm unterstützt. aber ich weiß, dass sie nicht höher als 1260 ist . Der begrenzende Faktor ist, dass er die Beschleunigung im Würfel speichert und prüft, ob der Würfel gelöst ist, indem er nur prüft, ob die Summe der oberen Fläche 0 ist (eine unvollständige Prüfung). Es scheint für die Beschleunigung = 50 zu funktionieren, aber ich habe nicht getestet, wie hoch es werden kann.

Wie es funktioniert

$: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

Pyth , 11 Bytes

Dies nimmt sie in dieser Reihenfolge: Robber Acceleration, Cop Speed, Robber Positiongetrennt durch eine neue Zeile (wie in der Testsuite gezeigt).

<^-QyE2*8*E

Test Suite oder Online testen !

Pyke , 14 Bytes

Port of Totalhuman's Python Antwort . Returns 1für truthy und 0für falsy.

hQee-XQ1@Qe*}<

Probieren Sie es hier aus!

Erläuterung

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 , 15 Bytes

Meine allererste Pyke-Antwort! Port meiner Pyth-Lösung , die von Leakys Python-Einreichung inspiriert ist . Returns 1für truthy und 0für falsy.

eQh}-XQe8*Q1@*<

Probieren Sie es hier aus!

Erläuterung

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.

Python 2 , 62 Bytes

P=s=0;S,p,a=input()
while(s<S)*(P<p):s+=a;p+=s;P+=S
print s>=S

Probieren Sie es online!

Ruby , 29 27 25 Bytes

->c,p,a{(a-c-c)**2<8*p*a}

Probieren Sie es online!

Ich bin von 29 auf 27 gekommen, weil ich die Idee hatte, beide Seiten mit 4 zu multiplizieren. (Leaky Nuns Python-Antwort)

Wurde von 27 auf 25 durch Entfernen von Parens um Lambda-Parameter (danke totalhuman)

C # (.NET Core) , 33 Byte

(v,p,a)=>v/a*v<p+v/a*(1+v/a)*.5*a

Probieren Sie es online!

Ich habe das Gefühl, dass dies irgendwo anders ist, aber es besteht für alle Testfälle die Möglichkeit, dass es einfach keine Testfälle gibt, in denen der Cop den Räuber für eine einzige Zecke überholt, oder es könnte trotz meiner Vorbehalte einfach funktionieren.

Python 2 , 31 30 29 Bytes

-1 Byte danke an Herrn Xcoder.

Gestartet als Hafen der Ruby-Antwort .

lambda c,p,a:(c-a/2)**2<2*p*a

Probieren Sie es online!

Schnelle 3 , 55 Bytes

Beachten Sie, dass ich die Variable deklariert habe t weil der Ausdruck zu komplex wäre, um in angemessener Zeit gelöst zu werden (Swifts Fehler!).

func f(a:Int,b:Int,c:Int){let t=c-2*a;print(t*t<8*c*b)}

Test Suite.

oder 55 Bytes , exaktes Abschlussäquivalent (ich benötige den letzten Teil, da es sich um ein komplexes Konstrukt handelt):

{let t=$2-2*$0;return t*t<8*$2*$1}as(Int,Int,Int)->Bool

Test Suite.

Schnelle 3 , 57 Bytes

func f(a:[Int]){let t=a[2]-2*a[0];print(t*t<8*a[2]*a[1])}

Test Suite.

Python 2 , 30 Bytes

lambda c,p,a:c/a*(c-a+c%a)/2<p

Probieren Sie es online! Der Polizist hat c/aHäkchen, in denen er den Räuber fangen kann, wonach er den Polizisten ausbeschleunigt hat. Beim ersten Tick gewinnt der Cop c-aam Räuber, beim letzten Tick nur c%a. Somit ist die Summe, die der Cop gewinnen kann, das Produkt aus der Anzahl der Ticks und der durchschnittlichen Entfernung pro Tick. Dies wird einfach mit der anfänglichen Spur verglichen, die der Räuber hat.

TI BASIC (Serie TI-83/84), 18 Byte

Prompt C,R,A
(A-2C)²<8RA

Noch ein Hafen von einflussreichen Ruby-Lösung itdoesntwork .

Ausführung

Die Eingabereihenfolge ist Cop-Geschwindigkeit, Räuberposition, Räuberbeschleunigung.

C=?7
R=?30
A=?1
               1

Retina , 79 Bytes

\d+
$*
$
;
{`(1+);
$1;$1
,(1+;(1+))
$2,$1
1`(1+),\1
$1,
.*,,.*

^(1+),.*;\1.*
1

Probieren Sie es online! Erläuterung:

\d+
$*

Eingabe in Unary konvertieren.

$
;

Machen Sie Platz für die Geschwindigkeit des Räubers.

{`(1+);
$1;$1

Beschleunigen Sie den Räuber bei jedem Durchgang.

,(1+;(1+))
$2,$1

Bewegen Sie den Räuber vom Polizisten weg.

1`(1+),\1
$1,

Bewegen Sie den Polizisten in Richtung des Räubers.

.*,,.*

Hat der Cop den Räuber erwischt?

^(1+),.*;\1.*
1

Beschleunigt der Räuber den Polizisten?

Rekursiva , 19 16 Bytes

>b*I/acIH+-ac%ac

Probieren Sie es online!