Это математическая задача, которая ставит под сомнение довольно много вещей, что делает ее довольно сложной, и, как вы уже догадались, это кодовый гольф, поэтому он должен быть как можно короче.

Ввода , nявляется любое целое число (должно по крайней мере поддержки целых чисел, но не обязательно должны быть ограничены). Выход является средним из:

• n
• Площадь n
• Ближайшее простое число к n
• Ближайшее число nв последовательности Фибоначчи

Вскоре программа должна печатать на стандартный вывод канала на результат в(n+(n*n)+closestPrime(n)+closestFib(n))/4 .

Ты не нужно заботиться о возможных переполнениях и т. Д. Нормальная точность с плавающей запятой тоже подойдет.

Способ ввода данных полностью зависит от вас. Самая короткая программа (в символах) выигрывает, как всегда, с кодом игры в гольф.

В случае, если при поиске ближайшего вам подходит галстук, выберите один из следующих вариантов:

1. Подниматься
2. Опускаться
3. Выберите один случайно

Python 160 символов

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

Небольшое объяснение о ближайшей части Фибоначчи:

Когда цикл while завершается, a меньше N, а b равно или больше N. Теперь [b,a][2*N-a-b<0]часть. Посмотрите на это как [b, a] [(Na) - (bN)]. (Na) - это разница между N и a и, аналогично (bN), разница между b и N. Если разница между этими двумя значениями меньше 0, это означает, что a ближе к N, и наоборот.

GolfScript, 59 символов

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

Этот скрипт не удовлетворяет некоторым требованиям:

• Работает корректно только для входов n >= 2 , в противном случае происходит сбой.
• Выходные данные усекаются до целого числа.
• Ужасная производительность для любого умеренно большого n

Краткое описание кода:

1. ~:N..*Ввод сохраняется в N, и мы сразу же нажимаем nи квадрат, и квадрат n*n.
2. .,2>Мы сгенерируем список простых чисел путем фильтрации массива [2..n*n]. Мы использовали наше предыдущее вычисление n*nв качестве (очень плохой!) Верхней границы для нахождения простого числа, большего чем n.
3. {:P{(.P\%}do(!},Наш предыдущий массив фильтруется пробным делением. Каждое целое число P проверяется на каждое целое число [P-1..1].
4. {{N-.*}$0=}:C~Сортирует предыдущий массив по расстоянию до nи получает первый элемент. Теперь у нас есть ближайший штрих.
5. [1.{.@+.N<}do]C Мы генерируем Фибоначчи, пока не получим n . К счастью, этот алгоритм естественным образом отслеживает предыдущие Фибоначчи, поэтому мы бросаем их обоих в массив и используем нашу раннюю сортировку по расстоянию. Теперь у нас есть самые близкие Фибоначчи.
6. +++4/Средний. Обратите внимание, что GolfScript не поддерживает поплавки, поэтому результат усекается.

GolfScript, 81 символ

Вот вариант, который отвечает всем требованиям.

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

Чтобы обеспечить правильное поведение для n<2, я избегаю 2<(сбой, когда массив маленький), и вместо этого использую 3,|2,^. Это гарантирует, что массив-кандидат будет именно [2]тогда, когда n < 2. Я изменил верхнюю границу для следующего простого числа с n*nна 2*n( постулат Бертрана ). Также 0 считается числом Фибоначчи. Результат рассчитывается по математике с фиксированной точкой в ​​конце. Интересно, что кажется, что результат всегда в четвертых (0, .25, .5, .75), поэтому я надеюсь, что 2 десятичных знака точности достаточно.

Моя первая попытка использования GolfScript, я уверен, что есть возможности для улучшения!

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}

несжатый:

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 байт

Один байт сохранен благодаря Sp3000 (иногда встроенные модули - не лучший способ).

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

Это определяет безымянную функцию, принимающую целое число и производящую точное среднее значение как рациональное число. В случае связей выбирается меньшее простое число / число Фибоначчи.

Это очень неэффективно для больших входов, потому что на самом деле генерирует первые 2nпростые числа и числа Фибоначчи, прежде чем выбирать самые близкие.

Q, 119

Не самый эффективный.

{%[;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 символов

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 ваше целое число

Работает с нецелыми числами, насколько я тестировал, он работает и с очень большими числами, тоже работает чертовски быстро.

Скала 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)}

Тест и вызов:

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

Вопрос говорит о том, any Integerно проблема не так интересна для значений ниже 0. Однако - с чего начать? В 0? На 1? А какой следующий прайм для 11? 11 сама?

Идея разрешить следующий больший или меньший в случае ничьей плоха, потому что это делает сравнение бесполезным. Если ваши результаты отличаются, они могли выбрать другой фиб, другой простейший, другой фиб и другой простый, или ваш неверный, или результат другого человека неверный, или это комбинация: другой выбор, но неправильно, хотя, может быть, оба не правы.