Hãy nghĩ về một con đường như một dòng số, bắt đầu từ 0và tiếp tục vô tận:

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

Có hai chiếc xe trên đường: Cvà R. Clà cảnh sát đang cố bắt R, kẻ cướp. Cbắt đầu 0và Rbắt đầu từ đâu đó trên đường:

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

Người cảnh sát đã di chuyển - anh ta đuổi theo tên cướp. Anh ấy có một tốc độ không đổi. Tên cướp chỉ nhảy vào xe của mình. Anh ấy đang tăng tốc. Mỗi tích tắc, tốc độ của tên cướp tăng theo gia tốc của hắn.

Nói tốc độ của cảnh sát là 7và gia tốc của tên cướp là 1. Nếu tên cướp bắt đầu 30, đây là con đường trông giống như mỗi tích tắc:

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

Sau lần đánh dấu cuối cùng ở trên, tốc độ của tên cướp bằng với cảnh sát và anh ta vẫn ở phía trước. Vì cảnh sát đang di chuyển với tốc độ không đổi và tên cướp vẫn đang tăng tốc, tên cướp đã trốn thoát, do đó bạn đưa ra một giá trị trung thực. Tuy nhiên, nếu tốc độ của cảnh sát là 9...

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

... sau đó cảnh sát bắt kịp tên cướp trước khi tên cướp có thể trốn thoát (được đánh dấu bởi X), do đó bạn tạo ra giá trị chim ưng.

Nhiệm vụ của bạn

Đưa ra ba yếu tố đầu vào - tốc độ của cảnh sát, vị trí của tên cướp và gia tốc của tên cướp - xác định liệu tên cướp có thoát được hay không.

Quy tắc

• Các cảnh sát luôn bắt đầu lúc 0.
• Tất cả các đầu vào sẽ là số nguyên dương.
• Cảnh sát bắt được tên cướp nếu sau bất kỳ dấu tích nào, vị trí của cảnh sát lớn hơn hoặc bằng vị trí của tên cướp.
• Tên cướp đã trốn thoát khi anh ta chưa bị bắt và tốc độ của anh ta lớn hơn cảnh sát.
• Chương trình của bạn phải chấm dứt sau khi đầu ra.
• Tên cướp tăng tốc trước khi anh ta di chuyển từng tích tắc.

Các trường hợp thử nghiệm

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

Tham khảo triển khai Python 3 cũng tạo ra một hình ảnh: Hãy thử trực tuyến!

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

Thạch , 9 byte

_⁵Ḥ¤²÷÷8<

Hãy thử trực tuyến!

Câu trả lời Python 3 của Leaky Nun.

(chương trình đầy đủ) Đưa ra các đối số theo thứ tự acceleration, position, speed.

Python 3 , 29 byte

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

Hãy thử trực tuyến!

Giải trình

Vị trí của cảnh sát tại thời điểm tlà st.

Vị trí của tên cướp lúc đó tlà a(t)(t+1)/2 + p.

Khoảng cách đã ký từ cảnh sát đến tên cướp là (a/2)t^2 + (a/2-s)t + p.

Nó không bao giờ đạt đến 0 nếu người phân biệt đối xử là tiêu cực, người phân biệt đối xử (a/2 - s)^2 - 4(a/2)(p) = [(a-2s)^2-8ap]/4, có cùng dấu hiệu với (a-2s)^2-8ap.

Japt , 13 byte

²/W-V-U<o0W x

Kiểm tra nó trực tuyến!

Giải trình

U, Vvà Wlà các đầu vào ngầm. Đầu tiên, với việc Uo0Wchúng ta tạo phạm vi [0, W, 2 * W, ...] cho đến khi đạt được U. xsau đó tính tổng này, cho biết tên cướp đi được bao xa trước khi đạt tốc độ cảnh sát. Chúng tôi sẽ gọi đây là r .

Bây giờ, cảnh sát đi được bao xa trong thời gian này? Chúng tôi có thể tính toán này sử dụng U * (U // W - 1) , có thể được sắp xếp lại để (U * U) // W - U . Chúng tôi sẽ gọi đây là c .

Bây giờ cho bước cuối cùng: tên cướp có thoát được không? Tất cả những gì chúng ta cần làm ở đây là kiểm tra xem c <r + V hay sắp xếp lại, c - V <r .

Về cơ bản , 61 byte

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

Hãy thử trực tuyến! Để làm việc này trong TIO, bạn có thể cần phải thay thế &bằng &1do một lỗi trong trình biên dịch.

Đây là một câu trả lời không biết xấu hổ về câu trả lời của Leaky Nun . Đầu vào ở dạng a s p, trong đó alà gia tốc của tên cướp, slà tốc độ của cảnh sát và plà vị trí của tên cướp.

Nếu tăng tốc quá cao, điều này sẽ thất bại. Tôi không biết chương trình tăng tốc này sẽ hỗ trợ cao đến mức nào, nhưng tôi biết nó không cao hơn 1260 . Yếu tố giới hạn là nó lưu trữ gia tốc trong khối và kiểm tra xem khối có được giải không bằng cách chỉ kiểm tra nếu tổng của mặt trên là 0 (kiểm tra không đầy đủ). Nó dường như hoạt động để tăng tốc = 50, nhưng tôi chưa thử nghiệm để xem nó có thể tăng cao đến mức nào.

Làm thế nào nó hoạt động

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

Bình thường , 11 byte

Điều này đưa chúng theo thứ tự này: được Robber Acceleration, Cop Speed, Robber Positionphân tách bằng một dòng mới (như được hiển thị trong bộ thử nghiệm).

<^-QyE2*8*E

Test Suite hoặc dùng thử trực tuyến!

Pyke , 14 byte

Cổng câu trả lời Python hoàn toàn của con người . Trả lại 1cho sự thật và giả 0.

hQee-XQ1@Qe*}<

Hãy thử nó ở đây!

Giải trình

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

Câu trả lời Pyke đầu tiên của tôi! Cảng giải pháp Pyth của tôi , được lấy cảm hứng từ trình Python Leaky của . Trả lại 1cho sự thật và giả 0.

eQh}-XQe8*Q1@*<

Hãy thử nó ở đây!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Ruby , 29 27 25 byte

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

Hãy thử trực tuyến!

Có được từ 29 đến 27 bằng cách đánh cắp ý tưởng nhân cả hai bên lên 4. (Câu trả lời con trăn của Leaky Nun)

Có từ 27 đến 25 bằng cách loại bỏ các dấu kiểm xung quanh các tham số lambda (cảm ơn hoàn toàn)

C # (.NET Core) , 33 byte

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

Hãy thử trực tuyến!

Tôi cảm thấy như thế này bị tắt ở một nơi nào đó, nhưng nó vượt qua tất cả các trường hợp thử nghiệm vì vậy có thể đơn giản là không có trường hợp thử nghiệm nào mà cảnh sát vượt qua tên cướp chỉ trong một tích tắc, hoặc nó có thể chỉ hoạt động mặc dù tôi đã đặt trước.

Python 2 , 31 30 29 byte

-1 byte nhờ ông Xcoder.

Bắt đầu như một cổng của câu trả lời Ruby .

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

Hãy thử trực tuyến!

Swift 3 , 55 byte

Lưu ý rằng tôi đã khai báo biến tvì biểu thức sẽ quá phức tạp để giải quyết trong thời gian hợp lý nếu không (lỗi của Swift!).

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

Phòng thử nghiệm.

hoặc 55 byte , tương đương đóng chính xác (tôi cần phần cuối cùng vì đây là cấu trúc phức tạp):

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

Phòng thử nghiệm.

Swift 3 , 57 byte

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

Phòng thử nghiệm.

Python 2 , 30 byte

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

Hãy thử trực tuyến! Cảnh sát đã đánh c/adấu vào đó để bắt kẻ cướp, sau đó nó đã tăng tốc cho cảnh sát. Ở tích tắc đầu tiên, cảnh sát đạt được c-atrên tên cướp trong khi ở lần đánh dấu cuối cùng, anh ta chỉ được lợi c%a. Do đó, tổng số mà cảnh sát có thể đạt được là sản phẩm của số lượng bọ ve và khoảng cách trung bình trên mỗi đánh dấu. Điều này chỉ đơn giản là so với sự dẫn dắt ban đầu mà tên cướp có.

TI BASIC (sê-ri TI-83/84), 18 byte

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

Một cổng khác của giải pháp Ruby có ảnh hưởng của itdoesntwork .

Chấp hành

Thứ tự đầu vào là tốc độ cảnh sát, vị trí cướp, tăng tốc cướp.

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

Võng mạc , 79 byte

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

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

Hãy thử trực tuyến! Giải trình:

\d+
$*

Chuyển đổi đầu vào thành unary.

$
;

Nhường chỗ cho tốc độ của tên cướp.

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

Tăng tốc cho tên cướp trên mỗi đường chuyền.

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

Di chuyển tên cướp ra khỏi cảnh sát.

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

Di chuyển cảnh sát về phía tên cướp.

.*,,.*

Cảnh sát đã bắt được tên cướp?

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

Liệu tên cướp vượt quá tốc độ của cảnh sát?

Đệ quy , 19 16 byte

>b*I/acIH+-ac%ac

Hãy thử trực tuyến!