फोल्डिंग नंबर

Question

एक संख्या को देखते हुए अगर यह एक तह संख्या है।

एक तह संख्या एक ऐसी संख्या है जो यदि आप इसे द्विआधारी प्रतिनिधित्व लेते हैं और इसे आधा में "गुना" करते हैं, तो यह संख्या के पहले आधे भाग के XNOR गुणन का परिणाम है और दूसरी छमाही इसके अंकों के साथ उल्टा है, तो आपको मिलेगा शून्य।

यदि संख्या में अंकों की विषम संख्या है तो बाइनरी में इसका मध्य अंक 1 होना चाहिए और तह करते समय इसे नजरअंदाज कर दिया जाना चाहिए।

चूंकि मैं थोड़ा भ्रमित हो सकता हूं इसलिए मैं कुछ उदाहरण दूंगा:

178

178 का बाइनरी प्रतिनिधित्व है

10110010

इसे मोड़ने के लिए हमने पहले इसे आधे हिस्से में विभाजित किया

1011 0010

हम दूसरी छमाही को उल्टा करते हैं

1011
0100

और हम दो हिस्सों में XNOR:

0000

यह शून्य है इसलिए यह एक तह संख्या है।

1644

1644 का बाइनरी प्रतिनिधित्व है

11001101100

इसे मोड़ने के लिए हमने पहले इसे आधे हिस्से में विभाजित किया

11001 1 01100

मध्य बिट 1 है इसलिए हम इसे बाहर फेंक देते हैं।

11001 01100

हम दूसरी छमाही को उल्टा करते हैं

11001
00110

और हम दो हिस्सों में XNOR:

00000

यह शून्य है इसलिए यह एक तह संख्या है।

4254

4254 का बाइनरी प्रतिनिधित्व है

1000010011110

इसे मोड़ने के लिए हमने पहले इसे आधे हिस्से में विभाजित किया

100001 0 011110

मध्य बिट 0 है इसलिए यह फोल्डिंग नंबर नहीं है।

कार्य

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

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

यहां पहले 99 फोल्डिंग नंबर दिए गए हैं:

[1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120, 142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370, 412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738, 796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206, 1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848, 1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470, 2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132, 3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558]

Comments

4 एक तह संख्या नहीं है?

— अदनान

@ अदनान मध्यम बिट है 0, इसलिए नहीं। (हालांकि यह इस तरह एक तीसरा काम किया उदाहरण के लायक हो सकता है।) वही 18 के लिए चला जाता है।

— मार्टिन एंडर

@MartinEnder आह, मुझे वह हिस्सा याद आ गया। धन्यवाद :)

— अदनान

मध्य संख्या को एक (विषम अंक बाइनरी #s में) क्यों होना चाहिए? क्या वह मनमानी थी या कोई कारण था?

— greyShift

@timrxd यदि आप विपरीत अंको को जोड़कर किसी संख्या को मोड़ने की कोशिश करते हैं, तो केंद्र में एक संख्या जिसके साथ आपको सभी का एक स्ट्रिंग मिलेगा। यदि इसके केंद्र में एक शून्य है तो आप परिणाम में एक शून्य के साथ समाप्त हो जाएंगे।

— गेहूं जादूगर

Answer 1

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

Bœs2µḢ^UȦ

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

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

Bœs2µḢ^UȦ  Main link. Argument: n

B          Binary; convert n to base 2.
 œs2       Evenly split 2; split the base 2 array into chunks of equal-ish length.
           For an odd amount of digits, the middle digit will form part of the
           first chunk.
    µ      Begin a new, monadic chain. Argument: [A, B] (first and second half)
     Ḣ     Head; remove and yield A.
       U   Upend; reverse the digits in [B].
      ^    Perform vectorized bitwise XOR of the results to both sides.
           If A is longer than B, the last digit will remain untouched.
           n is a folding number iff the result contains only 1's.
        Ȧ  Octave-style all; yield 1 iff the result does not contain a 0.

Comments

बहुत यकीन है कि मैंने कोशिश की है कि, ओह अच्छा :)

— जोनाथन एलन

Answer 2

05AB1E , 13 12 बाइट्स

कोड:

bS2ä`R0¸«s^P

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

स्पष्टीकरण:

सबसे पहले, हम संख्या का उपयोग करके बाइनरी में कनवर्ट करते हैं b। 1644 11001101100 हो जाता है । हम इसे दो टुकड़ों में विभाजित करते हैं 2ä। उदाहरण के लिए, 11001101100 बन जाएगा:

[1, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 0]

यदि बिट्स की असमान संख्या है, तो पहले भाग को अतिरिक्त बिट प्राप्त होगा। हम Rअंतिम स्ट्रिंग को विकसित करते हैं और एक शून्य का उपयोग करके जोड़ते हैं 0¸«। इसका कारण केवल सत्य परिणाम देना है जब मध्य बिट 1 ( 1 XOR 0 = 1 और 0 XOR 0 = 1 ) है। यदि कोई मध्य बिट नहीं है, तो 05AB1E अंतिम बिट को अनदेखा करेगा (जो शून्य जोड़ा गया था):

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]

आखिरी चीज जो हमें करने की ज़रूरत है वह एक तत्व-वार XOR है और परिणाम का उत्पाद लेना है। यदि एक तत्व बहुत अधिक है, तो प्रोग्राम अंतिम तत्व को बाहर छोड़ देगा ( [1, 0, 0] XOR [0, 1] = [1, 1]) उदाहरण के लिए:

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0] XOR

हो जाता है:

[1, 1, 1, 1, 1, 1]

और उस का उत्पाद 1 है , जो सत्य है।

Comments

बहुत अच्छा! बहुत बुरा sआवश्यकता है।

— एमिग्ना

@Eigna हाँ, मुझे कुछ समय ठीक करना चाहिए। इससे मुझे अन्य आज्ञाओं के लिए भी कुछ प्रेरणा मिली: p

— अदनान

Awwh, मैं वहां आधा था, पहली बार 05AB1E को बाहर करने की कोशिश कर रहा था, यह एक कठिन था। bÐg;ôजहाँ तक मैं ताज़ा करने से पहले मिला था और आप इसे देखा था। महान जवाब, मुझे सीखने में मदद करना!

— मैजिक ऑक्टोपस Urn

@carusocomputing धन्यवाद! 05AB1E :) में नए लोगों को दिलचस्पी लेते हुए देखना हमेशा अच्छा होता है। यदि आपके कोई प्रश्न हैं, तो आप इस चैटरूम में हमेशा पूछ सकते हैं ।

— अदनान

ओह बकवास! यह एक अलग सवाल था! मैं "सुपर फोल्डिंग" प्रश्न पर था। मैंने उत्तर को उस समाधान तक भी पहुंचाने की कोशिश की, लेकिन पुनरावृति और भी चुनौतीपूर्ण है।

— मैजिक ऑक्टोपस Urn

Answer 3

जावा 7, 152 145 142 138 134 बाइट्स

boolean f(Long a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;for(;i<l/2;)z*=b[i]-b[l-++i];return z!=0;}

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

स्क्रॉल पट्टियों के बिना:

boolean f(Long a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;
    for(;i<l/2;)
        z*=b[i]-b[l-++i];
    return z!=0;
}

Comments

" लेकिन निश्चित रूप से नीचे गोल्फ हो सकता है " मुझे नहीं लगता कि आपका वर्तमान उत्तर अधिक गोल्फ हो सकता है, लेकिन मैं गलत साबित होना चाहूंगा। +1 (PS: आपके अनगुल्ड भाग में दो क्लोजिंग ब्रैकेट होते हैं।)

— केविन क्रूज़सेन

byte[]b=(a+"").getBytes();से छोटा है char[]b=a.toString(a,2).toCharArray();और अभी भी (-12 बाइट्स) काम करने लगता है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन यह एक बाइनरी स्ट्रिंग AFAICT नहीं है, लेकिन मुझे लगता है getBytesकि अभी भी चार [] पर काम कर सकता है। धन्यवाद :)

— ज्योबिट्स

@KevinCruijssen हाँ, एहसास हुआ कि और हटा दिया टिप्पणी> _ <।

— मैजिक ऑक्टोपस Urn

@Geobits: चूंकि विधि किसी भी सत्य या झूठे मूल्यों को वापस कर सकती है, आप सिर्फ zएक इंट ( झूठी के लिए, सत्य के 0लिए किसी भी अन्य) के रूप में वापस आ सकते हैं - आपको कुछ बाइट्स बचाएंगे।

— शौकी

Answer 4

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

पुनरावर्ती गणना:

(bit(N) XOR bit(0)) AND (bit(N-1) XOR bit(1)) AND (bit(N-2) XOR bit(2)) etc.

Nइनपुट में उच्चतम बिट सेट की रैंक कहां है।

यदि इनपुट में विषम संख्या में बिट्स हैं, तो मध्य बिट XOR'ed अपरिभाषित है ( pop()रिक्त सरणी पर दिया गया मान ), जो इसे अपरिवर्तित करता है। इसलिए, एक 0मध्य बिट आउटपुट को साफ करता है और एक 1मध्य बिट अन्य संचालन के परिणाम को नहीं बदलता है - जो एक तह संख्या की चुनौती की परिभाषा के अनुरूप है।

f=(n,[a,...b]=n.toString(2))=>a?(a^b.pop())&f(n,b):1

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

Comments

अच्छा! क्या आप बता सकते हैं कि यह कैसे मध्य बिट को ध्यान में रखता है?

— ETHproductions

@ETHproductions - ज़रूर। मैंने उस बारे में एक नोट जोड़ा है।

— अरनौलद

Answer 5

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

s=bin(input())[2:]
while''<s!='1':s[-1]==s[0]<_;s=s[1:-1]

निकास कोड के माध्यम से आउटपुट : फाल्सी के लिए त्रुटि, और ट्रू के लिए कोई त्रुटि नहीं।

इनपुट को बाइनरी में परिवर्तित करता है। जाँचता है कि क्या पहला और आखिरी चरित्र असमान है, उन पात्रों को हटाने के बाद इसे रखता है और दोहराता है।

s[-1]==s[0]<_यदि पहला और अंतिम वर्ण असमान नामांकित चर का मूल्यांकन करने की कोशिश कर रहा है, तो तुलना एक त्रुटि देती है _। यदि वे समान हैं, तो इसके बजाय असमानताओं की श्रृंखला कम परिचालित है। जब हम के मध्य तत्व को प्राप्त करते हैं 1, तो whileलूप को विशेष रूप से ठीक करने के लिए इसे समाप्त कर दिया जाता है।

मुझे लगता है कि विशुद्ध रूप से अंकगणितीय दृष्टिकोण एक पुनरावृत्ति के साथ कम होगा जैसे f=lambda n,r=0:...f(n/2,2*r+~n%2)...कि बाइनरी अंकों को फ़्लिप करने के लिए अंत से फ़्लिप किया गया और उलट दिया गया, और पता लगाया कि कब nऔर rएक केंद्र के बराबर हैं 1। हालांकि प्रमुख शून्य और केंद्र के साथ सूक्ष्मताएं हैं।

Answer 6

पायथन 2, 94 79 72 67 बाइट्स

F=lambda s:s in'1'or(s[0]!=s[-1])*F(s[1:-1])
lambda n:F(bin(n)[2:])

@Xnor के लिए धन्यवाद 12 बाइट्स सहेजे गए

दूसरी पंक्ति पर एक अनाम फ़ंक्शन को परिभाषित करता है।

स्पष्टीकरण (कुछ व्हाट्सएप के साथ जोड़ा गया):

F = lambda s:                                        # We define a function, F, which takes one argument, the string s, which returns the following:
             s in'1'                                 # Gives true if s is '' or s is '1', the first case is a base case and the second is for the middle bit case.
                     or(s[0] != s[-1])               # Or the first and last are different
                                      * F(s[1:-1])   # And check if s, without the first and last element is also foldable.
lambda n: F(bin(n)[:-2])                             # The main function, which calls F with the argument in binary form.

यहाँ कोशिश करो !

Comments

s==''or s=='1'हो सकता हैs in'1'

— xnor

ओह, ऐसे ही महान दिमाग ...

— जोनाथन एलन

andगणित हो सकता है *। साथ ही, fअनाम होने की अनुमति है।

— xnor

Answer 7

हास्केल, 89 88 86 बाइट्स

f n|n<2=[n]|1>0=mod n 2:f(div n 2)
g n=elem(product$zipWith(+)(f n)$reverse$f n)[1,2]

बिटवाइस को इसके रिवर्स के साथ और उत्पाद लेने के लिए संक्षेप में संक्षेप में काम करता है। यदि यह 1 या 2 है, तो संख्या एक तह संख्या है (1 यदि बिट्स भी हैं, तो 2 अजीब बिट्स और बीच में एक हैं)।

Answer 8

पायथन 2, 100 99 95 94 बाइट्स

यह थोड़ा लंबा लगता है, लेकिन मैं इस पर काम करता रहूंगा :) प्रिंट्स 1अगर एक नंबर को फोल्ड किया जा सकता है, 0अन्यथा।

a=bin(input())[2:]
b=len(a)
print(a[b/2]>=`b%2`)*all(c!=d for c,d in zip(a[:b/2],a[:~b/2:-1]))

^{इसे यहाँ टेस्ट करें!}

^{1-बाइट बचाने के लिए गेहूं जादूगर को धन्यवाद :)}

^{5-बाइट बचाने के लिए रॉड का धन्यवाद! :)}

Comments

आप के b-1साथ बदल सकते हैं~b

— गेहूं जादूगर

@WheatWizard बहुत बढ़िया, धन्यवाद!

— काडे

आप बदल सकते हैं [1,a[b]>'0'][len(a)%2]के साथ(a[b]>=`len(a)%2`)

— रॉड

आप 1 बाइट की बचत करके, ` e=len(a)को बदलने के लिए भी जोड़ सकते हैं b=e/2 `e%2। और फिर दोनों अजगर जवाब में बंध जाएंगे:

— रॉड

@Rod Awesome: D को छोड़कर अब दूसरा जवाब मुझे कुचल रहा है;)

— Kade

Answer 9

> <> , 37 + 3 = 40 बाइट्स

<,2-@:%2:v!?:
=2lrv?=1l<+={$r0?
0=n;>

इनपुट को प्रोग्राम स्टार्ट पर स्टैक पर उपस्थित होने की उम्मीद है, इसलिए -vध्वज के लिए +3 बाइट्स ।

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

Answer 10

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

Bœs2U0¦z0^/€Ạ

TryItOnline
या मिलान शब्द 4558 तक

कैसे?

Bœs2U0¦z0^/€Ạ - Main link: n
B             - binary
 œs2          - split into 2 slices (odd length will have first longer than second)
     0¦       - apply to index 0 (the right hand one)
    U         - reverse
       z0     - zip together with filler 0 (thus central 1 or 0 will pair with 0)
          /€  - reduce with for each
         ^    -     XOR
            Ạ - All truthy?

Answer 11

पर्ल, 46 बाइट्स

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

STDIN पर संख्या के साथ चलाएँ

folding.pl <<< 178

folding.pl:

#!/usr/bin/perl -p
$_=($_=sprintf"%b",$_)<s%.%!/\G1$/^$&^chop%eg

मैं इसे एक पर्ल बग मानता हूं जो यह काम करता है। आंतरिक $_को संशोधित होने के बाद मैच की स्थिति के अपडेट नहीं मिलने चाहिए। इस कार्यक्रम में मैच की स्थिति वास्तव में के अंत से आगे बढ़ती है$_

Comments

अच्छा है। सर्वश्रेष्ठ मैं कर सकता है 59 perl -pe '$_=sprintf("%b",$_)=~/^(.*)1?(??{reverse$^N=~y%01%10%r})$/':: /

— दादा

Answer 12

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

ḃḍ{↔|h1&b↔}ᵗz₂≠ᵐ

यह ऑनलाइन बहुत काम नहीं करता है ...

इनपुट चर के माध्यम से इनपुट लेता है और सफलता या विफलता के माध्यम से आउटपुट करता है। यह बहुत हद तक निर्भर करता है z₂, जो 30 अप्रैल से भाषा में है, लेकिन हम यह पूछना भूल गए हैं कि यह टीआईओ पर खींच लिया गया है, इसलिए यह केवल भाषा की स्थानीय स्थापना पर काम करता है। किसी भी तरह से यह शायद एक अत्यधिक भोली दृष्टिकोण है।

                    The input
ḃ                   's binary representation
 ḍ                  split in half
  {       }ᵗ        with its second half
   ↔|               either reversed, or
     h1             if it starts with 1
       &b           relieved of its first element
         ↔          and then reversed
              ≠     has no duplicate elements
            z  ᵐ    in any pair of elements zipped from the two halves
             ₂      which are equal in length.

ब्रेकीलॉग ( टीआईओ पर), 19 बाइट्स

ḃḍ{↔|h1&b↔}ᵗlᵛ↖Lz≠ᵐ

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

lᵛ↖Lzकार्यात्मक रूप से समतुल्य है z₂(यदि आप चर L का उपयोग कहीं और नहीं करते हैं), लेकिन यह भी तीन बाइट्स से अधिक लंबा है।

Answer 13

पायथन 2, 76 71 69 बाइट्स

-5 बाइट्स @ @ डेनिस के लिए धन्यवाद ( ''में मौजूद है '1', इसलिए इसके in('','1')साथ बदलें in'1')
-2 बाइट्स के लिए धन्यवाद @xnor (गुणन का उपयोग करें, (...)*के स्थान पर and)

f=lambda n:f(bin(n)[2:])if n<''else n in'1'or(n[0]!=n[-1])*f(n[1:-1])

Ideone

पुनरावर्ती कार्य, पहली कॉल nपर एक संख्या है, इसलिए यह खाली स्ट्रिंग की तुलना में कम का मूल्यांकन करता है if n<'', और फ़ंक्शन को फिर से बुलाया जाता है, लेकिन nबाइनरी स्ट्रिंग के लिए डाली जाती है; पूंछ या तो एक रिक्त स्ट्रिंग (बिट-लंबाई) या मध्य बिट है, जो खाली या ए के लिए सही है '1'; इसके नीचे यह असमानता (XOR के बराबर) के लिए बाहरी बिट्स का परीक्षण करता है और आंतरिक बिट्स पर पुनरावृत्ति करता है n[1:-1]।

Comments

मुझे लगता है कि n in'1'काम करता है।

— डेनिस

शानदार, मुझे नहीं लगता कि ''यह मौजूद था 'blah', लेकिन हाँ यह है :)

— जोनाथन एलन

andगणित हो सकता है *।

— xnor

Answer 14

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

s=bin(input())[2:]
while s[0]!=s[-1]:s=s[1:-1]or'1'
print'1'==s

प्रिंटों Trueया False। sजब तक वे असमान हैं, तब तक पहले और अंतिम पात्रों को बार-बार निकाले जाने का द्विआधारी प्रतिनिधित्व करता है । जाँचता है कि क्या बची हुई जगह खाली स्ट्रिंग या केंद्रीय है 1। यह परिवर्तित द्वारा किया जाता है ''करने के लिए '1'और पता चल सके कि परिणाम के बराबर होती है '1', जो भी रिक्त स्ट्रिंग पर एक सूचकांक त्रुटि से बचने के।

Answer 15

PowerShell v2 +, 143 बाइट्स

दो संभव दृष्टिकोण, दोनों एक ही बाइट गिनती।

विधि 1:

param($n)if($n-eq1){$n++}$o=1;0..(($b=($n=[convert]::ToString($n,2)).length-1)/2-!($b%2))|%{$o*=$n[$_]-ne$n[$b-$_]};$o*(+"$($n[$b/2])",1)[$b%2]

इनपुट लेता है $n, अगर यह इस एल्गोरिथ्म के लिए एक विशेष मामला है , तो इसे -eqबढ़ाएँ 1। $oहोने के लिए utput सेट करें 1(यानी, सत्य मान लें), फिर बाइनरी 0को [convert]एड किए गए इनपुट नंबर के मिडवे पॉइंट से लूप करें । -!($b%2)विषम लंबाई के बाइनरी नंबर के लिए खाते पर ध्यान दें ।

प्रत्येक पुनरावृत्ति, हम वर्तमान अंक की तुलना $n[$_]अंत से उसी लंबाई के अंक के साथ करते हैं $n[$b-$_], और बूलियन परिणाम को गुणा करते हैं $o(अनिवार्य रूप -andसे उन सभी पर प्रदर्शन कर रहे हैं)। एक बार जब लूप किया जाता है, तो हमें मध्य बाइनरी अंक के लिए संभावित रूप से खाते की आवश्यकता होती है, जो अंत में छद्म-त्रिगुट है (सरणी के माध्यम से अनुक्रमित $b%2)। कि 1या 0पाइपलाइन पर छोड़ दिया है, और उत्पादन निहित है।

---

विधि 2:

param($n)for($n=[convert]::ToString($n,2);$n.Length-gt2){if($n[0]-ne$n[-1]){$n=$n[1..($n.Length-2)]}else{0;exit}}($n-join'+'|iex)-eq1-or$n-eq10

इनपुट लेता है और [convert]बाइनरी की संख्या के लिए एक ही प्रक्रिया करता है । फिर हम एक में हैं forजब तक कि पाश .lengthबाइनरी स्ट्रिंग की है -greater tहान 2। जब हम लूप में होते हैं, यदि पहला $n[0]और अंतिम $n[-1]अंक -nओटी eक्वालिफ़ाइड है, तो उन दो अंकों को बंद कर दें $nऔर इसे फिर से स्टोर करें $n। अन्यथा, उत्पादन 0और exit। एक बार जब हम लूप से बाहर कर रहे हैं, हमारे पास या तो (की एक सरणी 1, 1,0, 0,1, 1,1, या 0,0), या दो के लिए बाइनरी स्ट्रिंग 10, या 3 11। इसलिए, हमें उन दो संभावनाओं का परीक्षण करने की आवश्यकता है। पहले के लिए, हम -join $nएक साथ +परिणाम का मूल्यांकन करते हैं और परीक्षण करते हैं कि यह है1(इस सरणियों के लिए सच है 1, 1,0है, और 0,1है, लेकिन है $falseसरणियों के लिए 0,0और 1,1या तार 10या 11)। अन्य -orका परीक्षण यह $nहै कि क्या -equal है 10(यानी, इनपुट 2)। उस बूलियन को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

Answer 16

सीजेएम , 13 बाइट्स

ri2b_W%.+:*3&

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

---

ri2b   e# convert input to binary
_W%.+  e# flip and sum (if folding all bits are 1 except middle)
:*     e# product is 0 or power of 2 (2 if middle folds)
3&     e# keep only 1 or 2, everything else becomes 0 (false)

Answer 17

MATL , 16 बाइट्स

tBn2/kW&\hBZ}P=~

सत्य सभी के साथ एक सरणी है। यहाँ सत्य / झूठे मापदंड की जाँच करें ।

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

व्याख्या

1644उदाहरण के रूप में इनपुट का उपयोग करते हैं ।

t     % Imolicitly take input. Duplicate
      %   STACK: 1644, 1644
Bn    % Number of digits of binary expansion
      %   STACK: 1644, 11
2/k   % Divide by 2 and round down
      %   STACK: 1644, 5
W     % 2 raised to that
      %   STACK: 1644, 32
&\    % Divmod
      %   STACK: 12, 51
h     % Concatenate horizontally
      %   STACK: [12 51]
B     % Binary expansion. Each numnber gives a row, left-padded with zeros if needed
      %   STACK: [0 0 1 1 0 0; 1 1 0 0 1 1]
Z}    % Split into rows
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
P     % Reverse
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
=~    % True for entries that have different elements
      %   STACK: [1 1 1 1 1 1]
      % Implicitly display

Answer 18

PHP, 101 बाइट्स

for($r=1;$i<($l=strlen($b=decbin($argv[1])))>>1;)$r*=$b[$i]^1^$b[$l-++$i]^1;$r*=$l%2?$b[$i]:1;echo$r;

या लॉग के साथ

for($r=1,$s=log($n=$argv[1],2)^0;2*$i<$s;)$r*=($n>>$i)%2^($n>>$s-$i++)%2;$s%2?:$r*=($n>>$i)%2;echo$r;

सरणी के साथ 108 बाइट्स

for($r=1,$a=str_split(decbin($argv[1]));$a;)$r*=array_pop($a)!=($a?array_shift($a):0);$r*=$a?$a[0]:1;echo$r;

सही मान <10000

1,2,6,10,12,22,28,38,42,52,56,78,90,108,120,142,150,170,178,204,212,232,240,286,310,346,370,412,436,472,496,542,558,598,614,666,682,722,738,796,812,852,868,920,936,976,992,1086,1134,1206,1254,1338,1386,1458,1506,1596,1644,1716,1764,1848,1896,1968,2016,2110,2142,2222,2254,2358,2390,2470,2502,2618,2650,2730,2762,2866,2898,2978,3010,3132,3164,3244,3276,3380,3412,3492,3524,3640,3672,3752,3784,3888,3920,4000,4032,4222,4318,4462,4558,4726,4822,4966,5062,5242,5338,5482,5578,5746,5842,5986,6082,6268,6364,6508,6604,6772,6868,7012,7108,7288,7384,7528,7624,7792,7888,8032,8128,8318,8382,8542,8606,8814,8878,9038,9102,9334,9398,9558,9622,9830,9894

Answer 19

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

c(s)=s==""||s=="1"||(s[1]!=s[end]&&c(s[2:end-1]))
f(x)=c(bin(x))

मेरा पहला गोल्फ! ठीक उसी तरह से काम करता है जैसे कि भाषा के कारण पाइथन का हल, भाषा के कारण मामूली अंतर (मैं अपने साथ इसे लेकर आया था, हालांकि ...)।

स्पष्टीकरण:

c(s) = s == "" || # Base case, we compared all the digits from 
                  # both halves.
       s == "1" || # We compared everything but left a 1 in the middle
       (s[1] != s[end] &&  # First digit neq last digit (XNOR gives 0).
        c(s[2:end-1]))     # AND the XNOR condition is satisfied for the  
                           # 2nd to 2nd to last digit substring.
f(x) = c(bin(x))  # Instead of a string f takes an integer now.

Answer 20

सी, 223 201 189 194 178 बाइट्स

i,j,m,l,r;f(n){for(m=j=1,i=n;i/=2;++j);for(l=r=i=0;i<j/2;i++)r|=n&m?1<<j/2-i-1:0,m*=2;i=(j&1&&n&m)?i+1:(j&1)?l=r:i;n>>=i;for(m=1;i<j;i++)l|=n&m,m*=2;return !(~(l^r)&(1<<j/2)-1);}

जानवर बल एल्गोरिथ्म। आइए देखते हैं कि इसे कितनी दूर तक पहुँचा जा सकता है।

बेहतर परीक्षण सेटअप बगफिक्स ...

 main()
 {
    int t, s, u, testSet[] = 
    {
    1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120,
    142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370,
    412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738,
    796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206,
    1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848,
    1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470,
    2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132,
    3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752,
    3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558
    };


    for (u=s=0,t=1;t<=4558;t++)
    {
        if (f(t))
        {
          u++;            
          if (testSet[s++]!=t)
              printf("BAD VALUE %d %d\n", testSet[s-1], t);
        }
    }

    printf("%d == %d Success\n", u,
           sizeof(testSet)/sizeof(testSet[0]));

}

Answer 21

MATL , 13 बाइट्स

BttP=<~5Ms2<*

सत्य सभी के साथ एक सरणी है। यहाँ सत्य / झूठे मापदंड की जाँच करें ।

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

व्याख्या

1644उदाहरण के रूप में इनपुट का उपयोग करना :

B     % Implicit input. Convert to binary
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0]
t     % Duplicate
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [1 1 0 0 1 1 0 1 1 0 0]
tP=   % Element-wise compare each entry with that of the reversed array
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [0 0 0 0 0 1 0 0 0 0 0]
<~    % True (1) if matching entries are equal or greater
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
5M    % Push array of equality comparisons again
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], [0 0 0 0 0 1 0 0 0 0 0]
s     % Sum of array
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
2<    % True (1) if less than 2
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
*     % Multiply
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
      % Implicitly display

Answer 22

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

(i,n=i.toString(2))=>/^(1*)2?\1$/.test(+n+ +n.split``.reverse().join``)

एक अनाम फ़ंक्शन को परिभाषित करता है।

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

Answer 23

रेटिना, 92 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$*
+`(1+)\1
${1}0
01
1
^((.)*?)1??((?<-2>.)*$.*)
$1¶$3
O$^`.(?=.*¶)

T`01`10`^.*
^(.*)¶\1

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

यूनीरी में बदलें। उसे बाइनरी में बदलें। संख्या को आधे में काटें और 1यदि हो तो एक बीच हटा दें । पहले हाफ का उलटा। इसके वाले और शून्य स्विच करें। मैच अगर दोनों हिस्सों में बराबर हैं।

Answer 24

रेटिना, 71 70 60 बाइट्स

.+
$*
+`^(1*)\1(1?)\b
$1 $.2
+`^ (.)(.*) (?!\1).$
$2
^( 1)?$

रेटिना के बारे में जानने के लिए मेरे पास अभी भी बहुत कुछ है (जैसे पुनरावर्ती रेगेक्स?)। व्याख्या: चरण १ दशमलव से अकारण परिवर्तित होता है। चरण 2 यूनिरी से छद्म बाइनरी में परिवर्तित होता है। चरण 3 तब तक दोनों सिरों से अंकों को निकालता है जब तक वे बेमेल नहीं होते। यदि आवश्यक हो तो चरण चार एक वैकल्पिक अंतिम केंद्रीय 1 से मेल खाता है। संपादित करें: @ mbomb007 पर 1 बाइट का धन्यवाद सहेजा गया। बाइनरी रूपांतरण के लिए मेरी एकता में सुधार करके 10 बाइट्स बचाए।

Comments

पहली पंक्ति .*या हो सकती है .+।

— mbomb007

Answer 25

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

बदलाव के लिए दो बाइट्स को गुणा में सहेजना

m=n=input()
i=0
while m:i*=2;i+=m&1;m/=2
print(n+i+1)&(n+i)

0एक तह संख्या के लिए रिटर्न और गैर-तह के लिए कुछ और। बिट-ट्विडलिंग दृष्टिकोण का उपयोग करता है।

Answer 26

सी, 65 63 बाइट्स

गुणन में बदलाव के लिए दो बाइट्स

i,m;
f(n){
 m=n;i=0;
 while(m)i*=2,i+=m&1,m/=2;
 return(n+i+1)&(n+i);
}

व्हॉट्सएप को पहले से ही बायटेकाउंट से बाहर रखा गया है, एक फोल्डिंग नंबर के लिए 0 और नॉन-फोल्डिंग के लिए कुछ और। बिट-ट्विडलिंग दृष्टिकोण का उपयोग करता है।

Answer 27

के, 77 बाइट्स

{X:2 0N#X@&:|\X:0b\:x;c:#:'X;$[(~*X 1)|(=). c;~|/(=).(::;|:)@'(-&/ c)#'X;0b]}

स्पष्टीकरण के माध्यम से, एक अनुवाद करने के लिए q

{X:2 0N#X where maxs X:0b vs x;
  c:count each X;
  $[(not first last X)or(=). c;
    not any(=).(::;reverse)@'(neg min c)#'X;0b]
  };