Jest to problem matematyczny, który poddaje w wątpliwość wiele rzeczy, co sprawia, że ​​jest to dość trudne, a jak można się domyślić, jest to golf golfowy, więc powinien być jak najkrótszy.

Wejście , nto dowolny całkowita liczba (powinien przynajmniej całkowite wsparcie, ale nie muszą być ograniczone do). Wyjściowa jest średnią z:

• n
• Kwadrat z n
• Najbliższa liczba pierwsza do n
• Najbliższa liczba nw sekwencji Fibonacciego

Krótko, program powinien wydrukować na standardowe wyjście kanał ten wynik z (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Ty nie musisz się martwić o ewentualne przelewy itd. Normalne zmiennoprzecinkową dokładność jest również ok.

Sposób wprowadzania danych zależy wyłącznie od Ciebie. Najkrótszy program (w postaci znaków) wygrywa, jak zawsze w golfach kodowych.

W przypadku remisu, gdy szukasz najbliższego, wybierz jedną z następujących opcji:

1. Wchodzić
2. Spadać
3. Wybierz jeden losowo

Python 160 znaków

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

Małe wyjaśnienie na temat najbliższej części Fib:

Kiedy pętla while kończy się, a jest mniejsze niż N, a b jest równe lub większe niż N. Teraz [b,a][2*N-a-b<0]część. Spójrz na to jako [b, a] [(Na) - (bN)]. (Na) jest różnicą między N a a i podobnie (bN) różnicą między b a N. Jeśli różnica między tymi dwoma jest mniejsza niż 0, oznacza to, że a jest bliższe N ​​i odwrotnie.

GolfScript, 59 znaków

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

Ten skrypt nie spełnia niektórych wymagań:

• Działa poprawnie tylko dla danych wejściowych n >= 2, w przeciwnym razie ulega awarii.
• Dane wyjściowe są obcinane do liczby całkowitej.
• Straszna wydajność dla każdego umiarkowanie dużego n

Krótki przewodnik po kodzie:

1. ~:N..*Dane wejściowe są przechowywane w N, a my od razu popychamy oba ni kwadrat n*n.
2. .,2>Wygenerujemy listę liczb pierwszych, filtrując tablicę [2..n*n]. Używamy naszych poprzednich obliczeń n*njako (bardzo źle!) Górnej granicy do znalezienia liczby pierwszej większej niż n.
3. {:P{(.P\%}do(!},Nasza poprzednia tablica jest filtrowana według podziału próbnego. Każda liczba całkowita P jest testowana z każdą liczbą całkowitą [P-1..1].
4. {{N-.*}$0=}:C~Sortuje poprzednią tablicę na podstawie odległości do ni pobiera pierwszy element. Teraz mamy najbliższą liczbę pierwszą.
5. [1.{.@+.N<}do]CGenerujemy Fibonnacis, dopóki nie otrzymamy jednego większego niż n. Na szczęście ten algorytm naturalnie śledzi poprzednie Fibonnaci, więc rzucamy je zarówno do tablicy, jak i używamy naszego wcześniejszego sortowania odległości. Teraz mamy najbliższy Fibonnaci.
6. +++4/Średni. Zauważ, że GolfScript nie obsługuje pływaków, więc wynik jest obcinany.

GolfScript, 81 znaków

Oto wariant, który spełnia wszystkie wymagania.

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

Aby zapewnić prawidłowe zachowanie n<2, unikam 2<(ulega awarii, gdy tablica jest mała), a zamiast tego używam 3,|2,^. To gwarantuje, że główna tablica kandydująca jest właśnie [2]wtedy n < 2. Zmieniłem górną granicę następnej liczby pierwszej z n*nna 2*n( postulat Bertranda ). Również 0 jest uważane za liczbę Fibonnaci. Wynik jest obliczany w matematyce punktu końcowego na końcu. Co ciekawe, wydaje się, że wynik jest zawsze w czwartych (0, .25, .5, .75), więc mam nadzieję, że 2 miejsca dziesiętne dokładności wystarczą.

Mój pierwszy błąd w korzystaniu z GolfScript, jestem pewien, że jest miejsce na ulepszenia!

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}

Nieskompresowane:

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 bajtów

Jeden bajt zaoszczędzony dzięki Sp3000 (czasem wbudowane nie są najlepszym sposobem na przejście).

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

Definiuje to nienazwaną funkcję przyjmującą liczbę całkowitą i wytwarzającą dokładną średnią jako liczbę wymierną. W przypadku więzi wybierana jest mniejsza liczba pierwsza / liczba Fibonacciego.

Jest to bardzo nieefektywne w przypadku dużych nakładów, ponieważ w rzeczywistości generuje pierwsze 2nliczby pierwsze i liczby Fibonacciego przed wybraniem najbliższego.

Q, 119

Nie najbardziej wydajny.

{%[;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 znaków

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 jest twoją liczbą całkowitą

Działa z liczbami niecałkowitymi, o ile testowałem, działa również z bardzo dużymi liczbami, działa też cholernie szybko.

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 i wywołanie:

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

Pytanie mówi, any Integerale problem nie jest interesujący dla wartości poniżej 0. Jednak - jak zacząć? 0? O 1? A jaka jest następna liczba pierwsza dla 11? 11 samo?

Pomysł, aby pozwolić na następny większy lub niższy w przypadku remisu, jest zły, ponieważ utrudnia porównywanie niepotrzebnych. Jeśli twoje wyniki się różnią, mogą wybrać inne włókno, drugie włókno, inne włókno i inne ziarno, lub twoje są złe, lub wynik drugiej osoby jest zły, lub jest to kombinacja: inny wybór, ale źle, ale może oba źle.