Đây là một vấn đề toán học đặt ra khá nhiều vấn đề, khiến nó trở nên khá khó khăn và như bạn có thể đoán, đó là một môn đánh gôn, vì vậy nó cũng phải ngắn nhất có thể.

Đầu vào , nlà bất kỳ số nguyên nào (ít nhất nên hỗ trợ các số nguyên, nhưng không cần giới hạn). Đầu ra là trung bình của:

• n
• Hình vuông của n
• Số nguyên tố gần nhất với n
• Số gần nhất ntrong chuỗi Fibonacci

Không lâu, chương trình nên in ra đầu ra tiêu chuẩn kênh các kết quả của (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Bạn không cần phải quan tâm đến việc tràn có thể xảy ra, vv Độ chính xác của dấu phẩy động bình thường cũng ổn.

Cách đầu vào được đưa ra là hoàn toàn tùy thuộc vào bạn. Chương trình ngắn nhất (tính theo ký tự) sẽ thắng, như mọi khi với mã golf.

Trong trường hợp cà vạt xảy ra khi bạn đang tìm kiếm gần nhất, hãy chọn một trong các cách sau:

1. Đi lên
2. Đi xuống
3. Chọn ngẫu nhiên

Python 160 Chars

p=lambda n:any(n%x<1for x in range(2,n))
N=input()
a=0;b=1
while b<N:a,b=b,a+b
c=d=N
while p(c)and p(d):c-=1;d+=1
print (N+N*N+[b,a][2*N-a-b<0]+[c,d][p(c)])/4.0

Một lời giải thích nhỏ về phần gần nhất củaibib:

Khi vòng lặp while kết thúc a nhỏ hơn N và b bằng hoặc lớn hơn N. Bây giờ là [b,a][2*N-a-b<0]phần. Nhìn vào nó như [b, a] [(Na) - (bN)]. (Na) là sự khác biệt giữa N và a và tương tự (bN) sự khác biệt giữa b và N. Nếu chênh lệch giữa hai giá trị này nhỏ hơn 0 thì có nghĩa là a gần với N và ngược lại.

GolfScript, 59 ký tự

~:N..*.,2>{:P{(.P\%}do(!},{{N-.*}$0=}:C~[1.{.@+.N<}do]C+++4/

Kịch bản này không đáp ứng một số yêu cầu:

• Nó chỉ hoạt động chính xác cho đầu vào n >= 2, nếu không nó bị hỏng.
• Đầu ra được cắt ngắn thành một số nguyên.
• Hiệu suất khủng khiếp cho bất kỳ lớn vừa phải n

Một hướng dẫn ngắn gọn về mã:

1. ~:N..*Đầu vào được lưu trữ trong N, và chúng tôi đẩy cả hai nvà hình vuông n*nngay lập tức.
2. .,2>Chúng tôi sẽ tạo một danh sách các số nguyên tố bằng cách lọc mảng [2..n*n]. Chúng tôi sử dụng phép tính trước đây của chúng tôi n*nlà giới hạn trên (rất xấu!) Để tìm một số nguyên tố lớn hơn n.
3. {:P{(.P\%}do(!},Mảng trước của chúng tôi được lọc bởi bộ phận thử nghiệm. Mỗi số nguyên P được kiểm tra đối với mọi số nguyên [P-1..1].
4. {{N-.*}$0=}:C~Sắp xếp mảng trước dựa trên khoảng cách đến nvà lấy phần tử đầu tiên. Bây giờ chúng ta có số nguyên tố gần nhất.
5. [1.{.@+.N<}do]CChúng tôi tạo ra Fibonnacis cho đến khi chúng tôi nhận được một lớn hơn n. May mắn thay, thuật toán này tự nhiên theo dõi các Fibonnaci trước đó, vì vậy chúng tôi ném cả hai vào một mảng và sử dụng sắp xếp khoảng cách trước đó của chúng tôi. Bây giờ chúng ta có Fibonnaci gần nhất.
6. +++4/Trung bình cộng. Lưu ý rằng GolfScript không có hỗ trợ cho số float, vì vậy kết quả bị cắt ngắn.

GolfScript, 81 ký tự

Đây là một biến thể đáp ứng tất cả các yêu cầu.

~:N..*2N*,3,|2,^{:P{(.P\%}do(!},{{N-.*}$0=}:C~[0.1{.@+.N<}do]C+++100:E*4/.E/'.'@E%

Để đảm bảo hành vi đúng n<2, tôi tránh 2<(gặp sự cố khi mảng nhỏ), và thay vào đó sử dụng 3,|2,^. Điều này đảm bảo mảng ứng cử viên chính chỉ là [2]khi n < 2. Tôi đã thay đổi giới hạn trên cho số nguyên tố tiếp theo từ n*nthành 2*n( định đề của Bertrand ). Ngoài ra, 0 được coi là một số Fibonnaci. Kết quả được tính toán trong điểm toán cố định ở cuối. Thật thú vị, có vẻ như kết quả luôn ở vị trí thứ tư (0, 0,25, 0,55, 0,75), vì vậy tôi hy vọng 2 vị trí thập phân của độ chính xác là đủ.

Lần đầu tiên tôi sử dụng GolfScript, tôi chắc chắn có chỗ để cải thiện!

JavaScript, 190

function n(n)
{z=i(n)?n:0
for(x=y=n;!z;x--,y++)z=i(x)?x:i(y)?y:0
for(a=b=1;b<n;c=a+b,a=b,b=c);
return(n+n*n+(2*n-a-b<0?a:b)+z)/4}
function i(n)
{for(j=2;j<n;j++)
if(!(n%j))return 0
return 1}

[257]

function n(n)
{return(n+n*n+p(n)+f(n))/4}
function p(n)
{if(i(n))return n
for(a=b=n;;a--,b++){if(i(a))return a
if(i(b))return b}}
function i(n)
{for(j=2;j<n;j++)
if(!(n%j))return 0
return 1}
function f(n)
{for(a=b=1;b<n;c=a+b,a=b,b=c);
return 2*n-a-b<0?a:b}

Không nén

function closest( a, b, c )
{
  return 2*a-b-c < 0 ? b : c;
}

function closestPrime( n )
{
  a=b=n;
  if (isPrime( n ) ) return n;
  while ( true )
  {
    a-=1;
    b+=1;
    if (isPrime(a))return a;
    if (isPrime(b))return b;
  }
}

function isPrime( n )
{
  for (i=2;i<n;i++)
  {
    if ( !( n % i ) ) return false;
  }
  return true;
}

function closestFib( n )
{
  for(fib1=0,fib2=1;fib2<n;fib3=fib1+fib2,fib1=fib2,fib2=fib3);
  return closest( n, fib1, fib2 );
}

function navg(n)
{
  n2 = n*n;
  np = closestPrime( n );
  nf = closestFib( n );
  return ( n + n2 + np + nf ) / 4;
}

Toán học, 70 69 byte

Một byte được lưu nhờ Sp3000 (đôi khi được tích hợp sẵn không phải là cách tốt nhất).

((n=#)+#^2+(f=#&@@#@Range@Max[1,2n]~Nearest~n&)@Prime+f@Fibonacci)/4&

Điều này xác định một hàm không tên lấy một số nguyên và tạo ra giá trị trung bình chính xác như một số hữu tỷ. Trong trường hợp quan hệ, số nguyên tố / Fibonacci nhỏ hơn được chọn.

Điều này rất không hiệu quả đối với các đầu vào lớn, bởi vì nó thực sự tạo ra các 2nsố nguyên tố và số Fibonacci đầu tiên trước khi chọn giá trị gần nhất.

Q, 119

Không phải là hiệu quả nhất.

{%[;4]x+(x*x)+((*:)a(&)b=min b:abs x-a:{x,sum -2#x}/[x-2;1 1])+(*:)d(&)e=min e:x-d:(&)1={(min x mod 2_(!)x)}each(!)x+2}

MATLAB 88 Chars

C=@(F)(F(abs(F-n)==min(abs(F-n))));(n+n^2+C(primes(n*2))+C(round(1.618.^(1:n)/2.236)))/4

n là số nguyên của bạn

Hoạt động với các số nguyên không, theo như tôi đã thử nghiệm, nó cũng hoạt động với số lượng rất lớn, cũng chạy khá nhanh.

Scala 299

object F extends App{type I=Int
def f(n:I,b:I=1,a:I=1):I=if(a>=n)if(a-n>n-b)b else a else f(n,a,b+a)
def p(n:I)=(2 to n-1).exists(n%_==0)
def i(n:I,v:I):Int=if(!p(n+v))n+v else i(n+v,v)
val a=readInt
println(({val p=Seq(-1,1).map(i(math.max(a,3),_))
if(a-p(0)>p(1)-a)p(1)else p(0)}+f(a)+a+a*a)/4.0)}

Kiểm tra và gọi:

a  a² nP(a) nF  ∑   /4.0 
------------------------
-2  4   2   1   5   1.25
-1  1   2   1   3   0.75
0   0   2   1   3   0.75
1   1   2   1   5   1.25
2   4   2   2   10  2.5
3   9   2   3   17  4.25
4   16  3   5   28  7.0
5   25  3   5   38  9.5

Câu hỏi nói về any Integernhưng vấn đề không thú vị đối với các giá trị dưới 0. Tuy nhiên - chúng ta bắt đầu như thế nào? Ở 0? Tại 1? Và số nguyên tố tiếp theo cho 11 là gì? 11 chính nó?

Ý tưởng cho phép tiếp theo lớn hơn hoặc thấp hơn trong trường hợp hòa là xấu, bởi vì nó làm cho việc so sánh không cần thiết trở nên khó khăn. Nếu kết quả của bạn khác nhau, họ có thể đã chọn sợi khác, số nguyên tố khác, số nguyên tố khác và số nguyên tố khác hoặc kết quả của bạn sai hoặc kết quả của người khác là sai hoặc đó là sự kết hợp: sự lựa chọn khác nhau, nhưng Mặc dù sai, có thể cả hai đều sai.