Ini adalah masalah matematika yang mempersoalkan banyak hal, membuatnya agak menantang, dan seperti yang bisa Anda duga, ini adalah kode golf, jadi harus sesingkat mungkin juga.

The masukan , n, adalah setiap bilangan bulat nomor (harus di bilangan bulat dukungan paling tidak, tetapi kebutuhan tidak terbatas pada). The Output adalah rata-rata dari:

• n
• Kuadrat dari n
• Nomor perdana terdekat n
• Angka terdekat dengan ndalam urutan Fibonacci

Tak lama, program harus mencetak ke output standar menyalurkan yang hasil dari(n+(n*n)+closestPrime(n)+closestFib(n))/4 .

Anda tidak perlu peduli dengan kemungkinan meluap dll. Presisi floating point normal juga ok.

Cara input diberikan sepenuhnya terserah Anda. Program terpendek (dalam karakter) menang, seperti biasa dengan kode golf.

Jika terjadi ikatan ketika Anda mencari yang terdekat, pilih salah satu dari yang berikut:

1. Naik
2. Turun
3. Pilih satu secara acak

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

Sedikit penjelasan tentang bagian terdekat:

Ketika loop sementara berakhir, lebih kecil dari N dan b sama dengan atau lebih besar dari N. Sekarang [b,a][2*N-a-b<0]bagian. Lihatlah itu sebagai [b, a] [(Na) - (bN)]. (Na) adalah perbedaan antara N dan a dan juga (bN) perbedaan antara b dan N. Jika perbedaan antara keduanya kurang dari 0 itu berarti a lebih dekat ke N dan sebaliknya.

GolfScript, 59 karakter

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

Skrip ini tidak memenuhi beberapa persyaratan:

• Ini hanya berfungsi dengan benar untuk input n >= 2 , jika tidak maka crash.
• Output dipotong ke integer.
• Performa mengerikan untuk semua yang cukup besar n

Panduan singkat dari kode:

1. ~:N..*Input disimpan dalam N, dan kami mendorong keduanya ndan kotak n*nsegera.
2. .,2>Kami akan menghasilkan daftar bilangan prima dengan memfilter array [2..n*n]. Kami menggunakan perhitungan sebelumnya n*nsebagai batas atas (sangat buruk!) Untuk menemukan bilangan prima yang lebih besar dari n.
3. {:P{(.P\%}do(!},Array kami sebelumnya difilter berdasarkan divisi percobaan. Setiap bilangan bulat P diuji terhadap setiap bilangan bulat [P-1..1].
4. {{N-.*}$0=}:C~ Mengurutkan array sebelumnya berdasarkan jarak ke n , dan meraih elemen pertama. Sekarang kita memiliki prime terdekat.
5. [1.{.@+.N<}do]C Kami menghasilkan Fibonnacis sampai kami mendapatkan yang lebih besar dari n . Untungnya, algoritma ini secara alami melacak Fibonnaci sebelumnya, jadi kami membuang keduanya dalam array dan menggunakan jenis jarak kami sebelumnya. Sekarang kami memiliki Fibonnaci terdekat.
6. +++4/Rata-rata Perhatikan bahwa GolfScript tidak memiliki dukungan untuk pelampung, sehingga hasilnya terpotong.

GolfScript, 81 karakter

Berikut adalah varian yang memenuhi semua persyaratan.

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

Untuk memastikan perilaku yang tepat untuk n<2 , saya menghindari 2<(crash ketika array kecil), dan sebagai gantinya digunakan 3,|2,^. Ini memastikan array kandidat utama tepat pada [2]waktunya n < 2. Saya mengubah batas atas untuk prime berikutnya dari n*nke 2*n( postulat Bertrand ). Juga, 0 dianggap sebagai nomor Fibonnaci. Hasilnya dihitung dalam matematika titik tetap di akhir. Menariknya, sepertinya hasilnya selalu di perempat (0, .25, .5, .75), jadi saya harap 2 tempat desimal presisi sudah cukup.

Celah pertama saya menggunakan GolfScript, saya yakin ada ruang untuk perbaikan!

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}

Terkompresi:

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

Satu byte disimpan berkat Sp3000 (terkadang built-in bukan cara terbaik untuk digunakan).

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

Ini mendefinisikan fungsi yang tidak disebutkan namanya mengambil bilangan bulat dan menghasilkan rata-rata yang tepat sebagai bilangan rasional. Dalam kasus ikatan, bilangan prima / Fibonacci yang lebih kecil dipilih.

Ini sangat tidak efisien untuk input besar, karena sebenarnya menghasilkan 2nbilangan prima dan Fibonacci pertama sebelum memilih yang terdekat.

Q, 119

Bukan yang paling efisien.

{%[;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 adalah bilangan bulat Anda

Bekerja dengan non integer, sejauh saya telah mengujinya bekerja dengan angka yang sangat besar juga, berjalan sangat cepat juga.

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

Tes dan doa:

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

Pertanyaannya berbicara tentang any Integertetapi masalahnya tidak begitu menarik untuk nilai di bawah 0. Namun - bagaimana kita memulai? Jam 0? Jam 1? Dan apa prime berikutnya untuk 11? 11 sendiri?

Gagasan untuk memperbolehkan yang berikutnya lebih besar atau lebih rendah dalam kasus dasi adalah buruk, karena itu membuat membandingkan tidak perlu sulit. Jika hasil Anda berbeda, mereka dapat memilih fib lainnya, prime lainnya, fib lainnya dan prime lainnya, atau Anda salah, atau hasil dari orang lain salah, atau itu adalah kombinasi: pilihan yang berbeda, tetapi salah meskipun, mungkin keduanya salah.