Considérez une route comme une droite numérique, commençant 0et se poursuivant indéfiniment:

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

Il y a deux voitures sur la route: Cet R. Cest le flic qui essaie d'attraper R, le voleur. Ccommence à 0, et Rcommence quelque part sur la route:

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

Le flic est déjà en mouvement - il poursuit le voleur. Il a une vitesse constante. Le voleur a sauté dans sa voiture. Il accélère. A chaque tick, la vitesse du voleur augmente par son accélération.

Disons que la vitesse du flic est 7et l'accélération du voleur est 1. Si le voleur commence 30, voici à quoi ressemblerait la route à chaque tick:

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

Après le dernier tick ci-dessus, la vitesse du voleur est égale à celle du flic, et il est toujours devant. Étant donné que le flic se déplace à une vitesse constante et que le voleur accélère toujours, le voleur s'échappe, vous produisez donc une valeur vraie. Cependant, si la vitesse du flic avait été 9...

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

... alors le flic rattrape le voleur avant que le voleur ne puisse s'enfuir (marqué par le X), vous produisez donc une valeur de falsey.

Ta tâche

Étant donné trois entrées - la vitesse du flic, la position du voleur et l'accélération du voleur - déterminez si le voleur s'en sortira ou non.

Règles

• Le flic commence toujours à 0.
• Toutes les entrées seront des entiers positifs.
• Le flic attrape le voleur si, après un tick, la position du flic est supérieure ou égale à la position du voleur.
• Le voleur s'enfuit quand il n'a pas encore été attrapé et sa vitesse est supérieure à celle du flic.
• Votre programme doit se terminer après la sortie.
• Le voleur accélère avant de déplacer chaque tick.

Cas de test

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

Référence à l'implémentation de Python 3 qui crée également un visuel: Essayez-le en ligne!

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

Gelée , 9 octets

_⁵Ḥ¤²÷÷8<

Essayez-le en ligne!

Réponse de Port of Leaky Nun's Python 3.

(programme complet) Prend les arguments dans l'ordre acceleration, position, speed.

Python 3 , 29 octets

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

Essayez-le en ligne!

Explication

La position du flic au moment test st.

La position du voleur à l'époque test a(t)(t+1)/2 + p.

La distance signée entre le flic et le voleur est (a/2)t^2 + (a/2-s)t + p.

Il n'atteint jamais zéro si le discriminant est négatif, l'être discriminant (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4, qui a le même signe que (a-2s)^2-8ap.

Japt , 13 octets

²/W-V-U<o0W x

Testez-le en ligne!

Explication

U, VEt Wsont les entrées implicites. Tout d'abord, avec Uo0Wnous créons la plage [0, W, 2 * W, ...] jusqu'à ce qu'elle atteigne U. xpuis résume cela, ce qui donne à quelle distance le voleur se déplace avant d'atteindre la vitesse de flic. Nous appellerons cela r .

Maintenant, jusqu'où le flic voyage-t-il en ce moment? Nous pouvons calculer cela en utilisant U * (U // W - 1) , qui peut être réarrangé (U * U) // W - U . Nous appellerons cela c .

Maintenant pour la dernière étape: le voleur s'enfuit-il? Tout ce que nous devons faire ici est de vérifier si c <r + V , ou réarrangé, c - V <r .

Cubiquement , 61 octets

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

Essayez-le en ligne! Pour que cela fonctionne dans TIO, vous devrez peut-être le remplacer &par en &1raison d'un bogue dans l'interpréteur.

C'est un port sans vergogne de la réponse de Leaky Nun . L'entrée est sous la forme a s p, où aest l'accélération du voleur, sla vitesse du flic et pla position du voleur.

Si l'accélération est trop élevée, cela échouera. Je ne sais pas à quel niveau d'accélération ce programme prendra en charge, mais je sais qu'il n'est pas supérieur à 1260 . Le facteur limitant est qu'il stocke l'accélération dans le cube et vérifie si le cube est résolu en vérifiant uniquement si la somme de la face supérieure est 0 (une vérification incomplète). Il semble fonctionner pour une accélération = 50, mais je n'ai pas testé pour voir à quelle hauteur il peut atteindre.

Comment ça fonctionne

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

Cela les prend dans cet ordre: Robber Acceleration, Cop Speed, Robber Positionséparés par une nouvelle ligne (comme indiqué dans la suite de tests).

<^-QyE2*8*E

Testez la suite ou essayez-la en ligne!

Pyke , 14 octets

Port de réponse Python de totalement humain . Retourne 1pour véridique et0 pour la fausseté.

hQee-XQ1@Qe*}<

Essayez-le ici!

Explication

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 octets

Ma toute première réponse Pyke! Port de ma solution Pyth , qui s'inspire de la soumission de Leaky's Python . Retourne 1pour la vérité et 0pour la fausseté.

eQh}-XQe8*Q1@*<

Essayez-le ici!

Explication

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 octets

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

Essayez-le en ligne!

Rubis , 29 27 25 octets

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

Essayez-le en ligne!

Je suis passé de 29 à 27 en volant l'idée de multiplier les deux côtés par 4. (Réponse de Leaky Nun en python)

Passé de 27 à 25 en supprimant les parens autour des paramètres lambda (merci totalement humain)

C # (.NET Core) , 33 octets

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

Essayez-le en ligne!

J'ai l'impression que c'est quelque part, mais cela passe pour tous les cas de test, il est donc possible qu'il n'y ait tout simplement pas de cas de test où le flic dépasse le voleur pour une seule tique, ou cela pourrait simplement fonctionner malgré mes réserves.

Python 2 , 31 30 29 octets

-1 octet merci à M. Xcoder.

Commencé comme port de la réponse Ruby .

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

Essayez-le en ligne!

Swift 3 , 55 octets

Notez que j'ai déclaré la variable tcar l'expression serait trop complexe pour être résolue dans un délai raisonnable sinon (faute de Swift!).

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

Suite de tests.

ou 55 octets , équivalent de fermeture exact (j'ai besoin de la dernière partie car c'est une construction complexe):

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

Suite de tests.

Swift 3 , 57 octets

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

Suite de tests.

Python 2 , 30 octets

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

Essayez-le en ligne! Le flic a des c/atiques pour attraper le voleur, après quoi il a accéléré le flic. Au premier tick, le flic gagne c-asur le voleur tandis qu'au dernier tick, il ne gagne que c%a. Ainsi, le total que le flic peut gagner est le produit du nombre de tiques et de la distance moyenne par tick. Ceci est simplement comparé à l'avance initiale du voleur.

TI BASIC (série TI-83/84), 18 octets

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

Encore un autre port de la solution Ruby influente de itdoesntwork .

Exécution

L'ordre d'entrée est la vitesse du flic, la position du voleur, l'accélération du voleur.

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

Rétine , 79 octets

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

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

Essayez-le en ligne! Explication:

\d+
$*

Convertissez l'entrée en unaire.

$
;

Faites de la place pour la vitesse du voleur.

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

Accélérez le voleur à chaque passage.

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

Éloignez le voleur du flic.

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

Déplacez le flic vers le voleur.

.*,,.*

Le flic a attrapé le voleur?

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

Le voleur dépasse-t-il le flic?

Recursiva , 19 16 octets

>b*I/acIH+-ac%ac

Essayez-le en ligne!