Questo è un problema di matematica che prende molte cose in discussione, rendendolo piuttosto impegnativo e, come avrete intuito, è un codice golf, quindi dovrebbe essere il più breve possibile.

L' input , nè un numero intero (dovrebbe almeno supportare numeri interi, ma non deve essere limitato a). L' output è la media di:

• n
• La piazza di n
• Il numero primo più vicino a n
• Il numero più vicino a nnella sequenza di Fibonacci

In breve, il programma dovrebbe stampare sullo standard output canale il risultato di (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Non devi preoccuparti di possibili trabocchi, ecc. Anche la normale precisione in virgola mobile è ok.

Il modo in cui viene fornito l'input dipende completamente da te. Il programma più breve (in caratteri) vince, come sempre con i golf di codice.

Nel caso in cui si verifichi un pareggio quando cerchi il più vicino, scegli una delle seguenti opzioni:

1. Vai su
2. Scendere
3. Scegli uno a caso

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 piccola spiegazione sulla parte più vicina:

Quando il ciclo while termina a è minore di N e b è uguale o maggiore di N. Ora la [b,a][2*N-a-b<0]parte. Guardalo come [b, a] [(Na) - (bN)]. (Na) è la differenza tra N e a e similmente (bN) la differenza tra b e N. Se la differenza tra questi due è inferiore a 0 significa che a è più vicina a N e viceversa.

GolfScript, 59 caratteri

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

Questo script non soddisfa alcuni dei requisiti:

• Funziona correttamente solo per gli input n >= 2, altrimenti si blocca.
• L'output viene troncato a un numero intero.
• Prestazioni terribili per qualsiasi moderatamente grande n

Una breve procedura dettagliata del codice:

1. ~:N..*L'ingresso è memorizzato in N e spingiamo subito entrambi ne il quadrato n*n.
2. .,2>Genereremo un elenco di numeri primi filtrando l'array [2..n*n]. Usiamo il nostro precedente calcolo di n*ncome (molto male!) Limite superiore per trovare un numero primo maggiore di n.
3. {:P{(.P\%}do(!},Il nostro array precedente è filtrato per divisione di prova. Ogni numero intero P viene testato rispetto a ogni numero intero [P-1..1].
4. {{N-.*}$0=}:C~Ordina la matrice precedente in base alla distanza ne prende il primo elemento. Ora abbiamo il numero primo più vicino.
5. [1.{.@+.N<}do]CGeneriamo Fibonnacis fino a quando non ne otteniamo uno maggiore n. Fortunatamente, questo algoritmo tiene naturalmente traccia dei precedenti Fibonnaci, quindi li gettiamo entrambi in un array e usiamo il nostro precedente ordinamento a distanza. Ora abbiamo il Fibonnaci più vicino.
6. +++4/Media. Nota che GolfScript non supporta i float, quindi il risultato viene troncato.

GolfScript, 81 caratteri

Ecco una variante che soddisfa tutti i requisiti.

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

Per garantire un comportamento corretto per n<2, evito 2<(si arresta in modo anomalo quando l'array è piccolo) e invece lo uso 3,|2,^. Questo si assicura che l'array candidato principale sia proprio [2]quando n < 2. Ho cambiato il limite superiore per il prossimo primo da n*na 2*n( postulato di Bertrand ). Inoltre, 0 è considerato un numero di Fibonnaci. Il risultato viene calcolato in matematica a virgola fissa alla fine. È interessante notare che il risultato è sempre in quarta (0, 0,25, 0,5, 75), quindi spero che siano sufficienti 2 decimali di precisione.

Il mio primo crack nell'uso di GolfScript, sono sicuro che ci sia spazio per miglioramenti!

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}

Non compresso:

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 byte

Un byte salvato grazie a Sp3000 (a volte i built-in non sono il modo migliore di procedere).

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

Questo definisce una funzione senza nome che prende un numero intero e produce la media esatta come un numero razionale. Nel caso di legami, viene scelto il numero primo / Fibonacci più piccolo.

Questo è molto inefficiente per input di grandi dimensioni, perché in realtà genera i primi 2nnumeri primi e numeri di Fibonacci prima di scegliere il più vicino.

Q, 119

Non il più efficiente.

{%[;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 è il tuo numero intero

Funziona con numeri non interi, per quanto ho provato funziona anche con numeri molto grandi, funziona anche abbastanza rapidamente.

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

Test e invocazione:

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 domanda parla any Integerma il problema non è così interessante per valori inferiori a 0. Tuttavia, come possiamo iniziare? A 0? A 1? E qual è il prossimo primo per 11? 11 stesso?

L'idea di consentire il prossimo più grande o più basso in caso di pareggio è cattiva, perché rende difficile il confronto inutile. Se i tuoi risultati differiscono, possono aver scelto l'altro fib, l'altro primo, l'altro primo e l'altro primo, o il tuo è sbagliato, oppure il risultato dell'altra persona è sbagliato, oppure è una combinazione: scelta diversa, ma sbagliato anche se, forse entrambi sbagliati.