¿Cuál es el promedio de n, el primo más cercano a n, el cuadrado de ny el número de Fibonacci más cercano a n?


13

Este es un problema matemático que cuestiona muchas cosas, lo que lo hace bastante desafiante y, como habrás adivinado, es un código de golf, por lo que también debe ser lo más corto posible.

La entrada , nes cualquier número entero (al menos debe ser compatible con enteros, pero no debe limitarse a). La salida es el promedio de:

  • n
  • El cuadrado de n
  • El número primo más cercano a n
  • El número más cercano a nen la secuencia de Fibonacci

En breve, el programa debe imprimir en el canal de salida estándar el resultado de (n+(n*n)+closestPrime(n)+closestFib(n))/4.

Usted no tiene que preocuparse por posibles desbordamientos etc. normal coma flotante de precisión es también aceptable.

La forma en que se proporciona la entrada depende completamente de usted. El programa más corto (en caracteres) gana, como siempre con los códigos de golf.

En caso de que se produzca un empate cuando esté buscando el más cercano, elija una de las siguientes opciones:

  1. Subir
  2. Bajar
  3. Elige uno al azar

Definir "más cercano". ¿Cómo se rompen los lazos?
Peter Taylor

@ Peter Taylor: Mueve hacia arriba, hacia abajo o elige uno al azar.
Anto

Dé una muestra de entrada / salida para verificar las soluciones.
fR0DDY

Cuando dice "no debe limitarse a", ¿qué más debe admitirse? ¿O quiso decir "no necesita limitarse a"?
Timwi

@Timwi! "no es necesario", lo siento, lo arreglará
Anto

Respuestas:


10

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 pequeña explicación sobre la parte de fibra más cercana:

Cuando el ciclo while finaliza a es menor que N yb es igual o mayor que N. Ahora la [b,a][2*N-a-b<0]parte. Míralo como [b, a] [(Na) - (bN)]. (Na) es la diferencia entre N y a y de manera similar (bN) la diferencia entre by N. Si la diferencia entre estos dos es menor que 0, significa que a está más cerca de N y viceversa.


¿Podría agregar una explicación de por qué está funcionando esto?
Quijotesco

@Debanjan ¿Algo específico que quieras saber? Pensé que todo se explicaba por sí mismo. :)
fR0DDY

Solo un poco de la parte fib más cercana [b,a][2*N-a-b<0]:)
Quijotesco

7

GolfScript, 59 caracteres

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

Este script no cumple algunos de los requisitos:

  • Solo funciona correctamente para las entradas n >= 2, de lo contrario se bloquea.
  • La salida se trunca a un entero.
  • Terrible rendimiento para cualquier moderadamente grande n

Un breve tutorial del código:

  1. ~:N..*La entrada se almacena en N, y empujamos ambos ny el cuadrado de n*ninmediato.
  2. .,2>Generaremos una lista de números primos filtrando la matriz [2..n*n]. Utilizamos nuestro cálculo anterior de n*ncomo un límite superior (¡muy malo!) Para encontrar un primo mayor que n.
  3. {:P{(.P\%}do(!},Nuestra matriz anterior se filtra por división de prueba. Cada entero P se prueba contra cada entero [P-1..1].
  4. {{N-.*}$0=}:C~Ordena la matriz anterior en función de la distancia ny toma el primer elemento. Ahora tenemos el primo más cercano.
  5. [1.{.@+.N<}do]C Generamos Fibonnacis hasta obtener uno mayor que n . Afortunadamente, este algoritmo hace un seguimiento natural de Fibonnaci anterior, por lo que los colocamos en una matriz y usamos nuestra clasificación de distancia anterior. Ahora tenemos el Fibonnaci más cercano.
  6. +++4/Promedio. Tenga en cuenta que GolfScript no tiene soporte para flotantes, por lo que el resultado se trunca.

GolfScript, 81 caracteres

Aquí hay una variante que cumple con todos los requisitos.

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

Para garantizar un comportamiento adecuado n<2, evito 2<(se bloquea cuando la matriz es pequeña) y en su lugar la uso 3,|2,^. Esto asegura que la matriz de candidatos principales sea justo [2]cuando n < 2. Cambié el límite superior para la próxima prima de n*na 2*n( postulado de Bertrand ). Además, 0 se considera un número de Fibonnaci. El resultado se calcula en matemáticas de punto fijo al final. Curiosamente, parece que el resultado siempre está en cuartos (0, .25, .5, .75), por lo que espero que sean suficientes 2 decimales de precisión.

Mi primer intento de usar GolfScript, ¡estoy seguro de que hay margen de mejora!


77
Ya sabes, al dividir entre 4 no es terriblemente sorprendente que obtengas cuartos ;-)
Joey

...¡en efecto! +1;)
Mike Welsh

3

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}

Sin comprimir:

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

Para su función principal más cercana: creo que puede ahorrar espacio si usa just a=0e incrementa positivamente. En lugar de comprobar isPrimepara ay b, sólo comprobar isPrime(n+a)y isPrime(n-a). Probablemente podría mezclarlo todo en una declaración ternaria loca, pero soy terrible con javascript.
Sr. Llama

El siguiente parece que funciona bastante bien: function closestPrime(n,o){return isPrime(n+o)?n+o:isPrime(n-o)?n-o:closestPrime(n,o+1);}. Llámalo como closestPrime(n,0)y se resolverá solo. Acortar según sea necesario.
Sr. Llama

1

Mathematica, 70 69 bytes

Un byte guardado gracias a Sp3000 (a veces, las funciones integradas no son la mejor opción).

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

Esto define una función sin nombre que toma un número entero y produce la media exacta como un número racional. En el caso de los empates, se elige el número primo / Fibonacci más pequeño.

Esto es muy ineficiente para entradas grandes, porque en realidad genera los primeros 2nnúmeros primos y los números de Fibonacci antes de elegir el más cercano.


#&@@#.. eh?
seequ

@Sieg Comenzando desde la derecha: #es el argumento de una función pura (de f). En este caso, en realidad es una función en sí misma, ya que fse aplica a Primey Fibonacci. Entonces eso #@Range@...aplica la función dada a cada número entero en el rango. Entonces #&@@es solo una forma de golf para extraer el primer elemento de una lista. Funciona aplicando #&a la lista, que es una función que simplemente devuelve su primer argumento.
Martin Ender

0

Q, 119

No es el más eficiente.

{%[;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}

0

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 es tu número entero

Funciona con números no enteros, por lo que he probado, también funciona con números muy grandes, también se ejecuta bastante rápido.


0

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

Prueba e invocación:

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 pregunta habla any Integerpero el problema no es tan interesante para valores inferiores a 0. Sin embargo, ¿cómo comenzamos? A 0? ¿A la 1? ¿Y cuál es el próximo prime para 11? 11 en sí?

La idea de permitir el próximo más grande o más bajo en caso de empate es mala, porque dificulta la comparación innecesaria. Si sus resultados difieren, pueden haber elegido el otro fib, el otro primo, el otro fib y el otro primo, o los suyos son incorrectos, o el resultado de la otra persona es incorrecto, o es una combinación: opción diferente, pero mal aunque, quizás ambos mal.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.