यह एक संख्या है?

37

एक प्रोथ नंबर , जिसका नाम फ्रांकोइस प्रोथ है, एक ऐसी संख्या है जिसे व्यक्त किया जा सकता है

N = k * 2^n + 1

kएक विषम धनात्मक पूर्णांक कहाँ है और nएक धनात्मक पूर्णांक ऐसा है 2^n > k। आइए एक अधिक ठोस उदाहरण का उपयोग करें। टेक 3. 3 एक प्रोथ नंबर है क्योंकि इसे लिखा जा सकता है

(1 * 2^1) + 1

और 2^1 > 1संतुष्ट है। 5 एक संख्या भी है क्योंकि इसे लिखा जा सकता है

(1 * 2^2) + 1

और 2^2 > 1संतुष्ट है। हालांकि, 7 एक प्रोथ नंबर नहीं है क्योंकि इसे फॉर्म में लिखने का एकमात्र तरीका N = k * 2^n + 1है

(3 * 2^1) + 1

और 2^1 > 3संतुष्ट नहीं है।

आपकी चुनौती काफी सरल है: आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा, जो एक पोस्टिव पूर्णांक देता है, यह निर्धारित करता है कि यह एक प्रॉथ नंबर है या नहीं। आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं, और अगर यह नहीं है तो यह एक संख्या और गलत मूल्य है, तो एक सत्य मूल्य का उत्पादन करना चाहिए। यदि आपकी भाषा में कोई "प्रोथ-नंबर डिटेक्टिंग" फ़ंक्शन है, तो आप उनका उपयोग कर सकते हैं।

परीक्षण IO

यहाँ 1000 तक पहले 46 प्रोथ नम्बर हैं । ( A080075 )

3, 5, 9, 13, 17, 25, 33, 41, 49, 57, 65, 81, 97, 113, 129, 145, 161, 177, 193, 209, 225, 241, 257, 289, 321, 353, 385, 417, 449, 481, 513, 545, 577, 609, 641, 673, 705, 737, 769, 801, 833, 865, 897, 929, 961, 993

हर दूसरे वैध इनपुट को मिथ्या मूल्य देना चाहिए।

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

संख्या सिद्धांत मजेदार तथ्य तथ्य नोट:

सबसे बड़ा ज्ञात प्रधानमंत्री है कि नहीं एक Mersenne प्रधानमंत्री है 19249 * 2^13018586 + 1जो सिर्फ इतना भी एक Proth संख्या होने के लिए होता है,!

code-golf  math  sequence  number-theory  decision-problem 
— DJMcMayhem
स्रोत

जवाबों:

41

जेली , 5 बाइट्स

’&C²>

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

चलो जे एक सख्ती से पूर्णांक होना। j + 1 टॉगल के सभी अनुगामी सेट बिट्स जे और आसन्न सेट नहीं बिट। उदाहरण के लिए, 10011 2 + 1 = 10100 2 ।

चूँकि ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , इसलिए -n ऊपर से लागू होता है बिट ऑफ़ NOT j (जो सभी बिट्स को टॉगल करता है), इस प्रकार अंतिम से पहले सभी बिट्स को टॉगल करना। १ ।

J &j को लेने से - j का बिट वाइज और j -j - अंतिम सेट बिट के पहले और बाद के सभी बिट्स nullified हैं (चूंकि j और -j में असमान हैं ), इस प्रकार 2 की उच्चतम शक्ति का उत्पादन होता है जो समान रूप से j को विभाजित करता है ।

के लिए इनपुट एन , हम करने के लिए ऊपर लागू करना चाहते हैं 1 - एन लगाने के लिए 2 एन , की सर्वोच्च शक्ति 2 कि विभाजित 1 - एन । यदि m = N - 1 , -m = - (N - 1) = 1 - N , तो (N - 1) & (1 - N) पैदावार 2 n ।

सभी परीक्षण के लिए छोड़ दिया जाता है अगर 2 n > k है । यदि k> 0 , यह सत्य है यदि और केवल यदि (2 n ) 2 > k2 n , जो कि यदि और केवल यदि (2 n ) 2 2 k2 n + 1 = N है, तो स्वयं सत्य है ।

अंत में, यदि (2 एन ) 2 = एन = के 2 एन + 1 , 2 एन विषम ( 1 ) होना चाहिए , तो दोनों पक्षों के समानताएं मेल खा सकती हैं, जिसका अर्थ है कि के = 0 और एन = 1 । इस मामले में (एन - 1) और (1 - एन) = 0 और 0 = 0 और ((एन - 1) और ((1 - एन)) 2 = 0 <1 = एन ।

इसलिए, ((एन - 1) और ((1 - एन)) 2 > एन सच है अगर और केवल अगर एन एक प्रॉथ नंबर है।

यह काम किस प्रकार करता है

’&C²>  Main link. Argument: N

’      Decrement; yield N - 1.
  C    Complement; yield 1 - N.
 &     Take the bitwise AND of both results.
   ²   Square the bitwise AND.
    >  Compare the square to N.
— डेनिस
स्रोत
ओह। अविश्वसनीय अविश्वसनीय
— उज्ज्वल
46

पायथन, 22 बाइट्स

lambda N:N-1&1-N>N**.5

यह मेरे जेली उत्तर का एक बंदरगाह है । Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

चलो जे एक सख्ती से पूर्णांक होना। j + 1 टॉगल के सभी अनुगामी सेट बिट्स जे और आसन्न सेट नहीं बिट। उदाहरण के लिए, 10011 2 + 1 = 10100 2 ।

चूँकि ~ j = - (j + 1) = -j - 1 , -j = ~ j + 1 , इसलिए -n ऊपर से लागू होता है बिट ऑफ़ NOT j (जो सभी बिट्स को टॉगल करता है), इस प्रकार अंतिम से पहले सभी बिट्स को टॉगल करना। १ ।

J &j को लेने से - j का बिट वाइज और j -j - अंतिम सेट बिट के पहले और बाद के सभी बिट्स nullified हैं (चूंकि j और -j में असमान हैं ), इस प्रकार 2 की उच्चतम शक्ति का उत्पादन होता है जो समान रूप से j को विभाजित करता है ।

के लिए इनपुट एन , हम करने के लिए ऊपर लागू करना चाहते हैं 1 - एन लगाने के लिए 2 एन , की सर्वोच्च शक्ति 2 कि विभाजित 1 - एन । यदि m = N - 1 , -m = - (N - 1) = 1 - N , तो (N - 1) & (1 - N) पैदावार 2 n ।

सभी परीक्षण के लिए छोड़ दिया जाता है अगर 2 n > k है । यदि k> 0 , यह सत्य है यदि और केवल यदि (2 n ) 2 > k2 n , जो कि यदि और केवल यदि (2 n ) 2 2 k2 n + 1 = N है, तो स्वयं सत्य है ।

अंत में, यदि (2 एन ) 2 = एन = के 2 एन + 1 , 2 एन विषम ( 1 ) होना चाहिए , तो दोनों पक्षों के समानताएं मेल खा सकती हैं, जिसका अर्थ है कि के = 0 और एन = 1 । इस मामले में (एन - 1) और (1 - एन) = 0 और 0 = 0 और ((एन - 1) और ((1 - एन)) 2 = 0 <1 = एन ।

इसलिए, ((एन - 1) और ((1 - एन)) 2 > एन सच है अगर और केवल अगर एन एक प्रॉथ नंबर है।

फ्लोटिंग पॉइंट अशुद्धि को अनदेखा करना, यह N-1&1-N>N**.5कार्यान्वयन में कोड के बराबर है ।

— डेनिस
स्रोत
23
मैं लगातार Math.SE, और मेरी आँखें वास्तव में 90 के दशक की साइट की तरह दिखने के बजाय इस साइट पर सुंदर लाटेक्स की कामना करती हैं ...
— qwr
यह मेरा पसंदीदा है।
— Qix
9

गणितज्ञ, 50 48 45 40 38 35 31 29 बाइट्स

Mathematica आम तौर पर बेकार हो जाता है जब यह कोड गोल्फ की बात आती है, लेकिन कभी-कभी इसमें एक अंतर्निहित होता है जिससे चीजें वास्तव में अच्छी लगती हैं।

1<#<4^IntegerExponent[#-1,2]&

एक परीक्षा:

Reap[Do[If[f[i],Sow[i]],{i,1,1000}]][[2,1]]

{3, 5, 9, 13, 17, 25, 33, 41, 49, 57, 65, 81, 97, 113, 129, 145, 161, 177, 193, 209, 225, 241, 257, 289, 321, 353, 385, 417, 449, 481, 513, 545, 577, 609, 641, 673, 705, 737, 769, 801, 833, 865, 897, 929, 961, 993}

संपादित करें: वास्तव में, अगर मैं डेनिस के बिटवाइज और विचार को चुरा लेता हूं, तो मैं इसे 23 22 20 बाइट तक ले सकता हूं ।

गणितज्ञ, २३ २२ २० बाइट्स (धन्यवाद ए सिमंस )

BitAnd[#-1,1-#]^2>#&
— माइकल ली
स्रोत
2
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! :)
— अदनान
1
के साथ शुरू करने की कोई ज़रूरत नहीं है g=, एक शुद्ध कार्य ठीक है!
— एक सीमन्स
आह मधुर। अब निश्चित कर दिया।
— माइकल ली
वैसे, आपके परीक्षण को काफी सरल बनाया जा सकता है Select[Range@1000,f]।
— नंबरमान
8

05AB1E , 14 10 बाइट्स

4 बाइट बचाने के लिए Emigna को धन्यवाद !

कोड:

<©Ó¬oD®s/›

का उपयोग करता है CP-1252 एन्कोडिंग का । इसे ऑनलाइन आज़माएं! ।

स्पष्टीकरण:

स्पष्टीकरण के लिए, आइए 241 नंबर का उपयोग करें । हम पहले एक-एक करके संख्या घटाते हैं <। इसका परिणाम 240 है । अब, हम मुख्य कारकों (डुप्लिकेट के साथ) का उपयोग करके गणना करते हैं Ò। प्रमुख कारक हैं:

[2, 2, 2, 2, 3, 5]

हमने उन्हें दो भागों में विभाजित किया। का उपयोग करते हुए 2Q·0K, हम दो की सूची प्राप्त करते हैं:

[2, 2, 2, 2]

साथ ®2Kमें, हम शेष संख्या की सूची मिलती है:

[3, 5]

अंत में, दोनों का उत्पाद लें। 16[2, 2, 2, 2] में परिणाम । 15 में परिणामों का उत्पाद ।[3, 5]

यह परीक्षण मामला 16 > 15 के बाद से सत्य है ।

— अदनान
स्रोत
<©Ó¬oD®s/›या <DÓ0èoDŠ/›10. के लिए
— एमिग्ना
@Eignign कि प्रतिभा है! धन्यवाद :)।
— अदनान
7

ब्रेन-फ्लैक , 460 350 270 266 264 188 176 बाइट्स

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

({}[()])(((<>()))){{}([(((({}<(({}){})>){}){})<>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}}(<{}{}>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<>)

व्याख्या

कार्यक्रम दो और चार की शक्तियों से गुजरता है जब तक कि यह एन -1 की तुलना में दो की शक्ति नहीं पाता है। जब यह पाता है कि यह modulo का उपयोग करके दो की शक्ति द्वारा N-1 की विभाज्यता की जांच करता है और परिणाम को आउटपुट करता है

({}[()])      #Subtract one from input
(((<>())))    #Put three ones on the other stack
{
 {}           #Pop the crap off the top
 ([(
  ((({}<(({}){})>){}){}) #Multiply the top by four and the bottom by two
  <>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{} #Check if the power of four is greater than N-1
}
(<{}{}>) #Remove the power of 4
<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>) #Modulo N-1 by the power of two

यह कार्यक्रम स्वच्छ नहीं है। यदि आप एक अतिरिक्त 4 बाइट्स जोड़ते हैं, तो आप इसे साफ कर सकते हैं:

({}[()])(((<>()))){{}([(((({}<(({}){})>){}){})<>[({})(())])](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}}(<{}{}>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)
— गेहूं का जादूगर
स्रोत
5

MATL , 9 बाइट्स

qtYF1)EW<

ट्रू आउटपुट है 1। झूठा है 0या खाली आउटपुट है। (केवल आउटपुट जो खाली आउटपुट का उत्पादन करते हैं 1और 2, बाकी सभी 0या तो उत्पादन करते हैं 1)।

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

व्याख्या

चलो एक्स इनपुट को दर्शाते हैं। आज्ञा देना y की सबसे बड़ी शक्ति 2 है जो x and1 को विभाजित करता है , और z = ( x )1) / y । ध्यान दें कि z स्वतः विषम है। तब x एक प्रोथ संख्या है यदि और केवल यदि y > z , या समकक्ष है तो y 2 > x .1।

q    % Input x implicitly. Subtract 1
t    % Duplicate
YF   % Exponents of prime factorization of x-1
1)   % First entry: exponent of 2. Errors for x equal to 1 or 2
E    % Duplicate
W    % 2 raised to that. This is y squared
<    % Is x-1 less than y squared? Implicitly display
— लुइस मेंडो
स्रोत
5

ब्रेकीलॉग , 28 बाइट्स

>N>0,2:N^P:K*+?,P>K:2%1,N:K=

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

एक बार में सभी टेस्टकेस का सत्यापन करें। (ज़रा - सा संशोधित।)

व्याख्या

Brachylog, Prolog का व्युत्पन्न होना, चीजों को साबित करने में बहुत अच्छा है।

यहाँ, हम इन बातों को सिद्ध करते हैं:

>N>0,2:N^P:K*+?,P>K:2%1,N:K=

>N>0                           input > N > 0
     2:N^P                     2^N = P
         P:K*+?                P*K+1 = input
                P>K            P > K
                  K:2%1        K%2 = 1
                        N:K=   [N:K] has a solution
— लीक नन
स्रोत
5

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

f x=length [x|k<-[1,3..x],n<-[1..x],k*2^n+1==x,2^n>k]>0

संपादित करें: nimi के लिए धन्यवाद, अब 46 बाइट्स

f x=or[k*2^n+1==x|k<-[1,3..x],n<-[1..x],2^n>k]
— X88B88
स्रोत
4
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!
— डेनिस
धन्यवाद दोस्त! कुछ देर के लिए यहाँ दुबके रहे। बिग फैन btw, जेली सुपर कूल है। काश मैं सीख सकता था, लेकिन अफसोस, मुझे समझ में नहीं आता
— X88B88
2
एक सामान्य टिप: यदि आप केवल एक समझ द्वारा बनाई गई सूची की लंबाई में रुचि रखते हैं, तो आप उपयोग कर सकते हैं sum[1| ... ]। यहाँ हम आगे जा सकते हैं और समानता परीक्षण को आगे बढ़ा सकते हैं |और जाँच सकते हैं orकि उनमें से कोई भी सत्य है या नहीं f x=or[k*2^n+1==x|k<-...,n<-...,2^n>k]।
— nimi
वाह। शानदार टिप्स। मैं जरूर रिवाइज करूंगा।
— X88B88
2
यदि आप जेली सीखने में रुचि रखते हैं, तो विकी देखें या जेली कमरे में शामिल हों ।
— डेनिस
5

ECMAScript रेगेक्स, 48 43 41 बाइट्स

नील और H.PWiz के regexes (दोनों भी ECMAScript फ्लेवर) अपने आप में खूबसूरत हैं। इसे करने का एक और तरीका है, जो एक बहुत साफ संयोग से नील की तुलना में 1 बाइट अधिक था, और अब H.PWiz के सुझाए गए गोल्फ के साथ (धन्यवाद!), 1 बाइट अधिक है। H.PWiz की तुलना में कम।

चेतावनी: इस रेगेक्स के छोटे आकार के बावजूद, इसमें एक बड़ा स्पॉइलर है । मैं प्रारंभिक गणितीय अंतर्दृष्टि को स्वतंत्र रूप से समझकर ECMAScript रेगेक्स में एकतरफा गणितीय समस्याओं को हल करने का तरीका सीखने की सलाह देता हूं। यह मेरे लिए एक आकर्षक यात्रा रही है, और मैं इसे किसी ऐसे व्यक्ति के लिए खराब नहीं करना चाहता, जो संभवतः इसे स्वयं प्रयास करना चाहते हैं, विशेष रूप से संख्या सिद्धांत में रुचि रखने वाले। यह पहले वाला पोस्ट देखेंएक के एक हल करने के लिए लगातार बिगाड़ने-टैग की गई अनुशंसित समस्याओं की सूची के लिए ।

तो आगे पढ़िए नहीं अगर आप नहीं चाहते कि आपके लिए कुछ उन्नत यूरीज़ रेगेक्स मैजिक खराब हो जाए । यदि आप स्वयं इस जादू का पता लगाने के लिए एक शॉट लेना चाहते हैं, तो मैं उच्च स्तर पर उल्लिखित उस पोस्ट में उल्लिखित ECMAScript regex में कुछ समस्याओं को हल करके शुरू करने की सलाह देता हूं।

तो, यह रेगेक्स काफी सरलता से काम करता है: यह एक को घटाकर शुरू होता है। तब यह सबसे बड़ा अजीब कारक है, के । फिर हम विभाजित करते हैं k से करते हैं (विभाजन एल्गोरिथ्म का उपयोग करके मेरे फैक्टरियल नंबर regex पोस्ट के एक स्पॉइलर-टैग किए गए पैराग्राफ में समझाया गया है )। हम चुपके से एक साथ दावा करते हैं कि परिणामी भागफल k से अधिक है । यदि विभाजन मेल खाता है, तो हमारे पास एक प्रॉथ नंबर है; यदि नहीं, तो हम नहीं।

मैं इस रेगेक्स (43 → 41) से 2 बाइट्स को छोड़ने में सक्षम था, जो ग्रिम द्वारा पाए गए एक ट्रिक का उपयोग कर रहा था इस मामले में विभाजन को छोटा कर सकते हैं कि भागफल की तुलना में अधिक या बराबर होने की गारंटी है।

^x(?=(x(xx)*)\1*$)((\1x*)(?=\1\4*$)x)\3*$

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


 # Match Proth numbers in the domain ^x*$
 ^
 x                         # tail = tail - 1
 (?=(x(xx)*)\1*$)          # \1 = largest odd factor of tail
 
 # Calculate tail / \1, but require that the quotient, \3, be > \1
 # (and the quotient is implicitly a power of 2, because the divisor
 # is the largest odd factor).
 (                         # \3 = tail / \1, asserting that \3 > \1
     (\1x*)                # \4 = \3-1
     (?=\1\4*$)            # We can skip the test for divisibility by \1-1
                           # (and avoid capturing it) because we've already
                           # asserted that the quotient is larger than the
                           # divisor.
     x
 )
 \3*$

— Deadcode
स्रोत
1
O_o वाह, केवल 48 बाइट्स
— ASCII- केवल
नील डेनिस की तुलना में मेरे लिए अधिक समान है
— H.PWiz
4

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

!x=~-x&-~-x>x^.5

उत्तर और कुछ गोल्फ टिप्स के लिए @ डेनिस को श्रेय!

— मामा फन रोल
स्रोत
यह काम नहीं करता है। जूलिया में, के रूप &में एक ही मिसाल है *।
— डेनिस
1
अरे हाँ। फिक्स्ड: पीआई को वास्तव में मेरे कोड का परीक्षण करना चाहिए।
— मामा फन रोल
2
आप उपयोग कर सकते हैं -~-xके बजाय (1-x)। इसके अलावा, इसके √xबजाय है x^.5, लेकिन यह किसी भी बाइट्स को नहीं बचाता है।
— डेनिस
4

आर, 52 50 बाइट्स

x=scan()-1;n=0;while(!x%%2){x=x/2;n=n+1};2^(2*n)>x

इस कार्यक्रम को समीकरण के भाग को खोजने के लिए N-1(यहां पर Pऔर तब तक x) विभाजित करके शुरू किया जाता है, छोड़ना और फिर गणना करना कि इस तथ्य का उपयोग करके हीन या नहीं से हीन है22^nk=(N-1)/2^nk2^n2^n>x/2^n <=> (2^n)²>x <=> 2^2n>x

— फ़्रेडरिक
स्रोत
1
आप P=शुरुआत में खींच सकते हैं , और अंत को बदल सकते हैं 2^n>xऔर 5 या 6 बाइट्स की तरह बचा सकते हैं
— user5957401
4

रेगेक्स (ईसीएमएस्क्रिप्ट), 40 38 बाइट्स

-2 बाइट्स डेडकोड ​​के लिए धन्यवाद

^x(?=((xx)+?)(\1\1)*$)(?!(\1x\2*)\4*$)

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

टिप्पणी संस्करण:

# Subtract 1 from the input N
^x

# Assert N is even.
# Capture \1 = biggest power of 2 that divides N.
# Capture \2 = 2.
(?=((xx)+?)(\1\1)*$)

# Assert no odd number > \1 divides N
(?!(\1x\2*)\4*$)
— ग्रिमी
स्रोत
वाह, यह बहुत अच्छा है। इस समस्या को करने के लिए कई अलग अलग तरीके!
— डेडकोड
1
38 बाइट्स: ^x(?=((xx)+?)(\1\1)*$)(?!(\1x\2*)\4*$)( इसे ऑनलाइन आज़माएं )
— डेडकोड
2

जे, 10 बाइट्स

%:<<:AND-.

@ डेनिस के बिटवाइज़ समाधान पर आधारित ।

nयदि कोई इनपुट लेता है और 1 लौटाता है, तो वह नंबर 0 है।

प्रयोग

   f =: %:<<:AND-.
   f 16
0
   f 17
1
   (#~f"0) >: i. 100  NB. Filter the numbers [1, 100]
3 5 9 13 17 25 33 41 49 57 65 81 97

व्याख्या

%:<<:AND-.  Input: n
        -.  Complement. Compute 1-n
   <:       Decrement. Compute n-1
     AND    Bitwise-and between 1-n and n-1
%:          Square root of n
  <         Compare sqrt(n) < ((1-n) & (n-1))
— मील
स्रोत
हुह। मैं इसके बारे में नहीं जानता था AND। ठंडा!
— कोनोर ओ'ब्रायन
2

रेटिना 0.8.2 , 47 बाइट्स

\d+
$*
+`(1+)\1
$+0
01
1
+`.10(0*1)$
1$1
^10*1$

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: एक सिद्ध संख्या को देखते हुएकश्मीर·2n+1, आप दो नए प्रोथ नंबर प्राप्त कर सकते हैं (2कश्मीर±1)·2n+1+1। हम इसे रिवर्स में चला सकते हैं जब तक कि हम एक प्रॉथ नंबर प्राप्त नहीं करते हैंकश्मीर=1। यह बाइनरी प्रतिनिधित्व को बदलकर आसानी से किया जाता है।

\d+
$*

यूनीरी में बदलें।

+`(1+)\1
$+0
01
1

बाइनरी में कनवर्ट करें।

+`.10(0*1)$
1$1

बार-बार प्रोथ जनरेशन फॉर्मूला को रिवर्स में चलाएं।

^10*1$

प्रोथ पीढ़ी सूत्र के आधार मामले से मेल खाते हैं।

संपादित करें: मुझे लगता है कि एक एकल रेगेक्स के साथ एक संख्या के खिलाफ सीधे प्रोथ संख्या का मिलान करना वास्तव में संभव है। वर्तमान में यह मेरे लिए 47 बाइट्स लेता है, 7 बाइट्स मेरे वर्तमान रेटिना कोड से अधिक यह जांचने के लिए है कि क्या एक यूरीटी नंबर एक प्रॉथ नंबर है:

^.(?=(.+?)(\1\1)*$)(?=((.*)\4.)\3*$).*(?!\1)\3$
— नील
स्रोत
2

ECMAScript रेगेक्स, 42 बाइट्स

^x(?=(x(xx)*)\1*$)(?=(x+?)((\3\3)*$))\4\1x

इसे ऑनलाइन आज़माएं! (रेटिना का उपयोग करके)

मैं अनिवार्य रूप से 1 घटाता हूं, सबसे बड़ी संभव विषम संख्या से विभाजित करता हूं, फिर जांचता हूं kकि कम से कम k+1बचा हुआ है।

यह पता चला है कि मेरा रेग्क्स उसी के समान है जो नील अपने जवाब के अंत में देता है । मैं के x(xx)*बजाय का उपयोग करें (x*)\2x। और मैं जांचने के लिए एक छोटी विधि का उपयोग करता हूंk < 2^n

— H.PWiz
स्रोत
वाह, यह बहुत बढ़िया है! बहुत अच्छी तरह से किया। ध्यान दें कि आप इसे एक छोटा सा तेजी से बदल कर कर सकते हैं (\3\3)*)$करने के लिए(\3\3)*$)
— Deadcode
उस रेटिना कोड के साथ अच्छा काम। मैं $=और के बारे में नहीं जानता था $.=। इसे और भी बेहतर बनाया जा सकता है ।
— डेडकोड
2
@ डीडकोड यदि आप हेडर और फुटर को नाइटपिक करने जा रहे हैं, तो कुछ और सुधार करें ।
— नील
@ नील यह अच्छा गोल्फ की तरह दिखता है, लेकिन दुर्भाग्य से यह एक बग है लगता है। एकल संख्या का प्रयास करें । वे काम नहीं करते।
— डेडकोड
1
@Deadcode क्षमा करें, मुझे महसूस नहीं हुआ था कि एकल नंबर "युक्ति" का हिस्सा थे।
— नील
2

ब्रेन-फ्लैक , 128 बाइट्स

({<{({}[()]<(([{}]())<>{})<>>)}{}>{{}(<>)}{}}<><(())>){([()]{}<(({}){})>)}{}([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

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

मैंने पुराने ब्रेन-फ्लैक समाधान की तुलना में बहुत अलग एल्गोरिथ्म का उपयोग किया ।

मूल रूप से, मैं 2 से विभाजित करता हूं (तब तक चक्कर लगाता हूं) जब तक कि मैं एक सम संख्या से नहीं टकराता। फिर मैं बस दो के साथ अंतिम विभाजन के परिणाम की तुलना करता हूं, जितनी बार मैंने विभाजित की थी।

स्पष्टीकरण:

({
  # (n+1)/2 to the other stack, n mod 2 to this stack
  <{({}[()]<(([{}]())<>{})<>>)}{}>
  # if 1 (n was odd) jump to the other stack and count the one
  {{}(<>)}{}
#end and push the sum -1, with a one under it
}<>[(())])
#use the one to get a power of two
{([()]{}<(({}){})>)}{}
#compare the power of two with the remainder after all the divisions
([({}[{}(())])](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}
— MegaTom
स्रोत
1

मेपल, 100 बाइट्स (रिक्त स्थान सहित)

IsProth:=proc(X)local n:=0;local x:=X-1;while x mod 2<>1 do x:=x/2;n:=n+1;end do;is(2^n>x);end proc:

पठनीयता के लिए अच्छी तरह से फैला हुआ:

IsProth := proc( X )
    local n := 0;
    local x := X - 1;
    while x mod 2 <> 1 do
        x := x / 2;
        n := n + 1;
    end do;
    is( 2^n > x );
end proc:

कई अन्य लोगों के समान विचार; X को 2 से तब तक विभाजित करें जब तक X 2 से समान रूप से विभाज्य नहीं हो जाता है, तब मापदंड 2 ^ n> x की जांच करें।

— DSkoog
स्रोत
1

जावा 1.7, 49 43 बाइट्स

एक और 6 @charlie के लिए धूल धन्यवाद बाइट्स।

boolean g(int p){return p--<(p&-p)*(p&-p);}

कोशिश करो! (ideone)

दो तरीके, समान रूप से लंबे। यहां अधिकांश उत्तरों के साथ, अभिव्यक्ति के लिए क्रेडिट निश्चित रूप से @ डेनिस पर जाते हैं।

अभिव्यक्ति के दाहिने भाग की जड़ को लेना:

boolean f(int p){return(p-1&(1-p))>Math.sqrt(p);}

अभिव्यक्ति के बाएं ओर दो को लागू करने की शक्ति:

boolean g(int p){return Math.pow(p-1&(1-p),2)>p;}

यदि सकारात्मक सांख्यिक मूल्य को 'सत्य' का प्रतिनिधित्व करने की अनुमति दी जाती है, और नकारात्मक मान 'मिथ्या':

double g(int p){return Math.pow(p-1&(1-p),2)-p;}

दुर्भाग्य से 'नैरोइंग प्रिमिटिव कन्वर्ज़न' की वजह से कोई भी इसे जावा में नहीं लिख सकता है और सही परिणाम प्राप्त कर सकता है:

((p - 1 & (1 - p))^2) > p;

और 'पी' को चौड़ा करने के किसी भी प्रयास से एक संकलित त्रुटि हो जाएगी क्योंकि बिटवाइज़ ऑपरेटर को फ़्लोट या डबल्स पर समर्थित नहीं किया जाता है: ...

— एमएच।
स्रोत
1
f = 47:boolean f(int p){return Math.sqrt(p--)<(p&-p);}
— charlie
1
g = 43:boolean g(int p){return p--<(p&-p)*(p&-p);}
— charlie
अच्छा है! मुझे पता था कि Math.*कॉल से छुटकारा पाने का एक तरीका होना चाहिए ; अभी पता नहीं कैसे! धन्यवाद!
— एमएच।
0

सी (137 बाइट्स)

int P(int N){int x=1,n=0,k=1,e=1,P=0;for(;e;n++){for(x=1,k=1;x&&x<N;k+=2){x=2<<n;x=x>k?x*k+1:0;if(x>N&&k==1)e=0;}if(x==N)P=1;}return P;}

मेरे द्वारा कोशिश करने के बाद ही उत्तर पढ़ने के लिए आया था।

N=k*2^n+1की शर्त के साथ विचार k<2^n(k=1,3,5.. औरn=1,2,3..

हमारे n=1पास kपरीक्षण के लिए एक उपलब्ध है। जैसे-जैसे हम बढ़ाते हैं, nहमें कुछ और k'sपरीक्षण करने को मिलते हैं :

n = 1; k = 1

n = 2; k = 1 k = 3

n = 3; k = 1 k = 3 k = 5 k = 7

...

अगर हम किसी दिए गए nके लिए N एक संभावित संख्या नहीं है, तो हम उन संभावनाओं के माध्यम से I सुनिश्चित कर सकते हैंk=1 नंबर के लिए N से बड़ा है और कोई अन्य पुनरावृत्ति मैच नहीं था।

तो मेरा कोड मूल रूप से एन को खोजने में अपना रास्ता "सेना-बल" है।

अन्य उत्तरों को पढ़ने और महसूस करने के बाद आप एन -1 को खोजने के लिए 2 से कारक बना सकते हैं nऔर फिर से सशर्त बना सकते हैं k<2^n, मुझे लगता है कि इस पद्धति का उपयोग करके मेरा कोड छोटा और अधिक कुशल हो सकता है।

आजमाने लायक था!

दिए गए सभी नंबरों और कुछ "नॉन-प्राउथ" नंबरों का परीक्षण किया। फंक्शन रिटर्न 1 अगर नंबर एक प्राउथ नंबर है और 0 अगर यह नहीं है।

— IanC
स्रोत
0

जावास्क्रिप्ट ईएस 7, 16 बाइट्स

x=>x--<(-x&x)**2

पोर्ट ऑफ मेरे जूलिया उत्तर, जो @ डेनिस जेली उत्तर का एक बंदरगाह है।

@ बाइट के लिए धन्यवाद @ बाइट ने बचा लिया!

— मामा फन रोल
स्रोत
n=x=>x-1&1-x>x**.5; n(3)मुझे देता है 0(वास्तव में यह मुझे 0 इनपुट की परवाह किए बिना देता है)
— eithed
क्या ब्राउज़र? यह सिर्फ इतना हो सकता है।
— मामा फन रोल 20
क्रोम 52. फ़ायरफ़ॉक्स 48 के लिए एक ही उत्तर देता हैn=x=>x-1&1-x>Math.pow(x,0.5); n(3)
— eithed
ठीक है - यह ऑपरेटर पूर्वता है। इसके (x-1&1-x)बिना ऐसा होना चाहिए जैसे कि ऑपरेटर पूर्वता वास्तव में है:(x-1)&((1-x)>x**.5)
— eithed
1
-1 बाइट: x=>x--**.5<(x&-x)याx=>x**.5<(--x&-x)
— चार्ली
0

स्याही , 60 बाइट्स

=p(n)
~n-=n>1
~temp x=1
-(k){n%2:{n<x}->->}
~x+=x
~n=n/2
->k

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

@ DSkoog के मेपल उत्तर के आधार पर - यह अपनी तरह का पहला पोस्ट नहीं था, लेकिन यह अपनी तरह का पहला था जिसे मैंने देखा था।

Ungolfed

= is_proth(number) =

/* It's easy to check if a number is one less than a Proth number.
   We take the number and divide it by 2 until we can't.
   Once we can't, we've found the smallest possible "k".
   If we also keep track of how many times we divided, we have our corresponding "2^n"
   All we have to do then is compare those
*/

~ number -= (number > 1)            // So, we first subtract one. Except this implementation won't ever halt for 0, so we don't subtract if the input is 1 (this is fine since the desired outputs for inputs 1 and 2 are the same)
~ temp power_of_two = 1             // We declare a variable to store our "2^n"
- (check)
  {
  - number % 2:                     // Once we can't divide by 2 anymore, we've found the smallest possible "k"
    {number < power_of_two}         // At that point, we print whether it's smaller than the "2^n" we found
    ->->                            // And then we return to where we were called from
  }

  ~ number = number / 2             // We keep dividing by 2 until we can't.
  ~ power_of_two += power_of_two    // and update our "2^n" as we go
-> check
— सारा जे
स्रोत
0

x86 मशीन कोड, 15 बाइट्स

4F 89 F8 F7 D8 21 F8 0F AF C0 39 C7 19 C0 C3

ये बाइट्स एक फ़ंक्शन को परिभाषित करते हैं जो EDIरजिस्टर में इनपुट तर्क (एक अहस्ताक्षरित पूर्णांक) को लेता है, x86 सिस्टम के लिए मानक सिस्टम V कॉलिंग कन्वेंशन का पालन करता है, और यह सभी x86 कॉलिंग सम्मेलनों की EAXतरह रजिस्टर में परिणाम देता है ।

असेंबलर mnemonics में:

4F          dec   edi            ; input -= 1
89 F8       mov   eax, edi       ; \ temp
F7 D8       neg   eax            ; |      =
21 F8       and   eax, edi       ; /        (input & -input)
0F AF C0    imul  eax, eax       ; temp *= temp
39 C7       cmp   edi, eax       ; set CF if (input < temp)
19 C0       sbb   eax, eax       ; EAX = -CF
C3          ret                  ; return with result in EAX
                                 ;  (-1 for Proth number; 0 otherwise)

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

यह एक बहुत सीधा समाधान है- और वैचारिक रूप से यह मेगाटॉम के सी संस्करण के समान है । वास्तव में, आप इसे C में कुछ इस तरह लिख सकते हैं:

unsigned IsProthNumber(unsigned input)
{
    --input;
    unsigned temp  = (input & -input);
    temp          *= temp;
    return (input < temp) ? -1 : 0;
}

लेकिन ऊपर दिए गए मशीन कोड से बेहतर है कि आप सी कंपाइलर से बाहर निकलेंगे, भले ही यह आकार के लिए ऑप्टिमाइज़ करने के लिए सेट हो।

यहाँ केवल "धोखा" -1 को "सत्य" मान के रूप में और 0 को "मिथ्या" मान के रूप में लौटा रहा है। यह चाल 3-बाइट SBBअनुदेश के विपरीत 2-बाइट अनुदेश के उपयोग की अनुमति देती है SETB।

— कोडी ग्रे
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.