Hilbert Primes Golf

18

Los números de Hilbert se definen como enteros positivos de la forma 4n + 1para n >= 0. Los primeros números de Hilbert son:

1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97

La secuencia numérica de Hilbert está dada por la secuencia OEIS A016813 .

Una secuencia numérica relacionada, los primos de Hilbert, se definen como los números de Hilbert H > 1que no son divisibles por ningún número de Hilbert ktal que 1 < k < H. Los primeros primos de Hilbert son:

5, 9, 13, 17, 21, 29, 33, 37, 41, 49, 53, 57, 61, 69, 73, 77, 89, 93, 97, 101, 109, 113, 121, 129, 133, 137, 141, 149, 157, 161, 173, 177, 181, 193, 197

Naturalmente, OEIS también tiene esta secuencia .

Dado un entero ntal que 0 <= n <= 2^16como entrada, salga el nth Hilbert prime.

Este es el código de golf , por lo que se aplican reglas estándar, y gana el código más corto en bytes.

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera la tabla de clasificación a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntuación, se puede mantener viejas cuentas en el título, golpeándolos a través. Por ejemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

## Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar fragmento de código

code-golf math number sequence number-theory Mego
fuente
Creo que quiere decir "no divisible por" en lugar de "relativamente primo con". 21 y 9 comparten un factor común de 3.
xnor

Respuestas:

3

Pyth, 21 bytes

Lh*4bye.fqZf!%yZyT1hQ

Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

Lh*4bye.fqZf!%yZyT1Q    implicit: Q = input number
L                       define a function y(b), which returns
 h*4b                      4*b + 1
                        this converts a index to its Hilbert number
       .f          hQ   find the first (Q+1) numbers Z >= 1, which satisfy:
           f      1        find the first number T >= 1, which satisfies:
            !%yZyT            y(Z) mod y(T) == 0
         qZ                test if the result is equal to Z 

                        this gives a list of indices of the first Q Hilbert Primes
      e                 take the last index
     y                  apply y and print
Jakube
fuente
11

Haskell, 46 bytes

(foldr(\a b->a:[x|x<-b,mod x a>0])[][5,9..]!!)

Una función anónima.

El núcleo es foldr(\a b->a:[x|x<-b,mod x a>0])[][5,9..], que itera a través de la progresión aritmética 5,9,13,..., eliminando múltiplos de cada uno de la lista a su derecha. Esto produce la lista infinita de primos de Hilbert. Luego, !!toma el nelemento th.

Intenté hacer un punto (\a b->a:[x|x<-b,mod x a>0])libre pero no encontré un camino más corto.

xnor
fuente
3
Convertir la foldrcomprensión en otra lista ahorra dos adiós:([x|x<-[5,9..],all((>0).mod x)[5,9..x-1]]!!)
nimi
@nimi Buena solución. Deberías publicar eso, es un método diferente. Lamento que sea más corto porque es más directo a la definición y la repetición de la lista es menos bonita.
xnor
4

CJam, 36 33 32 23 bytes

5ri{_L+:L;{4+_Lf%0&}g}*

Pruébalo en línea

La última versión es en realidad mucho más @ MartinBüttner que la mía. La idea clave en su solución sugerida es usar dos bucles anidados para encontrar el enésimo valor que cumple la condición. Pensé que estaba siendo inteligente al usar solo un bucle en mi solución original, pero resulta que la lógica agregada cuesta más de lo que ahorré al no usar un segundo bucle.

Explicación

5       Push first Hilbert prime.
ri      Get input n and convert to integer.
{       Loop n times.
  _       Push a copy of current Hilbert prime.
  L       Push list of Hilbert primes found so far (L defaults to empty list).
  +       Prepend current Hilbert prime to list.
  :L      Store new list of Hilbert primes in variable L.
  ;       Pop list off stack.
  {       Start while loop for finding next Hilbert prime.
    4+      Add 4 to get next Hilbert number.
    _       Copy candidate Hilbert number.
    L       Push list of Hilbert primes found so far.
    f%      Element wise modulo of Hilbert number with smaller Hilbert primes.
    0&      Check for 0 in list of modulo values.
  }g      End while loop.
}*      End loop n times.
Reto Koradi
fuente
2

Minkolang 0.14 , 46 37 32 bytes

No me di cuenta de que el gosub era totalmente innecesario ...> _>

n$z(xxi4*5+d(4-$d%)1=,z+$ziz-)N.

Pruébelo aquí y verifique todos los casos de prueba aquí .

Explicación

n$z                                 Take number from input and store it in the register
   (                                Open while loop
    xx                              Dump the stack
      i4*5+                         Loop counter times 4 plus 5 (Hilbert number)
           d                        Duplicate
            (                       Open while loop
             4-                     Subtract 4
               $d                   Duplicate stack
                 %                  Modulo
                  )                 Exit while loop when top of stack is 0
                   1=,              0 if 1, 1 otherwise
                      z             Push register value
                       +            Add
                        $z          Pop and store in register
                          iz-       Subtract z from loop counter
                             )      Exit while loop when top of stack is 0
                              N.    Output as number and stop.

El registro se utiliza para almacenar el índice de destino. El bucle while exterior calcula cada número de Hilbert y realiza un poco de contabilidad. El bucle while interno verifica la primalidad de cada número de Hilbert. Si un número de Hilbert no es un primo de Hilbert, entonces el objetivo se incrementa de modo que el bucle while externo tenga que repetirse (al menos) una vez más, omitiendo efectivamente los compuestos de Hilbert.

El'endia Starman
fuente
2

Mathematica, 65 bytes

Select[4Range[4^9]+1,Divisors[#][[2;;-2]]~Mod~4~FreeQ~1&][[#+1]]&

Genera la lista completa y selecciona el elemento de ella.

LegionMammal978
fuente
1

Rubí, 60 bytes.

h=->i{n=[];x=5;n.any?{|r|x%r<1}?x+=4: n<<x until e=n[i-1];e}

Solo verifica los factores primos de Hilbert.

MegaTom
fuente
0

JavaScript (ES6), 73 bytes

n=>{for(i=0,t=2;i<=n;)i+=!/^(.(....)+)\1+$/.test(Array(t+=4));return t-1}

Simplemente verifique los números de Hilbert uno por uno hasta que alcancemos el enésimo primer de Hilbert. La divisibilidad por número de Hilbert es manejada por regex.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
fuente
0

Matlab, 74 83 bytes

function t=H(n)
x=5;t=x;while nnz(x)<n
t=t+4;x=[x t(1:+all(mod(t,x)))];end

¡Gracias a Tom Carpenter por eliminar 9 bytes!

Ejemplo de uso:

>> H(20)
ans =
   101
Luis Mendo
fuente
@TomCarpenter ¡Gracias! Ahora esta respuesta es más tuya que mía :-)
Luis Mendo
De nada :). Sigue siendo tu lógica, solo apliqué algunos trucos que aprendí en el camino.
Tom Carpenter
0

Julia, 73 bytes

n->(a=[x=5];while length(a)<n;x+=4;all(k->mod(x,k)>0,a)&&push!(a,x)end;x)

¡Gracias Alex A. por guardar 11 bytes! Utiliza el mismo algoritmo que las respuestas de Matlab y Ruby. Dado que las matrices de Julia están indexadas, esto comienza conf(1) == 5 .

Mi primer intento, usando el paquete Lazy, es de 106 bytes . Si planea ejecutar esto en REPL, asegúrese de agregar punto y coma a los extremos de las líneas para suprimir la salida infinita. Y llame Pkg.Add("Lazy")si aún no lo tiene instalado.

using Lazy
r=range
h=r(1,Inf,4)
p=@>>r() filter(n->n!=1&&all(map(x->mod(h[n],h[x])<1,2:n-1)))
f=n->h[p[n]]
Andrew dice reinstalar a Mónica
fuente
1
73 bytes:n->(a=[x=5];while length(a)<n x+=4;all(k->mod(x,k)>0,a)&&push!(a,x)end;x)
Alex A.
1
Puede guardar algo más utilizando en endoflugar de lengthy en x%klugar de mod(x,k).
Alex A.