这是一个数学问题，涉及很多问题，使其颇具挑战性，并且您可能已经猜到，这是代码高尔夫球，因此它也应尽可能短。

的输入，n是任何整数数量（至少应该支持整数，但不必限于）。该输出是平均的：

• n
• 的平方 n
• 最接近质数 n
• n斐波那契数列中最接近的数字

不久，程序应该打印到标准输出通道的结果的(n+(n*n)+closestPrime(n)+closestFib(n))/4。

您不必担心可能的溢出等。正常的浮点精度也可以。

输入的方式完全取决于您。最短的程序（以字符为单位）获胜，就像打高尔夫球一样。

如果在寻找最接近的位置时出现平局，请选择以下选项之一：

1. 上
2. 下去
3. 随机选择一个

Python 160个字符

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

关于mostestFib部分的一些解释：

当while循环结束的小于N和b是任一等于或大于现在N.越大 [b,a][2*N-a-b<0]的部分。将其视为[b，a] [（Na）-（bN）]。（Na）是N和a之间的差异，类似地（bN）是b和N之间的差异。如果这两者之间的差异小于0，则表示a接近N，反之亦然。

GolfScript，59个字符

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

该脚本不满足某些要求：

• 它仅适用于输入n >= 2，否则将崩溃。
• 输出被截断为整数。
• 任何中等大小的机器都表现糟糕 n

代码的简要演练：

1. ~:N..*输入存储在N中，我们立即按下n和同时按下平方n*n。
2. .,2>我们将通过过滤数组生成素数列表[2..n*n]。我们使用先前的计算n*n作为（非常糟糕！）上限，以查找大于n的素数。
3. {:P{(.P\%}do(!},我们以前的数组是按试验划分过滤的。针对每个整数[P-1..1]测试每个整数P。
4. {{N-.*}$0=}:C~根据到的距离对前一个数组进行排序n，并获取第一个元素。现在我们有了最接近的素数。
5. [1.{.@+.N<}do]C我们产生斐波那契，直到得到大于1的斐波那契n。幸运的是，该算法自然会跟踪先前的斐波那契，因此我们将它们都放入数组中并使用我们之前的距离排序。现在我们有最接近的斐波那契。
6. +++4/平均。请注意，GolfScript不支持浮点数，因此结果将被截断。

GolfScript，81个字符

这是一个满足所有要求的变体。

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

为了确保的正确行为n<2，我避免使用2<（当数组较小时崩溃），而是使用3,|2,^。这样可确保主要候选数组仅[2]在时n < 2。我将下一个素数的上限从n*n更改为2*n（Bertrand的假设）。同样，0被认为是斐波那契数。最后，将在定点数学中计算结果。有趣的是，结果似乎总是四分之一（0，.25，.5，.75），所以我希望精度的两位小数就足够了。

我的第一个使用GolfScript的技巧是，我确信还有改进的空间！

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}

未压缩：

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;
}

Mathematica，70 69字节

Sp3000节省了一个字节（有时内置的方法并不是最好的选择）。

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

这定义了一个未命名的函数，该函数采用整数并将确切的均值作为有理数。如果是平局，则选择较小的素数/斐波那契数。

对于大型输入，这是非常低效的，因为它实际上会2n在选择最接近的数之前生成第一个质数和斐波那契数。

问119

不是最有效的。

{%[;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个字符

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是您的整数

就非整数而言，据我测试，它也可以与非常大的数一起使用，而且运行得非常快。

斯卡拉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)}

测试和调用：

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

问题在讨论，any Integer但是对于小于0的值，问题并不那么有趣。但是-我们如何开始？在0？在1？那么11的下一个素数是什么？11本身？

如果出现平局，则允许下一个更大或更小的想法是不好的，因为这使得比较不必要的困难。如果您的结果不同，他们可以选择另一个fib，另一个质数，另一个fib和另一个质数，或者您的错误，或者另一个人的结果错误，或者这是一个组合：不同的选择，但是虽然错了，但也许都错了。