पूर्णांक द्विआधारी-भारी होता है यदि इसके बाइनरी प्रतिनिधित्व में अग्रणी शून्य की अनदेखी करते हुए 1एस की तुलना में अधिक एस होता है 0। उदाहरण के लिए 1 द्विआधारी-भारी है, क्योंकि इसका द्विआधारी प्रतिनिधित्व बस है 1, हालांकि 4 द्विआधारी भारी नहीं है, जैसा कि इसका द्विआधारी प्रतिनिधित्व है 100। एक टाई की स्थिति में (उदाहरण के लिए 2, एक द्विआधारी प्रतिनिधित्व के साथ 10), संख्या को द्विआधारी-भारी नहीं माना जाता है।

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

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

प्रारूप: input -> binary -> output

1          ->                                1 -> True
2          ->                               10 -> False
4          ->                              100 -> False
5          ->                              101 -> True
60         ->                           111100 -> True
316        ->                        100111100 -> True
632        ->                       1001111000 -> False
2147483647 ->  1111111111111111111111111111111 -> True
2147483648 -> 10000000000000000000000000000000 -> False

स्कोरिंग

यह प्रत्येक भाषा की जीत में कोड-गोल्फ इतनी कम बाइट्स है

— Skidsdev
स्रोत

क्या होगा यदि मेरी भाषा अंतिम परीक्षण मामले को संभाल नहीं सकती है क्योंकि यह एक सकारात्मक पूर्णांक माना जाता है की सीमा के बाहर है?

— संगीतज्ञ ५२३

1

@ musicman523 afaik Standard I / O नियम बताता है कि आपको केवल अपनी भाषा के नंबर प्रारूप द्वारा प्रतिनिधित्व करने योग्य संख्या स्वीकार करनी होगी। ध्यान दें कि boolfuck जैसी किसी चीज़ का उपयोग करके इसे "गेमिंग" एक मानक लूपहोल माना जाता है

— Skidsdev

क्या किसी सत्य / मिथ्या मूल्य की गणना होती है या हमें दो अलग-अलग मूल्यों की आवश्यकता होती है?

— निकोलग्राफ जूल

@EriktheOutgolfer किसी भी मूल्य

— Skidsdev

6

अका A072600 , अगर यह किसी की मदद करता है।

— dcsohl

28

x86 मशीन कोड, 15 14 बाइट्स

F3 0F B8 C1 0F BD D1 03 C0 42 2B D0 D6 C3

यह Microsoft के __fastcall कॉलिंग कन्वेंशन (ईएक्सएक्स में पहला और एकमात्र पैरामीटर, ईएक्सएक्स में रिटर्न वैल्यू, कैलिब को क्लोबर एडक्स की अनुमति है) का उपयोग करते हुए एक फ़ंक्शन है, हालांकि यह तुच्छ रूप से रजिस्टरों में तर्क पास करने वाले अन्य कॉलिंग सम्मेलनों के लिए संशोधित किया जा सकता है।

यह २५५ सत्य के रूप में, और ० फलसी के रूप में देता है।

यह अनिर्दिष्ट (लेकिन व्यापक रूप से समर्थित) opcode का उपयोग करता है salc।

नीचे Disassembly:

;F3 0F B8 C1 
  popcnt eax, ecx ; Sets eax to number of bits set in ecx

;0F BD D1
  bsr edx, ecx    ; Sets edx to the index of the leading 1 bit of ecx

;03 C0
  add eax, eax

;42
  inc edx

;2B D0
  sub edx, eax

  ; At this point, 
  ;   edx = (index of highest bit set) + 1 - 2*(number of bits set)
  ; This is negative if and only if ecx was binary-heavy.

;D6
  salc           ; undocumented opcode. Sets al to 255 if carry flag 
                 ; is set, and to 0 otherwise. 

;C3
  ret

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

साथ देने के सुझाव के लिए पीटर कॉर्ड्स का धन्यवाद ।lzcntbsr

— ZH लियू
स्रोत

अच्छा लगा। मैं popcntजवाब देखने के लिए नीचे स्क्रॉल करने से पहले जितना स्पष्ट था, लेकिन सवाल के lzcntलिए केवल महत्वपूर्ण अंकों से निपटने के लिए नहीं सोचा था ।

— पीटर कॉर्ड्स

(उर्फ ) के bsrबजाय उपयोग करने से शुद्ध बचत प्राप्त करने का कोई तरीका है ? इसके बजाय आपको इसका उपयोग करना होगा क्योंकि यह आपको 32-lzcnt देता है। (या सभी मौजूदा इंटेल और एएमडी हार्डवेयर पर src = 0 के लिए dm अनमॉडिफाइड छोड़ देता है। एएमडी भी इस व्यवहार को दस्तावेज करता है, लेकिन इंटेल अपरिभाषित कहता है ... वैसे भी, ओपी ने सकारात्मक कहा , जो नियम से बाहर है ।)lzcntrep bsrsublea0

— पीटर कॉर्ड्स

1

मैं निश्चित रूप से @Peter के समान लाइनों के साथ सोच रहा था, क्योंकि चुनौती सकारात्मक पूर्णांक के लिए इनपुट को स्पष्ट रूप से सीमित करती है। वास्तव में, मेरे पास एक समाधान का उपयोग करके मसौदा तैयार किया गया था popcntऔर bsr, लेकिन यह 17 बाइट्स था। मैं सोच रहा था कि मैंने पहले देखे गए उत्तर की तुलना में बहुत अच्छा था , लेकिन इस चतुर leaचाल ने पैंट को बंद कर दिया। मैं भी की तुलना को देखा bsfऔर popcnt। लेकिन मैं किसी भी तरह से इस समाधान को नहीं देख सकता हूं, यहां तक कि 1 बाइट को ध्यान में रखते हुए जिसे आप repउपसर्ग को छोड़ने से बचा सकते हैं ।

— कोडी ग्रे

1

salcइसके बराबर नहीं है setc al: उत्तरार्द्ध सेट al1 के लिए यदि CF सेट, 255 तक नहीं।

— रुस्लान

1

के वास्तविक समकक्ष salcहै sbb al, al, लेकिन आपको इसे एनकोड करने के लिए 1 बाइट की बचत मिलती है। वैसे, यह है एएमडी द्वारा प्रलेखित है, और यह व्यापक रूप से स्मरक भी इंटेल पी 6 opcode नक्शे से आने के साथ, इंटेल द्वारा समर्थित है। तो यह वास्तव में उपयोग करने के लिए बहुत सुरक्षित है। इसके अलावा, उस निर्देश का उपयोग करने के लिए सोचने के लिए यहां अच्छा सुधार! यह मूल रूप से मेरा मूल मसौदा था, (1) को छोड़कर, मैंने x86-64 कोड का उपयोग किया incथा , इसलिए इसे एन्कोड करने के लिए दो बार था, और (2) मैंने salcऐसा नहीं सोचा था , इसलिए मैं एक ही काम कर रहा था लंबा रास्ता। बहुत बुरा मैं केवल एक बार बढ़ सकता है।

— कोडी ग्रे

17

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

Bo-SR

पैदावार गैर-खाली उत्पादन (सत्य) या खाली उत्पादन (झूठा)।

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

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

Bo-SR  Main link. Argument: n

B      Binary; convert n to base 2.
 o-    Compute the logical OR with -1, mapping 1 -> 1 and 0 -> -1.
   S   Take the sum s. We need to check if the sum is strictly positive.
    R  Range; yield [1, ..., s], which is non-empty iff s > 0.

— डेनिस
स्रोत

अच्छा लगा। मेरे पास था Bo-S, लेकिन मुझे 1-बाइट परमाणु नहीं मिला जो सकारात्मक / गैर-सकारात्मक को

— सत्य

तार्किक या ical1 के साथ, है ना?

— लिन

@ लियन हाँ, वास्तव में। धन्यवाद।

— डेनिस

1

4 बाइट्स

— caird coinheringaahing

@cairdcoinheringaahing धन्यवाद, लेकिन Æṃतब वापस मौजूद नहीं था।

— डेनिस

14

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

lambda n:max('10',key=bin(n).count)

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

पुराना उत्तर, 38 बाइट्स

^{आउटपुट 0falsy और के रूप में -2या -1के रूप में truthy}

lambda n:~cmp(*map(bin(n).count,'10'))

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

— छड़ी
स्रोत

2

क्या binइस समाधान की समस्याओं के कारण की वापसी में अग्रणी 0 है?

— छाया

3

@ शादो कोई समस्या नहीं है, क्योंकि जिस तरह से maxकाम करता है। एक टाई होने की स्थिति में, अधिकतम उस मान में पहला मान लौटाएगा जिसमें अधिकतम मूल्य है। यह कोड इस तथ्य का उपयोग करता है कि यह सुनिश्चित करने के लिए कि 1 को टाई की स्थिति में लौटाया जाता है, जिसका वास्तव में मतलब है कि शून्य से अधिक लोग हैं, क्योंकि एक अतिरिक्त शून्य द्वारा जोड़ा गया था bin। यह वास्तव में गलत होगा जब इस तरह से लिखा जाए, यदि अतिरिक्त शून्य के लिए नहीं।

— फ्राइअमईएग्गमैन

@FryAmTheEggman यह भी पुराने जवाब पर सच है, जहां cmpरिटर्न 0जब वे दोनों बराबर होते हैं

— रॉड

11

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

@(n)mode(de2bi(n))

TIO काम नहीं करता है क्योंकि संचार उपकरण बॉक्स शामिल नहीं है। इसका परीक्षण ऑक्टेव-ऑनलाइन पर किया जा सकता है ।

यह कैसे काम करता है:

de2biदशमलव संख्या को बाइनरी न्यूमेरिक वेक्टर में कनवर्ट करता है, न कि एक स्ट्रिंग के रूप dec2binमें।

modeवेक्टर में सबसे लगातार अंक देता है। यह एक टाई के मामले में सबसे कम करने के लिए चूक।

@(n)                % Anonymous function that takes a decimal number as input 'n'
    mode(        )  % Computes the most frequent digit in the vector inside the parentheses
         de2bi(n)   % Converts the number 'n' to a binary vector

— स्टीवी ग्रिफिन
स्रोत

क्या संचार टूलबॉक्स ऑक्टेव का एक मानक हिस्सा है, या यह अन्य भाषाओं में पुस्तकालय के लिए अधिक महत्वपूर्ण है?

— dcsohl

यह एक ऐसा पैकेज है जो इंस्टॉलेशन के साथ आता है। आपको इसे विशेष रूप से कुछ प्रतिष्ठानों में लोड करना होगा, और यह स्वचालित रूप से दूसरों में मानक के रूप में लोड होता है। यह Octave-Online.net पर मानक का हिस्सा है, इसलिए मैं इसे एक संदर्भ के रूप में उपयोग कर रहा हूं। (कोड को कम से कम एक दुभाषिया में काम करना चाहिए जो चुनौती से पहले मौजूद था)।

— स्टीवी ग्रिफिन

9

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

f=(n,x=0)=>n?f(n>>>1,x+n%2-.5):x>0

— ETHproductions
स्रोत

f=(n,x=0)=>n?f(n>>>1,x+=n%2-.5):x>035 बाइट्स के लिए।

— ovs

बाइट को बचाने के n>>1बजाय उपयोग करें n>>>1क्योंकि इनपुट कभी भी नकारात्मक नहीं होता है।

— kamoroso94

@ kamoroso94 धन्यवाद, लेकिन फिर इसे 2147483648. पर विफल हो जाएगा

— ETHproductions

@ETHproductions डार, और n/2|0बेहतर नहीं है: /

— kamoroso94

9

MATL , 3 बाइट्स

BXM

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

मुझे वास्तव में MATL का पता नहीं है, मैंने अभी देखा कि alephalpha के ऑक्टेव उत्तरmode में काम कर सकता था और लगा कि MATL में कुछ समान था।

B   ' binary array from input
 XM ' value appearing most.  On ties, 0 wins

— nmjcman101
स्रोत

8

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

@MartinEnder और @JungHwanMin को एक-एक बाइट धन्यवाद दिया ।

#>#2&@@#~DigitCount~2&

— alephalpha
स्रोत

2

मुझे लगता है कि infix संकेतन की तुलना में अधिक पूर्वता है @@।

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

1

-1 बाइट (@ मर्टिनएंडर के रूप में):#>#2&@@#~DigitCount~2&

— जुंगवान मिन जुले

7

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

ḃọtᵐ>₁

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

व्याख्या

Example input: 13

ḃ        Base (default: binary): [1,1,0,1]
 ọ       Occurences:             [[1,3],[0,1]]
  tᵐ     Map Tail:               [3,1]
    >₁   Strictly decreasing list

चूँकि ḃअग्रणी ज़ीरो के साथ अंकों की सूची के साथ इसके उत्पादन को कभी भी एकीकृत नहीं किया जाएगा, हम जानते हैं कि घटनाएँ 1हमेशा पहले रहेंगी और इच्छाएँ घटने के 0बाद दूसरे स्थान पर रहेंगी ọ।

— Fatalize
स्रोत

7

पायथन 3 , 44 (धन्यवाद @ c-mcavoy) 40 बाइट्स

lambda n:bin(n).count('0')<len(bin(n))/2

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

— wrymug
स्रोत

5

क्रॉस आउट 44 अभी भी 44 है

— जंगवान मिन

6

सी (जीसीसी) , 51 48 41 40 बाइट्स

i;f(n){for(i=0;n;n/=2)i+=n%2*2-1;n=i>0;}

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

— cleblanc
स्रोत

ओपी के स्पष्टीकरण के आधार पर, आप निकाल सकते हैंunsigned

— musicman523

चूंकि NNN सकारात्मक है, आप बदल सकते हैं n>>=1करने के लिए n/=2। मैं भी लगता है कि आप उपयोग कर सकते हैं ~nके बजाय n^-1, जो भी आप को बदलने की अनुमति चाहिए &&करने के लिए&

— musicman523

अजीब बातें होती हैं जब मैं टिप्पणियों को संपादित - "NNN" का अर्थ है n, और बदलने के बारे में कोई बात नहीं &&करने के लिए &, मुझे नहीं लगता कि काम करेगा। लेकिन इसे बदलने के *लिए काम करने लगता है

— musicman523

@ musicman523 &&केवल अहस्ताक्षरित मामले को संभालने के लिए था, लेकिन जब से मुझे केवल सकारात्मक पूर्णांक को संभालने की आवश्यकता है, मैं इसे एक साथ निकाल सकता हूं। अच्छा होने के बारे में अच्छी /=बात >>=है, हालांकि, धन्यवाद!

— क्लेब्लांक जूल

आप एक बाइट बदलते बचा सकते हैं n&1?++i:--1करने के लिए i+=n%2*2-1। आप यह भी कह कर छुटकारा पा सकते हैं >0कि आप भारी और नॉनज़रो के लिए शून्य का उत्पादन करेंगे न कि भारी के लिए

— संगीतज्ञ 523

6

आर , 54 53 51 बाइट्स

मैक्स लॉनबॉय को -1 बाइट

n=scan();d=floor(log2(n))+1;sum(n%/%2^(0:d)%%2)*2>d

स्टड से पढ़ता है; TRUEद्विआधारी भारी संख्या के लिए रिटर्न । dबाइनरी अंकों की संख्या है; sum(n%/%2^(0:d)%%2अंक राशि (यानी, लोगों की संख्या) की गणना करता है।

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

— ग्यूसेप
स्रोत

मेरा जवाब पोस्ट करने के बाद ही देखा ... वैसे भी, आप 1 बाइट बचाने log2(n)के log(n,2)लिए उपयोग कर सकते हैं

— मैक्सिम मिखायलोव

@MaxLawnboy आह, बिल्कुल। धन्यवाद!

— ग्यूसेप

एक और 12 बाइट्स के साथ गोल्फ

— JAD

6

x86_64 मशीन कोड, 23 22 21 बाइट्स

31 c0 89 fa 83 e2 01 8d 44 50 ff d1 ef 75 f3 f7 d8 c1 e8 1f c3

disassembled:

  # zero out eax
  xor  %eax, %eax
Loop:
  # copy input to edx
  mov  %edi, %edx
  # extract LSB(edx)
  and  $0x1, %edx
  # increment(1)/decrement(0) eax depending on that bit
  lea -1(%rax,%rdx,2), %eax
  # input >>= 1
  shr  %edi
  # if input != 0: repeat from Loop
  jnz  Loop

  # now `eax < 0` iff the input was not binary heavy,
  neg %eax
  # now `eax < 0` iff the input was binary heavy (which means the MSB is `1`)
  # set return value to MSB(eax)
  shr  $31, %eax
  ret

धन्यवाद @Ruslan, @PeterCordes -1बाइट के लिए!

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

— ბიმო
स्रोत

क्या कोई विशेष कारण है जिसके 8d 1fबजाय आप उपयोग करते हैं 89 fb?

— रुस्लान

2

असली सवाल यह है कि क्या कोई विशेष कारण है कि आप उस घृणित एटी एंड टी सिंटैक्स का उपयोग कर रहे हैं? इसके अलावा, disassembly और आपकी disassembly दोनों इस बात से सहमत हैं कि आपके पास add eax, 2+ है dec eax, लेकिन आपकी टिप्पणियां बताती हैं कि आप वेतन वृद्धि चाहते हैं ebx, नहीं eax।

— कोडी ग्रे

1

आप बदल सकते हैं jnz Next/ add/ decसाथ (7 बाइट्स) lea -1(%rax, %rbx, 2), %eax(4 बाइट्स) करने के लिए eax += 2*ebx - 1(में की तरह अन्य x86 मशीन कोड जवाब )। फिर लूप के बाहर, neg %eax(2 बाइट्स) साइन बिट को नीचे की ओर शिफ्ट करने से पहले। 1 बाइट की शुद्ध बचत। या test %eax,%eax/ setge %alयह भी काम करेगा, अगर आपकी वापसी का मूल्य है boolया int8_t।

— पीटर कॉर्डेस

1

@PeterCordes मुझे लगता है कि मुझे पता है कि क्या हुआ था, लेकिन मुझे यकीन नहीं है: मैंने कोशिश नहीं की होगी, lea -1(%rax,rbx,2)लेकिन केवल lea -1(%eax,%eax,2)और इस तरह से बाइट्स बर्बाद किया है .. वैसे भी, आप दोनों सही थे, मैं इस तरह से एक बाइट बचा सकता हूं। धन्यवाद एक बहुत (बदले में मुझे लगता है कि बदल देंगे leaएक करने के लिए movजब मैं उस पर हूँ)!

— ბიმო

1

@ Moonheart08: मैं उस समय के बारे में नहीं जानता था, लेकिन किसी ने एक उत्तर दिया जिसने 7 बाइट्स बचाए।

— ბიმო

5

पर्ल 6 , 32 30 बाइट्स

{[>] .base(2).comb.Bag{qw<1 0>}}

झसे आज़माओ

{[>] .polymod(2 xx*).Bag{1,0}}

झसे आज़माओ

विस्तारित:

{      # bare block lambda with implicit parameter ｢$_｣

  [>]  # reduce the following with &infix:« > »

    .polymod(2 xx *) # turn into base 2 (reversed) (implicit method call on ｢$_｣)
    .Bag\            # put into a weighted Set
    { 1, 0 }         # key into that with 1 and 0
                     # (returns 2 element list that [>] will reduce)
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

5

समझदार , 40 39 बाइट्स

::^?[:::^~-&[-~!-~-~?]!~-?|>]|:[>-?>?]|

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

व्याख्या

::^?                                      Put a zero on the bottom
    [                                     While
     :::^~-&                              Get the last bit
            [-~!-~-~?]!~-?|               Increment counter if 0 decrement if 1
                           >              Remove the last bit
                            ]|            End while
                              :[>-?>?]|   Get the sign

— गेहूं का जादूगर
स्रोत

5

हास्केल, ४१ ३४

g 0=0
g n=g(div n 2)+(-1)^n
(<0).g

यदि nयह विषम है, -1तो यदि यह सम है, तो ले लो 1। के साथ एक पुनरावर्ती कॉल जोड़ें n/2और अगर बंद करो n = 0। यदि परिणाम 0संख्या से कम है तो बाइनरी-हेवी है।

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

संपादित करें: @ Johanrjan जोहानसन ने कुछ शॉर्टकट ढूंढे और 7 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

mod n 2बस हो सकता है n, और यह एक संचायक के बिना बाइट कम है। इसे ऑनलाइन आज़माएं!

— अर्जन जोहानसन

5

रेटिना , 37 34 बाइट्स

.+
$*
+`(1+)\1
$1@
@1
1
+`.\b.

1+

इसे ऑनलाइन आज़माएं! लिंक में छोटे परीक्षण मामले शामिल हैं (बड़े लोग संभवतः स्मृति से बाहर चलेंगे)। संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए। स्पष्टीकरण: पहला चरण दशमलव से यूनरी में परिवर्तित हो जाता है, और अगले दो चरण यूनिरी से बाइनरी में परिवर्तित हो जाते हैं (यह रेटिना विकी पर यूनिरी अंकगणितीय पृष्ठ से लगभग सीधा है, सिवाय इसके कि मैं @इसके बजाय उपयोग कर रहा हूं 0)। तीसरा चरण भिन्न-भिन्न वर्णों के जोड़े के लिए दिखता है, जो @1या तो हो सकते हैं 1@, और उन्हें तब तक हटा सकते हैं जब तक कोई नहीं रहता। अंतिम चरण तब शेष 1s के लिए जाँच करता है।

— नील
स्रोत

${1}हो सकता है $+। या आप !इसके बजाय उपयोग कर सकते हैं 0और फिर छोटा 01|10कर सकते हैं .\b.।

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

@MartinEnder हुह, $+पैटर्न सही होने पर सही काम करता है |? मुझे आश्चर्य है कि क्या मैं इससे पहले इस्तेमाल कर सकता था ...

— नील

2

नहीं, $+सुपर बेवकूफ है और बस सबसे बड़ी संख्या के साथ समूह का उपयोग करता है, चाहे इसका उपयोग किया गया था या नहीं। यह केवल गोल्फिंग के लिए उपयोगी है जब आपको नौ से अधिक समूह मिल गए हों या यहां जैसी स्थिति में हो, और मुझे नहीं पता कि मैं इसे प्रोडक्शन रेगेक्स में क्यों इस्तेमाल करूंगा।

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

5

आर , 43 बाइट्स

max(which(B<-intToBits(scan())>0))/2<sum(B)

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

             intToBits(scan())              # converts to bits
          B<-                 >0            # make logical and assign to B
max(which(                      ))/2        # get the length of the trimmed binary and halve
                                    <sum(B) # test against the sum of bits

— MickyT
स्रोत

+1 स्वच्छ समाधान! मैं भी के बारे में पता नहीं थाintToBits

— ग्यूसेप

एक और 4 बाइट्स के साथ गोल्फ

— JAD

5

कोटलिन , 50 बाइट्स

{i:Int->i.toString(2).run{count{it>'0'}>length/2}}

निहित प्रकार का लैम्ब्डा (Int) -> Boolean। संस्करण 1.1 और उच्चतर केवल उपयोग के कारणInt.toString(radix: Int) ।

दुर्भाग्य से टीआईओ का कोटलिन रनटाइम 1.0.x लगता है, इसलिए यहां टीआईओ लिंक के बजाय एक उदास कुत्ता है:

— एफ जॉर्ज
स्रोत

4

अजगर, ९ 9 बाइट्स

ehc2S.B

इसे यहाँ आज़माएँ।

-२ फ्राइअमईएग्गमैन को धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत

एक और 9 बाइट दृष्टिकोण:>ysJjQ2lJ

— कार्लक्स्टर

1

7 बाइट्स लेकिन मुझे लगता है कि अभी भी कुछ कम होना चाहिए ...

— FryAmTheEggman

@FryAmTheEggman हम्म ... जो केवल एक पूर्ण कार्यक्रम के रूप में काम कर सकता था। (मुझे पता था कि उपयोग करने का एक तरीका था .B!)

— एरिक आउटगोल्फर

4

आर, ३ ९ 37 बाइट्स

sum(intToBits(x<-scan())>0)>2+log2(x)

यह @MickyT और @Giuseppe द्वारा उपयोग किए जाने वाले तरीकों का एक संयोजन है, जो कुछ अन्य बाइट्स को बचाते हैं।

sum(intToBits(x) > 0)1बिट्स की मात्रा को गिना जाता है , और बिट्स 2+log2(x)/2की कुल राशि का आधा होता है, जब नीचे गोल होता है। दो मान समान होने पर हमें व्यवहार के कारण चक्कर नहीं काटने पड़ेंगे।

— JAD
स्रोत

4

सी # (.NET कोर) , 62 , 49 बाइट्स

LINQ के बिना।

संपादित करें: एक -13 बाइट गोल्फ के साथ दाना जबकि एक पुनरावर्ती के लिए बदल रहा है और पूर्णांक के बजाय एक बूल वापस कर रहा है।

x=>{int j=0;for(;x>0;x/=2)j+=x%2*2-1;return j>0;}

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

— Destroigo
स्रोत

4

रेगेक्स (ईसीएमएस्क्रिप्ट), 85 73 71 बाइट्स

^((?=(x*?)\2(\2{4})+$|(x*?)(\4\4xx)*$)(\2\4|(x*)\5\7\7(?=\4\7$\2)\B))*$

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

_{^{डेडकोड द्वारा स्पष्टीकरण}}

पहले के 73 बाइट संस्करण को नीचे समझाया गया है।

^((?=(x*?)\2(\2{4})+$)\2|(?=(x*?)(\4\4xx)*$)(\4|\5(x*)\7\7(?=\4\7$)\B))+$

ECMAScript रेगेक्स की सीमाओं के कारण, एक प्रभावी रणनीति अक्सर हर चरण में आवश्यक संपत्ति को अपरिवर्तित रखते हुए एक समय में एक नंबर को बदलने के लिए होती है। उदाहरण के लिए, एक पूर्ण वर्ग या 2 की शक्ति का परीक्षण करने के लिए, इसे हर चरण में 2 (क्रमशः) का वर्ग या शक्ति रखते हुए आकार में संख्या कम करें।

यहाँ इस उपाय को हर कदम पर किया जाता है:

यदि सबसे सही बिट कोई नहीं है 1, तो सबसे सही 1बिट (यदि यह एकमात्र 1बिट नहीं है, अर्थात यदि वर्तमान संख्या 2 की शक्ति नहीं है) को एक कदम दाईं ओर ले जाया जाता है, तो प्रभावी रूप से a 10को बदलना 01(उदाहरण के लिए, 1101 1 000 → 11010 1 00 → 110,100 1 0 → 1,101,000 1 ) है, जो संख्या के द्विआधारी-भारीपन पर कोई प्रभाव नहीं है। अन्यथा, 01सही हटा दिया गया है (उदाहरण के लिए 101110 01 → 101110, या 110 01 11 → 11011)। इससे संख्या के भारीपन पर भी कोई प्रभाव नहीं पड़ता है, क्योंकि का सत्य या असत्य $ones>zeroes$ $1$

$ones>zeroes⇔ones-1>zeroes-1$

जब ये दोहराए गए कदम आगे नहीं बढ़ सकते हैं, तो अंतिम परिणाम या तो 1बिट्स की एक सन्निहित स्ट्रिंग होगी , जो भारी है, और इंगित करता है कि मूल संख्या भी भारी थी, या 2 की शक्ति, यह दर्शाता है कि मूल संख्या भारी नहीं थी।

और हां, हालांकि इन कदमों को संख्या के द्विआधारी प्रतिनिधित्व पर टाइपोग्राफिक जोड़तोड़ के रूप में ऊपर वर्णित किया गया है, वे वास्तव में एक अंकगणित के रूप में कार्यान्वित किए जाते हैं।

# For these comments, N = the number to the right of the "cursor", a.k.a. "tail",
# and "rightmost" refers to the big-endian binary representation of N.
^
(                          # if N is even and not a power of 2:
    (?=(x*?)\2(\2{4})+$)   # \2 = smallest divisor of N/2 such that the quotient is
                           # odd and greater than 1; as such, it is guaranteed to be
                           # the largest power of 2 that divides N/2, iff N is not
                           # itself a power of 2 (using "+" instead of "*" is what
                           # prevents a match if N is a power of 2).
    \2                     # N = N - \2. This changes the rightmost "10" to a "01".
|                          # else (N is odd or a power of 2)
    (?=(x*?)(\4\4xx)*$)    # \4+1 = smallest divisor of N+1 such that the quotient is
                           # odd; as such, \4+1 is guaranteed to be the largest power
                           # of 2 that divides N+1. So, iff N is even, \4 will be 0.
                           # Another way of saying this: \4 = the string of
                           # contiguous 1 bits from the rightmost part of N.
                           # \5 = (\4+1) * 2 iff N+1 is not a power of 2, else
                           # \5 = unset (NPCG) (iff N+1 is a power of 2), but since
                           #   N==\4 iff this is the case, the loop will exit
                           #   immediately anyway, so an unset \5 will never be used.
    (
        \4                 # N = N - \4. If N==\4 before this, it was all 1 bits and
                           # therefore heavy, so the loop will exit and match. This
                           # would work as "\4$", and leaving out the "$" is a golf
                           # optimization. It still works without the "$" because if
                           # N is no longer heavy after having \4 subtracted from it,
                           # this will eventually result in a non-match which will
                           # then backtrack to a point where N was still heavy, at
                           # which point the following alternative will be tried.
    |
        # N = (N + \4 - 2) / 4. This removes the rightmost "01". As such, it removes
        # an equal number of 0 bits and 1 bits (one of each) and the heaviness of N
        # is invariant before and after. This fails to match if N is a power of 2,
        # and in fact causes the loop to reach a dead end in that case.
        \5                 # N = N - (\4+1)*2
        (x*)\7\7(?=\4\7$)  # N = (N - \4) / 4 + \4
        \B                 # Assert N > 0 (this would be the same as asserting N > 2
                           # before the above N = (N + \4 - 2) / 4 operation).
    )
)+
$       # This can only be a match if the loop was exited due to N==\4.

— ग्रिमी
स्रोत

2

हालांकि यह डेडकोड के उत्तर से प्रेरित है , एल्गोरिथ्म काफी अलग है कि मुझे लगा कि यह एक टिप्पणी के बजाय एक अलग जवाब के योग्य है।

— ग्रिमी

2

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

— डेडकोड

4

रेगेक्स (ECMAScript), 183 बाइट्स

ECMA regex के साथ हल करने के लिए यह एक और दिलचस्प समस्या थी। इसे संभालने का "स्पष्ट" तरीका है, की संख्या गिनना1 बिट्स और इसकी तुलना बिट्स की कुल संख्या से करना है। लेकिन आप सीधे ECMAScript रेगेक्स में चीजों की गिनती नहीं कर सकते हैं - लगातार बैकरेफेरेंस की कमी का मतलब है कि एक लूप में केवल एक नंबर को संशोधित किया जा सकता है, और प्रत्येक चरण में इसे केवल कम किया जा सकता है।

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

2 में सबसे बड़ी शक्ति का वर्गमूल लें जो एन में फिट बैठता है, और ध्यान दें कि क्या वर्गमूल सही था या नीचे गोल किया जाना था। यह बाद में उपयोग किया जाएगा।
लूप में, प्रत्येक सबसे महत्वपूर्ण 1बिट को कम से कम महत्वपूर्ण स्थिति में ले जाएं जहां एक 0बिट है। इनमें से प्रत्येक चरण एक घटाव है। लूप के अंत में, शेष संख्या (जैसा कि इसे बाइनरी में दर्शाया जाएगा) एस का एक स्ट्रिंग है 1जिसमें कोई 0एस नहीं है । ये ऑपरेशन वास्तव में एकता में किए गए हैं; यह केवल वैचारिक रूप से है कि वे बाइनरी में किए जा रहे हैं।
1पहले प्राप्त वर्गमूल के खिलाफ इस "बाइनरी स्ट्रिंग ऑफ़ एस" की तुलना करें । यदि वर्गमूल को गोल करना होता है, तो इसके दोहरे संस्करण का उपयोग करें। यह सुनिश्चित करता है कि "बाइनरी स्ट्रिंग ऑफ़ 1एस" के लिए आधे से अधिक बाइनरी अंकों की आवश्यकता होती है क्योंकि एन के लिए अंतिम मैच होना चाहिए।

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

आगे कोई हलचल नहीं है, रेगेक्स:

^(?=.*?(?!(x(xx)+)\1*$)(x)*?(x(x*))(?=(\4*)\5+$)\4*$\6)(?=(((?=(x(x+)(?=\10$))*(x*))(?!.*$\11)(?=(x*)(?=(x\12)*$)(?=\11+$)\11\12+$)(?=.*?(?!(x(xx)+)\14*$)\13(x*))\16)*))\7\4(.*$\3|\4)

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

# For the purposes of these comments, the input number = N.
^
# Take the floor square root of N
(?=
    .*?
    (?!(x(xx)+)\1*$)    # tail = the largest power of 2 less than tail
    (x)*?               # \3 = nonzero if we will need to round this square root
                        #      up to the next power of two
    (x(x*))             # \4 = potential square root; \5 = \4 - 1
    (?=
        (\4*)\5+$       # Iff \4*\4 == our number, then the first match here must result in \6==0
    )
    \4*$\6              # Test for divisibility by \4 and for \6==0 simultaneously
)
# Move all binary bits to be as least-significant as possible, e.g. 11001001 -> 1111
(?=
    (                                 # \7 = tool for making tail = the result of this move
        (
            (?=
                (x(x+)(?=\10$))*(x*)  # \11 = {divisor for getting the least-significant 0 bit}-1
            )
            (?!.*$\11)                # Exit the loop when \11==0
            (?=
                (x*)                  # \12 = floor((tail+1) / (\11+1)) - 1
                (?=(x\12)*$)          # \13 = \12+1
                (?=\11+$)
                \11\12+$
            )
            (?=
                .*?
                (?!(x(xx)+)\14*$)     # tail = the largest power of 2 less than tail
                \13                   # tail -= \13
                (x*)                  # \16 = tool to move the most-significant 1 bit to the
                                      # least-significant 0 bit available spot for it
            )
            \16
        )*
    )
)
\7                  # tail = the result of the move
\4                  # Assert that \4 is less than or equal to the result of the move
(
    .*$\3
|
    \4              # Double the value of \4 to compare against if \3 is non-empty,
                    # i.e. if we had an even number of total digits.
)

— Deadcode
स्रोत

1

-98 बाइट्स

— ग्रिम

3

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

Bµċ0<S

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

— आउटगोल्फर को एरिक करें
स्रोत

Bo-Sइनपुट के द्विआधारी "वजन" की गणना करने के लिए इस्तेमाल किया जा सकता है, दुर्भाग्य से उपयोग करने का सबसे छोटा तरीका है Bo-S>0...

— ETHproductions

@ETHproductions हां, अभी कोई "सकारात्मक" परमाणु नहीं है।

— निकोलस

अच्छी तरह से स्पष्ट रूप से Ḷकाम करता है: P

— ETHproductions

3

जे , 12 बाइट्स

(+/>-:@#)@#:

J, दाएँ-से-बाएँ क्रियाओं को निष्पादित करता है, तो चलिए अंत में शुरू करते हैं और शुरुआत की ओर अपना काम करते हैं।

व्याख्या

         #:       NB. Convert input to list of bits
       -:@#       NB. Half (-:) the (@) length (#)
          >       NB. Greater than 
         +/       NB. Sum (really plus (+) reduce (/)

— डैन ब्रॉन
स्रोत

1

(#<2*+/)@#:1 बचाना चाहिए जब तक मैं कुछ याद नहीं कर रहा हूँ।

— FrownyFrog

3

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

x->2*x<4^count_ones(x)

— Tanj
स्रोत

2

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

@(a)sum(2*dec2bin(a)-97)>0

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

— alephalpha
स्रोत

2

आप के साथ कुछ कर सकते हैंmode(dec2bin(a)-48)

— nmjcman101

2

पीएचपी , 44 बाइट्स

for(;$a=&$argn;$a>>=1)$r+=$a&1?:-1;echo$r>0;

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

PHP , 48 बाइट्स

<?=($c=count_chars(decbin($argn)))[49]-$c[48]>0;

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

— जार्ग हुल्सरमैन
स्रोत

2

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

f=lambda n,c=0:f(n/2,c+n%2*2-1)if n else c>0

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

पुराना उत्तर, 47 बाइट्स

c,n=0,input()
while n:c+=n%2*2-1;n/=2
print c>0

यह केवल @ क्लेब्लांक के सी उत्तर का एक बंदरगाह है । यह अन्य पायथन उत्तरों की तुलना में लंबा है, लेकिन मुझे लगा कि यह पोस्ट करने के लायक था क्योंकि यह उत्तर खोजने की पूरी तरह से अलग विधि है।

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

— musicman523
स्रोत

2

सी #, 82 बाइट्स

n=>{var s=System.Convert.ToString(n,2);return s.Replace("0","").Length>s.Length/2}

— TheLethalCoder
स्रोत

आप स्ट्रिंग को IEnumerable <char> के रूप में मानकर कुछ और ट्रिम कर सकते हैं। n=>{var s=Convert.ToString(n,2);return s.Count(c=>c=='1')>s.Length/2;}

— गांगेय

@GalacticCowboy जो 11 बाइट्स जोड़ता है क्योंकि आपको पूरी तरह से अर्हता प्राप्त करना Convertऔर शामिल करना है using System.Linq;(जैसा छोटा लिखा है namespace System.Linq{})। अच्छा विचार सिर्फ इस मामले में बचत को वारंट करने के लिए पर्याप्त नहीं है।

— द लीथेलकोडर

क्या संख्या द्विआधारी-भारी है?

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

स्कोरिंग

x86 मशीन कोड, 15 14 बाइट्स

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

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

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

पुराना उत्तर, 38 बाइट्स

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

यह कैसे काम करता है:

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

MATL , 3 बाइट्स

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

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

व्याख्या

पायथन 3 , 44 (धन्यवाद @ c-mcavoy) 40 बाइट्स

सी (जीसीसी) , 51 48 41 40 बाइट्स

आर , 54 53 51 बाइट्स

x86_64 मशीन कोड, 23 22 21 बाइट्स

disassembled:

पर्ल 6 , 32 30 बाइट्स

विस्तारित:

समझदार , 40 39 बाइट्स

व्याख्या

हास्केल, ४१ ३४

रेटिना , 37 34 बाइट्स

आर , 43 बाइट्स

कोटलिन , 50 बाइट्स

अजगर, ९ 9 बाइट्स

आर, ३ ९ 37 बाइट्स

सी # (.NET कोर) , 62 , 49 बाइट्स

रेगेक्स (ईसीएमएस्क्रिप्ट), 85 73 71 बाइट्स

रेगेक्स (ECMAScript), 183 बाइट्स

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

जे , 12 बाइट्स

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

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

पीएचपी , 44 बाइट्स

PHP , 48 बाइट्स

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

पुराना उत्तर, 47 बाइट्स

सी #, 82 बाइट्स