Chơi bi-a

Trong mã golf này, bạn sẽ phải xác định hướng của cú đánh ngắn nhất chạm chính xác n đệm trước khi rơi vào túi.

Bàn bida là một bàn bi-a 6 túi với các đặc điểm sau:

• Kích thước là biến ( a x b )
• Không ma sát: quả bóng sẽ lăn mãi mãi cho đến khi nó rơi vào túi
• Túi và kích thước bóng gần như bằng không. Điều này có nghĩa là bóng sẽ rơi vào túi chỉ khi chúng có cùng vị trí.
• Quả bóng được đặt ở lỗ dưới cùng bên trái lúc ban đầu (nhưng không rơi vào đó)

Tạo một chương trình hoặc hàm đầy đủ lấy các kích thước ( a , b ) của bảng và số lượng đệm để nhấn n làm đầu vào và trả về góc theo độ của đường đi ngắn nhất chạm chính xác n đệm trước khi rơi vào túi.

• a > 0
• b > 0
• 0 <= n <10000000
• Độ chính xác 0 < alpha <90 (tính theo độ): ít nhất 10 ^ -6

ví dụ:

với a = 2, b = 1, n = 1 có ba đường dẫn có thể: (1) (2) (3) trên hình sau. số (1) là ngắn nhất nên đầu ra phải là atan (2) = 63.43494882292201 độ

Giải pháp cho a = 2, b = 1, n = 4 là atan (4/3) = 53.13010235415598 độ

mẫu thử nghiệm :

a = 2,    b = 1,    n = 1,       -> alpha = 63.43494882292201
a = 2,    b = 1,    n = 2,       -> alpha = 71.56505117707799
a = 2,    b = 1,    n = 3,       -> alpha = 75.96375653207353
a = 2,    b = 1,    n = 4,       -> alpha = 53.13010235415598
a = 2,    b = 1,    n = 5,       -> alpha = 59.03624346792648
a = 2,    b = 1,    n = 6,       -> alpha = 81.86989764584403
a = 4.76, b = 3.64, n = 27,      -> alpha = 48.503531644784466
a = 2,    b = 1,    n = 6,       -> alpha = 81.86989764584403
a = 8,    b = 3,    n = 33,      -> alpha = 73.24425107080101
a = 43,   b = 21,   n = 10005,   -> alpha = 63.97789961246943

Đây là mã / billiard golf: mã ngắn nhất thắng!

Python 2.7, 352 344 281 byte

from math import*
def l(a,b,n):
 a*=1.;b*=1.
 r=set()
 for i in range(1,n+3):
  t=[]
  for k in range(1,i):
   for h in[0,.5]:
    x=(i-k-h)
    if 1-(x/k in r):r.add(x/k);t+=(x*a,k*b),
 d=(a*n+1)**2+(b*n+1)**2
 for x,y in t:
  if x*x+y*y<d:d=x*x+y*y;o=degrees(atan(y/x))
 return o

• -16 byte nhờ @Dschoni

Giải thích: thay vì tính toán các lần truy cập đệm, tôi thêm n bảng và lấy các lỗ mới là hợp lệ: Đường viền / lỗ đen là đường viền gốc / lỗ màu xanh lá cây là hợp lệ cho n = 1, đường viền / lỗ màu đỏ là hợp lệ cho n = 2 và cứ thế. Sau đó, tôi loại bỏ các lỗ không hợp lệ (ví dụ mũi tên màu xanh cho n = 1). Tôi sẽ có một danh sách các lỗ hợp lệ và tọa độ của chúng, sau đó tôi tính khoảng cách của chúng từ điểm ban đầu, và sau đó là góc của khoảng cách nhỏ hơn.
Lưu ý:
a = 4,76, b = 3,64, n = 27 - đưa ra 52.66286, cố gắng tìm hiểu tại sao cố định và lưu 8 byte trong quy trình = D
a = 43, b = 21, n = 10005 - mất ~ 80 giây ( nhưng cho góc bên phải)

phiên bản có thể đọc được:

from math import *
def bill(a,b,n):
    a=float(a)
    b=float(b)
    ratios = set()
    for i in range(0,n+2): # Create the new boards
        outter = []
        j=i+1
        for k in range(1,j): # Calculate the new holes for each board
            #y=k
            for hole_offset in [0,0.5]:
                x=(j-k-hole_offset)
                if (x/k) not in ratios:
                    ratios.add(x/k)
                    outter.append((x*a,k*b))
    min_dist = (a*n+1)**2+(b*n+1)**2
    for x,y in outter:
        if x*x+y*y<min_dist:
            min_dist = x*x+y*y
            min_alpha=degrees(atan(y/x))
    return min_alpha

Haskell, 133 117 byte

Đây là triển khai của tôi:

Với bảng 2x1, một đường dẫn sẽ đánh chính xác n đệm trước khi đi vào túi nếu: (x-1) / 2 + (y-1) == n và x, y là các số nguyên tố lẫn nhau. Trong đó x, y là khoảng cách của quả bóng trên các trục ngang / dọc.

Các đường dẫn giống nhau với kích thước bảng tùy ý, vì vậy chúng ta chỉ cần cập nhật độ dài và góc với (a, b) và giữ ngắn nhất. Độ dài đường dẫn là sqrt ((x * a / 2) ^ 2 + (y * b) ^ 2) và góc là atan ((y * b) / (x * a / 2))

z=toEnum
f a b n=minimum[[z x^2+r^2,180/pi*atan(r/z x)]|x<-[1..2*n+2],y<-[n+1-div(x-1)2],r<-[2*b/a*z y],gcd x y<2]!!1