28

यदि आप बाइनरी में कुछ सकारात्मक पूर्णांक को बिना किसी अग्रणी शून्य के साथ व्यक्त करते हैं और हर 1को ए (और हर के 0साथ प्रतिस्थापित करते हैं ), तो क्या सभी कोष्ठक मिलान होगा?

ज्यादातर मामलों में वे नहीं करेंगे। उदाहरण के लिए, 9 1001बाइनरी में है, जो बन जाता है ())(, जहां केवल पहले दो कोष्ठक मेल खाते हैं।

लेकिन कभी-कभी वे मैच करेंगे। उदाहरण के लिए, 44 101100बाइनरी में है, जो बन जाता है ()(()), जहां सभी बाएं कोष्ठक में एक मिलान दाएं कोष्ठक होता है।

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक आधार दस पूर्णांक और प्रिंट में लेता है या एक सत्य मान देता है यदि संख्या के द्विआधारी-कोष्ठक संस्करण में सभी मिलान कोष्ठक हैं। यदि यह नहीं है, तो एक नकली मूल्य प्रिंट या वापस करें ।

बाइट्स में सबसे छोटा कोड जीतता है।

संबंधित OEIS अनुक्रम।

100 से नीचे के सत्य उदाहरण:

2, 10, 12, 42, 44, 50, 52, 56

100 से नीचे के झूठे उदाहरण:

1, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 45, 46, 47, 48, 49, 51, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99

— केल्विन के शौक
स्रोत

5

अधिक OEIS

— मेगो

10

हर चीज के लिए एक सीक्वेंस है ...

— आर्कटुरस

8

TeaScript , 9 बाइट्स 16 18 20 22 24

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

!x÷W(n,¢)

ओह। वह छोटा है। @ Xnor के दृष्टिकोण का उपयोग करता है। यह पुनरावर्ती प्रतिस्थापन फ़ंक्शन ( W) का उपयोग करेगा, जो सभी 10को बिना किसी समान के बदले देगा ()। यदि स्ट्रिंग रिक्त है तो यह संतुलित है।

इस चुनौती को पोस्ट करने के बाद बने टेस्क्रिप्ट के संस्करण का उपयोग करके यह 7 बाइट्स बन सकता है :

!x÷W(n)

Ungolfed

!xT(2)W(n,``)

व्याख्या

!      // NOT, returns true if empty string, else false
 xT(2)   // To binary
 W(n,``) // n is 10, reclusive replaces 10 or (), with nothing.

— Downgoat
स्रोत

1

अति उत्कृष्ट! दो चीजें जो मदद कर सकती हैं: 1) यदि ऊपर जाते समय यह गलत है, तो यह पहले से ही गलत है, इसलिए आपको पहले टिल्ड की आवश्यकता नहीं होनी चाहिए। 2) मेरा मानना ~--cहै कि वास्तव में उसी तरह से मिथ्या है जैसे कि c--।

— ETHproductions

@ETHproductions भयानक, धन्यवाद! अब मैं 16 बाइट्स से नीचे हूँ

— डाउनगोट

13

अजगर, 10 बाइट्स

!uscG`T.BQ

पायथ कंपाइलर में इस परीक्षण सूट की कोशिश करें ।

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

              (implicit) Store the evaluated input in Q.
       .BQ    Return the binary string representation of Q.
 u            Reduce w/base case; set G to .BQ and begin a loop:
     `T         Return str(10) = "10".
   cG           Split G (looping variable) at occurrences of "10".
  s             Join the pieces without separators.
              Set G to the returned string.
              If the value of G changed, repeat the loop.
              This will eventually result in either an empty string or a
              non-empty string without occurrences of "10".
!             Return (and print) the logical NOT of the resulting string.

— डेनिस
स्रोत

मैं बराबर आ गया !u:G`Tk.BQ। समझने में आसान है।

— orlp

हां, यह निश्चित रूप से एक अधिक प्राकृतिक विकल्प है।

— डेनिस

8

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

try:exec"print 1,"+"".join(["],","["][int(c)]for c in bin(input())[2:])
except:print 0

एक भयानक कार्यान्वयन जो वाक्यविन्यास त्रुटियों का दुरुपयोग करता है।

— orlp
स्रोत

3

यह कोड गोल्फ है। भयानक एक तारीफ है।

— corsiKa

8

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

n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

@ Vs और @xsot को धन्यवाद बाइट्स से बचा लिया !

व्याख्या

n=>
  ![...n.toString(    // convert the input to an array of binary digits
    d=2)]             // d = current depth (+2)
      .some(c=>       // iterate through the digits
        (d+=c*2-1)    // increment or decrement the parenthesis depth
          <2          // if the depth goes negative, return false
      )*
        d==2          // if we finished at a depth of 0, return true

— user81655
स्रोत

1

आप जरूरत नहीं हटाकर दो बाइट बचा सकते हैं f=। आप पूर्णांक के मामले के +cबजाय उपयोग का उपयोग भी कर सकते हैं c|0। आप यह भी उपयोग कर सकते हैं (+c?d++:d--)जो और भी छोटा है

— डाउगाट

@ V @ ठीक है। क्या किसी प्रकार का मार्गदर्शक है जब मुझे उपयोग करने की आवश्यकता है f=? क्योंकि साइट पर कई अन्य जावास्क्रिप्ट जवाब उनके कार्यों का नाम देते हैं।

— user81655

1

आमतौर पर आपको केवल फ़ंक्शन को एक नाम देने की आवश्यकता होती है यदि चुनौती के लिए आपको ऐसा करने की आवश्यकता होती है। अन्यथा यह मान लेना सुरक्षित है कि अनाम कार्य ठीक हैं।

— एलेक्स ए।

फ़ायरफ़ॉक्स में, इसके लिए चल रहा है 11, trueजब इसे वापस लौटना चाहिएfalse

— डाउनगोट

2

मैं जावास्क्रिप्ट नहीं जानता, लेकिन मैंने कुछ बाइट्स काटने का प्रयास किया और यह क्रोम में काम करता है:n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

— xsot

7

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

f=lambda n,i=1:i*n>0<f(n/2,i+(-1)**n)or n<i<2

एक पुनरावर्ती कार्य। Parens के वर्तमान घोंसले के स्तर की nएक गिनती रखते हुए, अंत से द्विआधारी अंक पढ़ता है i। यदि यह नीचे आता है 0, तो अस्वीकार करें। जब हम प्रारंभ पर पहुंचते हैं, तो जांचता है कि क्या गिनती है 0।

दरअसल, हम गिनती शुरू करते हैं i=1कि यह जांचना आसान है कि यह गिर गया है या नहीं 0। केवल टर्मिनल सफलता का मामला है n==0और i==1, के साथ जाँच की n<i<2। हम इस जांच को यह सुनिश्चित करने के लिए बाध्य करते हैं कि क्या हो सकता है n==0, या यदि वह iगिर जाता है 0, तो किस स्थिति में यह स्वचालित रूप से विफल हो जाता है।

feersum ने शॉर्ट-सर्किट के लिए असमानता वाले गैर-पुनरावर्ती मामलों को पुनर्गठन करके दो बाइट्स को बचाया।

— XNOR
स्रोत

3

अधिक सशर्त दुरुपयोग की आवश्यकता है। f=lambda n,i=1:n>0<i*f(n/2,i+(-1)**n) or n<i<2कम से कम, 1 बचाता है।

— feersum

6

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

ri2b"}{"f=~

यह एक टेड अशुद्ध है: पेरेंटहिफिबल नंबर के लिए, यह एक या अधिक ब्लॉक प्रिंट करेगा। गैर-अभिभावक संख्याओं के लिए, यह STDOUT को कुछ भी छापे बिना दुर्घटनाग्रस्त हो जाएगा। यदि आप CJam दुभाषिया में यह ऑनलाइन कोशिश करते हैं , तो ध्यान रखें कि यह STDOUT और STDERR के बीच अंतर नहीं करता है।

चूंकि CJam में गैर-खाली / खाली तार सत्य / मिथ्या हैं और मुद्रित आउटपुट हमेशा एक स्ट्रिंग होता है, यह यकीनन नियमों का अनुपालन करता है। कुल 14 बाइट्स के लिए 3 और बाइट्स की अतिरिक्त लागत पर , हम वास्तव में स्टैक पर एक सत्य या नकली स्ट्रिंग छोड़ सकते हैं :

Lri2b"}{"f=~]s

यह अभी भी गैर-अभिभावक संख्याओं के लिए क्रैश होता है, जिसे डिफ़ॉल्ट रूप से अनुमति दी जाती है ।

टेस्ट चलता है

$ cjam <(echo 'ri2b"}{"f=~') <<< 52 2>&-; echo
{{}{}}
$ cjam <(echo 'ri2b"}{"f=~') <<< 53 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 54 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 55 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 56 2>&-; echo
{{{}}}

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

ri          e# Read an integer from STDIN.
  2b        e# Push the array of its binary digits.
    "}{"f=  e# Replace 0's with }'s and 1's with {'s.
          ~ e# Evaluate the resulting string.
            e# If the brackets match, this pushes one or more blocks.
            e# If the brackets do not match, the interpreter crashes.

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

ri2bs_,{As/s}*!

प्रयास करें इस बेला CJam दुभाषिया में या एक ही बार में सभी प्रकार के परीक्षण की पुष्टि ।

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

ri               Read an integer from STDIN.
  2b             Push the array of its binary digits.
    s            Cast to string.
     _,          Push the string's length.
       {    }*   Do that many times:
        As/        Split at occurrences of "10".
           s       Cast to string to flatten the array of strings.
              !  Push the logical NOT of the result.

— डेनिस
स्रोत

1

— डार

6

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

lambda n:eval("'0b'==bin(n)"+".replace('10','')"*n)

एक अनाम फ़ंक्शन। एक अभिव्यक्ति का मूल्यांकन करता है जो दिखता है

'0b'==bin(n).replace('10','').replace('10','').replace('10','')...

प्रत्येक प्रतिस्थापन सभी को हटा देता है 10, जिसके अनुरूप है ()। सभी प्रतिस्थापन किए जाने के बाद, फ़ंक्शन वापस आता है कि क्या बचा है बस बाइनरी उपसर्ग है 0b। यह nप्रतिस्थापन करने के लिए पर्याप्त से अधिक है , क्योंकि एक k-digit संख्या अधिकांश k/2चरणों में होती है, और इसका मूल्य सबसे अधिक है 2**k।

— XNOR
स्रोत

4

रूबी, ४०

->i{n='%0b'%i;1while n.slice!'10';n<?0}

सरल स्ट्रिंग हेरफेर। तब तक 10 ’गिरता है जब तक कोई नहीं बचा।

— चार्ल्स नहीं
स्रोत

4

गंभीरता से , 17 बाइट्स

,;2@¡@`""9u$(Æ`nY

0असत्य के लिए और 1सत्य के लिए आउटपुट । इसे ऑनलाइन आज़माएं ।

स्पष्टीकरण:

,      get value from stdin
;      dupe top of stack
2@¡    pop a: push a string containing the binary representation of a (swapping to get order of operands correct)
@      swap top two elements to get original input back on top
`""9u$(Æ` define a function:
  ""     push empty string
  9u$    push "10" (push 9, add 1, stringify)
  (      rotate stack right by 1
  Æ      pop a,b,c: push a.replace(b,c) (replace all occurrences of "10" in the binary string with "")
n      pop f,a: call f a times
Y      pop a: push boolean negation of a (1 if a is falsey else 0)

— मै जाऊं
स्रोत

4

जाप, 23 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है । दुभाषिया

Us2 a e@+X?++P:P-- &&!P

यह मुझे याद दिलाता है कि TeaScript की तुलना में Japt को अभी तक कितनी दूर जाना है। अगले कुछ दिनों में दुभाषिया को फिर से जारी करने के बाद, मैं Vɪʜᴀɴ की तरह "शॉर्टकट" चार्ट में जोड़ना चाहूंगा।

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

       // Implicit: U = input number, P = empty string
Us2 a  // Convert U to base 2, then split the digits into an array.
e@     // Assert that every item X in this array returns truthily to:
 +X?   //  If X = 1,
 ++P   //   ++P. ++(empty string) returns 1.
 :P--  //  Otherwise, P--. Returns false if P is now -1.
&&!P   // Return the final result && !P (true if P is 0; false otherwise).
       // Implicit: output final expression

इस चुनौती के कुछ समय बाद, @ Vɪʜᴀɴ (जिसे अब @Downgoat के रूप में जाना जाता है) ने मुझे एक पुनरावर्ती-प्रतिस्थापित सुविधा को लागू करने में मदद की, जैसे Wकि टीस्क्रिप्ट उत्तर में। इसका मतलब है कि यह चुनौती अब सिर्फ 5 बाइट्स में की जा सकती है:

!¢eAs  // Implicit: U = input integer, A = 10
 ¢     // Convert U to binary.
  eAs  // Recursively remove instances of A.toString().
!      // Return the logical NOT of the result (true only for the empty string).

इसे ऑनलाइन टेस्ट करें!

— ETHproductions
स्रोत

3

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

(#~IntegerDigits~2//.{x___,1,0,y___}:>{x,y})=={}&

— alephalpha
स्रोत

मैं गणितज्ञ नहीं पढ़ सकता। स्पष्टीकरण, कृपया? :)

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ संख्या को आधार 2 (एक सूची के रूप में) में परिवर्तित करें, फिर 1,0सूची से बार-बार निकालें , और यदि परिणाम एक खाली सूची है तो परीक्षण करें।

— एलेफाल्फा

3

ऑक्टेव, 48 बाइट्स

@(a)~((b=cumsum(2*dec2bin(a)-97))(end)|any(b<0))

— alephalpha
स्रोत

3

सी ++, 104 94 बाइट्स

#include<iostream>
int n,c;int main(){for(std::cin>>n;n&c>=0;n>>=1)c+=n&1?-1:1;std::cout<<!c;}

इस संकलक के साथ चलाएँ , दौड़ने से पहले मानक इनपुट निर्दिष्ट करना होगा।

व्याख्या

मुख्य प्रारंभिक के बाहर घोषणाएं 0 से शुरू होती हैं।
दशमलव को पढ़ना स्पष्ट रूप से बाइनरी में परिवर्तित होता है, क्योंकि यह एक कंप्यूटर है।
हम बिट्स / कोष्ठक की जांच करते हैं क्योंकि बाएं से दाएंn>>=1 ।
c+=n&1?-1:1ओपन कोष्ठक की गिनती रखता है )।
n&c>=0 रुकता है जब केवल अग्रणी 0 रहता है या कोष्ठक खुलने से अधिक बंद हो जाता है।

— लीनुस
स्रोत

3

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

0#l=l==1
_#0=2<1
n#l=div n 2#(l+(-1)^n)
f=(#1)

प्रयोग उदाहरण: f 13-> False।

मैं lकई अन्य उत्तरों की तरह घोंसले के शिकार होने के स्तर पर नज़र रख रहा हूं । हालांकि, "संतुलित" मामले का प्रतिनिधित्व किया जाता है 1, इसलिए "अधिक- )-थान (" मामला है 0।

पुनश्च: l+(-1)^nXnor के जवाब में घोंसले के शिकार स्तर समायोजन पाया ।

— nimi
स्रोत

signumबहुत जटिल लगता है, कैसे के बारे में अभी _#0=1<0?

— xnor

@ एक्सनॉर: हाँ, धन्यवाद।

— nimi

l>0इसके बजाय क्यों नहीं l==1?

— माइकल क्लेन

@ मिचेल कोलीन: क्योंकि केवल l==1संतुलित है। यदि l>1, कोष्ठक असंबद्ध हैं।

— निमि

@ मैं देख रहा हूं, मैंने गलत व्याख्या की कि यह कैसे काम करता है

— माइकल क्लेन

3

पायथन 2, 60 57 56 55 53 52 50 49 बाइट्स

n=input()
i=1
while i*n:i+=1|n%-2;n/=2
print i==1

अंतिम बाइट गिनती को 49 तक लाने के लिए दो बाइट्स और फ़ेर्सम को बचाने के लिए xnor का धन्यवाद!

व्याख्या

इनपुट नंबर, nको इसके कम से कम महत्वपूर्ण बिट से संसाधित किया जाता है। iएक काउंटर है जो 0 और 1 की संख्या का ट्रैक रखता है। ध्यान दें कि यह 1एक बाइट को बचाने के लिए आरंभीकृत है । लूप n0 तक पहुंचने से पहले गर्भपात करेगा यदि 1 की संख्या 0 की संख्या ( i<=0) से अधिक है।

कोष्ठक संतुलित होने के लिए दो शर्तों की आवश्यकता होती है:

0 और 1 की संख्या बराबर हैं (अर्थात i==1)
1 की संख्या इस प्रक्रिया के दौरान 0 की संख्या से अधिक नहीं है (यानी लूप समय से पहले गर्भपात नहीं करता है n==0)। संपादित करें: मुझे एहसास हुआ कि यह स्थिति आवश्यक नहीं है क्योंकि iयदि n!=0पिछली स्थिति पर्याप्त है तो यह गैर-सकारात्मक होना चाहिए ।

— xsot
स्रोत

अगर iऔर nनॉनवेज है तो i==n==0है i+n==0।

— orlp

iयदि लूप समय से पहले गर्भपात करता है तो नकारात्मक हो सकता है।

— xsot

दरअसल, i|n==0हमेशा काम करना चाहिए।

— orlp

महान सुझाव, यह पंक्ति अब बेहतर लगती है।

— xsot

while i*nकाम करना चाहिए

— xnor

3

जावास्क्रिप्ट ईएस 5, 118 87 85 82 77 बाइट्स

मेरी राय में दिलचस्प तकनीक। माइनस एक बहुत की पूरी बिल्ली, @ETHproductions, और @NotthatCharles के लिए धन्यवाद

function p(x){x=x.toString(2);while(/10/.test(x))x=x.replace(10,"");return!x}

जावास्क्रिप्ट ईएस 6, 77 57 56 54 बाइट्स

-21 बाइट्स से ETHproductions।

x=>[...x=x.toString(2)].map(_=>x=x.replace(10,""))&&!x

— कोनोर ओ ब्रायन
स्रोत

मुझे कोष्ठक में अनुवाद पसंद है। हालाँकि, यदि आप इसे 1s और 0s के रूप में छोड़ते हैं, तो यह थोड़ा अच्छा है:function p(x){x=x.toString(2);r=/10/;while(x.search(r)>=0){x=x.replace(r,"")}return!x}

— ETHproductions

@ETHproductions अच्छी बात है! मुझे लगता है कि मैं दूसरे कोड को नीचे छोड़ दूंगा, मुझे वास्तव में एल्गोरिथम पसंद है ^ _ ^ धन्यवाद दोस्त!

— कॉनर ओ'ब्रायन

ईएस 6 संस्करण अभी भी एक गुच्छा हो सकता है: x=>([...x=x.toString(2)].map(_=>x=x.replace(/10/,"")),!x)चाल को लूप को एक में स्थानांतरित करना है .map, क्योंकि इसकी लंबाई की तुलना में इनपुट में कभी भी अधिक 10 'नहीं हैं।

— ETHproductions

@ETHproductions धन्यवाद फिर से ^ _ ^ अच्छी चाल के साथ map।

— कॉनर ओ'ब्रायन

कोई समस्या नहीं है :) BTW, एक और बाइट एक चाल के साथ बचाया जा सकता है edc65 सभी समय का उपयोग करता है: x=>[...x=x.toString(2)].map(_=>x=x.replace(/10/,""))&&!xIDK अगर यह छोटा हो सकता है।

— ETHproductions

2

डी, 209 170 बाइट्स

import std.stdio;import std.format;import std.conv;void main(char[][]a){string b=format("%b",to!int(a[1]));int i;foreach(c;b){i+=c=='1'?1:-1;if(i<0)break;}writeln(i==0);}

यह बिल्कुल वही करता है जो इसे बिना किसी जोड़ या फायदे के करना चाहिए।

— अवस्था
स्रोत

2

सी, 67 बाइट्स

n;main(i){for(scanf("%d",&n);n*i;n/=2)i+=1-n%2*2;putchar(48+!~-i);}

मेरे अजगर प्रस्तुत का एक बहुत बहुत बंदरगाह।

— xsot
स्रोत

2

प्रोलॉग, 147 बाइट्स

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).
q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.
p(X):-b(X,L),!,q(L,0).

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

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).

एक सूची (उलट) के रूप में बाइनरी प्रतिनिधित्व को दशमलव संख्या एन में परिवर्तित करता है। अर्थ:

b(42,[0,1,0,1,0,1]) is true

फिर:

q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.

सूची से अधिक [एच | टी] एन बढ़ रही है अगर सिर तत्व 0 है अन्यथा इसे कम करना।
यदि किसी भी बिंदु पर N ऋणात्मक हो जाता है या यदि N अंत में 0 नहीं है, तो यह गलत है।

में कटौती

p(X):-b(X,L),!,q(L,0).

क्या ब-बैक (एन, [एन])

परीक्षण के लिए गैर-द्विआधारी समाधान खोजने और रोकने के लिए है,
इसे यहां ऑनलाइन आज़माएं: इसे
क्वेरी के साथ चलाएं जैसे:

p(42).

— Emigna
स्रोत

2

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

param($a)$b=[convert]::ToString($a,2);1..$b.Length|%{if($b[$_-1]%2){$c++}else{$c--}if($c-lt0){0;exit}};!$c

_{किसी भी कम लंबाई की प्रतियोगिताओं को जीतने के लिए नहीं, यह सुनिश्चित करने के लिए है। लेकिन हे, कम से कम यह जावा की धड़कन है?}

[convert]::ToString($a,2)बाइनरी अंकों का प्रतिनिधित्व करने वाले हमारे इनपुट नंबर को स्ट्रिंग में बदलने के लिए बहुत लंबे .NET कॉल का उपयोग करता है । हम तब के साथ उस स्ट्रिंग के माध्यम से लूप के लिए 1..$b.length|%{..}। प्रत्येक लूप, यदि हमारा अंक एक है 1( एक युगल बाइट को बचाने के %2बजाय मूल्यांकन किया जाता है -eq1), हम अपने काउंटर को बढ़ाते हैं; और, हम इसे घटाते हैं। यदि हम कभी नकारात्मक पहुंचते हैं, तो इसका मतलब है कि अब तक सामना करने की )तुलना में अधिक थे (, इसलिए हम आउटपुट 0और exit। एक बार जब हम लूप के माध्यम से होते हैं, $cतो 0या तो कुछ संख्या होती है >0, इसलिए हम तार्किक नहीं लेते हैं! , जो आउटपुट प्राप्त करता है।

0अगर पार्सन्स बेमेल हो तो यह आउटपुट करने की विडम्बना है क्योंकि हमारे पास अधिक है ), लेकिन Falseयदि हम अधिक हैं तो पार्सन्स बेमेल होने के कारण आउटपुट कर रहे हैं (। अनिवार्य रूप से कार्यात्मक समकक्ष मिथ्या कथन, बस दिलचस्प। यदि सभी मेल खाता है, तो आउटपुट True।

— AdmBorkBork
स्रोत

पक्का निश्चित। (ठीक है, अगर मैं सता संदेह को ठीक कर सकता हूं कि मैं गलत समस्या को हल कर रहा हूं, तो मैं करूंगा)।

— TessellatingHeckler

1

GNU सेड (eval एक्सटेंशन के साथ), 27

s/.*/dc -e2o&p/e
:
s/10//
t

सेड को वास्तव में सत्य और गलत के परिभाषित विचार नहीं है, इसलिए यहां मैं दावा कर रहा हूं कि खाली स्ट्रिंग का मतलब सत्य है और अन्य सभी तार का अर्थ है गलत।

यदि यह स्वीकार्य नहीं है, तो हम निम्नलिखित कार्य कर सकते हैं:

जीएनयू सैड (निकासी विस्तार के साथ), 44

s/.*/dc -e2o&p/e
:
s/10//
t
s/.\+/0/
s/^$/1/

यह सत्य के लिए 1 आउटपुट और अन्यथा 0।

— डिजिटल आघात
स्रोत

1

In (ESMin), 21 वर्ण / 43 बाइट्स

ô⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ)

Try it here (Firefox only).

ध्यान दें कि यह संख्याओं के लिए पूर्वनिर्धारित चर का उपयोग करता है (विशेष रूप से 2 और 0)। 0 से 256 तक पूर्वनिर्धारित संख्या चर हैं।

19 वर्ण / 40 बाइट, गैर-प्रतिस्पर्धी

⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ

Try it here (Firefox only).

अंतर्निहित आउटपुट को लागू करने का निर्णय लिया गया ... हालांकि, पिछले आउटपुट फॉर्म अभी भी समर्थित हैं, इसलिए आपको कई आउटपुट विकल्प मिलते हैं!

— मामा फन रोल
स्रोत

क्योंकि हर कोई चार गिनती से मापता है

— चरण

1

जावा, 129 131 बाइट्स

boolean T(int i){int j=0,k=0;for(char[]a=Integer.toString(i,2).toCharArray();j<a.length&&k>=0;j++){k+=a[j]=='1'?1:-1;}return k==0;}

शायद छोटा किया जा सकता है। आने की व्याख्या। 4 बाइट्स के लिए जियोबिट्स का धन्यवाद!

— GamrCorps
स्रोत

क्या इसके int k=0;साथ संयोजन करना संभव है int j=0;?

— 19

नहीं, जम्मू लूप के लिए एक आंतरिक चर है और इसके बाहर संदर्भित नहीं किया जा सकता है।

— गेमक्रॉप्स

आपको दूसरे तरीके से गठबंधन करने में सक्षम होना चाहिए, हालांकि: int k=0,j=0;for(...तब आप char[]अर्धचालक को बचाने के लिए घोषणा को लूप इनिशियलाइज़र के अंदर रख सकते हैं।

— भूतकाल

बड़ी समस्या यह है कि यह झूठी सकारात्मकता देता है। यह उदाहरण के लिए 9, 35, 37, 38 के लिए सही है ।

— भूतकाल

@Geobits उफ़, मुझे भी एहसास नहीं था कि, मौका मिलने पर ठीक कर दूंगा।

— गेमक्रॉप्स

1

सी ++, 61 बाइट्स

मुझे लगता है कि वर्तमान C ++ उत्तर गलत है: यह सभी सम संख्याओं के लिए एक सत्य मान देता है, उदाहरण के लिए 4. अस्वीकरण: मैं उल्लेख संकलक का उपयोग करने में सक्षम नहीं था, इसलिए मैंने g ++ 4.8.4 का उपयोग किया। समस्या तार्किक के बजाय बाइनरी और ऑपरेटर के उपयोग में निहित है और जिसका उपयोग शुरुआती तोड़ने के लिए किया जाता है जब समापन कोष्ठक की संख्या खोलने वाले कोष्ठक की संख्या से अधिक हो जाती है। यह दृष्टिकोण काम कर सकता है अगर trueएक शब्द के रूप में सभी सच्चे बिट पैटर्न के साथ प्रतिनिधित्व किया जाए। मेरे सिस्टम पर, और शायद सबसे अन्य सिस्टम, trueके बराबर है 1; केवल एक बिट सच है। साथ ही, इससे n/=2छोटा है n>>=1। यहाँ एक कार्य के रूप में एक बेहतर संस्करण है:

int f(int n,int c=0){for(;c>=0&&n;n/=2)c+=n&1?-1:1;return c;}

— vysar
स्रोत

0

Com (बहुत ही नॉनकमेटीवेट), 6 चार्ट / 8 बाइट्स

!ïⓑĦⅩ

Try it here (Firefox only).

मैंने एक बहुत लंबे समय के बाद इस चुनौती को फिर से लाने का फैसला किया है। । बहुत बेहतर हो गया है।

इसका कारण एक अलग उत्तर है क्योंकि 2 संस्करण लगभग पूरी तरह से अलग हैं।

व्याख्या

इनपुट को बाइनरी में कनवर्ट करता है, 10 के उदाहरणों को फिर से बदलता है, फिर जांचता है कि क्या परिणाम एक रिक्त स्ट्रिंग है।

— मामा फन रोल
स्रोत

0

C # 98 बाइट्स

bool f(int m){int i=0;foreach(char s in Convert.ToString((m),2)){if(s=='1')i+=2;i--;}return i==0;}

किसी भी सुझाव के लिए खुला। मुझे लगता है कि यह पुराना है-यह भी इस तरह का चालान

— downrep_nation
स्रोत

Parenthifiable बाइनरी नंबर

TeaScript , 9 बाइट्स 16 18 20 22 24

Ungolfed

व्याख्या

अजगर, 10 बाइट्स

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

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

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

व्याख्या

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

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

टेस्ट चलता है

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

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

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

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

रूबी, ४०

गंभीरता से , 17 बाइट्स

जाप, 23 बाइट्स

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

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

ऑक्टेव, 48 बाइट्स

सी ++, 104 94 बाइट्स

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

पायथन 2, 60 57 56 55 53 52 50 49 बाइट्स

व्याख्या

जावास्क्रिप्ट ईएस 5, 118 87 85 82 77 बाइट्स

जावास्क्रिप्ट ईएस 6, 77 57 56 54 बाइट्स

डी, 209 170 बाइट्स

सी, 67 बाइट्स

प्रोलॉग, 147 बाइट्स

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

GNU सेड (eval एक्सटेंशन के साथ), 27

जीएनयू सैड (निकासी विस्तार के साथ), 44

In (ESMin), 21 वर्ण / 43 बाइट्स

19 वर्ण / 40 बाइट, गैर-प्रतिस्पर्धी

जावा, 129 131 बाइट्स

सी ++, 61 बाइट्स

Com (बहुत ही नॉनकमेटीवेट), 6 चार्ट / 8 बाइट्स

व्याख्या

C # 98 बाइट्स