Esse é um problema de matemática que coloca muitas coisas em questão, tornando-o bastante desafiador e, como você deve ter adivinhado, é um código de golfe, portanto deve ser o mais curto possível.

A entrada , n, é qualquer número inteiro número (deve pelo menos inteiros de suporte, mas não necessita de ser limitado a). A saída é a média de:

• n
• A praça de n
• O número primo mais próximo de n
• O número mais próximo nna sequência de Fibonacci

Logo, o programa deve imprimir para a saída padrão canalizar o resultado de (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Você não precisa se preocupar com possíveis estouros, etc. A precisão normal do ponto flutuante também é boa.

A maneira como a entrada é fornecida é totalmente sua. O programa mais curto (em caracteres) vence, como sempre no código de golfe.

Caso ocorra um empate ao procurar o mais próximo, escolha uma das seguintes opções:

1. Ir para cima
2. Descer
3. Escolha um aleatoriamente

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

Uma pequena explicação sobre a parte mais próxima da Fib:

Quando o loop while termina, a é menor que N e b é igual ou superior a N. Agora, a [b,a][2*N-a-b<0]peça. Veja como [b, a] [(Na) - (bN)]. (Na) é a diferença entre N e a e similarmente (bN), a diferença entre be N. Se a diferença entre esses dois for menor que 0, significa que a está mais próximo de N e vice-versa.

GolfScript, 59 caracteres

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

Este script não atende a alguns dos requisitos:

• Funciona apenas corretamente para entradas n >= 2, caso contrário, trava.
• A saída é truncada para um número inteiro.
• Desempenho terrível para qualquer moderadamente grande n

Uma breve explicação passo a passo do código:

1. ~:N..*A entrada é armazenada em N e pressionamos ambos ne o quadrado n*nimediatamente.
2. .,2>Geraremos uma lista de números primos filtrando a matriz [2..n*n]. Usamos nosso cálculo anterior n*ncomo um limite superior (muito ruim!) Para encontrar um primo maior que n.
3. {:P{(.P\%}do(!},Nossa matriz anterior é filtrada por divisão de teste. Cada número inteiro P é testado em relação a todo número inteiro [P-1..1].
4. {{N-.*}$0=}:C~Classifica a matriz anterior com base na distância ne agarra o primeiro elemento. Agora temos o primo mais próximo.
5. [1.{.@+.N<}do]CGeramos Fibonnacis até obter um maior que n. Felizmente, esse algoritmo controla naturalmente a Fibonnaci anterior, portanto, nós os lançamos em uma matriz e usamos nosso tipo de distância anterior. Agora temos a Fibonnaci mais próxima.
6. +++4/Média. Observe que o GolfScript não tem suporte para carros alegóricos, portanto, o resultado é truncado.

GolfScript, 81 caracteres

Aqui está uma variante que atende a todos os requisitos.

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

Para garantir um comportamento adequado n<2, evito 2<(trava quando a matriz é pequena) e uso 3,|2,^. Isso garante que a matriz de candidatos principais seja exatamente [2]quando n < 2. Mudei o limite superior para o próximo primo de n*npara 2*n( postulado de Bertrand ). Além disso, 0 é considerado um número de Fibonnaci. O resultado é calculado em matemática de ponto fixo no final. Curiosamente, parece que o resultado está sempre em quartos (0, 0,25, 0,5, 0,75), então espero que 2 casas decimais de precisão sejam suficientes.

Minha primeira tentativa de usar o GolfScript, tenho certeza de que há espaço para melhorias!

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}

Descomprimido:

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

Um byte economizado graças ao Sp3000 (às vezes, os embutidos não são o melhor caminho a percorrer).

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

Isso define uma função sem nome que pega um número inteiro e produz a média exata como um número racional. No caso de empates, é escolhido o menor número primo / Fibonacci.

Isso é muito ineficiente para entradas grandes, porque na verdade gera os primeiros 2nnúmeros primos e números de Fibonacci antes de escolher o mais próximo.

Q, 119

Não é o mais 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 é o seu número inteiro

Funciona com números não inteiros, tanto quanto eu testei, também funciona com números muito grandes, também é muito 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)}

Teste e invocação:

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

A pergunta fala sobre, any Integermas o problema não é tão interessante para valores abaixo de 0. No entanto - como começamos? A 0? Em 1? E qual é o próximo primo para 11? 11 em si?

A idéia de permitir o próximo maior ou menor em caso de empate é ruim, porque dificulta a comparação desnecessária. Se seus resultados diferirem, eles podem ter escolhido a outra mentira, a outra prima, a outra mentira e a outra mentira, ou a sua está errada, ou o resultado da outra pessoa está errado, ou é uma combinação: escolha diferente, mas errado, embora, talvez ambos errado.