Este es un problema matemático que cuestiona muchas cosas, lo que lo hace bastante desafiante y, como habrás adivinado, es un código de golf, por lo que también debe ser lo más corto posible.

La entrada , nes cualquier número entero (al menos debe ser compatible con enteros, pero no debe limitarse a). La salida es el promedio de:

• n
• El cuadrado de n
• El número primo más cercano a n
• El número más cercano a nen la secuencia de Fibonacci

En breve, el programa debe imprimir en el canal de salida estándar el resultado de (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Usted no tiene que preocuparse por posibles desbordamientos etc. normal coma flotante de precisión es también aceptable.

La forma en que se proporciona la entrada depende completamente de usted. El programa más corto (en caracteres) gana, como siempre con los códigos de golf.

En caso de que se produzca un empate cuando esté buscando el más cercano, elija una de las siguientes opciones:

1. Subir
2. Bajar
3. Elige uno al azar

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

Una pequeña explicación sobre la parte de fibra más cercana:

Cuando el ciclo while finaliza a es menor que N yb es igual o mayor que N. Ahora la [b,a][2*N-a-b<0]parte. Míralo como [b, a] [(Na) - (bN)]. (Na) es la diferencia entre N y a y de manera similar (bN) la diferencia entre by N. Si la diferencia entre estos dos es menor que 0, significa que a está más cerca de N y viceversa.

GolfScript, 59 caracteres

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

Este script no cumple algunos de los requisitos:

• Solo funciona correctamente para las entradas n >= 2, de lo contrario se bloquea.
• La salida se trunca a un entero.
• Terrible rendimiento para cualquier moderadamente grande n

Un breve tutorial del código:

1. ~:N..*La entrada se almacena en N, y empujamos ambos ny el cuadrado de n*ninmediato.
2. .,2>Generaremos una lista de números primos filtrando la matriz [2..n*n]. Utilizamos nuestro cálculo anterior de n*ncomo un límite superior (¡muy malo!) Para encontrar un primo mayor que n.
3. {:P{(.P\%}do(!},Nuestra matriz anterior se filtra por división de prueba. Cada entero P se prueba contra cada entero [P-1..1].
4. {{N-.*}$0=}:C~Ordena la matriz anterior en función de la distancia ny toma el primer elemento. Ahora tenemos el primo más cercano.
5. [1.{.@+.N<}do]C Generamos Fibonnacis hasta obtener uno mayor que n . Afortunadamente, este algoritmo hace un seguimiento natural de Fibonnaci anterior, por lo que los colocamos en una matriz y usamos nuestra clasificación de distancia anterior. Ahora tenemos el Fibonnaci más cercano.
6. +++4/Promedio. Tenga en cuenta que GolfScript no tiene soporte para flotantes, por lo que el resultado se trunca.

GolfScript, 81 caracteres

Aquí hay una variante que cumple con todos los requisitos.

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

Para garantizar un comportamiento adecuado n<2, evito 2<(se bloquea cuando la matriz es pequeña) y en su lugar la uso 3,|2,^. Esto asegura que la matriz de candidatos principales sea justo [2]cuando n < 2. Cambié el límite superior para la próxima prima de n*na 2*n( postulado de Bertrand ). Además, 0 se considera un número de Fibonnaci. El resultado se calcula en matemáticas de punto fijo al final. Curiosamente, parece que el resultado siempre está en cuartos (0, .25, .5, .75), por lo que espero que sean suficientes 2 decimales de precisión.

Mi primer intento de usar GolfScript, ¡estoy seguro de que hay margen de mejora!

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}

Sin comprimir:

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 bytes

Un byte guardado gracias a Sp3000 (a veces, las funciones integradas no son la mejor opción).

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

Esto define una función sin nombre que toma un número entero y produce la media exacta como un número racional. En el caso de los empates, se elige el número primo / Fibonacci más pequeño.

Esto es muy ineficiente para entradas grandes, porque en realidad genera los primeros 2nnúmeros primos y los números de Fibonacci antes de elegir el más cercano.

Q, 119

No es el más eficiente.

{%[;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 es tu número entero

Funciona con números no enteros, por lo que he probado, también funciona con números muy grandes, también se ejecuta bastante rápido.

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

Prueba e invocación:

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

La pregunta habla any Integerpero el problema no es tan interesante para valores inferiores a 0. Sin embargo, ¿cómo comenzamos? A 0? ¿A la 1? ¿Y cuál es el próximo prime para 11? 11 en sí?

La idea de permitir el próximo más grande o más bajo en caso de empate es mala, porque dificulta la comparación innecesaria. Si sus resultados difieren, pueden haber elegido el otro fib, el otro primo, el otro fib y el otro primo, o los suyos son incorrectos, o el resultado de la otra persona es incorrecto, o es una combinación: opción diferente, pero mal aunque, quizás ambos mal.