बिटफ्लिप-प्रतिरोधी समग्र संख्या


26

कभी-कभी, प्रोग्राम लिखते समय, आपको किसी कारण या अन्य (जैसे क्रिप्टोग्राफी) के लिए प्राइम नंबर का उपयोग करने की आवश्यकता होती है। मुझे लगता है कि कभी-कभी, आपको एक समग्र संख्या का भी उपयोग करने की आवश्यकता होती है। कभी-कभी, पीपीसीजी पर कम से कम यहां, आपके कार्यक्रम को मनमाने परिवर्तनों से निपटने में सक्षम होना चाहिए। और परिस्थितियों में आसानी से एक दिलचस्प पीपीसीजी प्रश्न बनाने के लिए संघर्ष किया, शायद यहां तक ​​कि आपके द्वारा उपयोग किए जा रहे नंबर भी भ्रष्टाचार के लिए प्रतिरोधी हो…

परिभाषाएं

एक मिश्रित संख्या एक पूर्णांक that 4 है जो अभाज्य नहीं है, अर्थात यह दो छोटे पूर्णांकों का गुणनफल है जो 1. से अधिक है। एक बिटफ्लिप-प्रतिरोधी समग्र संख्या को इस प्रकार परिभाषित किया गया है: यह एक समग्र धनात्मक पूर्णांक है जिसके लिए, यदि आप इसे लिखते हैं बिट्स की न्यूनतम संभव संख्या में बाइनरी में, आप संख्या से किसी एक या दो बिट्स को बदल सकते हैं, और संख्या अभी भी समग्र है।

उदाहरण

उदाहरण के लिए, संख्या 84 पर विचार करें। बाइनरी में, यह 1010100। यहाँ सभी संख्याएँ हैं जो उस से 2 बिट्स से अधिक नहीं हैं:

0000100 4 2 × 2
0010000 16 4 × 4
0010100 20 4 × 5
0010101 21 3 × 7
0010110 22 2 × 11
0011100 28 4 × 7
0110100 52 4 × 13
1000000 64 8 × 8
1000100 68 4 × 17
1000101 69 3 × 23
1000110 70 7 × 10
1001100 76 4 × 19
1010000 80 8 × 10
1010001 81 9 × 9
1010010 82 2 × 41
1010100 84 7 × 12
1010101 85 5 × 17
1010110 86 2 × 43
1010111 87 3 × 29
1011000 88 8 × 11
1011100 92 4 × 23
1011101 93 3 × 31
1011110 94 2 × 47
1100100 100 10 × 10
1110000 112 8 × 14
1110100 116 4 × 29
1110101 117 9 × 13
1110110 118 2 × 59
1111100 124 4 × 31

पहला कॉलम बाइनरी में संख्या है; दूसरा स्तंभ दशमलव में संख्या है। जैसा कि तीसरा कॉलम इंगित करता है, ये सभी संख्याएं संयुक्त हैं। जैसे, 84 एक बिटफ्लिप-प्रतिरोधी कंपोजिट संख्या है।

काम

आपको निम्नलिखित तीन कार्यक्रमों या कार्यों में से एक लिखना होगा, जो भी आपकी भाषा के लिए सबसे अधिक समझ में आता है:

  • एक प्रोग्राम या फ़ंक्शन जो इनपुट के रूप में एक नॉनजेटिव पूर्णांक n लेता है , और पहले n बिटफ्लिप-प्रतिरोधी समग्र संख्याओं को आउटपुट करता है ।
  • एक कार्यक्रम या समारोह है कि ग़ैर-ऋणात्मक पूर्णांक लेता n इनपुट के रूप में है, और कम से कम सभी bitflip प्रतिरोधी संयुक्त संख्या आउटपुट n (या आप चाहें, तो कम से कम या बराबर है, तो n , यानी आप चुन सकते हैं कि n उत्पादन करता है, तो bitflip में शामिल है प्रतिरोधी)।
  • एक प्रोग्राम या फ़ंक्शन जो कोई इनपुट नहीं लेता है, और सभी बिटफ्लिप-प्रतिरोधी समग्र संख्याओं को आउटपुट करता है। (यह आउटपुट आउटपुट उत्पादन में सक्षम होना चाहिए, जबकि प्रोग्राम अभी भी चल रहा है, जैसे कि स्टडआउट पर प्रिंटिंग, एक आलसी सूची, या एक जनरेटर; आप सिर्फ पूरी सूची की गणना नहीं कर सकते हैं और फिर इसे प्रिंट कर सकते हैं।)

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

यहां पहले कुछ बिटफ्लिप-प्रतिरोधी कंपोजिट नंबर दिए गए हैं:

84, 184, 246, 252, 324, 342, 424, 468, 588, 636, 664, 670, 712, 730, 934, 958

स्पष्टीकरण

  • यह केवल आपके द्वारा उत्पादित नंबर है जो बिटफ्लिप के लिए प्रतिरोधी है। यह ऐसा कार्यक्रम बनाने के बारे में नहीं है जो उन्हें बिटफ़्लिप के लिए प्रतिरोधी बनाता है; कार्यक्रम में जो भी संख्याएँ आपको पसंद हों, उनका उपयोग करें।
  • आपके द्वारा आउटपुट किए जाने वाले नंबरों को "अग्रणी शून्य" में एक बिटफ्लिप के लिए प्रतिरोधी नहीं होना चाहिए; कल्पना करें कि संख्याओं को न्यूनतम संभव संख्या में बिट्स में संग्रहीत किया जाएगा, और केवल उन बिट्स को फ़्लिपिंग के लिए प्रतिरक्षा होना चाहिए। हालांकि, आपके द्वारा आउटपुट किए जाने वाले नंबरों पर शुरुआती 1 बिट्स को बिटफ़्लिप्स के लिए प्रतिरक्षा होना चाहिए।
  • किसी भी एल्गोरिथ्म का उपयोग करें जिसे आप पसंद करते हैं जो सही परिणाम उत्पन्न करता है; आपको यहां दक्षता पर चिह्नित नहीं किया जा रहा है।
  • यदि आप यह साबित कर सकते हैं कि बहुत कम बिटफ्लिप-प्रतिरोधी समग्र संख्याएं हैं, तो ए) आउटपुट प्रारूप पर प्रतिबंध हटा दिए गए हैं, और बी) हार्डकोडिंग सूची की अनुमति दी जाएगी (हालांकि शायद इसकी गणना करने की तुलना में अधिक क्रिया है)। यह नियम अधिकतर पूर्णता के लिए है; मुझे इसकी प्रासंगिकता की उम्मीद नहीं है।

विजय की स्थिति

यह , इसलिए हमेशा की तरह, कम बेहतर है। हमेशा की तरह, कार्यक्रम की लंबाई बाइट्स में मापी जाएगी।


"एक प्रोग्राम या फ़ंक्शन जो एक nonnegative पूर्णांक n को इनपुट के रूप में लेता है, और सभी बिटफ्लिप-प्रतिरोधी कंपोजिट संख्या n से कम है" - क्या मैं शामिल कर सकता हूं nयदि nबिटफ्लिप-प्रतिरोधी है? (यानी इसे "n से कम या उसके बराबर"
बनाइए


2
मुझे पसंद है कि आपके चश्मे कितने स्पष्ट और गहन हैं
लुइस मेन्डो

भ्रष्टाचार की प्रतिरोधक क्षमता के बारे में शुरुआत में बात करने के साथ, मैंने सोचा कि यह एक और लगभग असंभव विकिरण-सख्त चुनौती होने वाली थी ...
ETHproductions

2
@ ais523 यह खाली कार्यक्रम की तरह दिखेगा। सभी खाली कार्यक्रमों का सेट।
mbomb007

जवाबों:


5

जेली , 20? 22 बाइट्स

BµJŒċ;0Ṭ^µḄµÆPoỊṀ¬
⁴Ç#

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

पहली n ऐसी संख्याएँ देता है।

शायद ;0हटाया जा सकता है (इसके बिना हम यह जाँच नहीं करते हैं कि क्या संख्या स्वयं समग्र है - क्या सभी बिट-फ़्लिप समग्र के साथ कोई भी अपराध हैं?)

ध्यान दें कि बिट-फ़्लिप किए गए नंबरों के सेट पर परीक्षण करना पर्याप्त नहीं हैnot(any(is prime)) । हमें यह भी परखना चाहिए कि 0सेट में नहीं है।

यह इसलिए है क्योंकि 0प्रधान नहीं है और समग्र नहीं है ( 1बहुत नीचे है, लेकिन नीचे देखें)।

के लिए जांच करने की आवश्यकता 0एक जवाबी उदाहरण के द्वारा देखा जा सकता है:

  • 131136( flip +२ ) में निम्न बिट-फ्लिप सेट है:

[0, 64, 65, 66, 68, 72, 80, 96, 192, 320, 576, 1088, 2112, 4160, 8256, 16448, 32832, 65600, 131072, 131073, 131074, 131076, 131080, 131088, 131104, 131136, 131137, 131138, 131139, 131140, 131141, 131142, 131144, 131145, 131146, 131148, 131152, 131153, 131154, 131156, 131160, 131168, 131169, 131170, 131172, 131176, 131184, 131200, 131264, 131265, 131266, 131268, 131272, 131280, 131296, 131328, 131392, 131393, 131394, 131396, 131400, 131408, 131424, 131520, 131584, 131648, 131649, 131650, 131652, 131656, 131664, 131680, 131776, 131904, 132096, 132160, 132161, 132162, 132164, 132168, 132176, 132192, 132288, 132416, 132672, 133120, 133184, 133185, 133186, 133188, 133192, 133200, 133216, 133312, 133440, 133696, 134208, 135168, 135232, 135233, 135234, 135236, 135240, 135248, 135264, 135360, 135488, 135744, 136256, 137280, 139264, 139328, 139329, 139330, 139332, 139336, 139344, 139360, 139456, 139584, 139840, 140352, 141376, 143424, 147456, 147520, 147521, 147522, 147524, 147528, 147536, 147552, 147648, 147776, 148032, 148544, 149568, 151616, 155712, 163840, 163904, 163905, 163906, 163908, 163912, 163920, 163936, 164032, 164160, 164416, 164928, 165952, 168000, 172096, 180288, 196608, 196672, 196673, 196674, 196676, 196680, 196688, 196704, 196800, 196928, 197184, 197696, 198720, 200768, 204864, 213056, 229440]

जो सभी को छोड़कर, 0समग्र हैं, फिर 0भी प्रमुख नहीं है।

1गैर-प्रमुख और गैर-समग्र भी है और सेट में दिखाई दे सकता है। हालाँकि हम कर सकते हैं, यदि हम चाहें, तो इसे छोड़ दें जैसे कि यह एक समग्र था:

  • 3(यदि सभी पर विचार किया जा रहा है) से कम या बराबर सभी इनपुट 0में वैसे भी (वास्तव में सभी कम से कम 7) होते हैं।

  • पहुंच के लिए 1एक बिट फ्लिप में मूल संख्या इस रूप में होने चाहिए 2 कश्मीर + 2 0 है, और अगर यह से अधिक है 3, यानी कश्मीर> 1 , तो हम तक पहुंच सकता है 3बंद flipping द्वारा कश्मीर -बिट और सेटिंग 1 -बिट ( 2 1 +2 0 = 3 )।

  • 1दो बिट फ़्लिप में पहुंचने के लिए मूल संख्या फॉर्म 2 k की होनी चाहिए और यदि इससे अधिक है तो 3हम 2इसके बजाय दो फ़्लिप में पहुँच सकते हैं , और 2प्राइम है।

जैसा कि यह खड़ा है कि कोड दोनों को संभाल रहा है 0और 1साथ में "तुच्छ" परमाणु का उपयोग कर रहा है

कैसे?

⁴Ç# - Main link: n
⁴   - 16
  # - count up from 16 finding the first n matches of
 Ç  -     last link (1) as a monad

BµJŒċ;0Ṭ^µḄµÆPoỊṀ¬ - Link 1, test a number: i
B                  - convert to a binary list
 µ                 - start a new monadic chain
  J                - range(length): [1,2,...,nBits]
   Œċ              - pairs with replacement: [[1,1],[1,2],...,[1,nBits],[2,2],[2,3],...,[2,nBits],...,[nBits-1,nBits]]
     ;0            - concatenate a zero
       Ṭ           - untruth (makes lists with ones at those indexes - the [1,1], [2,2], etc make the one-flips, the zero makes the no-flip, the rest make the two-flips)
        ^          - exclusive or with the binary list version of i (flip the bits)
         µ         - start a new monadic chain
          Ḅ        - un-binary (get the integer values of each of the flipped versions)
           µ       - start a new monadic chain
            ÆP     - is prime? (make a list of 1s for primes and 0 for non-primes)
               Ị   - is insignificant (abs(v)<=1)
              o    - logical or (now we have true for any primes, 0 or 1 - hence non-composites)
                Ṁ  - maximum (1 if any non-composite was found)
                 ¬ - not (1 if all were composite)

क्या इनपुट सभी संख्याओं के आपके सेट में शामिल है जो कि अधिकतम 2 बिट्स से भिन्न होता है? यदि हां, तो यह वैसे भी इनपुट की कंपोजिटिटी की जांच करेगा।
जंगवान मिन

नहीं, यही कारण है कि ;0वहाँ है - Œċअनुक्रमित ( J) के प्रतिस्थापन के साथ सभी unordered जोड़े हो जाता है , इसलिए 84 के लिए, जिसमें 7 बिट्स हैं जो 28 हैं (एकल 1,1 से पसंद के लिए [सिंगल बिट फ़्लिप सहित) "रिप्लेसमेंट के साथ" भाग), 29 नहीं (प्लस नो चेंज)।
जोनाथन एलन

इसे हटाया जा सकता है अगर हम जानते हैं कि कोई भी प्राइम ऐसा नहीं है, जो सभी बिट-फ़्लिप किए गए चचेरे भाई हैं; लेकिन मुझे इस तथ्य पर यकीन नहीं है।
जोनाथन एलन

5

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

2<≜.¬(ḃ↰₂↰₂~ḃ≜{ṗ|ℕ<2}∧)
k~k|tgT∧?k↰:Tc

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

यह एक फ़ंक्शन / विधेय है ↰₀जो एक जनरेटर को लौटाता है जो ऐसे सभी नंबर उत्पन्न करता है। (टीआईओ लिंक केवल पहले नंबर को प्रिंट करता है, ताकि कुछ देखने योग्य हो। इसे स्थानीय स्तर पर चलाने से बहुत अधिक उत्पादन हुए हैं, हालांकि।)

अब उन नंबरों को संभालने के लिए अपडेट किया गया जो 0 या 1 के दो बिटफ़्लिप के भीतर हैं (जो न तो प्राइम हैं और न ही कंपोजिट) ​​सही ढंग से।

व्याख्या

हेल्पर विधेय करता है ↰₂ (इनपुट के बराबर एक सूची देता है, शायद एक तत्व को छोड़कर)

k~k|tgT∧?k↰:Tc
   |            Either:
 ~k               the output is produced by appending an arbitrary element
k                 to the input minus its last element
                Or:
        ?k        take the input minus its last element,
          ↰       call this predicate recursively on that,
      T    :Tc    then append
     g            the singleton list consisting of
    t             the last element of the input

अगर यह अपेक्षाकृत सरल पुनरावृत्ति करने के लिए एक कठिन तरीका था, तो मुझे अच्छा लगेगा, लेकिन मुझे यकीन नहीं है कि वहाँ अभी तक है; विनिर्देशन में कुछ आशाजनक दिखने वाली विशेषताएं हैं, लेकिन उन्हें अनिमित के रूप में चिह्नित किया गया है।

मुख्य कार्यक्रम ↰₀

2<≜.¬(ḃ↰₂↰₂~ḃ≜{ṗ|ℕ<2}∧)
2<≜                      For each integer greater than 2
   .                     generate it if
    ¬(                )  it does not have the following property:
      ḃ                  converting it to binary,
       ↰₂↰₂              running the helper predicate twice,
           ~ḃ            and converting back to decimal
             ≜           does not allow us to find a specific value
              {     }    that is:
               ṗ           prime;
                |        or:
                 ℕ<2       nonnegative and less than 2
                     ∧   (disable an unwanted implicit constraint)

4

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

एक पूर्ण कार्यक्रम जो पूर्णांक की संख्या के लिए संकेत देता है और उन्हें एक-एक करके, प्रदर्शित करता है alert()

for(i=prompt(n=2);i;n+=2)(g=b=>b>n?alert(n,i--):(C=(n,x=n)=>n%--x?C(n,x):x>1)(n^b|1)&&g(b*2))(1)

जब तक आपका ब्राउज़र टेल कॉल ऑप्टिमाइज़ेशन का उपयोग करने के लिए सेट नहीं किया जाता है, तब तक यह पुनरावृत्ति अतिप्रवाह के कारण टूट जाएगा।

नीचे एक गैर-पुनरावर्ती संस्करण (102 बाइट्स) है।

for(i=prompt(n=2);i;n+=2){for(c=b=1;b<n;b*=2,c&=C)for(C=k=2,x=n^b|1;k<x;k++)C|=!(x%k);c&&alert(n,i--)}

कल्पना

यह एल्गोरिथ्म इस धारणा पर निर्भर करता है कि सभी बिटफ्लिप-प्रतिरोधी समग्र संख्याएं समान हैं। यह एक अधिक महत्वपूर्ण सरलीकरण की ओर जाता है: हर संभव जोड़ी बिट्स को फ़्लिप करने के बजाय, हम केवल बिट # 0 और एक और (या कोई अन्य बिट बिल्कुल नहीं) फ्लिप करते हैं और जांचते हैं कि सभी परिणामी संख्याएं समग्र हैं।

हालाँकि, मैं किसी भी स्पष्ट प्रमाण का पता नहीं लगा सकता कि एक विषम बिटफ़्लिप-प्रतिरोधी समग्र संख्या वास्तव में मौजूद नहीं है। यह सिर्फ छोटी संख्या (मैंने 1,000,000 तक की जांच की) के मामले में कभी नहीं होता है, और ऐसा लगता है कि किसी को खोजने की संभावना कम हो रही है क्योंकि बिट्स की संख्या बढ़ रही है (लेकिन यह मूल रूप से इसके बारे में सिर्फ मेरा अंतर्ज्ञान है)।


3

जेली , 20 17 बाइट्स

BJŒċṬUḄ^;⁸ÆḍṂỊµÐḟ

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

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

BJŒċṬUḄ^;⁸ÆḍṂỊµÐḟ  Main link. Argument: n

              µ    Combine all links to the left into a chain.
               Ðḟ  Filter-false; keep only integers k from [1, ..., n] for which
                   the chain returns 0.
B                    Convert k to binary.
 J                   Get the indices of all digits.
  Œċ                 Take all combination of two indices, with replacement.
    Ṭ                Untruth; map each index pair [i, j] to the Boolean array of
                     length j that has 1's at (and only at) indices i and j.
     U               Upend; reverse each Boolean array.
      Ḅ              Unbinary; convert each array from base 2 to integer.
       ^             XOR the resulting numbers with k.
        ;⁸           Append k to the resulting list.
          Æḍ         Count the number of proper divisors of each result.
            Ṃ        Take the minimum.
             Ị       Insignificant; test if the minimum is 0 or 1.

1
अब मैं सोच रहा हूं कि यह मेरे बारे में क्या कहता है कि मुझे पता चला कि यह कैसे काम करता है, जिसमें कोई स्पष्टीकरण उपलब्ध नहीं है (आपके स्रोत कोड को पढ़कर)। मैं इस सवाल पर जेली में गया था, लेकिन बहुत दूर नहीं आया (यानी मेरे पास एक काम करने वाला समाधान था - यह वही है जो परीक्षण मामलों की सूची उत्पन्न करता है - लेकिन यह स्पष्ट रूप से बहुत अधिक क्रिया है)। मुझे जो याद आ रहा था, वह पहले नंबर-टू-नो-टू-टू-1-बिट्स के उत्पादन की चाल थी, और फिर इसे XORing करना था।

3

पायथन 2, 113 बाइट्स

r=range
lambda N:[n for n in r(1,N)if 1-any((bin(k).count('1')<3)*all((n^k)%q for q in r(2,n^k))for k in r(n+1))]

(दूसरी पंक्ति एक अनाम फ़ंक्शन है जो सभी बिटफ्लिप-प्रतिरोधी समग्र संख्याओं की एक सूची देता है जो फ़ंक्शन के इनपुट से कम हैं।)

सिंटैक्स all(u%q for q in range(2,u))का मूल्यांकन होगा कि Trueजब भी uया तो के बराबर या उससे कम या इसके बराबर 2, और अन्यथा का मूल्यांकन होगा False। ( Trueयदि uयह इससे कम या बराबर है, तो रिक्त है 2।)

दूसरे शब्दों में, अगर all(u%q for q in range(2,u))समान है 0और केवल अगर uसमग्र है।

यदि फ़ंक्शन का इनपुट इससे कम है 2, तो फ़ंक्शन एक खाली सूची (इच्छानुसार) देता है। तो मान लें कि इनपुट Nकम से कम है 2, और मान लीजिए 1 <= n < N। (सम्मिलित) के माध्यम kसे प्रत्येक के लिए , कोड की जाँच करेगा कि क्या XOR'd के साथ समग्र है, और यह भी जाँच करता है कि उसके बाइनरी प्रतिनिधित्व में दो सबसे अधिक है या नहीं। यदि संमिश्र है, या यदि दो से अधिक है , तो यह अगले मान पर जाता है । यदि यह इस तरह से सभी मूल्यों से गुजरता है , तो यह सूची में शामिल है।0nnkk1n^kk1kk0nn

दूसरी ओर, यदि kअधिकांश दो के साथ ऐसा कोई मूल्य है 1जो n^kसमग्र नहीं है, तो nसूची में शामिल नहीं है।


2

पर्ल 6 , 87 85 बाइट्स

{grep {!grep {$_%all 2..^$_},($_ X+^grep {.base(2)~~m:g/1/ <3},^(2+<.log(2)))},2..$_}

ऐसे सभी नंबर लौटाता है जो इनपुट नंबर से छोटे या बराबर होते हैं।

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

प्रत्येक संख्या n से 2 इनपुट के लिए, यह निम्नलिखित करता है:

  1. ^ (2 + <.log (2))

    सभी गैर-नकारात्मक पूर्णांक बनाता है जो n की तुलना में समान या छोटी बिट लंबाई है ।

  2. grep {.base (2) ~~ m: g / 1 / <3},

    इस सूची से फ़िल्टर संख्याएँ जिनके पास तीन बिट्स से कम है (एक रेगेक्स का उपयोग करके)।

  3. $ _ X + ^

    XOR के n उन संख्याओं से प्रत्येक के साथ, के सभी वैध "उत्परिवर्तन" उपज एन

  4. grep {$ _% सभी 2 .. ^ $ _}

    यदि आउटपुट में से कोई भी गैर-समग्र नहीं है (तो प्रत्येक उत्परिवर्तन x मोडुलो को 2 और x -1 के बीच संख्याओं का एक-जंक्शन द्वारा जाँचकर) केवल n आउटपुट आउटपुट सूची का हिस्सा होने देता है ।


2

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

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

Cases[4~Range~#,x_/;And@@CompositeQ[Fold[#+##&]/@Select[{0,1}~Tuples~BitLength@x,Tr@Abs[#-x~IntegerDigits~2]<3&]]]&

(* or *)

(s=Select)[4~Range~#,xAnd@@CompositeQ[Fold[#+##&]/@s[{0,1}~Tuples~BitLength@x,Tr@Abs[#-x~IntegerDigits~2]<3&]]]&

बहुत अक्षम है क्योंकि यह 2 ^ तक की सभी संख्याओं को उत्पन्न करता है (lg (n))।

दूसरा कोड U + F4A1 ( Functionफ़ंक्शन) का उपयोग करता है


1

फ्लोराइड , 95 109 बाइट्स

Bj:[n KnIw(j)Fp(Cao(hm("".y(k)))Mhm("".y(k))>1KkIcd("10"*Z(hi(n)),Z(hi(n)))FT(a!=b Ka,bIq(hi(n),"".y(k)))<3)]

बिटफ्लिप-प्रतिरोधी संख्या की एक सूची देता है input - 1। नुकीली स्थितियों (0 और 1) को भी संभालता है।

फ्लोरॉयड मेरी एक पुरानी भाषा है, जिसका मैंने केवल दो बार इस्तेमाल किया है। यह एक loooong समय के लिए छुआ नहीं है, इसलिए कार्यक्रम का आकार।

निम्नलिखित पायथन कोड में अनुवाद करता है, जो मुझे लगता है कि पुनरावृत्ति के साथ कम किया जा सकता है।

lambda j:[n for n in  range(j) if  all( not  functions.isPrime( functions.fromBinStr("".join(k))) and  functions.fromBinStr("".join(k))>1for k in  functions.combinations_with_replacement("10"*len( functions.pureBin(n)),len( functions.pureBin(n))) if sum (a!=b for a,b in  zip( functions.pureBin(n),"".join(k)))<3)]

यहां इस्तेमाल किया गया प्रत्येक फंक्शन फ्लोरॉयड में पूर्वनिर्धारित है। इस पृष्ठ में सभी फ़ंक्शन और उनकी परिभाषाएँ हैं।


बस एक नोट के रूप में: कुछ संख्याएँ (0 और 1) हैं, जो प्रमुख नहीं हैं, लेकिन समग्र भी नहीं हैं। इसके कारण कुछ समाधानों को सुधारना पड़ा है; मुझे संदेह है कि यह भी होगा।

@ ais523 मैं वास्तव में उसके बारे में पढ़ा था। क्या अभी तक कोई ज्ञात परीक्षण मामला है? वैसे भी, मैं उसे ठीक कर दूंगा, क्योंकि यह (शायद) उस पर भी प्रवण है, धन्यवाद!
यति

@TuukaX: 131136 में 0 एकमात्र गैर-समग्र मूल्य के रूप में है जिसे दो बिटफ्लिप्स (और 0 अभाज्य नहीं है) के माध्यम से पहुँचा जा सकता है। इसे खोजने के लिए जोनाथनअलन का धन्यवाद।

1

MATL , 30 28 27 26 बाइट्स

:GBnW:qtB!s3<)!Z~tZpw~+a~f

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

सभी बिटफ्लिप-प्रतिरोधी कंपोजिट संख्या को (और सहित) n तक आउटपुट करता है। जेली समाधान दोनों के विचारों का उपयोग करता है - केवल 0 को समस्याग्रस्त गैर-प्रधान मानता है; और पहले 2 की दूरी के भीतर संख्याओं की एक सूची बनाता है, फिर एक xor लेता है।

वैकल्पिक समाधान, लूपिंग द्वारा (30 बाइट्स):

:"@BnW:qt@Z~B!s3<)Zp1M~ha~?@D]

सभी बिटफ्लिप-प्रतिरोधी कंपोजिट संख्या को (और सहित) n तक आउटपुट करता है।


0

CJam , 34 33 बाइट्स

ri{_2b,,2\f#_m*::|0+f^:mp:+!},2>p

सभी बिटफ्लिप प्रतिरोधी कंपोजिट की गणना n से कड़ाई से कम करता है ।

जोनाथन एलन की तरह, मुझे यकीन नहीं है कि यह वास्तव में 0 बिटफ्लिप्स की जांच करना आवश्यक है। यदि यह पता चलता है कि किसी भी अभाज्य संख्या में उसके सभी बिटफ्लिप परिणाम नहीं हैं, तो समग्र संख्या 0+को हटाया जा सकता है।

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

व्याख्या

ri                                 Take an integer from input (n)
  {                                Filter out all numbers in the range 0...n-1 for which
                                    the following block is false
   _                                 Duplicate the number
    2b,                              Convert to binary, get the length
       ,                             Range from 0 to length-1
        2\f#                         Map each number in that range as a power of 2
                                      results in all powers of 2 less than or equal to n
            _m*                      Cartesian product with itself
               ::|                   Reduce each Cartesian pair with btiwse OR
                                      results in all numbers that have 1-2 1 bits in binary
                  0+                 Add 0 to that list
                    f^               Bitwise XOR the number we're checking with each of these
                                      This computes all the bitflips
                      :mp            Map each result to 0 if it's prime, 1 if it's composite
                         :+!         Take the sum of the list, check if it's 0
                                      If it is, then none of the results were prime
                            },     (end of filter block)
                              2>   Discard the first 2 numbers, since 0 and 1 always pass
                                p  Print the list nicely

0

MATL , 29 बाइट्स

एक सुधार के लिए जोनाथन एलन को धन्यवाद।

q:Q"@BtnFTZ^=~!s3<fqt2>)Zp~?@

यह एक संख्या n लेता है और सभी बिटफ्लिप-प्रतिरोधी समग्र संख्याओं को n तक आउटपुट करता है ।

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

MATL ऑनलाइन पर यह कोशिश करो!

q:Q       % Input n implicitly. Push range [2 3 ... n]
"         % For each k in [2 3 ... n]
  @       %   Push k
  B       %   Convert to binary. Gives a row vector of zeros and ones, say v
  tn      %   Duplicate. Number of elements, say m
  FT      %   Push [0 1]
  Z^      %   Cartesian power of [0 1] raised to m. This gives a matrix,
          %   where each row is a binary number of length m
  =~      %   Compare with v, with broadcast
  !s      %   Sum of each row. Gives a row vector. This is the number of
          %   bit flips
  3<      %   True for numbers that are less than 3 bit flips away from k
  fq      %   Find their indices and subtract 1 to convert to decimal form.
          %   This gives a vector of numbers that are less than 3 bit flips
          %   away from k
  t2>)    %   Remove 0 or 1
  Zp~     %   Test each entry for non-primeness
?         % If all entries are true
  @       %   Push k
          % End (implicit)
          % Display stack (implicit)

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