हिल्बर्ट प्राइम्स गोल्फ

18

हिल्बर्ट संख्या प्रपत्र के सकारात्मक पूर्णांक के रूप में परिभाषित कर रहे हैं 4n + 1के लिए n >= 0। पहले कुछ हिल्बर्ट संख्या हैं:

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

हिल्बर्ट संख्या अनुक्रम OEIS अनुक्रम A016813 द्वारा दिया गया है ।

इससे संबंधित एक संख्या अनुक्रम, हिल्बर्ट अभाज्य संख्या, हिल्बर्ट संख्या के रूप में परिभाषित कर रहे हैं H > 1कि किसी भी हिल्बर्ट संख्या से विभाज्य नहीं कर रहे हैं kजैसे कि 1 < k < H। पहले कुछ हिल्बर्ट primes हैं:

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

स्वाभाविक रूप से, OEIS में भी यही क्रम है ।

पूर्णांक को देखते हुए nजैसे कि 0 <= n <= 2^16इनपुट, आउटपुट nवें हिल्बर्ट प्राइम।

यह कोड-गोल्फ है , इसलिए मानक नियम लागू होते हैं, और बाइट्स में सबसे छोटा कोड जीतता है।

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) ए प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

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

कोड स्निपेट दिखाएं

code-golf  math  number  sequence  number-theory 
— मै जाऊं
स्रोत
मुझे लगता है कि आप "अपेक्षाकृत प्रमुख के बजाय" से "विभाज्य नहीं" का मतलब है। 21 और 9 का साझा कारक 3 है
— xnor

जवाबों:

3

पायथ, 21 बाइट्स

Lh*4bye.fqZf!%yZyT1hQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

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
स्रोत
11

हास्केल, 46 बाइट्स

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

एक अनाम फ़ंक्शन।

कोर है foldr(\a b->a:[x|x<-b,mod x a>0])[][5,9..], जो अंकगणित की प्रगति के माध्यम से पुनरावृत्ति 5,9,13,...करता है, सूची से प्रत्येक के गुणकों को हटाकर उसके दाईं ओर। यह हिल्बर्ट primes की अनंत सूची का उत्पादन करता है। फिर, वें तत्व को !!लेता है n।

मैं (\a b->a:[x|x<-b,mod x a>0])बिंदु बनाने की कोशिश की है, लेकिन एक छोटा रास्ता नहीं मिला।

— XNOR
स्रोत
3
टर्निंग foldr: एक और सूची समझ में दो बाई की बचत होती है([x|x<-[5,9..],all((>0).mod x)[5,9..x-1]]!!)
— nimi
@ निम्मी अच्छा समाधान। आपको यह पोस्ट करना चाहिए, यह एक अलग तरीका है। मुझे दुख है कि यह छोटा है, क्योंकि यह परिभाषा के लिए अधिक प्रत्यक्ष है और सूची की पुनरावृत्ति कम सुंदर है।
— xnor
4

CJam, 36 33 32 23 बाइट्स

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

इसे ऑनलाइन आज़माएं

नवीनतम संस्करण वास्तव में बहुत अधिक @ मार्टिनबटनर के मुकाबले मेरा है। उनके सुझाए गए समाधान में मुख्य विचार यह है कि शर्त को पूरा करने वाले एन-वें मूल्य को खोजने के लिए दो नेस्टेड छोरों का उपयोग करना है। मुझे लगा कि मैं अपने मूल समाधान में केवल एक लूप का उपयोग करके चालाक हो रहा हूं, लेकिन यह पता चला है कि जोड़े गए तर्क की लागत मैंने एक दूसरे लूप का उपयोग न करके जितनी बचत की है।

व्याख्या

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.
— रेटो कोराडी
स्रोत
2

मिन्कोलांग 0.14 , 46 37 32 बाइट्स

मुझे महसूस नहीं हुआ कि गोसब पूरी तरह से अनावश्यक था ...> _>

n$z(xxi4*5+d(4-$d%)1=,z+$ziz-)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.

रजिस्टर का उपयोग लक्ष्य सूचकांक को संग्रहीत करने के लिए किया जाता है। बाहरी जबकि लूप प्रत्येक हिल्बर्ट संख्या की गणना करता है और कुछ बहीखाता करता है। आंतरिक लूप प्रत्येक हिल्बर्ट की संख्या की जांच करता है। यदि एक हिल्बर्ट संख्या एक हिल्बर्ट प्राइम नहीं है, तो लक्ष्य को बढ़ा दिया जाता है ताकि बाहरी जबकि लूप को एक बार फिर (कम से कम) एक बार, प्रभावी ढंग से हिल्बर्ट कंपोजिट को दोहराना पड़े।

— एलेंडिया स्ट्राटन
स्रोत
2

गणितज्ञ, 65 बाइट्स

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

संपूर्ण सूची बनाता है और उसमें से तत्व का चयन करता है।

— LegionMammal978
स्रोत
1

रूबी, 60 बाइट्स

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

केवल हिल्बर्ट प्राइम कारकों की जाँच करता है।

— MegaTom
स्रोत
0

जावास्क्रिप्ट (ईएस 6), 73 बाइट्स

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

जब तक हम n n हिल्बर्ट प्राइम तक नहीं पहुँचते, तब तक एक-एक करके हिल्बर्ट नंबरों की जाँच करें। हिल्बर्ट संख्या द्वारा विभाजन को रेगेक्स द्वारा नियंत्रित किया जाता है।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत
0

मतलाब, 74 83 बाइट्स

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

9 बाइट निकालने के लिए टॉम बढ़ई का धन्यवाद!

उदाहरण का उपयोग करें:

>> H(20)
ans =
   101
— लुइस मेंडो
स्रोत
@TomCarpenter धन्यवाद! अब यह उत्तर मेरा तुम्हारा अधिक है :-)
— लुइस मेंडू
आपका स्वागत है :)। यह अभी भी आपका तर्क है, बस कुछ तरकीबें लागू की हैं जो मैंने रास्ते में सीखी हैं।
— टॉम कारपेंटर
0

जूलिया, 73 बाइट्स

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

11 बाइट्स बचाने के लिए धन्यवाद एलेक्स ए! यह मैटलैब और रूबी के उत्तर के समान एल्गोरिथ्म का उपयोग करता है। चूंकि जूलिया सरणियाँ एक-अनुक्रमित हैं, यह इसके साथ शुरू होती है f(1) == 5।

मेरा पहला प्रयास, आलसी पैकेज का उपयोग करते हुए, 106 बाइट्स है । यदि आप आरईपीएल में इसे चलाने की योजना बनाते हैं, तो अनंत आउटपुट को दबाने के लिए लाइनों के सिरों पर अर्धविराम जोड़ना सुनिश्चित करें। और कॉल करें Pkg.Add("Lazy")यदि आपके पास पहले से यह स्थापित नहीं है।

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]]
— एंड्रयू का कहना है कि मोनिका की बहाली करें
स्रोत
1
73 बाइट्स:n->(a=[x=5];while length(a)<n x+=4;all(k->mod(x,k)>0,a)&&push!(a,x)end;x)
— एलेक्स ए।
1
के endofबजाय lengthऔर के x%kबजाय का उपयोग करके आप कुछ और बचा सकते हैं mod(x,k)।
— एलेक्स ए।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.