Hilbert Primes Golf

18

Hilbert numaraları formun pozitif tamsayılar olarak tanımlanır 4n + 1için n >= 0. İlk birkaç Hilbert numarası:

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

Hilbert sayı dizisi OEIS dizisi A016813 ile verilir .

İlgili bir sayı dizisi, Hilbert asal, Hilbert sayı olarak tanımlandığı H > 1bir Hilbert sayısına göre bölünebilir değildir k, öyle ki 1 < k < H. İlk birkaç Hilbert primeri:

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

Doğal olarak, OEIS de bu diziye sahiptir .

Girdi ngibi bir tamsayı verildiğinde 0 <= n <= 2^16, nth Hilbert prime çıktı .

Bu kod golf , bu nedenle standart kurallar geçerlidir ve bayttaki en kısa kod kazanır.

Liderler Sıralaması

Bu yazının altındaki Yığın Parçacığı, a) her dil için en kısa çözüm listesi ve b) genel bir lider tablosu olarak cevaplardan lider tablosunu oluşturur.

Yanıtınızın göründüğünden emin olmak için lütfen aşağıdaki Markdown şablonunu kullanarak yanıtınızı bir başlıkla başlatın:

## Language Name, N bytes

Ngönderiminizin büyüklüğü nerede . Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğu veya yorumlayıcı bayrak cezalarını ayrı olarak listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını snippet'te görünecek bir bağlantı da yapabilirsiniz:

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

Kod snippet'ini göster

code-golf  math  number  sequence  number-theory 
— Mego
kaynak
Bence "nispeten asal" yerine "bölünemez" demek istediniz. 21 ve 9 ortak bir 3 faktörünü paylaşır.
— xnor

Yanıtlar:

3

Pyth, 21 bayt

Lh*4bye.fqZf!%yZyT1hQ

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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

Haskell, 46 bayt

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

Anonim bir işlev.

Çekirdek, foldr(\a b->a:[x|x<-b,mod x a>0])[][5,9..]aritmetik ilerleme boyunca yinelenen 5,9,13,...ve her birinin katlarını listeden sağa kaldıran çekirdektir . Bu, Hilbert primlerinin sonsuz listesini üretir. Ardından, th öğesini !!alır n.

(\a b->a:[x|x<-b,mod x a>0])Pointfree yapmayı denedim ama daha kısa bir yol bulamadım.

— XNOR
kaynak
3
Torna foldrbaşka liste anlayışı içine iki byes kaydeder:([x|x<-[5,9..],all((>0).mod x)[5,9..x-1]]!!)
— nimi
@nimi Güzel bir çözüm. Bunu göndermelisiniz, bu farklı bir yöntem. Üzgünüm, daha kısa çünkü listenin tanımına daha doğrudan ve listenin tekrarı daha az güzel.
— xnor
4

CJam, 36 33 32 23 bayt

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

Çevrimiçi deneyin

En son sürüm aslında MartinBüttner's benimkinden çok daha fazla. Önerilen çözümündeki anahtar fikir, koşulu karşılayan n'inci değeri bulmak için iki iç içe döngü kullanmaktır. Orijinal çözümümde sadece tek bir döngü kullanarak akıllı olduğumu düşündüm, ancak eklenen mantığın ikinci bir döngü kullanmadan tasarruf ettiğimden daha pahalı olduğu ortaya çıktı.

açıklama

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

Minkolang 0.14 , 46 37 32 bayt

Gosub'ın tamamen gereksiz olduğunun farkında değildim ...> _>

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

Burada deneyin ve tüm test senaryolarını buradan kontrol edin .

açıklama

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.

Kayıt, hedef dizini saklamak için kullanılır. Dış while döngüsü her Hilbert sayısını hesaplar ve bazı defter tutma yapar. İç while döngüsü her Hilbert sayısını öncelik açısından kontrol eder. Bir Hilbert sayısı Hilbert asal değilse , hedef artırılır, böylece dış while döngüsü bir kez daha (en az) tekrarlanır ve Hilbert kompozitlerini etkili bir şekilde atlar.

— El'endia Starman
kaynak
2

Mathematica, 65 bayt

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

Listenin tamamını oluşturur ve öğeyi listeden seçer.

— LegionMammal978
kaynak
1

Yakut, 60 bayt

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

Sadece Hilbert'in ana faktörlerini kontrol eder.

— Megatom
kaynak
0

JavaScript (ES6), 73 bayt

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

Hilbert sayılarını n. Hilbert'in başlangıcına ulaşıncaya kadar tek tek kontrol edin. Hilbert sayısına göre bölünebilirlik normal ifade ile ele alınmaktadır.

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

Matlab, 74 83 bayt

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

Tom Carpenter'a 9 bayt ayırdığı için teşekkürler!

Örnek kullanım:

>> H(20)
ans =
   101
— Luis Mendo
kaynak
@TomCarpenter Teşekkürler! Şimdi bu cevap benimkinden daha fazla :-)
— Luis Mendo
Rica ederim :). Hala senin mantığın, yol boyunca öğrendiğim birkaç püf noktası uyguladım.
— Tom Carpenter
0

Julia, 73 bayt

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

Alex A.'ye 11 bayt kaydettiğiniz için teşekkürler! Bu, Matlab ve Ruby'nin cevaplarıyla aynı algoritmayı kullanır. Julia dizileri tek endeksli olduğundan, bu ile başlar f(1) == 5.

Lazy paketini kullanarak ilk denemem 106 bayt . Bunu REPL'de çalıştırmayı planlıyorsanız, sonsuz çıktıyı bastırmak için satırların sonuna noktalı virgül eklediğinizden emin olun. Ve Pkg.Add("Lazy")zaten yüklemediyseniz arayın .

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 Reinstate Monica diyor
kaynak
1
73 bayt:n->(a=[x=5];while length(a)<n x+=4;all(k->mod(x,k)>0,a)&&push!(a,x)end;x)
— Alex
1
endofYerine lengthve x%kyerine kullanarak biraz daha tasarruf edebilirsiniz mod(x,k).
— Alex
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.