20

Pensa a una strada come una linea numerica, a partire da 0e continuando indefinitamente:

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

Ci sono due macchine sulla strada: Ce R. Cè il poliziotto che sta cercando di catturare R, il ladro. Cinizia alle 0e Rinizia da qualche parte sulla strada:

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

Il poliziotto si sta già muovendo, sta inseguendo il ladro. Ha una velocità costante. Il ladro è appena salito in macchina. Sta accelerando. Ad ogni tick, la velocità del ladro aumenta con la sua accelerazione.

Di 'che la velocità del poliziotto è 7e l'accelerazione del ladro è 1. Se il ladro inizia 30, ecco come apparirebbe la strada per ogni segno di spunta:

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

Dopo l'ultimo segno di spunta sopra, la velocità del ladro è pari a quella del poliziotto, ed è ancora avanti. Poiché il poliziotto si sta muovendo a una velocità costante e il ladro sta ancora accelerando, il ladro scappa, quindi si genera un valore veritiero. Tuttavia, se la velocità del poliziotto fosse stata 9...

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

... quindi il poliziotto raggiunge il ladro prima che il ladro possa fuggire (contrassegnato dal Xsimbolo), in modo da emettere un valore falso.

Il tuo compito

Dati tre input - la velocità del poliziotto, la posizione del ladro e l'accelerazione del ladro - determinano se il ladro scapperà o meno.

Regole

Il poliziotto inizia sempre alle 0.
Tutti gli input saranno numeri interi positivi.
Il poliziotto cattura il ladro se, dopo ogni segno di spunta, la posizione del poliziotto è maggiore o uguale alla posizione del ladro.
Il ladro si allontana quando non è ancora stato catturato e la sua velocità è maggiore di quella del poliziotto.
Il programma deve terminare dopo l'output.
Il ladro accelera prima di spostare ogni segno di spunta.

Casi 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

Implementazione di riferimento di Python 3 che crea anche un elemento visivo: provalo online!

Questo è code-golf , quindi vince la risposta più breve in byte.

code-golf decision-problem

— Stefano
fonte

Sandbox (cancellato)

— Stephen

8

Ohhhh ... questa non è una sfida per poliziotti e ladri; ha più senso.

— Magic Octopus Urn l'

L'input è garantito nel formato specificato o possiamo prendere l'input nel formato che vogliamo (come robber acceleration, cop speed, robber positioninvece)?

— TehPers,

@TehPers quello che vuoi (coerente ogni volta), ma se stai facendo qualcosa di diverso, dillo nella tua risposta

— Stephen

2

Richiesta del test case: 100, 451, 10. (Le risposte non sono tutte d'accordo sul risultato).

— Neil,

2

Gelatina , 9 byte

_⁵Ḥ¤²÷÷8<

Provalo online!

La risposta Python 3 di Port of Leaky Nun.

(programma completo) Accetta gli argomenti in ordine acceleration, position, speed.

— Erik the Outgolfer
fonte

16

Python 3 , 29 byte

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

Provalo online!

Spiegazione

La posizione del poliziotto al momento tè st.

La posizione del ladro al momento tè a(t)(t+1)/2 + p.

La distanza indicata dal poliziotto al ladro è (a/2)t^2 + (a/2-s)t + p .

Non arriva mai a zero se il discriminante è negativo, l'essere discriminante (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4, che ha lo stesso segno di (a-2s)^2-8ap.

— Perdente Suora
fonte

Provalo online! - Porta spudorato a 05AB1E per 9 byte (potresti prenderlo, dato che sto male con la Fisica e probabilmente non potrei fare una spiegazione giusta).

— Magic Octopus Urn l'

1

Questo non fallisce nel caso di test "100, 451, 10 -> verità"?

— Mark S.

Mi manca qualcosa o dovremmo anche verificare se esiste un numero intero tra le soluzioni dell'equazione quadratica (a/2)t^2 + (a/2-s)t + p = 0 -> 10t^2 - 50t + 61 = 0? Ad esempio, per 60, 61, 20 il ladro si allontana facilmente (le soluzioni di equazione: 2.1 e 2.9 sono entrambe tra 2 e 3).

— mackoo13

5

Japt , 13 byte

²/W-V-U<o0W x

Provalo online!

Spiegazione

U, Ve Wsono gli input impliciti. Innanzitutto, Uo0Wcreiamo l'intervallo [0, W, 2 * W, ...] fino a raggiungere U. xquindi somma questo, che indica quanto lontano il ladro viaggia prima di raggiungere la velocità del poliziotto. Chiameremo questo r .

Ora, quanto viaggia il poliziotto in questo periodo? Possiamo calcolare questo usando U * (U // W - 1) , che possono essere disposti (U * U) // W - U . Chiameremo questo c .

Ora per l'ultimo passaggio: il ladro se ne va? Tutto ciò che dobbiamo fare qui è verificare se c <r + V , o riorganizzato, c - V <r .

— ETHproductions
fonte

5

Cubicamente , 61 byte

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

Provalo online! Affinché ciò funzioni in TIO, potrebbe essere necessario sostituirlo &con a &1causa di un bug nell'interprete.

Questa è una porta spudorata della risposta di Leaky Nun . L'input è nella forma a s p, dove si atrova l'accelerazione del ladro, sla velocità del poliziotto e pla posizione del ladro.

Se l'accelerazione è troppo alta, questo fallirà. Non so quanta accelerazione supporterà questo programma, ma so che non è superiore a 1260 . Il fattore limitante è che memorizza l'accelerazione nel cubo e controlla se il cubo è risolto controllando solo se la somma della faccia superiore è 0 (un controllo incompleto). Sembra funzionare per l'accelerazione = 50, ma non ho testato per vedere quanto può arrivare.

Come funziona

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

1

L' 6in %6e *6può essere rimosso come ora possono essere chiamati in modo implicito.

— MD XF,

4

Pyth , 11 byte

Questo li porta in questo ordine: Robber Acceleration, Cop Speed, Robber Positionseparati da una nuova riga (come mostrato nella suite di test).

<^-QyE2*8*E

Test Suite o provalo online!

— Mr. Xcoder
fonte

4

Pyke , 14 byte

La risposta di Port of totalmente umana Python . Ritorna 1per la verità e 0per la falsità.

hQee-XQ1@Qe*}<

Provalo qui!

Spiegazione

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 byte

La mia primissima risposta Pyke! La soluzione Port of my Pyth , che si ispira alla presentazione Python di Leaky . Ritorna 1per la verità e 0per la falsità.

eQh}-XQe8*Q1@*<

Provalo qui!

Spiegazione

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.

— Mr. Xcoder
fonte

2

Python 2 , 62 byte

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

Provalo online!

— Mr. Xcoder
fonte

2

Rubino , 29 27 25 byte

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

Provalo online!

Ottenuto dal 29 al 27 rubando l'idea di moltiplicare entrambe le parti per 4. (Risposta del pitone di Leaky Nun)

Ottenuto da 27 a 25 rimuovendo le parentesi attorno ai parametri lambda (grazie totalmente umano)

— itdoesntwork
fonte

2

Benvenuti in PPCG! Si può golf la risposta un po 'rinominando la funzione da hita ho simili. Potresti anche essere in grado di salvare alcuni byte passando da un metodo a un proc, in questo modo:->c,p,a{(c-a*0.5)**2<2*p*a}

— Conor O'Brien,

1

È inoltre necessario sostituire collisionnel collegamento TIO con il nome del metodo corretto.

— Leaky Nun,

Pssst, guarda il loro nome utente. : P

— totalmente umano,

1

Sono abbastanza sicuro che non hai bisogno delle parentesi in giro c,p,a.

— totalmente umano l'

2

C # (.NET Core) , 33 byte

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

Provalo online!

Sento che questo è fuori da uno da qualche parte, ma passa per tutti i casi di test, quindi è possibile che semplicemente non ci siano casi di test in cui il poliziotto sorpassa il ladro per un singolo tick, o potrebbe funzionare nonostante le mie riserve.

— Kamil Drakari
fonte

1

Python 2 , 31 30 29 byte

-1 byte grazie a Mr. Xcoder.

Iniziato come una porta della risposta di Ruby .

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

Provalo online!

— totallyhuman
fonte

1

.5anziché 0.5> _>

— Mr. Xcoder l'

Haha, ho pensato che sarebbe stato così tanto port. XD Grazie!

— totalmente umano l'

a/2usa la divisione intera, potrebbe andare storto?

— itdoesntwork

Usa la divisione intera. Anche se non ho elaborato alcun calcolo matematico (a dire il vero, non sono sicuro di poterlo fare), funziona per tutti i casi di test.

— totalmente umano l'

1

Swift 3 , 55 byte

Si noti che ho dichiarato la variabile tperché l'espressione sarebbe troppo complessa per essere risolta in tempi ragionevoli altrimenti (colpa di Swift!).

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

Test Suite.

o 55 byte , equivalente di chiusura esatta (ho bisogno dell'ultima parte perché è un costrutto complesso):

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

Test Suite.

Swift 3 , 57 byte

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

Test Suite.

— Mr. Xcoder
fonte

1

Python 2 , 30 byte

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

Provalo online! Il poliziotto ha delle c/azecche in cui catturare il ladro, dopo di che ha accelerato il poliziotto. Al primo tick il poliziotto guadagna c-ail ladro mentre all'ultimo tick guadagna solo c%a. Quindi il totale che il poliziotto può ottenere è il prodotto del numero di tick e della distanza media per tick. Questo è semplicemente paragonato al vantaggio iniziale che ha il ladro.

— Neil
fonte

1

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

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

Ancora un altro porto della influente soluzione Ruby di itdoesntwork .

Esecuzione

L'ordine di input è la velocità della polizia, la posizione del ladro, l'accelerazione del ladro.

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

— Jakob
fonte

1

Retina , 79 byte

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

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

Provalo online! Spiegazione:

\d+
$*

Converti input in unario.

$
;

Fai spazio alla velocità del ladro.

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

Accelera il ladro ad ogni passaggio.

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

Allontana il ladro dal poliziotto.

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

Sposta il poliziotto verso il ladro.

.*,,.*

Il poliziotto ha catturato il ladro?

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

Il ladro supera il poliziotto?

— Neil
fonte

1

Recursiva , 19 16 byte

>b*I/acIH+-ac%ac

Provalo online!

— officialaimm
fonte

Prevedere una collisione: il ladro scapperà?

Il tuo compito

Regole

Casi test

Gelatina , 9 byte

Python 3 , 29 byte

Spiegazione

Japt , 13 byte

Spiegazione

Cubicamente , 61 byte

Come funziona

Pyth , 11 byte

Pyke , 14 byte

Spiegazione

Pyke , 15 byte

Spiegazione

Python 2 , 62 byte

Rubino , 29 27 25 byte

C # (.NET Core) , 33 byte

Python 2 , 31 30 29 byte

Swift 3 , 55 byte

Swift 3 , 57 byte

Python 2 , 30 byte

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

Esecuzione

Retina , 79 byte

Recursiva , 19 16 byte