Piense en una carretera como una recta numérica, que comienza 0y continúa indefinidamente:

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

Hay dos autos en la carretera: Cy R. Ces el policía que intenta atrapar R, el ladrón. Ccomienza en 0, y Rcomienza en algún lugar del camino:

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

El policía ya se está moviendo, está persiguiendo al ladrón. Él tiene una velocidad constante. El ladrón saltó a su auto. El esta acelerando. Cada tic, la velocidad del ladrón aumenta con su aceleración.

Digamos que la velocidad del policía es 7y la aceleración del ladrón es 1. Si el ladrón comienza 30, así es como se vería el camino en cada tic:

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

Después del último tic arriba, la velocidad del ladrón es igual a la del policía, y él todavía está por delante. Como el policía se está moviendo a una velocidad constante y el ladrón todavía se está acelerando, el ladrón escapa, por lo que genera un valor verdadero. Sin embargo, si la velocidad del policía hubiera sido 9...

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

... entonces el policía alcanza al ladrón antes de que el ladrón pueda escapar (marcado por el X), por lo que genera un valor falso.

Tu tarea

Dadas tres entradas: la velocidad del policía, la posición del ladrón y la aceleración del ladrón, determinan si el ladrón se escapará o no.

Reglas

• El policía siempre comienza a las 0.
• Todas las entradas serán enteros positivos.
• El policía atrapa al ladrón si, después de cualquier tic, la posición del policía es mayor o igual que la posición del ladrón.
• El ladrón se escapa cuando aún no lo han atrapado y su velocidad es mayor que la del policía.
• Su programa debe terminar después de la salida.
• El ladrón acelera antes de mover cada tic.

Casos de prueba

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

Implementación de Python 3 de referencia que también crea un visual: ¡ Pruébelo en línea!

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Jalea , 9 bytes

_⁵Ḥ¤²÷÷8<

Pruébalo en línea!

Port of Leaky Nun's Python 3 respuesta.

(programa completo) Toma los argumentos en orden acceleration, position, speed.

Python 3 , 29 bytes

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

Pruébalo en línea!

Explicación

La posición del policía en el momento tes st.

La posición del ladrón en el momento tes a(t)(t+1)/2 + p.

La distancia firmada del policía al ladrón es (a/2)t^2 + (a/2-s)t + p.

Nunca llega a cero si el discriminante es negativo, siendo el discriminante (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4, que tiene el mismo signo que (a-2s)^2-8ap.

Japt , 13 bytes

²/W-V-U<o0W x

¡Pruébelo en línea!

Explicación

U, Vy Wson las entradas implícitas. Primero, Uo0Wcreamos el rango [0, W, 2 * W, ...] hasta que llegue U. xluego suma esto, lo que da qué tan lejos viaja el ladrón antes de alcanzar la velocidad de policía. Llamaremos a esto r .

Ahora, ¿qué tan lejos viaja el policía en este momento? Podemos calcular esto usando U * (T // W - 1) , que se puede reordenarse para (T * T) // W - T . Llamaremos a esto c .

Ahora para el paso final: ¿se escapa el ladrón? Todo lo que necesitamos hacer aquí es verificar si c <r + V , o reorganizado, c - V <r .

Cúbicamente , 61 bytes

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

Pruébalo en línea! Para que esto funcione en TIO, es posible que tenga que sustituir &con &1debido a un error en el intérprete.

Este es un puerto descarado de la respuesta de Leaky Nun . La entrada está en la forma a s p, donde aestá la aceleración del ladrón, sla velocidad del policía y pla posición del ladrón.

Si la aceleración es demasiado alta, esto fallará. No sé qué tan alta aceleración soportará este programa, pero sé que no es superior a 1260 . El factor limitante es que almacena la aceleración en el cubo y comprueba si el cubo está resuelto comprobando solo si la suma de la cara superior es 0 (una comprobación incompleta). Parece que funciona para la aceleración = 50, pero no lo he probado para ver qué tan alto puede llegar.

Cómo funciona

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

Esto los lleva en este orden: Robber Acceleration, Cop Speed, Robber Positionseparados por una nueva línea (como se muestra en el conjunto de pruebas).

<^-QyE2*8*E

Test Suite o Pruébelo en línea!

Pyke , 14 bytes

Puerto de la respuesta de Python totalmente humana . Retornos 1por verdad y 0por falsedad.

hQee-XQ1@Qe*}<

Pruébalo aquí!

Explicación

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

¡Mi primera respuesta de Pyke! Solución Port of my Pyth , inspirada en el envío de Python de Leaky . Retornos 1por verdad y 0por falsedad.

eQh}-XQe8*Q1@*<

Pruébalo aquí!

Explicación

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

Pruébalo en línea!

Ruby , 29 27 25 bytes

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

Pruébalo en línea!

Obtuve del 29 al 27 robando la idea de multiplicar ambos lados por 4. (la respuesta de Python de Leaky Nun)

Obtuve del 27 al 25 eliminando los parámetros de los parámetros lambda (gracias totalmente humano)

C # (.NET Core) , 33 bytes

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

Pruébalo en línea!

Siento que esto está fuera de lugar en alguna parte, pero pasa para todos los casos de prueba, por lo que es posible que simplemente no haya casos de prueba en los que el policía supere al ladrón por un solo tic, o podría funcionar a pesar de mis reservas.

Python 2 , 31 30 29 bytes

-1 byte gracias al Sr. Xcoder.

Comenzó como un puerto de la respuesta de Ruby .

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

Pruébalo en línea!

Swift 3 , 55 bytes

Tenga en cuenta que he declarado la variable tporque la expresión sería demasiado compleja para ser resuelta en un tiempo razonable de lo contrario (¡culpa de Swift!).

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

Banco de pruebas.

o 55 bytes , cierre exacto equivalente (necesito la última parte porque es una construcción compleja):

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

Banco de pruebas.

Swift 3 , 57 bytes

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

Banco de pruebas.

Python 2 , 30 bytes

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

Pruébalo en línea! El policía tiene c/agarrapatas para atrapar al ladrón, después de lo cual ha acelerado al policía. En el primer tic, el policía gana c-asobre el ladrón, mientras que en el último solo gana c%a. Así, el total que el policía puede ganar es el producto del número de ticks y la distancia promedio por tick. Esto simplemente se compara con el plomo inicial que tiene el ladrón.

TI BASIC (serie TI-83/84), 18 bytes

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

Otro puerto más es la influyente solución de Ruby del trabajo .

Ejecución

El orden de entrada es la velocidad del policía, la posición del ladrón, la aceleración del ladrón.

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

Pruébalo en línea! Explicación:

\d+
$*

Convierta la entrada a unario.

$
;

Haga espacio para la velocidad del ladrón.

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

Acelera al ladrón en cada pase.

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

Aleja al ladrón del policía.

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

Mueve al policía hacia el ladrón.

.*,,.*

¿El policía ha atrapado al ladrón?

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

¿El ladrón supera al policía?

Recursiva , 19 16 bytes

>b*I/acIH+-ac%ac

Pruébalo en línea!