C'est un problème mathématique qui remet en question beaucoup de choses, ce qui le rend plutôt difficile, et comme vous l'avez peut-être deviné, c'est un golf de code, donc il devrait être aussi court que possible.

L' entrée , nest un nombre entier (devrait au moins prendre en charge les entiers, mais ne doit pas être limité à). La sortie est la moyenne de:

• n
• Le carré de n
• Le nombre premier le plus proche de n
• Le nombre le plus proche de ndans la séquence de Fibonacci

Peu de temps, le programme devrait imprimer sur la sortie standard canal le résultat de (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Vous n'avez pas à vous soucier des débordements possibles, etc. La précision normale en virgule flottante est également correcte.

La façon dont l'entrée est donnée dépend entièrement de vous. Le programme le plus court (en caractères) gagne, comme toujours avec les golfs à code.

Dans le cas où une égalité se produit lorsque vous recherchez le plus proche, choisissez l'une des options suivantes:

1. Monter
2. Descendre
3. Choisissez-en un au hasard

Python 160 caractères

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

Une petite explication sur la partie Fib la plus proche:

Lorsque la boucle while se termine, a est inférieur à N et b est égal ou supérieur à N. Maintenant, la [b,a][2*N-a-b<0]partie. Regardez-le comme [b, a] [(Na) - (bN)]. (Na) est la différence entre N et a et de même (bN) la différence entre b et N. Si la différence entre ces deux est inférieure à 0, cela signifie que a est plus proche de N et vice-versa.

GolfScript, 59 caractères

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

Ce script ne remplit pas certaines des conditions:

• Il ne fonctionne correctement que pour les entrées n >= 2, sinon il se bloque.
• La sortie est tronquée en un entier.
• Performances terribles pour tout modérément grand n

Une brève procédure pas à pas du code:

1. ~:N..*L'entrée est stockée dans N, et nous poussons les deux net le carré n*ntout de suite.
2. .,2>Nous allons générer une liste de nombres premiers en filtrant le tableau [2..n*n]. Nous utilisons notre calcul précédent n*ncomme limite supérieure (très mauvaise!) Pour trouver un nombre premier supérieur à n.
3. {:P{(.P\%}do(!},Notre tableau précédent est filtré par division d'essai. Chaque entier P est testé contre chaque entier [P-1..1].
4. {{N-.*}$0=}:C~Trie le tableau précédent en fonction de la distance net capture le premier élément. Nous avons maintenant le nombre premier le plus proche.
5. [1.{.@+.N<}do]CNous générons Fibonnacis jusqu'à ce que nous obtenions un supérieur à n. Heureusement, cet algorithme garde naturellement la trace de la Fibonnaci précédente, nous les jetons donc tous les deux dans un tableau et utilisons notre tri par distance antérieur. Nous avons maintenant la Fibonnaci la plus proche.
6. +++4/Moyenne. Notez que GolfScript ne prend pas en charge les flottants, donc le résultat est tronqué.

GolfScript, 81 caractères

Voici une variante qui répond à toutes les exigences.

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

Pour garantir un comportement correct pour n<2, j'évite 2<(se bloque lorsque le tableau est petit) et j'utilise à la place 3,|2,^. Cela garantit que le premier tableau de candidats est juste au [2]moment n < 2. J'ai changé la limite supérieure pour le prochain premier de n*nla 2*n( postulat de Bertrand ). De plus, 0 est considéré comme un nombre de Fibonnaci. Le résultat est calculé en mathématiques à virgule fixe à la fin. Fait intéressant, il semble que le résultat soit toujours en quart (0, 0,25, 0,5, 0,75), donc j'espère que 2 décimales de précision sont suffisantes.

Ma première fissure à utiliser GolfScript, je suis sûr qu'il y a place à amélioration!

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 compressé:

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 octets

Un octet sauvé grâce au Sp3000 (parfois les intégrés ne sont pas la meilleure solution).

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

Ceci définit une fonction sans nom prenant un entier et produisant la moyenne exacte comme un nombre rationnel. En cas d'égalité, le plus petit nombre premier / Fibonacci est choisi.

Ceci est très inefficace pour les entrées de grande taille, car il génère en fait les premiers 2nnombres premiers et Fibonacci avant de choisir le plus proche.

Q, 119

Pas le plus efficace.

{%[;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 caractères

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 est votre entier

Fonctionne avec des non entiers, pour autant que je l'ai testé, il fonctionne également avec de très grands nombres, fonctionne très vite aussi.

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 et invocation:

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 question parle any Integermais le problème n'est pas si intéressant pour les valeurs inférieures à 0. Cependant - comment commencer? À 0? À 1? Et quelle est la prochaine prime pour 11? 11 lui-même?

L'idée d'autoriser le prochain plus grand ou plus bas en cas d'égalité est mauvaise, car cela rend la comparaison inutile. Si vos résultats diffèrent, ils peuvent avoir choisi l'autre fib, l'autre prime, l'autre fib et l'autre prime, ou le vôtre est faux, ou le résultat de l'autre personne est faux, ou c'est une combinaison: choix différent, mais mal bien, peut-être les deux mal.