पूर्णांक से सबसे महत्वपूर्ण बिट समाशोधन

29

इनपुट

इनपुट एकल धनात्मक पूर्णांक है n

उत्पादन

आउटपुट nइसके सबसे महत्वपूर्ण बिट सेट के साथ है 0।

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

1 -> 0
2 -> 0
10 -> 2
16 -> 0
100 -> 36
267 -> 11
350 -> 94
500 -> 244

उदाहरण के लिए: 350बाइनरी में है 101011110। इसकी सबसे महत्वपूर्ण बिट (यानी सबसे बाईं ओर 1) को सेट करना, जिसमें 0यह 001011110दशमलव पूर्णांक 94, आउटपुट के बराबर है । यह OEIS A053645 है ।

code-golf  sequence  binary 
— मार्कस एंड्रयूज
स्रोत
19
10स्पष्ट रूप से सबसे महत्वपूर्ण बिट को 0
— साफ करना
@clabacchio I .. यह ... एर ... wha? (अच्छा एक)
— बाल्ड्रिक
12
यह मुझे लगता है कि शून्य बस के रूप में महत्वपूर्ण हैं। जब आप कहते हैं "सबसे महत्वपूर्ण बिट" का मतलब है "सबसे महत्वपूर्ण बिट जो एक पर सेट है"।
— Kay में माइकल Kay

जवाबों:

12

सी (जीसीसी) , 49 44 40 39 बाइट्स

i;f(n){for(i=1;n/i;i*=2);return n^i/2;}

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

— cleblanc
स्रोत
1
आप बदल सकते हैं i<=nके साथ n/iके लिए -1 बाइट। यह मेरा गोल्फ नहीं है, किसी और ने इसे आपके पोस्ट में संपादित करने की कोशिश की, लेकिन मैंने इसे वापस ले लिया क्योंकि गोल्फिंग पोस्ट के लिए संपादन हमारे सामुदायिक नियमों के अनुसार स्वीकार नहीं किए जाते हैं।
— हाइपरएन्यूट्रीनो
1
@ हाइपरनेटिनो मैंने देखा और अभी संपादन को मंजूरी दी। कि नियम के बारे में पता नहीं था, लेकिन यह एक अच्छा गोल्फ टिप है!
— क्लेब्लांक
आह ठीक है। हाँ आमतौर पर लोगों को गोल्फ टिप्स के लिए टिप्पणी पोस्ट करने के लिए माना जाता है और ओपी को संपादन करना चाहिए, लेकिन अगर आपने इसे स्वीकार कर लिया है, तो यह वास्तव में एक समस्या के रूप में नहीं है। :)
— हाइपरएनुट्रिनो 13
9

05AB1E , 5 बाइट्स

.²óo-

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

एक पूर्णांक से सबसे महत्वपूर्ण बिट निकाल रहा है एन से दूरी पाने के लिए बराबर है एन के उच्चतम पूर्णांक सत्ता में 2 की तुलना में कम एन ।

इस प्रकार, मैंने सूत्र N - 2 तल का उपयोग किया (लॉग 2 एन) :

  • .²- आधार 2 के साथ लघुगणक ।
  • ó - एक पूर्णांक तक फर्श।
  • o- 2 ऊपर परिणाम की शक्ति के लिए उठाया।
  • - - अंतर।
— श्री Xcoder
स्रोत
1
b¦Cभी काम करता है ... है ना? बाइनरी में कनवर्ट करें, एमएसबी हमेशा इंडेक्स 1 पर होता है, एमएसबी को हटा दें, वापस कन्वर्ट करें।
— मैजिक ऑक्टोपस Urn
2
@MagicOctopusUrn कोई गलत नहीं है, के लिए विफल रहता है 1!
— मिस्टर एक्सकोडर
8

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

BḊḄ

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

व्याख्या

BḊḄ  Main Link
B    Convert to binary
 Ḋ   Dequeue; remove the first element
  Ḅ  Convert from binary
— HyperNeutrino
स्रोत
2
नहीं कर रहे हैं Ḅऔर Ḋदो-बाइट कोड पॉइंट्स? यह समग्र आकार को 5 बाइट्स में बदल देगा।
— बार्टेक बानचेविच
3
@BartekBanachewicz जेली अपने स्वयं के कोडपेज का उपयोग करती है , जहां वे चार्ट केवल 1 बाइट हैं।
— स्टैनबर्ग
1
यह पूछने और जवाब देने के लिए धन्यवाद, जिसने मुझे लंबे समय तक खराब कर दिया है!
— उक्को
8

सी (जीसीसी) - 59 बाइट्स

main(i){scanf("%d",&i);return i&~(1<<31-__builtin_clz(i));}

यह gcc उत्तर केवल पूर्णांक बिटवाइज़ और अंकगणितीय परिचालनों का उपयोग करता है। यहाँ कोई लघुगणक नहीं! इसमें 0 के इनपुट के साथ समस्याएँ हो सकती हैं, और यह पूरी तरह से गैर-पोर्टेबल है।

यह इस साइट पर मेरा पहला जवाब है, इसलिए मुझे प्रतिक्रिया और सुधार पसंद आएगा। मुझे यकीन है कि बिटवाइज़ भाव सीखने में मज़ा आता था।

— चार्ल्स डिप्लोमा
स्रोत
1
PPCG में आपका स्वागत है, और पहला जवाब! हमें उम्मीद है कि आप
— ETHproductions
आपको एक पूर्ण कार्यक्रम की आवश्यकता नहीं है main, एक फ़ंक्शन एक मान्य सबमिशन है । इसे एक फंक्शन में बदलना और कहा फंक्शन के रूप में इनपुट लेना 18 बाइट्स को बचाता है ।
— १
1
आप इसे दो और बाइट्स को बचाने के लिए मैक्रो के रूप में भी लिख सकते हैं ।
— स्टेडीबॉक्स बॉक्स
7

MATL , 8 6 बाइट्स

B0T(XB

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

Cinaski के लिए धन्यवाद दो बाइट्स सहेजे गए। संदर्भ अनुक्रमण के बजाय असाइनमेंट इंडेक्सिंग पर स्विच करना 2 बाइट्स छोटा था :)

स्पष्टीकरण:

          % Grab input implicitly: 267
B         % Convert to binary: [1 0 0 0 0 1 0 1 1]
 0T(      % Set the first value to 0: [0 0 0 0 0 1 0 1 1]
    XB    % Convert to decimal: 11
— स्टीवी ग्रिफिन
स्रोत
1
आप संदर्भ अनुक्रमण (6 बाइट्स के लिए भी) का उपयोग कर सकते थे, यदि आप इसके 4Lबजाय उपयोग करते थे [2J]। एक और मजेदार 6 बाइट्स: tZlcW-(केवल MATLAB में काम करता है, TIO / ऑक्टेव में नहीं)
— Sanchises
6

जावा (ओपनजेडके 8) , 23 बाइट्स

n->n^n.highestOneBit(n)

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

क्षमा करें, अंतर्निहित: - /

— ओलिवियर ग्रेजायर
स्रोत
जावा एक बिल्ड-इन के साथ। कुछ अन्य लोकप्रिय भाषाओं जैसे .NET और पायथन ने नहीं किया है ?! o. o +1 उस तक। बिल्ड-इन्स के बिना कुछ लंबे समय तक पोस्ट करने वाला था .. आपका 15 बाइट्स छोटा है। XD
— केविन क्रूज़सेन
@ केविनक्रूजसेन कुछ इस तरह n->n^1<<(int)Math.log2(n)काम करेगा और संभवतः 38 बाइट्स से छोटा होगा। यह मेरा दूसरा (अभी तक अप्रकाशित) विचार था, अगर highestOneBitकोई उचित रूप से काम नहीं करता था। जिज्ञासा से बाहर, आपका क्या समाधान था
— ओलिवियर ग्रेजायर
मेरा था n->n^1<<(int)(Math.log(n)/Math.log(2))क्योंकि Math.log2जावा में मौजूद नहीं है। ; पी केवल Math.log, Math.log10और Math.loglpउपलब्ध हैं।
— केविन क्रूजसेन 7
2
मैं एक ही पोस्ट करने जा रहा था, एक्सोर के बजाय केवल माइनस। से विधि याद किए गए इस
— JollyJoker
1
@KevinCruijssen उफ़, Math.log2वास्तव में मौजूद नहीं है ... मेरा बुरा। देख? एक अच्छा तरीका ( highestOneBit) मौजूद है लेकिन दूसरा नहीं ( Math.log2)। Java अजीब है ;-)
— Olivier Grégoire
6

भूसी , 3 बाइट्स

ḋtḋ

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

स्पष्टीकरण:

    -- implicit input, e.g. 350
  ḋ -- convert number to list of binary digits (TNum -> [TNum]): [1,0,1,0,1,1,1,1,0]
 t  -- remove first element: [0,1,0,1,1,1,1,0]
ḋ   -- convert list of binary digits to number ([TNum] -> TNum): 94
— Laikoni
स्रोत
जैली समाधान के समान, ऐसा लगता है कि यह वास्तव में 5 बाइट्स है, न कि 3.
— बार्टेक बैनचेविक्ज़
1
इसी तरह जेली को @BartekBanachewicz, भूसी का अपना कोड पृष्ठ पर उपयोग करता है, तो यह है वास्तव में 3 बाइट्स: पी
— HyperNeutrino
@BartekBanachewicz यहां कोडपेज के लिए देखें: github.com/barbuz/Husk/wiki/Codepage
— Laikoni
5

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

lambda n:n-2**len(bin(n))/8

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

व्याख्या

lambda n:n-2**len(bin(n))/8  # Lambda Function: takes `n` as an argument
lambda n:                    # Declaration of Lambda Function
              len(bin(n))    # Number of bits + 2
           2**               # 2 ** this ^
                         /8  # Divide by 8 because of the extra characters in the binary representation
         n-                  # Subtract this from the original
— HyperNeutrino
स्रोत
... बस जब मैं बिटवाइज गणित का काम कर रहा था। : पी
— 19
@totallyhuman हेह सॉरी, लेकिन आप इसे हरा दें: P
— HyperNeutrino
2**len(bin(n))/8यह भी लिखा जा सकता है 1<<len(bin(n))-3, और फिर यह 2 और 3 दोनों में काम करेगा (कोई बाइट नहीं बचा / जोड़ा गया)।
— Mego
@ मेगो कूल, इसके अलावा के लिए धन्यवाद!
— हाइपरनीट्रीनो
5

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

-8 बाइट्स के लिए धन्यवाद caird coinheringaahing। मैंने स्मृति से टाइप किया। : ओ

lambda n:int('0'+bin(n)[3:],2)

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

— totallyhuman
स्रोत
क्यों नहीं lambda n:int(bin(n)[3:],2)?
— caird coinheringaahing
ठीक है, क) जो 1 , बी पर त्रुटि करेगा ) मैं उस के बारे में नहीं सोचने के लिए पर्याप्त गूंगा हूं। लेकिन मैंने इसे मामूली बदलाव के साथ ठीक किया। धन्यवाद!
— पूरी तरह से
मैंने कोड को संपादित किया है ताकि यह काम करे, (और 4 बाइट्स बचाता है)
— caird coinheringaahing
अभी भी 1 पर त्रुटियाँ हैं ।
— अमानवीय
@cairdcoinheringaahing यह मेरा मूल उत्तर था , लेकिन तब मुझे यह पता चला कि यह 1 पर
— गलत है
4

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

2 बाइट्स ओव्स के लिए धन्यवाद बचा

a=>a^1<<Math.log2(a)

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

एक और दृष्टिकोण, 32 बाइट्स

a=>'0b'+a.toString`2`.slice`1`^0

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

.slice`1`^0जब आप .slice(1)^0काम करेंगे, तो आप ऐसा क्यों करेंगे , हाहा
— ETHproductions
@ETHproductions। यह एक बेहतर लग रहा है :)
4

जे, 6 बाइट्स

}.&.#:

बहुत साधारण।

व्याख्या

}.&.#:
    #:  convert to list of binary digits
  &.    apply right function, then left, then the inverse of right
}.      behead
— गोभी
स्रोत
मैं इस पोस्ट करने जा रहा था :(
— Cyoce
@Cyoce Me भी ...
— Adám
4

एपीएल (डायलॉग) , 10 बाइट्स

टैसिट उपसर्ग फ़ंक्शन।

2⊥1↓2∘⊥⍣¯1

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

2∘⊥... आधार -2 से डीकोड
 ... ⍣¯1 नकारात्मक एक समय (यानी आधार -2 में सांकेतिक शब्दों में बदलना)

1↓ पहले थोड़ा गिराओ

2⊥ बेस -2 से डीकोड

— एडम
स्रोत
4

रूबी, 26 बाइट्स

-7 बाइट्स वेंचरो को धन्यवाद। -२ बाइट्स हिस्टोरिट के लिए धन्यवाद।

->n{/./=~'%b'%n;$'.to_i 2}
— प्रदर्शित होने वाला नाम
स्रोत
आप पहले चरित्र को छोड़ने और निरर्थक कोष्ठक छोड़ने के द्वारा कुछ बाइट्स बचा सकते हैं:->n{n.to_s(2)[1..-1].to_i 2}
— वेंटरो
->n{/./=~'%b'%n;$'.to_i 2}
— histocrat
4

सी (जीसीसी), 38 बाइट्स

बिल्ट-इन gcc का इस्तेमाल किया।

f(c){return c^1<<31-__builtin_clz(c);}
— कोलेरा सु
स्रोत
दो बाइट को बचाने के 31-साथ प्रतिस्थापित करना ~चाहिए।
@ ThePirateBay यह हार्डवेयर पर निर्भर करता है कि शिफ्ट नकाबपोश है या नहीं। अपने कंप्यूटर पर, यह उत्पादन 0.
— Colera र
4

एआरएम असेंबली, 46 43 बाइट्स

(आप स्रोत के रूप में एक ही समय पर गंतव्य रजिस्टर को छोड़ सकते हैं)

clz x1,x0
add x1,1
lsl x0,x1
lsr x0,x1
ret
— माइकल डोरगन
स्रोत
एआरएम असेंबली सिंटैक्स का क्या स्वाद है? मेरा GNU असेंबलर shr/ shl/ को नहीं समझता है retऔर इसके बजाय lsr/ lsl/ कुछ चाहता है bx lr।
— रुस्लान
संभवतया कई संस्करणों में वाक्यविन्यास को मिलाया जा सकता है (रिट अनार 64 से है), हालांकि मुझे लगा कि कोडांतरक आपके लिए इन्हें छद्म करेगा। यहाँ के प्रयोजनों के लिए, हालांकि, पुराने और प्रत्यक्ष lsl / lsr का उपयोग करना संभवतः सही है।
— माइकल डोरगन
मजेदार बात, मैं इसे 1 कम ऑपरेशन में कर सकता हूं, लेकिन मैं बाइट का आकार 2. आह कोड गोल्फ से बढ़ाता हूं।
— माइकल डोरगन
3

ऐलिस , 8 बाइट्स

./-l
o@i

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

व्याख्या

.   Duplicate an implicit zero at the bottom of the stack. Does nothing.
/   Switch to Ordinal mode, move SE.
i   Read all input as a string.
l   Convert to lower case (does nothing, because the input doesn't contain letters).
i   Try reading all input again, pushes an empty string.
/   Switch to Cardinal mode, move W.
.   Duplicate. Since we're in Cardinal mode, this tries to duplicate an integer.
    To get an integer, the empty string is discarded implicitly and the input is 
    converted to the integer value it represents. Therefore, at the end of this,
    we get two copies of the integer value that was input.
l   Clear lower bits. This sets all bits except the MSB to zero.
-   Subtract. By subtracting the MSB from the input, we set it to zero. We could
    also use XOR here.
/   Switch to Ordinal, move NW (and immediately reflect to SW).
o   Implicitly convert the result to a string and print it.
/   Switch to Ordinal, move S.
@   Terminate the program.
— मार्टिन एंडर
स्रोत
3

जाप , 6 बाइट्स

^2p¢ÊÉ

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

व्याख्या

^2p¢ÊÉ
   ¢     Get binary form of input
    Ê    Get length of that
     É   Subtract 1
 2p      Raise 2 to the power of that
^        XOR with the input

यदि इनपुट 1विफल हो सकता है: 4 बाइट्स

¢Ån2

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

स्पष्टीकरण : इनपुट बाइनरी ( ¢) प्राप्त करें, पहले चार का टुकड़ा बंद करें ( Å), एक नंबर पर बाइनरी के रूप में पार्स करें ( n2)।

— जस्टिन मेरिनर
स्रोत
3

एपीएल (डायलॉग यूनिकोड) , 9 बाइट्स

⊢-2*∘⌊2⍟⊢

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

एडम को -1 बाइट

— HyperNeutrino
स्रोत
पूरी तरह से सही है, हालाँकि मैंने मेरे लिए एक टेम्पलेट बनाने के लिए TIO का उपयोग किया होगा । वैसे भी, ⊢-2*∘⌊2⍟⊢एक बाइट बचाता है।
— एडमंड
मुझे दुख था कि एपीएल का प्रतिनिधित्व नहीं किया गया था, और वहाँ था, लगभग स्क्रॉल में खो गया! मुझे एपीएल की याद आती है।
— सीएम
@cmm एपीएल जीवित और अच्छी तरह से है। स्टैक एक्सचेंज एपीएल चैट रूम में घूमने के लिए स्वतंत्र महसूस करें ।
— अदम
3

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

{2b()b}

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

स्पष्टीकरण:

{     }  Block:         267
 2b      Binary:        [1 0 0 0 0 1 0 1 1]
   (     Pop:           [0 0 0 0 1 0 1 1] 1
    )    Increment:     [0 0 0 0 1 0 1 1] 2
     b   Base convert:  11

इसे हटाने से बचने के लिए MSB (जो हमेशा 1 है) का पुन: उपयोग करें; उस चाल के बिना बराबर {2b1>2b}या होगा {2b(;2b}।

— फल तोड़ना
स्रोत
3

रेटिना , 15 13 बाइट्स

^(^1|\1\1)*1

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

इनपुट और आउटपुट एकरी में (परीक्षण सूट में सुविधा के लिए और दशमलव से रूपांतरण शामिल है)।

व्याख्या

यह एकतरफा में करना काफी आसान है। हम केवल इनपुट से 2 की सबसे बड़ी शक्ति को हटाना चाहते हैं। हम कुछ आगे के संदर्भों के साथ 2 की शक्ति का मिलान कर सकते हैं। यह फार्म के मान से मेल करने के लिए आसान हो जाता है 2 n -1 , इसलिए हम चाहते हैं कि क्या करना है और एक की भरपाई करेंगे 1 अलग से:

^(^1|\1\1)*1

समूह 1या तो 1चीजों को किक करने के लिए शुरुआत में एकल से मेल खाता है, या यह अंतिम पुनरावृत्ति पर दो बार मेल खाता है। तो यह मेल खाता है 1, तब 2, फिर 4और इसी तरह। चूंकि ये जुड़ जाते हैं, हम हमेशा 2 की शक्ति से कम होते हैं, जिसे हम 1अंत में ठीक कर देते हैं ।

अनुगामी लाइनफीड के कारण, मैच को इनपुट से हटा दिया जाता है।

— मार्टिन एंडर
स्रोत
3

आर , 28 बाइट्स

function(x)x-2^(log2(x)%/%1)

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

2 ^ floor(log2(x))बेस रूपांतरणों को करने के बजाय सबसे महत्वपूर्ण बिट की गणना करने के लिए सबसे आसान , जो आर में काफी क्रियात्मक हैं

— user2390246
स्रोत
3

PARI / GP, 18 बाइट्स

n->n-2^logint(n,2)

वैकल्पिक समाधान:

n->n-2^exponent(n)
— चार्ल्स
स्रोत
पहले वाला गलत जवाब देता है। क्या यह होना चाहिए n->n-2^logint(n,2)? दूसरा मेरे PARI / GP के संस्करण में समर्थित नहीं है, न ही tio.run द्वारा उपयोग किए गए संस्करण में । क्या यह एक नया कार्य है?
— जेपी स्टिग नील्सन
@JeppeStigNielsen ओह, तय - यही मुझे अपने फोन से सबमिट करने के लिए मिलता है। हां, दूसरा एक नया फंक्शन है।
— चार्ल्स
@JeppeStigNielsen मैंने अभी चेक exponentकिया था, इस चुनौती की तुलना में 5 दिन पहले जोड़ा गया था, जिसे कल जोड़ा गया था। :)
— चार्ल्स
3

हास्केल , 32 29 बाइट्स

(!1)
x!y|2*y>x=x-y|z<-2*y=x!z

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

-3 बाइट्स @ लिकोनी को धन्यवाद

पुराने समाधान, 32 बाइट्स

f x=last[x-2^i|i<-[0..x],2^i<=x]

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

— user28667
स्रोत
1
अनाम कार्यों की अनुमति है, इसलिए आपको f=पहले संस्करण में आवश्यकता नहीं है । इसके अतिरिक्त z<-2*y=x!zएक बाइट बचाता है: इसे ऑनलाइन आज़माएं!
— लकोनी
3

एक्सेल, 36 31 बाइट्स

-5 @ IanM_Matrix1 को बाइट्स धन्यवाद

=BIN2DEC(MID(DEC2BIN(A1),2,99))

कुछ खास दिलचस्प नहीं।

— Wernisch
स्रोत
REPLACE को एक MID: = BIN2DEC (MID (DEC2BIN (A1), 2,99)) के साथ बदलकर 31 बाइट्स का आकार कम करें
— IanM_Matrix1
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.