20

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.

code-golf decision-problem

— Stephen
source

Sandbox (supprimé)

— Stephen

8

Ohhhh ... ce n'est pas un défi pour les flics et les voleurs; cela a plus de sens.

— Urne de poulpe magique

L'entrée est-elle garantie d'être dans le format donné, ou pouvons-nous prendre l'entrée dans le format que nous voulons (comme à la robber acceleration, cop speed, robber positionplace)?

— TehPers

@TehPers tout ce que vous voulez (cohérent à chaque fois), mais si vous faites quelque chose de différent, dites-le dans votre réponse

— Stephen

2

Demande de cas de test: 100, 451, 10. (Les réponses ne sont pas toutes d'accord sur le résultat).

— Neil

2

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.

— Erik le Outgolfer
source

16

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.

— Leaky Nun
source

Essayez-le en ligne! - Port sans vergogne à 05AB1E pour 9 octets (vous pouvez le prendre, car je suis mauvais avec la physique, et je ne pourrais probablement pas faire une explication juste).

— Magic Octopus Urn

1

Cela n'échoue-t-il pas pour le cas de test "100, 451, 10 -> véridique"?

— Mark S.

Suis-je en train de manquer quelque chose, ou devrions-nous également vérifier s'il y a un entier entre les solutions de l'équation quadratique (a/2)t^2 + (a/2-s)t + p = 0 -> 10t^2 - 50t + 61 = 0? Par exemple, pour 60, 61, 20, le voleur s'échappe facilement (les solutions d'équation: 2.1 et 2.9 étant toutes deux entre 2 et 3).

— mackoo13

5

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 .

— ETHproductions
source

5

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

— TehPers
source

1

le 6 in %6et *6peuvent être supprimées car elles peuvent désormais être appelées implicitement.

— MD XF

4

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!

— M. Xcoder
source

4

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.

— M. Xcoder
source

2

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!

— M. Xcoder
source

2

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)

— itdoesntwork
source

2

Bienvenue chez PPCG! Vous pouvez jouer un peu à votre réponse en renommant votre fonction de hità hou similaire. Vous pouvez également être en mesure d'économiser certains octets en passant d'une méthode à un proc, comme ceci:->c,p,a{(c-a*0.5)**2<2*p*a}

— Conor O'Brien

1

Vous devez également remplacer collisiondans votre lien TIO par le nom de méthode correct.

— Leaky Nun

Pssst, regardez leur nom d'utilisateur. : P

— totalement humain

1

Je suis sûr que vous n'avez pas besoin des parenthèses c,p,a.

— 2017 totalement humain

2

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.

— Kamil Drakari
source

1

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!

— totalement humain
source

1

.5au lieu de 0.5> _>

— M. Xcoder

Haha, je pensais que ce serait tout autant à mettre en communication. Merci XD!

— 2017 totalement humain

a/2utilise la division entière, cela pourrait-il mal tourner?

— itdoesntwork

Il utilise une division entière. Bien que je n'ai pas travaillé sur les mathématiques (pour être honnête, je ne suis pas sûr de pouvoir le faire), cela fonctionne pour tous les cas de test.

— 2017

1

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.

— M. Xcoder
source

1

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.

— Neil
source

1

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

— Jakob
source

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?

— Neil
source

1

Recursiva , 19 16 octets

>b*I/acIH+-ac%ac

Essayez-le en ligne!

— officialaimm
source

Prédire une collision: le voleur s'en ira-t-il?

Ta tâche

Règles

Cas de test

Gelée , 9 octets

Python 3 , 29 octets

Explication

Japt , 13 octets

Explication

Cubiquement , 61 octets

Comment ça fonctionne

Pyth , 11 octets

Pyke , 14 octets

Explication

Pyke , 15 octets

Explication

Python 2 , 62 octets

Rubis , 29 27 25 octets

C # (.NET Core) , 33 octets

Python 2 , 31 30 29 octets

Swift 3 , 55 octets

Swift 3 , 57 octets

Python 2 , 30 octets

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

Exécution

Rétine , 79 octets

Recursiva , 19 16 octets