Hilbert Primes Golf

18

I numeri di Hilbert sono definiti come numeri interi positivi del modulo 4n + 1per n >= 0. I primi numeri di Hilbert sono:

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 sequenza numerica di Hilbert è data dalla sequenza OEIS A016813 .

Una sequenza numerica correlata, i numeri primi di Hilbert, sono definiti come numeri di Hilbert H > 1che non sono divisibili per nessun numero di Hilbert ktale che 1 < k < H. I primi numeri primi di Hilbert sono:

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, anche OEIS ha questa sequenza .

Dato un numero intero ntale che 0 <= n <= 2^16come input, genera il nprimo di Hilbert.

Questo è code-golf , quindi si applicano le regole standard e vince il codice più breve in byte.

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  math  number  sequence  number-theory 
— Mego
fonte
Penso che intendi "non divisibile per" invece di "relativamente prime con". 21 e 9 condividono un fattore comune di 3
— xnor

Risposte:

3

Pyth, 21 byte

Lh*4bye.fqZf!%yZyT1hQ

Provalo online: Dimostrazione o Test Suite

Spiegazione:

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
fonte
11

Haskell, 46 byte

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

Una funzione anonima.

Il nucleo è foldr(\a b->a:[x|x<-b,mod x a>0])[][5,9..], che scorre attraverso la progressione aritmetica 5,9,13,..., rimuovendo i multipli di ciascuno dall'elenco alla sua destra. Questo produce l'elenco infinito di numeri primi di Hilbert. Quindi, !!prende l' nelemento th.

Ho provato a rendere (\a b->a:[x|x<-b,mod x a>0])inutile ma non ho trovato un modo più breve.

— XNOR
fonte
3
Trasformando la foldrcomprensione in un'altra lista si risparmiano due ciao:([x|x<-[5,9..],all((>0).mod x)[5,9..x-1]]!!)
— nimi
@nimi Bella soluzione. Dovresti pubblicarlo, è un metodo diverso. Sono triste ma è più breve perché è più diretto alla definizione e la ripetizione della lista è meno carina.
— xnor
4

CJam, 36 33 32 23 byte

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

Provalo online

L'ultima versione è in realtà molto più di MartinBüttner della mia. L'idea chiave nella sua soluzione suggerita è quella di utilizzare due cicli nidificati per trovare l'ennesimo valore che soddisfa la condizione. Pensavo di essere intelligente usando solo un singolo loop nella mia soluzione originale, ma risulta che la logica aggiunta costava più di quanto risparmiassi non usando un secondo loop.

Spiegazione

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
fonte
2

Minkolang 0.14 , 46 37 32 byte

Non mi rendevo conto che il gosub era totalmente inutile ...> _>

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

Provalo qui e controlla tutti i casi di test qui .

Spiegazione

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.

Il registro viene utilizzato per memorizzare l'indice di destinazione. Il ciclo while esterno calcola ciascun numero di Hilbert ed esegue una contabilità. Il ciclo while interno controlla la primalità di ciascun numero di Hilbert. Se un numero di Hilbert non è un numero primo di Hilbert, il target viene incrementato in modo tale che il ciclo while esterno debba ripetere (almeno) ancora una volta, saltando efficacemente i compositi di Hilbert.

— El'endia Starman
fonte
2

Mathematica, 65 byte

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

Genera l'intero elenco e seleziona l'elemento da esso.

— LegionMammal978
fonte
1

Rubino, 60 byte

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

Controlla solo i fattori primi di Hilbert.

— Megatom
fonte
0

JavaScript (ES6), 73 byte

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

Controlla i numeri di Hilbert uno a uno fino a raggiungere l'ennesimo numero primo di Hilbert. La divisibilità per numero Hilbert è gestita da regex.

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
fonte
0

Matlab, 74 83 byte

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

Grazie a Tom Carpenter per aver rimosso 9 byte!

Esempio di utilizzo:

>> H(20)
ans =
   101
— Luis Mendo
fonte
@TomCarpenter Grazie! Ora questa risposta è più tua della mia :-)
— Luis Mendo l'
Prego :). È ancora la tua logica, ho appena applicato alcuni trucchi che ho imparato lungo la strada.
— Tom Carpenter,
0

Julia, 73 byte

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

Grazie Alex A. per aver salvato 11 byte! Questo utilizza lo stesso algoritmo delle risposte Matlab e Ruby. Poiché le matrici Julia sono a un indice, questo inizia con f(1) == 5.

Il mio primo tentativo, usando il pacchetto Lazy, è di 106 byte . Se si prevede di eseguirlo nel REPL, assicurarsi di aggiungere punti e virgola alle estremità delle righe per sopprimere l'output infinito. E chiama Pkg.Add("Lazy")se non lo hai già installato.

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 Reinstate Monica
fonte
1
73 byte: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
Puoi salvare un po 'di più usando endofinvece di lengthe x%kinvece di mod(x,k).
— Alex A.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.