Pense em uma estrada como uma linha numérica, começando 0e continuando indefinidamente:

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

Existem dois carros na estrada: Ce R. Cé o policial que está tentando pegar R, o ladrão. Ccomeça às 0e Rcomeça em algum lugar na estrada:

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

O policial já está se movendo - ele está perseguindo o ladrão. Ele tem uma velocidade constante. O ladrão entrou no carro. Ele está acelerando. A cada tick, a velocidade do ladrão aumenta com a aceleração.

Digamos que a velocidade do policial seja 7e a aceleração do assaltante 1. Se o ladrão começar 30, é assim que a estrada se pareceria com cada marca:

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

Após o último tique acima, a velocidade do ladrão é igual à do policial, e ele ainda está à frente. Como o policial está se movendo a uma velocidade constante e o ladrão ainda está acelerando, o ladrão escapa, então você gera um valor verdadeiro. No entanto, se a velocidade do policial tivesse sido 9...

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

... então o policial alcança o ladrão antes que ele possa fugir (marcado pelo X), para que você produza um valor de falsey.

Sua tarefa

Dadas três entradas - a velocidade do policial, a posição do ladrão e a aceleração do ladrão - determinam se o ladrão escapará ou não.

Regras

• O policial sempre começa às 0.
• Todas as entradas serão inteiros positivos.
• O policial pega o ladrão se, após qualquer marca, a posição do policial for maior ou igual à posição do ladrão.
• O ladrão foge quando ainda não foi pego e sua velocidade é maior que a da polícia.
• Seu programa deve terminar após a saída.
• O ladrão acelera antes de mover cada marca.

Casos de teste

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

Faça referência à implementação do Python 3 que cria um visual também: Experimente online!

Isso é código-golfe , então a resposta mais curta em bytes vence.

Geléia , 9 bytes

_⁵Ḥ¤²÷÷8<

Experimente online!

Resposta do Python 3 do porto de Freira Furada.

(programa completo) Leva os argumentos em ordem acceleration, position, speed.

Python 3 , 29 bytes

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

Experimente online!

Explicação

A posição do policial no momento té st.

A posição do ladrão no momento té a(t)(t+1)/2 + p.

A distância assinada entre o policial e o ladrão é (a/2)t^2 + (a/2-s)t + p.

Nunca chega a zero se o discriminante é negativo, sendo o discriminante (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4, que tem o mesmo sinal de (a-2s)^2-8ap.

Japonês , 13 bytes

²/W-V-U<o0W x

Teste online!

Explicação

U, V, E Wsão as entradas implícitas. Primeiro, Uo0Wcriamos o intervalo [0, W, 2 * W, ...] até que ele atinja U. xentão resume isso, o que indica o quão longe o ladrão viaja antes de atingir a velocidade da polícia. Vamos chamar isso de r .

Agora, até onde o policial viaja nesse período? Podemos calcular isso usando U * (U // W - 1) , que podem ser reorganizados para (U * L) // W - U . Vamos chamar isso de c .

Agora, para a etapa final: o ladrão foge? Tudo o que precisamos fazer aqui é verificar se c <r + V , ou reorganizado, c - V <r .

Cubicamente , 61 bytes

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

Experimente online! Para que isso funcione no TIO, você pode precisar de substituir &com &1devido a um bug no interpretador.

Este é um porto vergonhoso da resposta de Leaky Nun . A entrada está no formato a s p, onde aestá a aceleração do ladrão, sa velocidade do policial e pa posição do ladrão.

Se a aceleração for muito alta, isso falhará. Não sei até que ponto a aceleração suporta esse programa, mas sei que não é maior que 1260 . O fator limitante é que ele armazena a aceleração no cubo e verifica se o cubo foi resolvido verificando apenas se a soma da face superior é 0 (uma verificação incompleta). Parece funcionar para a aceleração = 50, mas não testei para ver quão alto ele pode chegar.

Como 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

Pitão , 11 bytes

Isso os leva nesta ordem: Robber Acceleration, Cop Speed, Robber Positionseparados por uma nova linha (como mostrado na suíte de testes).

<^-QyE2*8*E

Test Suite ou Experimente online!

Pyke , 14 bytes

Porto da resposta Python de totallyhuman . Retorna 1para verdade e 0para falsidade.

hQee-XQ1@Qe*}<

Experimente aqui!

Explicação

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

Minha primeira resposta Pyke! Porta da minha solução Pyth , inspirada em na submissão do Leaky's Python . Retorna 1para verdade e 0para falsidade.

eQh}-XQe8*Q1@*<

Experimente aqui!

Explicação

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

Experimente online!

Ruby , 29 27 25 bytes

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

Experimente online!

Chegou de 29 a 27 roubando a idéia de multiplicar os dois lados por 4. (resposta em python de Leaky Nun)

Obteve de 27 a 25 removendo parênteses em torno dos parâmetros lambda (obrigado totalmente humano)

C # (.NET Core) , 33 bytes

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

Experimente online!

Eu sinto que isso está errado em algum lugar, mas é aprovado em todos os casos de teste, portanto, é possível que simplesmente não haja casos de teste em que o policial supere o ladrão por um único tique, ou talvez funcione apesar das minhas reservas.

Python 2 , 31 30 29 bytes

-1 byte graças ao Sr. Xcoder.

Começou como uma porta da resposta Ruby .

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

Experimente online!

Swift 3 , 55 bytes

Observe que eu declarei a variável tporque a expressão seria muito complexa para ser resolvida em um tempo razoável, caso contrário (falha de Swift!).

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

Suíte de teste.

ou 55 bytes , fechamento exato equivalente (preciso da última parte porque é uma construção complexa):

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

Suíte de teste.

Swift 3 , 57 bytes

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

Suíte de teste.

Python 2 , 30 bytes

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

Experimente online! O policial tem c/acarrapatos para pegar o ladrão, após o que acelerou o policial. No primeiro tick, o policial ganha c-ano ladrão, enquanto no último tick ele só ganhac%a . Assim, o total que o policial pode ganhar é o produto do número de ticks e da distância média por tick. Isso é simplesmente comparado à liderança inicial do ladrão.

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

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

No entanto, outro porto de itdoesntwork é influente solução rubi .

Execução

A ordem de entrada é velocidade da bobina, posição do ladrão, aceleração do ladrão.

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

Experimente online! Explicação:

\d+
$*

Converter entrada para unário.

$
;

Abra espaço para a velocidade do ladrão.

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

Acelere o ladrão em cada passagem.

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

Afaste o ladrão do policial.

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

Mova o policial em direção ao ladrão.

.*,,.*

O policial pegou o ladrão?

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

O ladrão supera a velocidade do policial?

Recursiva , 19 16 bytes

>b*I/acIH+-ac%ac

Experimente online!