अल्टरनेटिव बिट स्मियरिंग

Question

परिचय

इस चुनौती के लिए आपको एक पूर्णांक बाइनरी प्रतिनिधित्व के अनुगामी शून्य को सेट करना होगा 010101…, यह एक उदाहरण के साथ सबसे अच्छा समझाया गया है:

पूर्णांक को देखते हुए 400, पहला कदम इसे बाइनरी में बदलना है:

110010000

जैसा कि हम देख सकते हैं कि पांचवीं बिट सबसे कम महत्वपूर्ण 1बिट है, इसलिए वहां से शुरू करके हम निम्न शून्य को प्रतिस्थापित करते हैं 0101:

110010101

अंत में हम उसे दशमलव में बदल देते हैं: 405

चुनौती

एक सकारात्मक पूर्णांक रिटर्न / उत्पादन को देखते हुए उपरोक्त परिभाषित प्रक्रिया के परिणामी मूल्य।

नियम

• यह अनुक्रम केवल कम से कम एक 1बिट के साथ पूर्णांकों के लिए परिभाषित किया गया है , इसलिए इनपुट हमेशा for 1 होगा
• आप इसके बजाय एक स्ट्रिंग, अंकों की सूची (दशमलव) के रूप में इनपुट ले सकते हैं
• आपको अमान्य इनपुट को संभालना नहीं है

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

यहाँ मध्यस्थ चरणों के साथ कुछ और टेस्टकेस हैं (आपको इन्हें प्रिंट / वापस करने की आवश्यकता नहीं है):

In -> … -> … -> Out
1 -> 1 -> 1 -> 1
2 -> 10 -> 10 -> 2
3 -> 11 -> 11 -> 3
4 -> 100 -> 101 -> 5
24 -> 11000 -> 11010 -> 26
29 -> 11101 -> 11101 -> 29
32 -> 100000 -> 101010 -> 42
192 -> 11000000 -> 11010101 -> 213
400 -> 110010000 -> 110010101 -> 405
298 -> 100101010 -> 100101010 -> 298

Comments

क्या हम 32-बिट पूर्णांक मान सकते हैं?

— अरनुलद

@ अरनल्ड: ज़रूर!

— ।

कुछ गोल्फ विचार: यदि nइनपुट को विभाजित करने वाली 2 की अधिकतम शक्ति है, तो इसका उत्तर केवल है(input) + ceil((2^n - 2)/3)

— जंगवान मिन

Answer 1

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

lambda n:(n&-n)//3+n

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

व्याख्या

192एक उदाहरण के रूप में लें । इसका बाइनरी फॉर्म है 11000000, और हमें इसे बदलने की आवश्यकता है 11010101।

हम ध्यान दें कि हमें 10101संख्या में जोड़ना होगा। यह एक ज्यामितीय श्रृंखला ( 4^0 + 4^1 + 4^2) है, जिसका एक बंद रूप है (4^3-1)/(4-1)। यह वही है 4^3//3जहाँ //पूर्णांक विभाजन को दर्शाता है।

यदि यह था 101010, तो यह अभी भी एक ज्यामितीय श्रृंखला ( 2×4^0 + 2×4^1 + 2×4^2) होगा, जो 2×4^3//3उपरोक्त कारणों से है।

वैसे भी, 4^3और 2×4^3बस कम से कम महत्वपूर्ण बिट होगा, जिसे हम प्राप्त करते हैं n&-n:

हम देखते हैं कि पूरक nहै 00111111। यदि हम एक जोड़ते हैं, तो यह बन जाता है 01000000, और यह केवल n=11000000कम से कम महत्वपूर्ण अंकों के साथ ओवरलैप होता है । ध्यान दें कि "पूरक और एक जोड़ें" केवल निषेध है।

Comments

@ Mr.Xcoder अच्छा स्पोर्ट्समैनशिप

— लीक

संभवतः lambda n:(n&-n)//3+nभी काम करता है? सभी नमूना परीक्षण मामलों को पास करता है , लेकिन मेरे अंतर्ज्ञान के अनुसार यह वैध, सही नहीं होना चाहिए?

— श्री एक्सकोडर

@ Mr.Xcoder यह वास्तव में वैध है।

— लीकी नून

एक बाइट को बचाने के लिए पायथन 2 का उपयोग क्यों नहीं किया जाता है? TIO

— पलटें

@ फैटलटैक मुझे अजगर 2 से नफरत है

— लीक नून

Answer 2

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

&N:3+

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

इस बार लीकी नून के दृष्टिकोण का एक बंदरगाह (कम से कम मैंने उसे थोड़ा नीचे गोल्फ में मदद की: पी)

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

^N+4:6ạ

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

का उपयोग करता है JungHwan मिन के शानदार दृष्टिकोण , से अप्रत्यक्ष मदद से मार्टिन Ender ।

Comments

डेनिस ने पोस्ट किया, फिर हटा दिया, आपके द्वारा संपादित किए जाने के ठीक बाद एक बहुत ही समान 5-बाइट समाधान । कुछ इस तरह &N:3|। बधाई हो; आप जैली में डेनिस को हरा दें! (लेकिन काफी आउट-गोल्फ नहीं किया गया।)

— wizzwizz4

@ wizzwizz4 मैं वास्तव में बहुत कुछ नहीं किया था, इसके अलावा एक छोटे से गोल्फ को लीक के दृष्टिकोण का सुझाव देने और फिर इसे पोर्ट करने के लिए। लेकिन एह :-)

— श्री एक्सकोडर

यह पहला एएससीआईआई-केवल जेली उत्तर है जिसे मैंने कभी देखा है।

— एमडी एक्सएफ

Answer 3

वोल्फ्राम भाषा (गणितज्ञ) , ३६ २ by २६ २४ बाइट्स

^{-8 बाइट्स @MartinEnder और -2 बाइट्स की बदौलत @ Mr.Xcoder को धन्यवाद}

#+⌊(#~BitAnd~-#)/3⌋&

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

हम केवल इनपुट में अनुगामी शून्यों की संख्या को खोजने के लिए, और पाते हैं बारी के साथ नंबर की आवश्यकता 0और एस 1इनपुट के लिए इसे जोड़ने लंबाई एक है कि कम से कम के साथ है, और।

इसलिए, 400 -> 11001000 -> 110010000 + 0000 -> 110010101 + 101 -> 405

एस और एस के nसाथ वें नंबर के लिए स्पष्ट सूत्र OEIS पर A000975 में दिया गया था । हम वें नंबर का उपयोग कर सकते हैं क्योंकि कोई भी दो अलग-अलग संख्याएं बाइनरी में समान लंबाई नहीं हो सकती हैं और बारी-बारी से अंक हो सकते हैं।10n

Comments

2^#~IntegerExponent~2है(BitXor[#,#-1]+1)/2

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

@MartinEnder वाह! और फिर मैं बस और बाइट्स को कम करने के लिए अंशों को जोड़ सकता हूं

— जंगहवान मिन

24 बाइट्स । आप #+⌊(#~BitAnd~-#)/3⌋&इसके बजाय उपयोग कर सकते हैं ।

— श्री एक्सकोडर

@ Mr.Xcoder संपादित :)

— जुंगह्वान मिन

Answer 4

जे , ₁₉ 18 बाइट्स

+(2|-.i.@#.-.)&.#:

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

त्वरित स्पष्टीकरण

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

+(2|i.@i.&1@|.)&.#:
                 #:  Convert to binary list
       i.&1@|.       Index of last 1 from right
            |.         Reverse
       i.&1            Index of first 1
    i.               Range [0, index of last 1 from right)
  2|                 That range mod 2
               &.    Convert back to decimal number
+                    Add to the input

अन्य उत्तर:

पिछला उत्तर (19 बाइट्स)।

+(2|i.@i.&1@|.)&.#:

इससे लंबा होना चाहिए क्योंकि \दाएं-बाएं जाता है।

+(2|#*-.#.-.)\&.(|.@#:)

Comments

18 बाइट्स+(2|-.i.@#.-.)&.#:

— मील

@ मीलों यह समझाते हुए कि आधार परिवर्तन के साथ क्या हो रहा है? मैं अनुमान लगा रहा हूं कि इसे शून्य के साथ कुछ करना है लेकिन मुझे यकीन नहीं है।

— कोल

#.~ अनुगामी सत्य की संख्या को गिना जाता है , इसलिए हमें #.~ -. #:अनुगामी शून्य की संख्या गिनने की आवश्यकता है

— मीलों

@ मीलों आह! वह बहुत, बहुत चालाक है।

— कोल

Answer 5

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

!n=n|n&-n÷3

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

Comments

यह एक कुशल विधि की तरह लग रहा है, क्या आप ऑपरेटर पूर्वता की व्याख्या कर सकते हैं? उदाहरण के लिए, मैं यह नहीं बता सकता कि क्या इसका मूल्यांकन किया गया है ((!n=(n|n))&-n)/3, या !n=(((n|n)&(-n))/3), आदि

— MD XF

जूलिया में, बिटवाइज़ ऑपरेटरों के पास उनके अंकगणितीय समकक्षों के समान ही उदाहरण हैं, इसलिए |जैसा है +और &जैसा है *। इसलिए, के n|n&-n÷3रूप में पार्स किया जाता है n | ((n&-n) ÷3)।

— डेनिस

Answer 6

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

32-बिट पूर्णांक के रूप में इनपुट लेता है।

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

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

let f =

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

console.log(f(1))   // 1 -> 1 -> 1
console.log(f(2))   // 10 -> 10 -> 2
console.log(f(3))   // 11 -> 11 -> 3
console.log(f(4))   // 100 -> 101 -> 5
console.log(f(24))  // 11000 -> 11010 -> 26
console.log(f(29))  // 11101 -> 11101 -> 29
console.log(f(32))  // 100000 -> 101010 -> 42
console.log(f(192)) // 11000000 -> 11010101 -> 213
console.log(f(400)) // 110010000 -> 110010101 -> 405
console.log(f(298)) // 100101010 -> 100101010 -> 298

Answer 7

05AB1E , 13 8 5 बाइट्स

श्री Xcoder और JungHwan मिन के स्वच्छ सूत्र के लिए 5 बाइट्स का धन्यवाद, श्री Xododer के लिए
एक और 3 धन्यवाद बचाया

(&3÷+

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

व्याख्या

(      # negate input
 &     # AND with input
  3÷   # integer divide by 3
    +  # add to input

Comments

शायद ध्यान देने योग्य बात यह है कि मैथेमेटिका का उत्तर देने के लिए आपको 8 बाइट्स

— मिलते हैं

@ Mr.Xcoder: ओह, यह एक साफ सूत्र है।

— एमिग्ना

क्या 05ab1e में बिट-वाइज है? यदि हां, तो (<bitwise and here>3÷+~ 5 बाइट्स के लिए काम करना चाहिए।

— श्री एक्सकोडर

Answer 8

आर , 71 58 बाइट्स

NofP -6 बाइट्स के लिए धन्यवाद

function(n){n=n%/%(x=2^(0:31))%%2
n[!cumsum(n)]=1:0
n%*%x}

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

माना जाता है कि इनपुट 32-बिट पूर्णांक है। आर ने केवल 32-बिट पूर्णांक ( doubleजब एक पूर्णांक ओवरफ्लो होता है) पर हस्ताक्षर किए हैं, वैसे भी और 64-बिट या अहस्ताक्षरित ints।

Comments

आप 65 बाइट्स समाधान प्राप्त which.max(n):1-1करने के !cumsum(n)लिए कनवर्ट कर सकते हैं

— एनओएफपी

@ नोफ़पी धन्यवाद! बढ़िया विचार है।

— ग्यूसेप

Answer 9

ब्रेनफक , 120 बाइट्स

>+<[[>-]++>[[>]>]<[>+>]<[<]>-]>[-<+>[-<[<]<]>]>[>]<[>+<[->+<]<[->+<]<]>>[<]+>[-[-<[->+<<+>]>[-<+>]]<[->++<]<[->+<]>>>]<<

यह ऑनलाइन की कोशिश करो!

वर्तमान सेल में मूल्य के साथ शुरू होता है और आउटपुट मान के साथ सेल पर समाप्त होता है। स्पष्ट रूप से 255 से ऊपर की संख्याओं पर काम नहीं करेगा क्योंकि यह विशिष्ट ब्रेनफक के लिए सेल सीमा है, लेकिन यदि आप अनंत सेल आकार मान लेते हैं तो यह काम करेगा।

Answer 10

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

param($n)$a=($c=[convert])::ToString($n,2);if(($x=[regex]::Match($a,'0+$').index)-gt0){$c::ToInt32(-join($a[0..($x-1)]+($a[$x..$a.length]|%{(0,1)[$i++%2]})),2)}else{$n}

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

आउच। बाइनरी और एरे स्लाइसिंग से / में रूपांतरण वास्तव में पॉवरशेल के मजबूत सूट नहीं हैं।

$nएक नंबर के रूप में इनपुट लेता है । हम तुरंत convertबाइनरी बेस 2और स्टोर करते हैं $a। अगला हमारे पास एक और / निर्माण है। यदि खंड परीक्षण है कि क्या एक regex Match1 या अधिक के खिलाफ 0स्ट्रिंग के अंत में है ( '0+$') है इसकी indexतुलना में एक स्थान पर अधिक से अधिक 0(यानी, बाइनरी स्ट्रिंग की शुरुआत)। यदि ऐसा होता है, तो हमारे पास काम करने के लिए कुछ है, elseहम सिर्फ संख्या का उत्पादन करते हैं।

हमारे अंदर if, हम xवें पहले अंकों के स्लाइस करते हैं , और +शेष अंकों के साथ सरणी को संक्षिप्त करते हैं। हालांकि, शेष अंकों के लिए, हम उनके माध्यम से लूप करते हैं और चुनने के लिए उपयोग करते हुए 0या तो 1आउटपुट $i++%2का चयन करते हैं। यह अंत 010101...में 0एस के बजाय हमें पैटर्न मिलता है । हम फिर -joinएक स्ट्रिंग में एक साथ वापस आते हैं, और $cइसे एक Int32बेस से वापस करते हैं 2।

किसी भी स्थिति में, नंबर पाइपलाइन पर छोड़ दिया जाता है और आउटपुट निहित होता है।

Answer 11

एपीएल + विन, 43 बाइट्स

p←+/^\⌽~n←((⌊1+2⍟n)⍴2)⊤n←⎕⋄2⊥((-p)↓n),p⍴0 1

स्क्रीन इनपुट के लिए संकेत

Answer 12

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

param($n)$n+(($x=$n-band-$n)-$x%3)/3

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

पोर्ट ऑफ़ लीकी नून का पायथन उत्तर ।

बची हुई नन की बदौलत 5 बाइट्स बचाई

Answer 13

PHP , 47 बाइट्स

<?php function b($a){echo(int)(($a&-$a)/3)+$a;}

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

वास्तव में @Leaky नन के समाधान का सिर्फ एक और बंदरगाह

Answer 14

पर्ल 5 , 54 बाइट्स

$_=sprintf'%b',<>;1while s/00(0*)$/01$1/;say oct"0b$_"

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

Answer 15

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

lambda n:eval((bin(n).rstrip("0")+"01"*n)[:len(bin(n))])

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

वास्तव में अभी तक इससे खुश नहीं हैं, लेकिन मैं वास्तव में सूत्र का उपयोग नहीं करना चाहता ... -2 रॉड के लिए धन्यवाद । -1 जोनाथन फ्रेच को धन्यवाद ।

Comments

eval(...)इसके बजाय int(...,2)एक बाइट बचा सकता है।

— जोनाथन फ्रीच

Answer 16

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

लीकी नून के दृष्टिकोण का एक और बंदरगाह।

->k{(k&-k)/3+k}

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

Answer 17

जंग , 18 बाइट्स

लीकी नून के दृष्टिकोण का एक बंदरगाह

|n:i32|(n&-n)/3+n;

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

Answer 18

AWK , 24 बाइट्स

जंगवान मिन की मैथमैटिक जवाब का एक बंदरगाह

$0=int(and($0,-$0)/3+$0)

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

Answer 19

जावास्क्रिप्ट ईएस 6, 13 बाइट्स

n=>(n&-n)/3|n

f = 
n=>(n&-n)/3|n
;
console.log (f(8));
console.log (f(243));
console.log (f(1048576));
console.log (f(33554432));

Answer 20

सी, 56 बाइट्स

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;return n|k;}

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

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

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;k|=n;}

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

अर्नुल्ड के समाधान का उपयोग करते हुए  51  48 बाइट्स :

तीन बाइट बचाने के लिए @ l4m2 के लिए धन्यवाद!

m;f(n){return n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

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

43 gcc के साथ:

m;f(n){m=n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

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

Comments

0xAAAAAAAA=>-1u/3*2

— l4m2

Answer 21

परी / जीपी , 19 बाइट्स

लीकी नून के दृष्टिकोण का एक बंदरगाह।

n->n+bitand(n,-n)\3

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

Answer 22

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

BŒgṪµ2Ḷṁ×CḄ+³

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

व्याख्या

एक उदाहरण इनपुट के रूप में 24 लो।

BŒgṪµ2Ḷṁ×CḄ+³
B                Binary representation of the input → 11000
 Œg              Group runs of equal length → [[1,1],[0,0,0]]
   Ṫ             Tail → [0,0,0]
    µ            New monadic link
     2Ḷ          [0,1] constant
       ṁ         Mold [0,1] to the shape of [0,0,0] → [0,1,0]
        ×        Multiply [0,1,0] by...
         C       1-[0,0,0]. If last bit(s) of the original input are 1 this will add nothing to the original input
          Ḅ      Convert to decimal from binary → 2
           +³    Add this with the original input → 26