बाइनरी बाइनरी विस्तार

Question

आम तौर पर, हम एक संख्या को द्विआधारी अंकों में 2 की शक्तियों के साथ 0या 1प्रत्येक के गुणांक के साथ निर्दिष्ट करके विघटित करते हैं :

25 = 1*16 + 1*8 + 0*4 + 0*2 + 1*1

की पसंद है 0और 1... बहुत बाइनरी नहीं है। हम 2 की शक्तियों के साथ विस्तार करके सही बाइनरी विस्तार करेंगे , लेकिन इसके बजाय 1या -1इसके गुणांक के साथ :

25 = 1*16 + 1*8 + 1*4 - 1*2 - 1*1

अब यह बाइनरी दिखता है।

किसी भी सकारात्मक संख्या को देखते हुए, यह देखने के लिए तुच्छ होना चाहिए:

• हर विषम संख्या में असीम रूप से कई सच्चे द्विआधारी विस्तार होते हैं
• हर सम संख्या में कोई भी द्विआधारी विस्तार नहीं है

इसलिए, एक सच्चे द्विआधारी विस्तार को अच्छी तरह से परिभाषित करने के लिए, हमें सबसे कम लंबाई यानी कम से कम विस्तार की आवश्यकता होती है ।

---

किसी भी सकारात्मक, विषम पूर्णांक को देखते हुए n, अपने वास्तविक बाइनरी विस्तार को, सबसे महत्वपूर्ण अंक से कम से कम महत्वपूर्ण अंक (या उलटा क्रम) में लौटाएं।

नियम:

• जैसा कि यह है कोड गोल्फ, आप कम से कम बाइट गिनती संभव में यह करने के लिए करना चाहिए । बिल बनाने की अनुमति है।
• कोई भी आउटपुट जो गुणांक का प्रतिनिधित्व और सूची कर सकता है वह स्वीकार्य है: एक सरणी, विभाजक के साथ गुणांक की एक स्ट्रिंग, आदि ...
• स्टैंडर्ड गोल्फिंग लूपहोल्स लागू होते हैं।
• आपका प्रोग्राम आपकी भाषा के मानक पूर्णांक आकार के मानों के लिए काम करना चाहिए।

---

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

25 -> [1,1,1,-1,-1]
47 -> [1,1,-1,1,1,1]
1 -> [1]
3 -> [1,1]
1234567 -> [1,1,-1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,1]

Comments

संबंधित लेकिन काफी अलग।

— Giuseppe

सरल एल्गोरिथ्म: बेस 2 में कनवर्ट करें, 0 के -1 को बदलें, एलएसडी को सामने रखें।

— जोशियाह विंसलो

Voile: मैं नीचे की व्याख्या नहीं कर रहा था, मैं सिर्फ उन लोगों के लिए एक एल्गोरिथ्म की रूपरेखा तैयार कर रहा था जिनके पास अपनी भाषा में आधार-रूपांतरण आदेश हैं।

— जोशिया विंसलो

चूंकि आप वास्तव में द्विआधारी होने के लिए उत्सुक हैं, क्या हम सामान्य स्थान-मूल्य लेकिन दो राज्यों की नई व्याख्या के साथ पैक बिट्स के रूप में मूल्य वापस कर सकते हैं? यानी विद्युत रूप से यह सिर्फ उच्च या निम्न वोल्टेज (या जो कुछ भी) है, और यह मेरी गलती नहीं है अगर मानक डिबगर कम वोल्टेज वाले राज्य के 0बजाय प्रिंट करते हैं -1। बिट्स प्राप्त करने वाले को पता है कि उनका क्या मतलब है। (यह अभी भी एक गैर-तुच्छ बिट-हेरफेर अभ्यास है, क्योंकि एक घुमाव अधिकार केवल तभी काम करता है जब इसमें 32 महत्वपूर्ण लंबाई होती है। जैसे 5-बिट संख्या को 5 की एक चौड़ाई की आवश्यकता होती है)

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

क्या आउटपुट में विभाजक शामिल करने की आवश्यकता है? के लिए 111-1-1एक वैध उत्पादन है 25?

— ओलिवर

Answer 1

जाप , 6 बाइट्स

¤é r0J

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

स्पष्टीकरण:

¤é r0J  // Test input:                  25
¤       // Binary the input:            11001
 é      // Rotate 1 chars to the right: 11100
   r0J  // Replace 0s with -1:          111-1-1

Comments

आह, रोटेशन; कि 's क्यों यह मेरे लिए काम नहीं कर रहा था।

— झबरा

घुमाएँ ??? dagnabbit।

— Giuseppe

Answer 2

पायथ ,  12  11 बाइट्स

|R_1.>jQ2 1

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

---

कैसे?

| R_1।> JQ2 1 पूर्ण कार्यक्रम।

      jQ2 इनपुट को बाइनरी सूची में बदलें।
     ।> 1 ऊपर की सूची को दाईं ओर 1 स्थान पर घुमाएं।
| R_1 सब्स्टिट्यूट 0 -1 के साथ।
               अवैध रूप से उत्पादन।

सबसे पहले, हम देखते हैं कि कार्य केवल " 0द्विआधारी लेखन में एस को विकल्प के साथ -1एस और 1 स्थान पर दाईं ओर शिफ्ट करने के लिए है।" - ठीक यही हमें करना चाहिए! बाइनरी रूपांतरण हमें 0s और 1s की सूची देता है । हम सब यहाँ क्या करना चाहिए करने के लिए एक गोल्फ रास्ता खोजने के 0लिए है -1। बिटवाइज़ ऑपरेटर |(बिटवाइज़ OR) हमारा मित्र है। बाइनरी प्रतिनिधित्व पर नक्शा के साथ स्थानांतरित कर दिया |और -1। यदि वर्तमान संख्या है 0, तो यह रूपांतरित हो जाती है -1।

Comments

मुझे नहीं लगता कि कोई बेहतर तरीका है। ;)

— जोशिया विंसलो

@ जोसाइविंसलो मैं करता हूं ... इसे खोजने की कोशिश कर रहा हूं

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

हम्म? एल्गोरिथ्म इष्टतम लगता है, शायद इसलिए कि मैं पायथ को नहीं जानता।

— जोशिया विंसलो

@ जोसैयाविंसलो को बेहतर तरीका मिला। सिंथेटिक बेहतर तरीका, एल्गोरिथम बेहतर तरीका नहीं।

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

@ Mr.Xcoder और अब वास्तव में मेरे लिए कोई कम से कम नहीं है।

— आउटगॉल्फ

Answer 3

पर्ल 6

स्ट्रिंग संस्करण, 31 बाइट्स

1~(*+>1).base(2).subst(0,-1,:g)

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

सूची संस्करण, 36 बाइट्स

{map * *2-1,1,|($_+>1).base(2).comb}

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

Answer 4

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

f=n=>n?[...f(n>>=1),!n|n%2||-1]:[]

टेस्ट स्निपेट

let f=n=>n?[...f(n>>=1),!n|n%2||-1]:[];

[25, 47, 1, 3, 1234567].map(x => console.log(x + ":", JSON.stringify(f(x))))

Answer 5

पर्ल 6 , 72 बाइट्स

निश्चित रूप से एक बेहतर तरीका है, लेकिन यह मेरे पास है ...

->$a {grep {$a==[+] @^a.reverse Z+< ^∞},[X] (1,-1)xx $a.base(2).chars}

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

स्पष्टीकरण : यह एक फ़ंक्शन है जो एक तर्क ( ->$a) लेता है । हमें सबसे पहले आवश्यक गुणांक की $a.base(2).charsसंख्या ( = आधार 2 प्रतिनिधित्व में वर्णों की संख्या) मिलती है , फिर Xउस कई जोड़े का कार्टेशियन उत्पाद ( ) बनाते हैं (1,-1)। (इसका [X]मतलब है: निम्नलिखित सूची को कम करें X।) इसलिए हमें 1s और -1s के सभी संभावित संयोजनों की एक सूची मिलती है। फिर हम grepकेवल उन सूचियों को फ़िल्टर ( ) करते हैं जो दी गई संख्या को कूटबद्ध करती हैं $a। केवल एक ही है, इसलिए हमें गुणांक वाले एक सूची की सूची मिलती है।

Grep ब्लॉक ऐसा करता है: अपने तर्क को एक सूची ( @^a) के रूप में लेता है , इसे उलट देता है और इसे 0,1,2,..."बाएं बिट शिफ्ट" ऑपरेटर का उपयोग करके एक अनंत सूची के साथ ज़िपित करता है +<। जैसे ही छोटी सूची समाप्त होती है (हमारे लिए अच्छा!) के रूप में ज़िप करना बंद हो जाता है। हम फिर सभी परिणामों को जोड़ते हैं और दिए गए नंबर के साथ तुलना करते हैं। हमें उपयोग करना था .reverseक्योंकि ओपी मांग करता है कि गुणांक सबसे महत्वपूर्ण से कम से कम महत्वपूर्ण क्रम में हो।

Answer 6

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

Bṙ-o-

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

Answer 7

05AB1E , 6 5 बाइट्स

bÁ0®:

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

Comments

D<हो सकता है ®( ®डिफ़ॉल्ट है -1)।

— आउटगॉल्फ

@EriktheOutgolfer धन्यवाद! इसका एहसास नहीं हुआ।

— ओकेक्स

Answer 8

जे, 11 बाइट्स

1-~2*_1|.#:

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

एल्गोरिथ्म के लिए @JosiahWinslow का धन्यवाद।

रूपांतरण को कम करने पर कोई विचार? मेरे विचार का उपयोग करने के लिए कर रहे हैं !.(nvm, यह सिर्फ रूपांतरण की सहिष्णुता को बदल देता है)।

का उपयोग करते हुए {-take 1 वर्ण से लंबा है।

_1 1{~_1|.#:

Answer 9

जावा 8, 101 बाइट्स

n->{String s=n.toString(n,2);return(s.charAt(s.length()-1)+s.replaceAll(".$","")).replace("0","-1");}

पोर्ट ऑफ़ @ ओलिवर के जाप उत्तर , कुछ और बाइट्स के साथ ;);

इस स्ट्रिंग दृष्टिकोण के बजाय गणितीय दृष्टिकोण का उपयोग करके निश्चित रूप से गोल्फ हो सकता है।

स्पष्टीकरण:

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

n->{                             // Method with Integer parameter and String return-type
  String s=n.toString(n,2);      //  Convert the Integer to a binary String
  return(s.charAt(s.length()-1)  //  Get the last character of the binary String
    +s.replaceAll(".$","")       //   + everything except the last character
   ).replace("0","-1");          //  Then replace all zeroes with -1, and return the result
}                                // End of method

Answer 10

आर , 90 88 46 बाइट्स

function(n)c((n%/%2^(0:log2(n))%%2)[-1],1)*2-1

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

ओलिवर के एल्गोरिथ्म को लागू करता है , लेकिन अंकों को रिवर्स ऑर्डर में लौटाता है। चूंकि हम गारंटी देते हैं कि nकभी भी नहीं, कम से कम महत्वपूर्ण बिट (पहला) हमेशा होता है 1, इसलिए हम इसे हटा देते हैं और 1आर को रोटेशन को अनुकरण करने के लिए अंत में जोड़ते हैं । मुझे अपना गणित ठीक करने के लिए झबरा के लिए धन्यवाद ।

सीधे शब्दों में कहें rev( ) पाद में फ़ंक्शन कॉल के चारों ओर उसी क्रम में मान वापस करना चाहिए।

मूल उत्तर, 88 बाइट्स:

function(n,b=2^(0:log2(n)))(m=t(t(expand.grid(rep(list(c(-1,1)),sum(b|1))))))[m%*%b==n,]

अनाम फ़ंक्शन; संलग्न किए गए कॉलम नामों के साथ मूल्यों को रिवर्स ऑर्डर में लौटाता है ।

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

स्पष्टीकरण:

function(n){
 b <- 2^(0:log2(n))         # powers of 2 less than n
 m <- expand.grid(rep(list(c(-1,1)),sum(b|1))) # all combinations of -1,1 at each position in b, as data frame
 m <- t(t(m))               # convert to matrix
 idx <- m%*%b==n            # rows where the matrix product is `n`
 m[idx,]                    # return those rows
}

Comments

मैं उस आउटपुट को वैध नहीं मानूंगा; पुष्टि के लिए चुनौती लेखक से पूछें।

— झबरा

@ शैगी उलट क्रम स्पष्ट रूप से अनुमत है: from the most significant digit to the least significant digit (or in reversed order).इसलिए यह पूरी तरह से स्वीकार्य होना चाहिए।

— ग्यूसेप

उलटा क्रम , उलटा संकेत नहीं। 25उदाहरण के लिए , मान्य आउटपुट का अर्थ होगा [1,1,1,-1,-1]या [-1,-1,1,1,1]।

— झबरा

@ शैगी आह, आप सही कह रहे हैं, मैंने सिर्फ गणित गलत किया है! के 2*bits - 1बजाय होना चाहिए 1-2*bits। धन्यवाद।

— ग्यूसेप

Answer 11

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

29 बाइट्स कोड, -pस्विच के लिए 1 बाइट ।

$_=sprintf'1%b',$_/2;s/0/-1/g

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

Answer 12

CJam, 12 बाइट्स

मेरे गोल्फस्क्रिप्ट उत्तर का एक बंदरगाह।

qi2b{_+(}%)\

Answer 13

रूबी , 44 37 33 32 बाइट्स

->n{("1%b"%n).chop.gsub ?0,"-1"}

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

Answer 14

गोल्फस्क्रिप्ट, 14 13 14 बाइट्स

-1 बाइट क्योंकि मैं भूल गया %था। +1 बाइट क्योंकि मैं भी भूल गया इनपुट एक स्ट्रिंग है।

~2base{.+(}%)\

Comments

यदि आप मान रहे हैं कि इनपुट पूर्णांक के रूप में आता है, तो आपको {}इसे ब्लॉक करने के लिए कोड को लपेटना चाहिए । पूर्ण कार्यक्रमों को केवल स्ट्रिंग्स के रूप में इनपुट मिल सकता है।

— पीटर टेलर

उम्म क्या? मेरा मतलब था, संख्या को पूर्णांक के रूप में धकेला जा रहा है, बजाय एक संख्या वाले स्ट्रिंग के।

— जोसिया विंसलो

उस स्थिति में आपका उत्तर पूर्ण कार्यक्रम नहीं है, और इसलिए "फ़ंक्शन" होना चाहिए , या गोल्फस्क्रिप्ट ब्लॉक के मामले में। इसलिए यह {2base{.+(}%\}15 बाइट्स के लिए है। इसी तरह आपका सीजेएम जवाब देता है।

— पीटर टेलर

यह एक पूर्ण कार्यक्रम है। गोल्फस्क्रिप्ट में इनपुट को कार्यक्रम की शुरुआत में स्टैक पर स्पष्ट रूप से धकेल दिया जाता है, और CJam में इनपुट निष्पादन से पहले निर्दिष्ट किया जाता है और q कमांड के साथ एक्सेस किया जाता है।

— जोसिया विंसलो

मुझे गोल्फस्क्रिप्ट से कुछ परिचितता है । ( और सीजेएम )। यदि आप यह दावा करना चाहते हैं कि यह एक पूर्ण कार्यक्रम है, तो आपको इसके साथ उपसर्ग करने की आवश्यकता है ~।

— पीटर टेलर