सुपर तह संख्या

Question

हमने पहले ही यहां एक तह संख्या परिभाषित की है ।

लेकिन अब हम एक सुपर फोल्डिंग नंबर को परिभाषित करने जा रहे हैं। एक सुपर फोल्डिंग संख्या एक संख्या है जिसे यदि पर्याप्त बार मोड़ दिया जाए तो अंततः यह दो की शक्ति से एक कम तक पहुंच जाएगी। फोल्डिंग की विधि, फोल्डिंग नंबर प्रश्न की तुलना में थोड़ी अलग है।

तह एल्गोरिथ्म निम्नानुसार है:

• बाइनरी प्रतिनिधित्व ले लो

  जैसे 5882

  1011011111010
  

• इसे तीन भागों में विभाजित किया। प्रथम आधा, अंतिम आधा और मध्य अंक (यदि इसमें अंकों की विषम संख्या है)

  101101 1 111010
  

• यदि मध्य अंक शून्य है तो इस संख्या को मोड़ा नहीं जा सकता है

• दूसरे हाफ को उलट दें और पहले हाफ में सुपरइम्पोज हो जाएं

  010111
  101101
  

• अंकों को जगह में जोड़ें

  111212
  

• Iff परिणाम संख्या को फोल्ड नहीं किया जा सकता है, अन्यथा नया नंबर फोल्डिंग एल्गोरिदम का परिणाम है।

एक संख्या एक सुपर तह संख्या है, अगर इसे लोगों के निरंतर स्ट्रिंग में मोड़ा जा सकता है। (सभी फोल्डिंग नंबर सुपर फोल्डिंग नंबर भी हैं)

आपका कार्य कोड लिखना है जो एक संख्या में लेता है और एक सत्य मान का उत्पादन करता है यदि संख्या सुपर तह संख्या है और मिथ्या अन्यथा। आप अपने कार्यक्रम के आकार पर बनाए जाएंगे।

उदाहरण

5200

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

1010001010000

आधे में विभाजित करें:

101000 1 010000

मध्य एक है, इसलिए हम सुपरवेज़ को जारी रखते हैं:

000010
101000

उन्हें जोड़ा गया:

101010

कोई ट्वोस नहीं है इसलिए हम आधे में विभाजन जारी रखते हैं:

101 010

तह:

010
101

111

परिणाम 111(7 दशमलव में) तो यह एक सुपर तह संख्या है।

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

पहले 100 सुपर तह संख्या हैं:

[1, 2, 3, 6, 7, 8, 10, 12, 15, 20, 22, 28, 31, 34, 38, 42, 48, 52, 56, 63, 74, 78, 90, 104, 108, 120, 127, 128, 130, 132, 142, 150, 160, 170, 178, 192, 204, 212, 232, 240, 255, 272, 274, 276, 286, 310, 336, 346, 370, 400, 412, 436, 472, 496, 511, 516, 518, 524, 542, 558, 580, 598, 614, 640, 642, 648, 666, 682, 704, 722, 738, 772, 796, 812, 852, 868, 896, 920, 936, 976, 992, 1023, 1060, 1062, 1068, 1086, 1134, 1188, 1206, 1254, 1312, 1314, 1320, 1338, 1386, 1440, 1458, 1506, 1572, 1596]

Comments

जब तक मैं गलत नहीं हूँ, 3परीक्षण के मामलों में फिर से कैसे घुस गया? मैं यह नहीं देख सकता कि इसे कैसे मोड़ा जा सकता है, क्योंकि यह फूट जाता है 1 1, तुरंत एक दे देता है 2। या आप कह रहे हैं कि इसे शून्य गुना मोड़ना भी मायने रखता है?

— जियोबिट्स

@geobits 3 को माना जाता है। मैंने इस बार जाँच की;)। तीन 11 है इसलिए यह शून्य फ़ाइलों में केवल लोगों को मिलता है

— Ad Hoc Garf Hunter

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

— जोनाथन एलन

Answer 1

यहाँ कोड गोल्फ में मेरा पहला शॉट है:

पायथन 3, 167 बाइट्स

167 बाइट्स यदि टैब या सिंगल स्पेस इंडेंटेशन के लिए उपयोग किए जाते हैं

def f(n):
 B=bin(n)[2:];L=len(B);M=L//2
 if'1'*L==B:return 1
 S=str(int(B[:M])+int(B[:-M-1:-1]))
 return 0if(~L%2==0and'0'==B[M])or'2'in S else{S}=={'1'}or f(int(S,2))

संपादित करें: नीचे सभी की मदद के लिए धन्यवाद, ऊपर के कोड को 232 बाइट्स के मूल आकार से कम कर दिया गया है!

Comments

PPCG में आपका स्वागत है! आप के बाद रिक्त स्थानों को हटाकर बाइट्स के एक झुंड को बचा सकता है :, और लौटने 0और 1के बजाय Trueऔर False।

— स्टीवन एच।

धन्यवाद स्टीवन। इसके अलावा, मैं 100% निश्चित नहीं हूं कि मैंने बाइट की लंबाई सही से गिना है।

— कपकोटिसि

मैं 232 बाइट्स देख रहा हूं । मुझे दूसरा मौका दें और मैं इसे थोड़ा और आगे बढ़ाने की कोशिश कर सकता हूं।

— स्टीवन एच।

मैं इस प्रयोग किया जाता है को मापने के लिए: bytesizematters.com

— Kapocsi

@Kapocsi, bytesizematters.com मायने रखता है नई-पंक्तियों गलत। Mothereff.in के साथ तुलना करें , 5 अंक और 5 नए अंक 10 बाइट्स होने चाहिए, न कि 14 जो मुझे बाइट्स पर मिले ... इसकी 232.

— लीनस

Answer 2

जावा 7, 202 बाइट्स

boolean g(Integer a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,o=0,c,z=(a+1&a)==0?-1:1;for(;i<l/2&z>0;o+=o+c*2,z*=c>1|(l%2>0&b[l/2]<49)?0:1)c=b[i]+b[l-++i]-96;return z<0?1>0:z<1?0>1:g(o/2);}

पुराने फोल्डिंग फ़ंक्शन को पुन: प्रयोज्य बनाने के लिए थोड़ा प्रयास करना पड़ा, लेकिन यहाँ यह है। यह पाप के रूप में बदसूरत है, ईमानदार होना। मुझे सुबह देखने के लिए यह देखना होगा कि क्या मैं इसे आगे बढ़ा सकता हूं, क्योंकि मैं अभी इसे देखने के लिए मुश्किल से खड़ा हो सकता हूं।

लाइन ब्रेक के साथ:

boolean g(Integer a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,o=0,c,z=(a+1&a)==0?-1:1;
    for(;i<l/2&z>0;o+=o+c*2,z*=c>1|(l%2>0&b[l/2]<49)?0:1)
        c=b[i]+b[l-++i]-96;
    return z<0?1>0:z<1?0>1:g(o/2);
}

Answer 3

CJam , 47 44 बाइट्स

ri2b{_W%.+__0e=)\_,1>\0-X+:*3<*&}{_,2/<}w2-!

इसे ऑनलाइन आज़माएं! या किसी दिए गए नंबर तक सुपर फोल्डिंग नंबरों की सूची तैयार करें ।
यहां गोल्फिंग प्रयास देखे जा सकते हैं ।

---

कोड निम्न चरणों में टूट जाता है:

ri2b                e# get input in binary
{                   e# While fold is legal
 _W%.+_             e#   "fold" the whole number onto itself
 _0e=)\             e#   count zeros and add 1 (I)
 _,1>\              e#   size check, leave 0 if singleton (II)*
 0-X+:*3<           e#   product of 2s, leave 0 if too many (III)
 *&                 e#   (II AND III) AND parity of I
}{                  e# Do
 _,2/<              e#   slice opposite to the actual fold**
}w                  e# End while
2-!                 e# return 1 if "fold" ended in all 2s

संपादित करें: यह संस्करण कम या ज्यादा पिछले संस्करण में डी मॉर्गन के कानून के दृष्टिकोण को लेता है ।

* एकल पर चलने के साथ समस्या यह है कि हम स्लाइस के बाद खाली स्ट्रिंग के साथ फंस जाते हैं।

** यदि एक बाइनरी नंबर सुपर फोल्डिंग है, तो इसकी मिरर इमेज (यदि जरूरत हो तो लीडिंग 0s के साथ) है। यह सही आधा लेने पर एक बाइट बचाता है।

Answer 4

जावास्क्रिप्ट, 149 बाइट्स

f=(i,n=i.toString(2),l=n.length,m=l/2|0)=>/^1*$/.test(n)?1:/[^01]/.test(n)|!+n[m]&l?0:f(0,+n.slice(0,m)+ +n.slice(m+l%2).split``.reverse().join``+"")

एक पुनरावर्ती कार्य को परिभाषित करता है।

स्पष्टीकरण:

f=(i                       //Defines the function: i is input
,n=i.toString(2)           //n is the current number
,l=n.length                //l is the length of the number,
,m=l/2|0)=>                //m is the index of the center character
/^1*$/.test(n)?1:          //returns 1 if the number is all ones
/[^01]/.test(n)            //returns 0 if the number has any chars other than 0 or 1
|!+n[m]&l?0:               //or if the middle char is 0
f(0,+n.slice(0,m)+ +n.slice(m+l%2).split``.reverse().join``+"")
                           //otherwise recurses using the first half of the number plus the second half

Comments

m=l>>1, /2/.test(n), n.slice(l-m)(या उलट स्ट्रिंग स्लाइस)। मुझे लगता है कि यदि आप विफलता और सफलता के मामलों को स्विच करते हैं तो आप उपयोग कर सकते हैं /0/.test(n)?f(...):1।

— नील

Answer 5

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

f=(n,[h,...r]=n.toString(2),b='')=>++n&-n-n?h?f(2,r,r[0]?b+(h- -r.pop()):+h?b:2):!isNaN(n=+('0b'+b))&&f(n):1

प्रारूपित और टिप्पणी की गई

f = (                               // given:
  n,                                // - n = integer to process
  [h, ...r] = n.toString(2),        // - h = highest bit, r = remaining low bits
  b = ''                            // - b = folded binary string
) =>                                //
  ++n & -n - n ?                    // if n is not of the form 2^N - 1:
    h ?                             //   if there's still at least one bit to process:
      f(                            //     do a recursive call with:
        2,                          //     - n = 2 to make the 2^N - 1 test fail
        r,                          //     - r = remaining bits
        r[0] ?                      //     - if there's at least one remaining low bit:
          b + (h - -r.pop())        //       append sum of highest bit + lowest bit to b
        : +h ? b : 2                //       else, h is the middle bit: let b unchanged
      )                             //       if it is set or force error if it's not
    : !isNaN(n = +('0b' + b)) &&    //   else, if b is a valid binary string:
      f(n)                          //     relaunch the entire process on it
  : 1                               // else: n is a super folding number -> success

डेमो

f=(n,[h,...r]=n.toString(2),b='')=>++n&-n-n?h?f(2,r,r[0]?b+(h- -r.pop()):+h?b:2):!isNaN(n=+('0b'+b))&&f(n):1

// testing integers in [1 .. 99]
for(var i = 1; i < 100; i++) {
  f(i) && console.log(i);
}

// testing integers in [1500 .. 1599]
for(var i = 1500; i < 1600; i++) {
  f(i) && console.log(i);
}

Answer 6

पर्ल, 71 70 बाइट्स

के लिए +1 शामिल है -p

STDIN पर नंबर दें

superfolding.pl:

#!/usr/bin/perl -p
$_=sprintf"%b",$_;s%.%/\G0$/?2:/.\B/g&&$&+chop%eg while/0/>/2/;$_=!$&

Answer 7

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

f=lambda n,r=0:f(bin(n)[2:],'')if r<''else(r==''and{'1'}==set(n)or(n in'1'and f(r,'')+2)or n!='0'and'11'!=n[0]+n[-1]and f(n[1:-1],r+max(n[0],n[-1])))%2

ideone

एक दोहराव-पुनरावर्ती कार्य जो पूर्णांक लेता है n, और रिटर्न 0या 1।

एक चर rको बनाए रखने के लिए तह के परिणाम और यह जानने के लिए बनाए रखा जाता है कि क्या हम वर्तमान में हैं: पूर्णांक (केवल पहले); गुना (बाहरी) को मोड़ने की कोशिश करने के लिए एक नया बाइनरी स्ट्रिंग है; या तह (आंतरिक) हैं।

पहले पास nपर और पूर्णांक है, जो कि <''पायथन 2 में है, इसलिए एक बाइनरी स्ट्रिंग को कास्टिंग करके पुनरावृत्ति शुरू होती है।

अगले निष्पादन में है r=''और इसलिए परीक्षण {'1'}==set(n)को निरंतर स्ट्रिंग के लिए जांच करने के लिए निष्पादित किया जाता है 1(आरएचएस नहीं हो सकता है {n}क्योंकि हमें बाद में इस बिंदु को पास करने की आवश्यकता हो सकती है r=''और एक खाली nजब यह एक शब्दकोश होगा जो न के बराबर होगा {'1'}, एक सेट)।

यदि यह संतुष्ट नहीं है तो आंतरिक पूंछ मानदंड का परीक्षण किया जाता है (भले ही अनावश्यक हो): यदि खाली स्ट्रिंग या एकल n in'1'होने पर True का मूल्यांकन करेगा , तो एक नई बाहरी पुनरावृत्ति को तब तक जोड़कर, बाइनरी स्ट्रिंग द्वारा शुरू किया जाता है। और में । इस फ़ंक्शन कॉल के परिणाम में शाब्दिक रूप से जोड़ा जाता है ताकि अगले भाग (तार्किक के दाईं ओर ) के माध्यम से गिरावट न हो सके ।n1rn''r2or

यदि यह एक सत्य मान नहीं है (सभी गैर-शून्य पूर्णांक पायथन में सत्य हैं) बाहरी पूंछ पुनरावृत्ति मानदंड के लिए परीक्षण किया जाता है: n!=0एक मध्य के साथ मामले 0को बाहर करता है और बाहरी दो वर्णों का परीक्षण किया जाता है, वे 2स्ट्रिंग प्रत्यावर्तन द्वारा योग नहीं करते हैं '11'!=n[0]+n[-1]; अगर ये दोनों सही हैं, तो बाहरी बिट्स के nसाथ छोड़ दिया जाता है n[1:-1], और उसके बाद अगर बाहरी पायदान पर एक 1है , तो इस बात से जोड़ा जाता है कि पायथन में इस तथ्य का उपयोग कर ।r0'1'>'0'max(n[0],n[-1])

अंत 2में प्रत्येक आंतरिक पुनरावृत्ति पर जोड़ को ठीक किया जाता है %2।

Answer 8

PHP, 113 बाइट्स

for($n=$argv[1];$n!=$c;$n=($a=$n>>.5+$e)|($b=$n&$c=(1<<$e/=2)-1))if($a&$b||($e=1+log($n,2))&!(1&$n>>$e/2))die(1);

त्रुटि (कोड 1) के साथ बाहर निकलता है यदि तर्क सुपर-फोल्डिंग, कोड नहीं है0 । के साथ भागो -r।
इनपुट 0सही (कोड 0) वापस आएगा ।

टूट - फूट

for($n=$argv[1];            
    $n!=$c;                 // loop while $n is != mask
                            // (first iteration: $c is null)
    $n=                     // add left half and right half to new number
        ($a=$n>>.5+$e)      // 7. $a=left half
        |
        ($b=$n&             // 6. $b=right half
            $c=(1<<$e/=2)-1 // 5. $c=mask for right half
        )
)
    if($a&$b                // 1. if any bit is set in both halves
                            // (first iteration: $a and $b are null -> no bits set)
        ||                  // or
        ($e=1+log($n,2))    // 2. get length of number
        &
        !(1&$n>>$e/2)       // 3. if the middle bit is not set -> 1
                            // 4. tests bit 0 in length --> and if length is odd
    )
    die(1);                 // -- exit with error

Answer 9

PHP, 197 बाइट्स

function f($b){if(!$b)return;if(!strpos($b,"0"))return 1;for($n="",$i=0;$i<($l=strlen($b))>>1;)$n.=$b[$i]+$b[$l-++$i];if($l%2&&!$b[$i]||strstr($n,"2"))return;return f($n);}echo f(decbin($argv[1]));

विस्तारित

function f($b){
    if(!$b)return; # remove 0
    if(!strpos($b,"0"))return 1; # say okay alternative preg_match("#^1+$#",$b)
    for($n="",$i=0;$i<($l=strlen($b))>>1;)$n.=$b[$i]+$b[$l-++$i]; #add first half and second reverse
    if($l%2&&!$b[$i]||strstr($n,"2"))return; #if middle == zero or in new string is a 2 then it's not a number that we search
    return f($n); #recursive beginning
}
echo f(decbin($argv[1]));

सही मान <10000

1, 2, 3, 6, 7, 8, 10, 12, 15, 20, 22, 28, 31, 31, 34, 38, 42, 48, 52, 56, 63, 74, 78, 90, 104, 108, 120, 127, 128, 130, 132, 142, 150, 160, 170, 178, 192, 204, 212, 232, 240, 255, 272, 274, 276, 286, 310, 336, 346, 370, 400, 400 412, 436, 472, 496, 511, 516, 518, 524, 542, 558, 558, 580, 598, 614, 640, 642, 648, 666, 682, 704, 722, 738, 772, 7972, 812, 812, 852, 868, 896, 920, 936, 976, 992, 1023, 1060, 1062, 1068, 1086, 1134, 1188, 1206, 1254, 1312, 1314, 1320, 1338, 1386, 1440, 1458, 1506, 1572, 1572, 1596, 1596, 1596, 1596, 1596, 1596, 1596। 1644, 1716, 1764, 1824, 1848, 1896, 1968, 2016, 2047, 2050, 2054, 2058, 2064, 2068, 2072, 2110, 2142, 2176, 2180, 2184, 2284, 2222, 2254, 2306, 2320, 2358, 2358, 2358। २३ ९ ०, २४३२, २४ ,०, २५६२, २५ 26६, २६ 26,, २६५ 24, २६ ,०, २ ,३०, २ ,३२, २ ,६२, २ 27६६, २, ९, २, ९, ३ ,०, ३० ,२, ३० ,०, ३१ ,०, ३१६४, ३२६४, ३२76४, ३२8३, ३३२8, ३३80०, ३४१२, ३४१२, ३४ ,२ 3492, 3524, 3584, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 40,000,4095, 4162, 4166, 4170, 4176, 4180, 4184, 4222, 4318, 4416, 4420, 4424, 4462, 4458, 4558, 4674, 4688, 4726, 4822, 4928, 4928, 5062, 5186, 52002, 5242, 5338। 5440, 5482, 5578, 5746, 5842, 5986, 6082, 6208, 6212, 6216, 6268, 6364, 6508, 6608, 6720, 6772, 6868, 7012, 7108, 7232, 7288, 7384, 7528, 7624, 7242, 7792। 7888, 8032, 8128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9038, 9102, 9218, 9218। 9222, 9234, 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9760, 9860, 9894, 99848128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9102, 9218, 9222, 9234, 9234। 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9730, 9760, 9830, 9894, 99848128, 8191, 8202, 8206, 8218, 8232, 8236, 8248, 8318, 8382, 8456, 8460, 8472, 8542, 8606, 8714, 8744, 8814, 8878, 8968, 9038, 9102, 9218, 9222, 9234, 9234। 9248, 9252, 9264, 9334, 9398, 9472, 9476, 9488, 9558, 9622, 9730, 9730, 9760, 9830, 9894, 9984