सबसे छोटा गुणक जो अर्धविराम के एक कारक को प्रकट करता है

Question

एक सेमीप्राइम एन को देखते हुए , सबसे छोटा धनात्मक पूर्णांक m ज्ञात कीजिए जैसे N के दो कारकों में से एक का द्विआधारी प्रतिनिधित्व N * m के द्विआधारी प्रतिनिधित्व में पाया जा सकता है ।

उदाहरण

चलो सेमीप्राइम एन = 9799 पर विचार करें ।

हम m के विभिन्न मूल्यों को आजमाते हैं , जो 1 से शुरू होता है:

 m |  N * m |   N * m in binary
---+--------+------------------
 1 |   9799 |    10011001000111
 2 |  19598 |   100110010001110
 3 |  29397 |   111001011010101
 4 |  39196 |  1001100100011100
 5 |  48995 |  1011111101100011
 6 |  58794 |  1110010110101010
 7 |  68593 | 10000101111110001
 8 |  78392 | 10011001000111000
 9 |  88191 | 10101100001111111
10 |  97990 | 10111111011000110
11 | 107789 | 11010010100001101

हम यहां रुकते हैं क्योंकि पिछले उत्पाद 101001के द्विआधारी प्रतिनिधित्व में 41 का द्विआधारी प्रतिनिधित्व है , जो 9799 के दो कारकों में से एक है (अन्य एक 239 है )।

तो जवाब होगा 11 ।

नियम और नोट

• M के मान को भी आज़माना व्यर्थ है। उन्हें पूर्णता के लिए उपरोक्त उदाहरण में दिखाया गया था।
• आपके प्रोग्राम को किसी भी N का समर्थन करना चाहिए जिसके लिए N * m आपकी भाषा की कंप्यूटिंग क्षमताओं के भीतर है।
• आपको N * m के बाइनरी प्रतिनिधित्व के प्रत्येक संभावित विकल्प की कोशिश करने के बजाय N को पहले से फ़ैक्टर करने की अनुमति है, यह देखने के लिए कि क्या यह N का कारक है ।
• के रूप में MitchellSpector द्वारा सिद्ध , मीटर हमेशा मौजूद है।
• यह कोड-गोल्फ है, इसलिए बाइट्स में सबसे कम उत्तर जीतता है। मानक खामियों को मना किया जाता है।

परीक्षण के मामलों

पहला कॉलम इनपुट है। दूसरा कॉलम अपेक्षित आउटपुट है।

         N |    m |         N * m |                              N * m in binary | Factor
-----------+------+---------------+----------------------------------------------+-------
         9 |    3 |            27 |                                      [11]011 |      3
        15 |    1 |            15 |                                       [11]11 |      3
        49 |    5 |           245 |                                   [111]10101 |      7
        91 |    1 |            91 |                                    10[1101]1 |     13
       961 |   17 |         16337 |                             [11111]111010001 |     31
      1829 |    5 |          9145 |                             1000[111011]1001 |     59
      9799 |   11 |        107789 |                          1[101001]0100001101 |     41
     19951 |   41 |        817991 |                       1[1000111]101101000111 |     71
    120797 |   27 |       3261519 |                     11000[1110001]0001001111 |    113
   1720861 |  121 |     208224181 |               11000110100[100111111101]10101 |   2557
 444309323 |  743 |  330121826989 |    100110011011100110010[1101010010101011]01 |  54443
 840000701 | 4515 | 3792603165015 | 11011100110000[1000110000111011]000101010111 |  35899
1468255967 |   55 |   80754078185 |      1001011001101010100010[1110001111]01001 |    911

Comments

हम्म, मैं आपके लाठी अनुक्रम चुनौती पर इस्तेमाल किए जाने वाले समान एल्गोरिथ्म को

— सूंघता हूं

@ETHproductions हम्म, वास्तव में? वे ईमानदारी से पूरी तरह से असंबंधित माना जाता है।

— अरनौलद

ठीक है, वे मुख्य रूप से इसी तरह के हैं कि आपको एक विशिष्ट संपत्ति के लिए प्रत्येक सन्निहित विकल्प की जांच करने की आवश्यकता है। इसके अलावा वे वास्तव में बहुत असंबंधित हैं।

— ETHproductions

"और शायद प्रोत्साहित किया" - मुझे क्षमा करें। हमें अपने कोड की गति की परवाह नहीं है।

— जॉन ड्वोरक

@ जैनध्वज मेला काफी हटा दिया।

— अरनौलद

Answer 1

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

ff}.BY.B*TQPQ

प्रदर्शन

स्पष्टीकरण:

ff}.BY.B*TQPQ
f                Find the first integer >= to 1 where the following is true
 f         PQ    Filter the prime factors of the input
        *TQ      Multiply the input by the outer integer
      .B         Convert to a binary string
   .BY           Convert the prime factor to a binary string
  }              Check whether the factor string is in the multiple string.

Answer 2

05AB1E , 18 16 15 बाइट्स

-2 बाइट्स रिले के लिए धन्यवाद!

-1 बाइट एमिग्ना को धन्यवाद!

[N¹*b¹Ñ¦¨båOiNq

स्पष्टीकरण:

[                   # Infinite loop start
 N                  # Push the amount of times we have iterated
  ¹*               # Multiplied by input
    b              # Convert to binary
     ¹Ñ¦¨b         # Calculate the proper divisors of the input in binary excluding one
          åO       # Check if a substring of N * m in binary is in the divisors
            iNq    # If so, print how many times we have iterated and terminate the program

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

Comments

¹Ñ¦¨båOप्रत्येक प्रतिस्थापन की जाँच करने के बजाय काम करना चाहिए।

— रिले

@ रिले हाजिर करने के लिए धन्यवाद!

— ओकेक्स

आप एक और बाइट को बदलने ¼और ¾साथ बचा सकते हैं N।

— इमिग्ना

@Emigna मैं उस चाल के बारे में नहीं जानता था, धन्यवाद!

— 17

Answer 3

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

n=>F=m=>(k=p=>p&&(q=1,g=x=>1<x&&x<n&n%x<1|g(x>>1,q*=2))(p)|k(p-q))(n*m)?m:F(-~m)

एक फ़ंक्शन जो एक पुनरावर्ती फ़ंक्शन देता है जो एक पुनरावर्ती फ़ंक्शन का उपयोग करता है जो एक पुनरावर्ती फ़ंक्शन का उपयोग करता है। मैं वास्तव में आश्चर्यचकित हूं कि क्या .toString(2)मार्ग छोटा होगा ...

एक चर जैसे असाइन f=n=>...और कोष्ठक की एक अतिरिक्त जोड़ी के साथ कॉल, f(9)()। यदि इसकी अनुमति नहीं है ( मेटा पोस्ट + 6 / -2 पर है), तो आप इस 83-बाइट संस्करण का उपयोग मानक मंगलाचरण के साथ कर सकते हैं:

f=(n,m)=>(k=p=>p&&(q=1,g=x=>1<x&&x<n&n%x<1|g(x>>1,q*=2))(p)|k(p-q))(n*m)?m:f(n,-~m)

दोनों संस्करण सभी लेकिन अंतिम तीन परीक्षण मामलों के लिए काम करते हैं। आप इन परीक्षण मामलों को बदलकर भी आजमा सकते हैंx>>1 करने के लिए (x-x%2)/2।

Comments

यकीन नहीं होता कि क्या वास्तव में इसके बारे में आम सहमति है (हम पोस्टिंग के समय + 6 / -2 पर हैं), लेकिन जहां तक ​​मेरा सवाल है, पहला इनपुट प्रारूप ठीक है।

— अरण्युलड

Answer 4

बैश + यूनिक्स उपयोगिताओं, 85 84 बाइट्स

for((;;m++)){ dc -e2o$[$1*m]n|egrep -q $(dc "-e2o`factor $1`nBEPn")&&break;}
echo $m

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

---

मैं यह भी इंगित करता हूं कि मी हमेशा किसी भी सेमीप्राइम एन के लिए मौजूद है। यहाँ पर क्यों:

N = pq लिखें, जहाँ p और q प्रधान हैं और p <= q।

N-1 के द्विआधारी प्रतिनिधित्व में अंकों की संख्या को b। फिर, 0 और n-1 समावेशी के बीच किसी भी k के लिए, बाइनरी में p * (2 ^ b) + k होते हैं, p के बाइनरी प्रतिनिधित्व होते हैं, इसके बाद b अतिरिक्त बिट्स k का प्रतिनिधित्व करते हैं।

तो संख्याएँ p * (2 ^ b) + k for 0 <= k <= n-1, जब बाइनरी में लिखा जाता है, तो सभी p के बाइनरी प्रतिनिधित्व से शुरू होते हैं। लेकिन ये n लगातार संख्याएँ हैं, इसलिए इनमें से एक को कई n होना चाहिए।

यह इस प्रकार है कि हमारे पास n का एक बहु mn है जिसका बाइनरी प्रतिनिधित्व पी के बाइनरी प्रतिनिधित्व से शुरू होता है।

इसके आधार पर, कोई 2 sqrt (n) के मीटर के लिए ऊपरी बाउंड के साथ आ सकता है। (एक शायद एक बहुत तंग ऊपरी इस से अधिक प्राप्त कर सकते हैं।)

Answer 5

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

import Data.List
(!)=mod
a#b|a!b==0=b|0<1=a#(b+1)
g 0=[]
g n=g(n`div`2)++show(n!2)
(a%b)c|g b`isInfixOf`g(a*c)=c|0<1=a%b$c+1
f n=min(n%(n#2)$1)$n%(n`div`(n#2))$1

सीधी जाँच। पहले कारक, फिर रैखिक 1 पर शुरू खोजें और दोनों कारकों के लिए न्यूनतम मूल्य लें।

आखिरी टेस्टकेस ( 1468255967), मेरे लैपटॉप पर ghciरिपोर्ट के लिए कुछ सेकंड लेता है (15.34 secs, 18,610,214,160 bytes)।

Answer 6

मैथेमेटिका, 83 बाइट्स

1//.x_/;FreeQ[Fold[#+##&]/@Subsequences@IntegerDigits[x#,2],d_/;1<d<#&&d∣#]:>x+1&

Answer 7

ब्रेकीलॉग (2), 14 बाइट्स

ḋḃᵐD∧?:.×ḃs∈D∧

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

Brachylog में 14 बाइट्स में इसे लिखने का एक से अधिक तरीका है, इसलिए मैं सबसे कुशल के लिए गया। जैसा कि Brachylog प्रस्तुतियाँ के लिए आम है, यह एक फ़ंक्शन सबमिशन है; इसका इनपुट अर्धवृत्त है, इसका आउटपुट गुणक है।

व्याख्या

ḋḃᵐD∧?:.×ḃs∈D∧
ḋ               Prime decomposition (finds the two prime factors)
 ḃᵐ             Convert each factor to binary
   D            Name this value as D
    ∧?          Restart with the user input
      :.×       The output is something that can be multiplied by it
         ḃ      to produce a number which, when expressed in binary
          s     has a substring
           ∈D   that is an element of D
             ∧  (suppress an implicit constraint that D is the output; it isn't)

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

Answer 8

पॉवरशेल , 136 बाइट्स

param($n)$a=2..($n-1)|?{!($n%$_)}|%{[convert]::ToString($_,2)};for(){$b=[convert]::toString(++$m*$n,2);if($a|?{$b-like"*$_*"}){$m;exit}}

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

PowerShell में रूपांतरण-से-बाइनरी कैसे काम करता है, इसके कारण बहुत लंबा। : - /

इनपुट लेता है $n, कारकों के माध्यम 2से छोरों $n-1और खींचता है !($n%$_)। उन लोगों को एक लूप में भेजता है |%{...}और convertउनमें से प्रत्येक को एक बाइनरी (बेस 2) स्ट्रिंग के लिए भेजता है । उन बाइनरी स्ट्रिंग्स को स्टोर करता है $a।

फिर हम एक अनंत for(){...}लूप में प्रवेश करते हैं । प्रत्येक पुनरावृत्ति, हम वृद्धि करते हैं ++$m, उस से गुणा करते हैं $n, और convertजो एक बाइनरी स्ट्रिंग में संग्रहीत होता है $b। फिर, ifउस स्ट्रिंग में regex -likeहै $a, हम आउटपुट $mऔर exit।

Answer 9

पर्ल 6 , 66 बाइट्स

->\n{first {(n*$_).base(2)~~/@(grep(n%%*,2..^n)».base(2))/},^∞}

Regex आधारित।

सुपर स्लो, क्योंकि यह सभी संख्याओं के प्रत्येक regex मैच पोजीशन पर n के कारकों को फिर से ब्रूट-फोर्स करता है जो कि कोशिश की जाती है।

केवल एक बार कारकों की गणना, प्रदर्शन में सुधार करता है, लेकिन यह 72 बाइट्स बनाता है:

->\n{my @f=grep(n%%*,2..^n)».base(2);first {(n*$_).base(2)~~/@f/},^∞}