दशमलव कनवर्टर के लिए द्विआधारी

Question

दशमलव कनवर्टर के लिए द्विआधारी

जहाँ तक मैं देख सकता हूँ, हमारे पास दशमलव रूपांतरण चुनौती के लिए एक सरल बाइनरी नहीं है।

---

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

आपको किसी भी बेसिन बेस कन्वर्शन फ़ंक्शंस का उपयोग करने की अनुमति नहीं है। पूर्णांक करने वाली दशमलव कार्यों (जैसे, एक समारोह है कि बदल जाता है 101010में [1, 0, 1, 0, 1, 0]या "101010") इस नियम से छूट दी गई है और इस तरह की अनुमति है।

नियम:

• कोड को द्विआधारी संख्या का समर्थन करना चाहिए जो आपकी भाषा के समर्थन के उच्चतम संख्यात्मक मान तक (डिफ़ॉल्ट रूप से)
• आप बाइनरी प्रतिनिधित्व में अग्रणी शून्य का चयन कर सकते हैं
• दशमलव आउटपुट में अग्रणी शून्य नहीं हो सकता है।
• इनपुट और आउटपुट प्रारूप वैकल्पिक हैं, लेकिन अंकों के बीच कोई विभाजक नहीं हो सकता है। (1,0,1,0,1,0,1,0)एक वैध इनपुट प्रारूप नहीं है, लेकिन दोनों हैं 10101010और (["10101010"])हैं।
  • आपको "सामान्य" दिशा में इनपुट लेना होगा। 1110है 14नहीं 7।

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

1
1

10
2

101010
42

1101111111010101100101110111001110001000110100110011100000111
2016120520371234567

यह चुनौती कुछ अन्य चुनौतियों से संबंधित है, उदाहरण के लिए यह , यह और यह ।

Comments

संबंधित

— mbomb007

क्या आउटपुट को अहस्ताक्षरित किया जाना है या उस पर हस्ताक्षर किए जा सकते हैं? साथ ही, यदि मेरी भाषा मूल्य की लंबाई के आधार पर 32-बिट और 64-बिट पूर्णांक के बीच स्वचालित रूप से स्विच करने के लिए होती है, तो क्या आउटपुट को दोनों श्रेणियों में हस्ताक्षरित किया जा सकता है? जैसे- दो द्विआधारी मूल्य हैं जो दशमलव में बदलेंगे -1( 32 1'sऔर 64 1's)

— दूध

इसके अलावा, क्या आउटपुट फ्लोटिंग हो सकता है, क्या यह पूर्णांक होना चाहिए?

— Carcigenicate

@Carcigenicate यह पूर्णांक होना चाहिए, लेकिन यह किसी भी डेटा प्रकार का हो सकता है। जब तक round(x)==xआप ठीक हैं :) के 2.000लिए आउटपुट स्वीकृत है 10।

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

आह मधुर। धन्यवाद।

— कैरिजेनिकेट

Answer 1

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

DḤ+¥/

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

व्याख्या

अभिनेता समूह

• Dएक मठ (एकल तर्क फ़ंक्शन) है: अंक, में बदल 1234रहे हैं [1, 2, 3, 4]।

• Ḥ एक सन्यासी है जो अपने एकल तर्क को दोगुना करता है।

• + एक रंग (दो तर्क फ़ंक्शन) है जो इसके बाएँ और दाएँ तर्क जोड़ता है।

वहां से, यह थोड़ा मुश्किल हो जाता है।

यहाँ तोते के समय क्या होता है

• D, Ḥऔर +पढ़े जाते हैं। चेन जैसा दिखता है [D, Ḥ, +]।

• अगले दो अक्षर क्विक हैं , जो अब तक पढ़े गए लिंक (फ़ंक्शंस) पर पार्स-टाइम पोस्टफ़िक्स ऑपरेटर्स की तरह काम करते हैं।

• जब ¥पढ़ा जाता है, तो अंतिम दो लिंक पॉप अप हो जाते हैं और एक लिंक द्वारा प्रतिस्थापित किया जाता है जो उन्हें बनाने के द्वारा बनाई गई डियाड की तरह काम करता है। तो अब चेन जैसा दिखता है [D, dyad(Ḥ+)]।

• जब /पढ़ा जाता है, तो अंतिम लिंक (जिसे एक डाईएड होना चाहिए) पॉप हो जाता है और एक मोनाड द्वारा प्रतिस्थापित किया जाता है जो इस डेड का उपयोग करके तह करता है (सहजता से: f/एक सूची लेता है, इसमें कॉमा की जगह लेता है f, और परिणाम का मूल्यांकन करता है।

• अंतिम श्रृंखला [D, fold(dyad(Ḥ+))]दो साधुओं की तरह दिखती है ।

यहां रन टाइम पर होता है

• इनपुट (एक संख्या) को अनुमानित रूप से काम के मूल्य (कहते हैं, 101010) में पढ़ा जाता है ।

• Dनिष्पादित किया जाता है, इसके अंकों के साथ काम के मूल्य की जगह ( [1,0,1,0,1,0])।

• fold(dyad(Ḥ+))निष्पादित किया जाता है 1∗0∗1∗0∗1∗0, जहां काम कर रहे मूल्य को बदल दिया जाता है , जहां ∗रंजक है Ḥ+।

तो क्या x∗yमूल्यांकन करता है?

• एक dyadic परिभाषा में, काम कर रहा मूल्य शुरू में है बाईं , तर्क x।

• Ḥ, डबल मोनाड, इस मूल्य को दोगुना करता है। काम करने का मूल्य अब है 2x।

• +, प्लस रंग, एक सही तर्क का अभाव है, इसलिए यह एक हुक है : एक विशेष वाक्यविन्यास पैटर्न जहां इस रंग के सही तर्क को इंजेक्ट किया जाता है +। यह 2x + yअंतिम कार्य मान के रूप में पैदावार देता है, जो वापस आ जाता है।

तो पूरी अभिव्यक्ति का मूल्यांकन करने के लिए:

1∗0∗1∗0∗1∗0 = 2×(2×(2×(2×(2×1+0)+1)+0)+1)+0
            = 32×1 + 16×0 + 8×1 + 4×0 + 2×1 + 1×0
            = 42

Comments

आपके स्पष्टीकरण बेहतर और बेहतर हो रहे हैं :-)

— लुइस मेंडो

हे, मुझे लगता है कि आप इसे अभी से करते हैं? यह कमाल है, +1।

— १२:०६ पर आउटगॉल्फ

मुझे लगता है कि यह जेली का पहला टुकड़ा है जिसे मैंने कभी समझा है। +1!

— ब्लू

वाहवाही। मुझे वास्तव में समझ में आया कि जो मैंने शुरू में सोचा था, वह केवल प्रतीत होने वाले यादृच्छिक पात्रों की गड़बड़ी थी। अद्भुत व्याख्या।

— स्वाइनफिश

@Mark जेली कार्यक्रमों को देखने, अहम, पठनीय बनाने के लिए अपना स्वयं का कोडपेज है, लेकिन कार्यक्रम के रूप में अच्छी तरह से बस bytestrings हो सकता है।

— लिन

Answer 2

पायथन 2, 49 37 31 30 बाइट्स

अब यह एक दशमलव प्रतिनिधित्व में एक द्विआधारी संख्या लेगा, क्योंकि पायथन मनमाने ढंग से बड़े पूर्णांकों को संभाल सकता है।

b=lambda n:n and n%2+2*b(n/10)

^{एक बाइट बचाने के लिए xnor के लिए धन्यवाद :)}

द्विआधारी को दशमलव में बदलने के लिए एक मूल सूत्र देखकर यह देखने का सबसे आसान तरीका है कि यह कैसे काम करता है:

= 101010 
= 1*(2^5) + 0*(2^4) + 1*(2^3) + 0*(2^2) + 1*(2^1) + 0*(2^0)
= 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1
= 42

यह रूपांतरित करने का एक 'मानक' तरीका है। आप इस तरह तीसरी पंक्ति का विस्तार कर सकते हैं:

= ((((1*2 + 0)*2 + 1)*2 + 0)*2 + 1)*2 + 0

और यह अनिवार्य रूप से मेरे द्वारा की गई पुनरावर्ती विधि है।

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

b=lambda n:n and n%10+2*b(n/10)
b=lambda n:n%10+2*(n and b(n/10))
b=lambda n:0if n<1else n%10+2*b(n/10)
b=lambda n:0**(n/10)or n%10+2*b(n/10)
b=lambda n,o=0:o*(n<'0')or b(n[1:],2*o+int(n[0]))
lambda j:sum(int(b)*2**a for a,b in enumerate(j,1))

Comments

आप कर सकते हैं n%5या n%2इसके बजाय n%10।

— xnor

@xnor आह, यकीन नहीं होता कि मैं कैसे चूक गया! धन्यवाद :)

— Kade

Answer 3

05AB1E , 6 बाइट्स

कोड:

$¦v·y+

अन्वेषण के लिए, आइए 101010 उदाहरण लेते हैं । हम नंबर 1 से शुरू करते हैं (जो पहले अंक द्वारा दर्शाया गया है)। उसके बाद, हमारे पास दो मामले हैं:

• यदि अंक 0 है , तो संख्या को 2 से गुणा करें।
• यदि अंक 1 है , तो संख्या को 2 से गुणा करें और 1 जोड़ें।

तो 101010 मामले के लिए, निम्नलिखित गणना की गई है:

• 1 01010, नंबर 1 से शुरू करें ।
• 1 0 1010, दो से गुणा करें, जिसके परिणामस्वरूप 2 ।
• 10 1 010, दो से गुणा करें और एक जोड़ें, जिसके परिणामस्वरूप 5 ।
• 101 0 10, दो से गुणा करें, जिसके परिणामस्वरूप 10 ।
• 1010 1 0, दो से गुणा करें और एक जोड़ें, जिसके परिणामस्वरूप 21 ।
• 10101 0 , दो से गुणा करें, जिसके परिणामस्वरूप 42 , जो वांछित परिणाम है।

कोड स्पष्टीकरण:

$         # Push 1 and input
 ¦        # Remove the first character
  v       # For each character (starting with the first)
   ·      #   Multiply the carry number by two
    y+    #   Add the current character (converted automatically to a number)

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Comments

अच्छा है! (0 के लिए काम नहीं करता है, हालांकि मैंने अभी देखा)

— एमिग्ना

@Emigna हां, सौभाग्य से आपके कोड को केवल सकारात्मक बाइनरी नंबर के लिए काम करने की आवश्यकता है।

— अदनान

उस हिस्से को भी नहीं देखा। बहुत अच्छा फिर :)

— एमिग्ना

Answer 4

हास्केल, 16 111 + 57 = 168 बाइट्स

import Data.String
instance IsString[Int]where fromString=map((-48+).fromEnum)
f::[Int]->Int
f=foldl1((+).(2*))

संकलित झंडे के लिए +57 बाइट्स -XOverloadedStrings, -XOverlappingInstancesऔर -XFlexibleInstances।

चुनौती में कुछ बोझिल आईओ प्रारूप है , क्योंकि यह बहुत निर्भर करता है कि स्रोत कोड में डेटा प्रकार कैसे व्यक्त किए जाते हैं। मेरा पहला संस्करण (16 बाइट्स), अर्थात्

foldl1((+).(2*))

पूर्णांकों की सूची लेता है, उदाहरण के लिए [1,0,1,0,1,0]और अमान्य घोषित किया गया था क्योंकि शाब्दिक हास्केल सूची ,तत्वों के बीच होती है । प्रति से सूची निषिद्ध नहीं है। अपने नए संस्करण में, मैं अब भी नाम के समान फ़ंक्शन का उपयोग करता हूं f, लेकिन मैं "उद्धरण संलग्न चरित्र अनुक्रम" को अधिभारित करता हूं। फ़ंक्शन अभी भी पूर्णांकों की एक सूची लेता है जैसा कि आप टाइप एनोटेशन में देख सकते हैं [Int] -> Int, लेकिन एकल अंकों वाले पूर्णांकों के साथ सूचियों को अब लिखा जा सकता है "1234", उदाहरण के लिए।

f "101010"

जो मूल्यांकन करता है 42। अशुभ हास्केल, क्योंकि देशी सूची प्रारूप चुनौती नियमों के अनुकूल नहीं है। Btw, f [1,0,1,0,1,0]अभी भी काम करता है।

Comments

दुर्भाग्य से एक सूची एक वैध इनपुट नहीं है।

— योनातन एलन

@JonathanAllan: क्यों? और यदि हां, तो इसे कैसे इनपुट लेना चाहिए? हास्केल में एक स्ट्रिंग पात्रों की एक सूची है।

— नीमी

मुझे नहीं पता कि क्यों ... लेकिन मैंने इस बारे में जल्दी से पूछताछ की और एक एड को जोड़ने के लिए बनाया गया था " (1,0,1,0,1,0,1,0)एक वैध इनपुट प्रारूप नहीं है, लेकिन दोनों 10101010और (["10101010"])हैं।" इसके अलावा, एक टिप्पणी से पता चलता है कि वर्णों का सरणी स्वीकार्य है यदि ऐसा है तो स्ट्रिंग इनपुट की व्याख्या कैसे की जाती है।

— जोनाथन एलन

@JonathanAllan: कोई भी "बाइनरी पूर्णांक" (जो इनपुट हमें लेना है) स्वाभाविक रूप से अलग है, यह 2 की शक्तियों का एक क्रम है। प्रतिबंध स्पष्ट विभाजकों (अंकों के बीच) के बारे में है और अलगाव के बारे में नहीं है। किसी तरह मुझे अलग-अलग अंक लेने होंगे।

— शाम 5:56

यहाँ पर क्लिक करें: यदि इनपुट करना संभव है 10101010, "10101010"या कुछ समान है और यह काम करता है तो सबमिशन मान्य है। आप इसे एक स्ट्रिंग, सूची, पूर्णांक या जो भी कह सकते हैं। इनपुट करना [1][0][1][0]या [1,0,1,0]ठीक नहीं है। मूल रूप से, यह संभव है कि कहीं एक पंक्ति में लोगों और शून्य का एक गुच्छा मारा जाए। क्या यह स्पष्ट है?

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

Answer 5

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

बाइनरी से यूनरी, फिर यूनिरी से दशमलव में परिवर्तित करता है।

1
01
+`10
011
1

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

Comments

आपको किसी भी बिलिन बेस कन्वर्शन फ़ंक्शंस का उपयोग करने की अनुमति नहीं है। ~ ओपी

— रोमन ग्रैफ

@ RomanGräf कोई भी नहीं हैं। मैं बस अपने समाधान की प्रक्रिया का वर्णन कर रहा था।

— mbomb007

Answer 6

PHP, 44 बाइट्स

for(;""<$c=$argv[1][$i++];)$n+=$n+$c;echo$n;

मैं शपथ ले सकता था कि Ive ने उस प्रश्न को पहले देखा था। लेकिन अच्छा।

बाएं से दाएं की संख्या पढ़ता है, बाईं ओर शिफ्ट करता है और वर्तमान बिट जोड़ता है।

Answer 7

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

s=>[...s].map(c=>r+=+c+r,r=0)|r

संपादित करें: छोटा लेकिन कम मीठा: 2 बाइट्स @ETHproductions के लिए धन्यवाद बचाए गए।

Comments

जैसा कि अक्सर होता है, .mapकम होता है:s=>[...s].map(c=>+c+r+r,r=0)|r

— ETHproductions

@ETHproductions आपका फ़ंक्शन 0 के अलावा और कुछ कैसे लौटाता है?

— नील

क्षमा करें, यह होना चाहिएs=>[...s].map(c=>r+=+c+r,r=0)|r

— ETHproductions

Answer 8

भूलभुलैया , 17 15 बाइट्स

-+:
8 +
4_,`)/!

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

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

पर शुरू लूप ,

• , स्टैक को रोकने के लिए अगले इनपुट वर्ण के एससीआई कोड मान को पुश करें, या यदि ईओएफ -1 को धक्का दें।
• _48 ढेर के शीर्ष पर 48 धक्का
• - पॉप वाई, पॉप एक्स, पुश x-y । पिछले निर्देशों में इनपुट 0 से "0" के लिए और "1" के लिए 1 से 48 घटाना का प्रभाव है।
• + पॉप वाई, पॉप एक्स, पुश x+y ।
• : ढेर के ऊपर डुप्लिकेट
• + यह और पिछले निर्देश में वर्तमान मूल्य को 2 से गुणा करने का प्रभाव है

इसलिए, कोड का परिपत्र हिस्सा, प्रभाव में, वर्तमान संख्या को 2 से गुणा करता है और या तो 1 या 0 जोड़ता है, यह निर्भर करता है कि क्या चरित्र 1 या 0 इनपुट था।

पूंछ

यदि स्टैक का शीर्ष नकारात्मक है (जिसका अर्थ है ईओएफ पाया गया था), कोड जंक्शन पर छोड़ दिया जाएगा (अर्धविराम की ओर जा रहा है)।

• `` `1 प्राप्त करने के लिए ढेर के शीर्ष को हटा दें
• ) 2 प्राप्त करने के लिए स्टैक के ऊपर का चिह्न
• /पॉप y, पॉप x, पुश x / y (पूर्णांक विभाजन)। इससे अंतिम को पूर्ववत करने का प्रभाव पड़ता है*2 लूप से ।
• !स्टैक के शीर्ष के पूर्णांक प्रतिनिधित्व को आउटपुट करें। इस बिंदु पर कार्यक्रम घूमता है क्योंकि यह एक मृत अंत मारा और फिर एक त्रुटि के साथ बाहर निकलता है क्योंकि यह शून्य से विभाजित करने की कोशिश करता है।

@ बर्टिन एंडर को मुझे 2 बाइट्स बचाने के लिए (और मुझे लेबिरिंथ में बेहतर सोचने के तरीके सिखाने के लिए) धन्यवाद ।

Comments

इसके बजाय _48-आप बस कर सकते हैं #%लेकिन दुर्भाग्य से मैं यह नहीं देखता कि यह बाइट की गिनती में कैसे मदद कर सकता है।

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

आप हालांकि के बजाय के साथ एक बाइट बचा सकते हैं । `);_2

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

@MartinEnder, मुझे आपकी टिप्पणी के बारे में समझ नहीं है #%। क्या आप बता सकते हैं कि कैसे यह एक एएसआई _48-से इंटि में बदलने के लिए एक प्रतिस्थापन के रूप में काम करता है । )टिप के लिए धन्यवाद । मैं वह बदलाव लाऊंगा।

— रॉबर्ट हिकमैन 21

आपके कार्यक्रम में उस बिंदु पर स्टैक पर हमेशा दो मान होते हैं इसलिए #बस इसके लिए छोटा है _2। हालांकि _2%ASCII के पूर्णांक के लिए एक सामान्य रूपांतरण विधि नहीं है, यह यहां काम करता है क्योंकि आप केवल संभव इनपुट के रूप में पहले दो अंकों में रुचि रखते हैं। एक विकल्प होगा _1&(चूंकि मॉडुलो 2 बस कम से कम महत्वपूर्ण बिट निकालता है)।

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

ओह। ये तो बहुत खूब है। लेकिन हाँ, मुझे यकीन नहीं है कि #%कोड को छोटा करने के लिए उस प्रतिस्थापन ( ) का उपयोग कैसे करें ।

— रॉबर्ट हिकमैन 21

Answer 9

ब्रेन-फ्लैक , 46 , 28 बाइट्स

([]){{}({}<>({}){})<>([])}<>

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

कई बाइट्स @Riley के लिए धन्यवाद बचा लिया!

चूंकि ब्रेन-फ्लैक बाइनरी इनपुट नहीं ले सकता है, इसलिए इनपुट '0' और '1' की सूची है।

स्पष्टीकरण:

#Push the height of the stack
([])

#While true:
{

 #Pop the height of the stack
 {}

 #Push this top number to (the other stack * 2)
 ({}<>({}){})

 #Toggle back on to the main stack
 <>

 #Push the new height of the stack
 ([])

#endwhile
}

#Toggle back to the other stack, implicitly display.
<>

Comments

स्पष्टीकरण प्यार! इसके बिना ब्रेन-फ्लैक पढ़ना मुश्किल है :)

— इमिग्ना

^। अगर मैं अपने आप को कुछ टिप्पणी नहीं छोड़ता तो मैं अपने खुद के कार्यक्रम भी नहीं पढ़ सकता।

— रिले 10

यदि आप पूरे भाग से छुटकारा पाकर इसे 32 बाइट्स तक प्राप्त कर सकते हैं, और चरण के लिए "अन्य स्टैक में संख्या जोड़ें" बस इसे (अन्य स्टैक) * 2 में जोड़ें। ([]){({}[()]<({}<>({}){})><>)}<>

— रिले

और आप एक और 4 को बचा सकते हैं बस थोड़ी देर की शुरुआत में पॉपिंग करके और अंत में फिर से ऊँचाई को धक्का दे सकते हैं। ([]){{}({}<>({}){})<>([])}<>

— रिले

@ रिले ओह माय गोश, वह जीनियस है। आपका बहुत बहुत धन्यवाद!

— DJMcMayhem

Answer 10

जावा, 84 79 46 48 बाइट्स

• संस्करण 3.1

long/ 48 बाइट्स में परिवर्तित :

s->{long x=0;for(char c:s)x=c-48l+x*2;return x;}

• संस्करण 3.0

क्या कुछ गोल्फिंग / 46 बाइट्स:

s->{int x=0;for(char c:s)x=c-48+x*2;return x;}

• संस्करण 2.0

@Geobits को धन्यवाद! / 79 बाइट्स:

s->{int i=Math.pow(2,s.length-1),j=0;for(char c:s){j+=c>48?i:0;i/=2;}return j;}

• संस्करण 1.0

84 बाइट्स:

s->{for(int i=-1,j=0;++i<s.length;)if(s[i]>48)j+=Math.pow(2,s.length-i+1);return j;}

Comments

मुझे लगता है कि एक पुनरावृत्त समाधान करना चाहिए था। lulz। अच्छा काम

— प्रहार

क्या आपका इनपुट प्रकार सूची <चरित्र> या स्ट्रिंग है? अगर यह बाद की बात है, तो मैं अनजान था जावा 8 ऐसा कर सकता था! यदि यह पूर्व है जिसे चुनौती द्वारा अनुमति दी गई है?

— प्रहार

sहोना चाहिए char[]। मुझे आशा है कि इसकी अनुमति है ...

— रोमन ग्रैफ

यहां वापसी का प्रकार क्या है? मुझे लगता है कि यह लंबा होना चाहिए क्योंकि "ओपी के अनुसार कोड को द्विआधारी संख्या का समर्थन करना चाहिए जो आपकी भाषा को उच्चतम संख्यात्मक मान का समर्थन करता है" लेकिन छोटे मूल्यों के लिए मुझे लगता है कि यह एक int

— Poke

संभवतः इस पर इनपुट प्रकार ठीक है । आउटपुट इमो के लिए 2 बाइट हिट लेना चाह सकते हैं

— पोक

Answer 11

Befunge-98, 12 बाइट्स

2j@.~2%\2*+

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

इनपुट से एक बार में एक चार्ट पढ़ता है, इसे 0 या 1 में परिवर्तित करता है, इसका मान लेता है modulo 2 (0 char (48), 1 char है (49)), फिर वर्तमान मूल्य को दोगुना करने और जोड़ने के सामान्य एल्गोरिथ्म का उपयोग करता है हर बार नया अंक।

बोनस: यह किसी भी तरह के इनपुट स्ट्रिंग के साथ काम करता है, मैं कुछ समय से कोशिश कर रहा हूं कि कोई भी फनी इनपुट-> आउटपुट कॉम्बिनेशन ढूंढूं, लेकिन मैं कुछ भी प्रोड्यूस नहीं कर पाया (दुख की बात है, "जवाब" = 46)। क्या आप?

Comments

जबरदस्त हंसी। मैं अपने जवाब के साथ वही खेल खेल रहा था। सबसे दिलचस्प संख्या मैं उत्पन्न कर सकता था 666 ।

— जेम्स होल्डरनेस

अच्छा है! मैं 666 के लिए कुछ भी फिटिंग खोजने में कामयाब नहीं हुआ था: डी यह बहुत आसान होगा यदि पूंजीकरण का मूल्यों पर प्रभाव पड़ता है ...

— सिंह

@ जेम्स होल्डरनेस - मैं यही कर रहा हूं और मैंने केवल 366 को वापस लाने के लिए 'theleapyear' पाया है, तुम्हारा वास्तव में अच्छा है।

— चैती करें

Answer 12

जावास्क्रिप्ट (ईएस 7) 41 40 36 बाइट्स

f=([c,...b])=>c?c*2**b.length+f(b):0

इनपुट के रूप में एक स्ट्रिंग लेता है

ETHproductions के लिए एक बाइट धन्यवाद दिया

f=([c,...b])=>c?c*2**b.length+f(b):0
document.write([
    f('101010'),
    f('11010'),
    f('10111111110'),
    f('1011110010110'),
].join("<br>"))

Comments

दाएं-से-बाएं **समरूपता अजीब है, लेकिन यहां इसका उपयोग करके अच्छा काम है। 1<<b.lengthएक ही काम करेगा, लेकिन इसे आगे बढ़ने से रोकने के लिए कोष्ठकों की आवश्यकता होगी (c*1)<<(b.length+...)। मुझे लगता है कि आप को बदल कर एक बाइट बचा सकता है b[0]के साथ b+b( यहाँ देखें )।

— ETHproductions 15

Answer 13

सी # 6, 85 37 36 बाइट्स

long b(long n)=>n>0?n%2+2*b(n/10):0;

• 41 बाइट बचाने के लिए केड का धन्यवाद !
• C # 6 में बदलने से 7 बाइट्स बच गए।

Comments

शायद इससे कुछ प्रेरणा मिल सके? ;)

— काडे

@ यह करता है, धन्यवाद! मैं पायथन जवाब को देख रहा था जो उसी तकनीक का उपयोग करता है जिस क्षण आपने लिंक किया था: DI C के साथ भी छोटा हो सकता है 6.

— Yytsi

Answer 14

05AB1E , 7 बाइट्स

RvNoy*O

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

व्याख्या

R         # reverse input
 v     O  # sum of
  No      # 2^index
     *    # times
    y     # digit

Answer 15

सी, 53

v(char*s){int v=0,c;while(c=*s++)v+=v+c-48;return v;}

मेरे जावास्क्रिप्ट उत्तर के रूप में भी

टेस्ट Ideone

Comments

आप 4 बाइट्स को घोषित करके vऔर cवैश्विक चर के रूप में सहेज सकते हैं (हालांकि आपको इसका नाम बदलने की आवश्यकता है v, क्योंकि यह पहले से ही फ़ंक्शन का नाम है):w=0;c;v(char*s){while(c=*s++)w+=w+c-48;return w;}

— Steadybox

@Steadybox यह हो सकता है, w,c;लेकिन जब उत्तर एक फ़ंक्शन (कोड-गोल्फ में भी) हो तो मैं ग्लोबल्स का उपयोग नहीं करना चाहता

— edc65

@Steadybox Globals 0 को भी डिफॉल्ट करता है, इसलिए आप इसे छोड़ सकते हैं =0।

— अल्जीमर

Answer 16

पर्ल, 25 बाइट्स

-3 बाइट्स @ डॉम हेस्टिंग्स को धन्यवाद।

-pध्वज के लिए कोड + 1 बाइट के 24 बाइट्स ।

$\|=$&<<$v++while s/.$//

इसे चलाने के लिए:

perl -pe '$\|=$&<<$v++while s/.$//' <<< 101010

स्पष्टीकरण:

$\|=$&<<$v++  # Note that: we use $\ to store the result
              # at first $v=0, and each time it's incremented by one
              # $& contains the current bit (matched with the regex, see bellow)
              # So this operation sets a $v-th bit of $\ to the value of the $v-th bit of the input
while         # keep doing this while...
s/.$//        #  ... there is a character at the end of the string, which we remove.
         # $\ is implicitly printed thanks to -p flag

Answer 17

पुष्य , 10 बाइट्स

कमांड लाइन पर 0/1 की सूची के रूप में इनपुट लेता है $ pushy binary.pshy 1,0,1,0,1,0:।

L:vK2*;OS#

एल्गोरिथ्म वास्तव में एक दूसरे स्टैक होने की सुंदरता को दर्शाता है:

            \ Implicit: Input on stack
L:    ;     \ len(input) times do:
  v         \   Push last number to auxiliary stack
   K2*      \   Double all items
       OS#  \ Output sum of auxiliary stack

यह विधि काम करती है क्योंकि stack length - nसंख्या तक पहुंचने से पहले स्टैक दोगुना हो जाएगा n, जिसे बाद में दूसरे स्टैक में डाल दिया जाता है। यहाँ इनपुट के लिए प्रक्रिया क्या दिखती है101010 :

1: [1,0,1,0,1,0]
2: []

1: [2,0,2,0,2]
2: [0]

1: [4,0,4,0]
2: [2]

1: [8,0,8]
2: [2,0]

1: [16,0]
2: [2,0,8]

1: [32]
2: [2,0,8,0]

1: []
2: [2,0,8,0,32]

2 + 8 + 32 -> 42

Answer 18

मतलाब, 30 बाइट्स

@(x)sum(2.^find(flip(x)-48)/2)

अंतिम परीक्षण के मामले में गोलाई त्रुटियां हैं (क्योंकि double), इसलिए यदि आपको पूर्ण सटीकता की आवश्यकता है:

@(x)sum(2.^uint64(find(flip(x)-48))/2,'native')

47 बाइट्स के साथ।

Comments

मैं इसका परीक्षण नहीं कर सकता, लेकिन मेरा मानना ​​है कि @(x)sum(2.^(find(flip(x)-48)-1))सभी मामलों के लिए 32 बाइट्स के लिए सही परिणाम देगा। flipकाम करता है जैसे fliplrकि xएक आयामी है।

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

अच्छा समाधान! मैं भी गोल त्रुटि में भाग गया, फिक्स के लिए धन्यवाद। X का प्रारूप क्या है? किसी नंबर पर फ्लिप या फ़्लिप्र को कॉल करना बस उस नंबर को लौटाता है।

— मटकाव

एक्स बाइनरी स्ट्रिंग, इसलिए से कॉल करने की है f=@(x)..; f('1111001010')।

— जोनास

Answer 19

रेटिना , 12 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

+%`\B
¶$`:
1

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

दूसरा तरीका:

+1`\B
:$`:
1

व्याख्या

यह शायद मेरे पुराने, कम गोल्फ वाले, संस्करण के आधार पर समझाने में आसान होगा और फिर दिखाऊंगा कि मैंने इसे कैसे छोटा किया। मैं इस तरह बाइनरी को दशमलव में परिवर्तित करता था:

^
,
+`,(.)
$`$1,
1

रेटिना में एक दशमलव संख्या बनाने का एकमात्र समझदार तरीका चीजों को गिनना है (क्योंकि रेटिना में कुछ विशेषताएं हैं जो इसे एक राशि का प्रतिनिधित्व करने वाले दशमलव संख्या को प्रिंट करने देती हैं)। तो वास्तव में एकमात्र संभव दृष्टिकोण बाइनरी को एकात्मक में बदलना है, और फिर एक अंक की संख्या की गणना करना है। अंतिम पंक्ति गिनती करती है, इसलिए पहले चार बाइनरी को एकात्मक में परिवर्तित करते हैं।

हम यह कैसे करे? सामान्य तौर पर, बिट्स की सूची से एक पूर्णांक में बदलने के लिए, हम परिणाम को इनिशियलाइज़ करते हैं 0और फिर बिट्स से कम से कम महत्वपूर्ण से गुजरते हैं, हमारे पास पहले से मौजूद मूल्य को दोगुना करते हैं और वर्तमान बिट को जोड़ते हैं। उदाहरण के लिए, यदि बाइनरी नंबर है 1011, तो हम वास्तव में गणना करेंगे:

(((0 * 2 + 1) * 2 + 0) * 2 + 1) * 2 + 1 = 11
           ^        ^        ^        ^

जहाँ मैंने स्पष्टता के लिए अलग-अलग बिट्स को चिह्नित किया है।

इसे unary में करने की ट्रिक) a है जो कि दोहरीकरण का अर्थ है संख्या और b को दोहराना) क्योंकि हम 1अंत में s को गिन रहे हैं , हमें प्रक्रिया में 0s और 1s के बीच अंतर करने की आवश्यकता नहीं है। यह एक सेकंड में स्पष्ट हो जाएगा।

प्रोग्राम क्या करता है कि यह पहली बार एक अल्पविराम को मार्कर के रूप में जोड़ता है कि हमारे द्वारा पहले से संसाधित किए गए इनपुट का कितना हिस्सा है:

^
,

मार्कर के बाईं ओर, हमारे पास वह मूल्य होगा जो हम जमा कर रहे हैं (जो कि शून्य के यूनिरी प्रतिनिधित्व के लिए सही ढंग से आरंभीकृत है), और मूल्य का अधिकार प्रक्रिया के लिए अगला बिट होगा। अब हम एक लूप में निम्नलिखित प्रतिस्थापन लागू करते हैं:

,(.)
$`$1,

बस देखते हुए ,(.)और $1,, यह मार्कर को हर बार दाईं ओर ले जाता है। लेकिन हम यह भी सम्मिलित करते हैं $`, जो मार्कर के सामने सब कुछ है, अर्थात वर्तमान मूल्य, जिसे हम दोगुना कर रहे हैं। इनपुट को संसाधित करते समय यहां व्यक्तिगत चरण दिए गए हैं 1011, जहां मैंने $`प्रत्येक पंक्ति के ऊपर डालने का परिणाम चिह्नित किया है (यह पहले चरण के लिए खाली है):

,1011

1,011
 _
110,11
   ___
1101101,1
       _______
110110111011011,

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

तो यह सवाल है कि यह कैसे 12 बाइट्स नीचे गोल्फ के लिए छोड़ देता है। 18-बाइट संस्करण का सबसे महंगा हिस्सा मार्कर का उपयोग करने के लिए है। उससे छुटकारा पाने का लक्ष्य है। हम वास्तव में हर बिट के उपसर्ग को दोगुना करना चाहते हैं, इसलिए पहला विचार यह हो सकता है:

.
$`$&

समस्या यह है कि ये प्रतिस्थापन एक साथ होते हैं, इसलिए पहले बिट प्रत्येक के लिए दोगुना नहीं होता है , लेकिन यह हर बार एक बार कॉपी हो जाता है। इनपुट के लिए 1011हम (सम्मिलित अंकन $`) प्राप्त करेंगे:

 _ __ ___
1101011011

हमें अभी भी इनपुट को पुनरावर्ती रूप से संसाधित करने की आवश्यकता है ताकि पहले से दोगुना उपसर्ग दोबारा दूसरे और इसी तरह दोगुना हो जाए। एक विचार हर जगह मार्करों को सम्मिलित करना है और बार-बार उन्हें उपसर्ग के साथ बदलना है:

\B
,
+%`,
¶$`

प्रत्येक मार्कर को पहली बार उपसर्ग के साथ बदलने के बाद, हमें यह याद रखने की आवश्यकता है कि इनपुट की शुरुआत कहां हुई थी, इसलिए हम लाइनफीड भी डालते हैं और %यह सुनिश्चित करने के लिए विकल्प का उपयोग करते हैं कि अगला$` केवल निकटतम लाइनफीड की चीजों को उठाता है।

यह काम करता है, लेकिन यह अभी भी बहुत लंबा है (16 बाइट्स जब 1अंत में गणना करता है)। हम चीजों को कैसे घुमाते हैं? वे स्थान जहाँ हम मार्करों को सम्मिलित करना चाहते हैं, उनकी पहचान \B(दो अंकों के बीच की स्थिति) द्वारा की जाती है। हम केवल उन पदों में उपसर्ग क्यों नहीं डालते हैं? यह लगभग काम करता है, लेकिन अंतर यह है कि पिछले समाधान में, हमने वास्तव में प्रत्येक प्रतिस्थापन में एक मार्कर को हटा दिया था, और प्रक्रिया को सफल बनाने के लिए महत्वपूर्ण है। हालांकि, \Bचरित्र नहीं हैं , लेकिन सिर्फ स्थिति है, इसलिए कुछ भी नहीं हटाया जाता है। हम हालांकि रोक सकते हैं\B इस स्थान पर एक गैर-अंक वर्ण डालने के बजाय मिलान से । यह गैर-शब्द सीमा को शब्द सीमा में बदल देता है, जो पहले वर्ण वर्ण को हटाने के बराबर है। और यही 12-बाइट समाधान करता है:

+%`\B
¶$`:

पूर्णता के लिए, यहां प्रोसेसिंग के अलग-अलग चरण हैं 1011, प्रत्येक चरण के बाद एक खाली लाइन के साथ:

1
1:0
10:1
101:1

1
1:0
1
1:0:1
1
1:0
10:1:1

1
1:0
1
1:0:1
1
1:0
1
1:0:1:1

फिर, आप पाएंगे कि अंतिम परिणाम में ठीक 11 1s शामिल हैं ।

पाठक के लिए एक अभ्यास के रूप में, आप देख सकते हैं कि कैसे यह सामान्य रूप से अन्य आधारों (आधार में कुछ अतिरिक्त बाइट्स प्रति वृद्धि के लिए) के लिए काफी आसानी से होता है?

Answer 20

टी-एसक्यूएल, 202 बाइट्स

DECLARE @b varchar(max)='1',@ int=1 declare @l int=LEN(@b)declare @o bigint=CAST(SUBSTRING(@b,@l,1)AS bigint)WHILE @<@l BEGIN SET @o=@o+POWER(CAST(SUBSTRING(@b,@l-@,1)*2AS bigint),@)SET @=@+1 END PRINT @o

Answer 21

PHP, 64 बाइट्स

foreach(str_split(strrev($argv[1]))as$k=>$v)$t+=$v*2**$k;echo$t;

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

Answer 22

बैश + जीएनयू उपयोगिताओं, 29 बाइट्स

sed 's/./2*&+/g;s/.*/K&p/'|dc

I / O stdin / stdout के माध्यम से।

sedअभिव्यक्ति प्रत्येक अंक में द्विआधारी अप विभाजन और के लिए एक आरपीएन अभिव्यक्ति बनाता है dcमूल्यांकन करने के लिए।

Answer 23

PowerShell v2 +, 55 बाइट्स

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i

बहुत लंबा लगता है ... यह किसी भी नीचे गोल्फ के लिए प्रतीत नहीं हो सकता है - सुझावों की सराहना की।

व्याख्या

param($n)$j=1;$n[$n.length..0]|%{$i+=+"$_"*$j;$j*=2};$i
param($n)$j=1;                                          # Take input $n as string, set $j=1
              $n[$n.length..0]                          # Reverses, also converts to char-array
                              |%{                  };   # Loop over that array
                                 $i+=+"$_"*$j;          # Increment by current value of $j times current digit
                                              $j*=2     # Increase $j for next loop iteration
                                                     $i # Leave $i on pipeline
                                                        # Implicit output

Answer 24

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

f=([...n])=>n+n&&+n.pop()+2*f(n)

फिर से दिन बचाता है! हालांकि मानदंड थोड़ा लंबा लगता है ...

Comments

चूंकि यह एक "तर्क" है, [...n]को कोष्ठक में घिरा होना चाहिए?

— सायोस डेस

@Cyoce दुर्भाग्य से, हाँ, या JS एक SyntaxError फेंकता है।

— ETHproductions

Answer 25

गणितज्ञ, 27 13 11 बाइट्स

Fold[#+##&]

Listबिट्स को इनपुट के रूप में स्वीकार करता है (उदाहरण के लिए {1, 0, 1, 1, 0}- गणितज्ञ संख्या का द्विआधारी प्रतिनिधित्व 22)

Comments

ग्रेग के जवाब पर टिप्पणी के बाद, "इनपुट में सभी अंकों को विभाजित करना" एक आधार रूपांतरण फ़ंक्शन नहीं है?

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

@MartinEnder मैं इसे Charactersफंक्शन की तरह इस्तेमाल कर रहा हूँ ।

— जुंगवान मिन

@MartinEnder वास्तव में, जैसा कि @ नीमी के उत्तर में देखा गया है , मैं सिर्फ 1s और 0s की सूची को स्वीकार कर सकता हूं, क्योंकि यह केवल मैथमेटिका में एक द्विआधारी संख्या का प्रतिनिधित्व करने का एकमात्र तरीका है , जिसका अर्थ है कि मुझे IntegerDigitsपहली जगह की आवश्यकता नहीं है।

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

यह मानता है कि आधार 10 एक पूर्णांक का "प्राकृतिक" प्रतिनिधित्व है। एक वास्तविक पूर्णांक मूल्य का कोई पसंदीदा आधार नहीं होता है (मुझे लगता है कि आप कह सकते हैं कि जिस तरह से इसे संग्रहीत किया गया है वह शायद आधार 256 है या शायद आधार 2 भी है लेकिन यह एक कार्यान्वयन विवरण है)। सिर्फ इसलिए कि हम (सामान्य रूप से) पूर्णांक 10 का उपयोग करते हुए पूर्णांक शाब्दिक लिखते हैं इसका मतलब यह नहीं है कि पूर्णांक मान पहले से ही आधार 10 में हैं

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

@MartinEnder @ लिन के जेली कोड का उपयोग करता है D, जो कि एक ही काम करता हैIntegerDigits

— जंगवान मिन

Answer 26

क्लोजर, 114 105 63 41 बाइट्स

V4: 41 बाइट्स

-22 बाइट्स @cliffroot की बदौलत। चूंकि digitयह एक चरित्र है, इसलिए इसे कोड के माध्यम से परिवर्तित किया जा सकता है int, फिर वास्तविक संख्या प्राप्त करने के लिए इसे 48 से घटाया जाता है। नक्शे को भी गलत बताया गया। मुझे नहीं पता कि यह क्यों जरूरी लग रहा था।

#(reduce(fn[a d](+(* a 2)(-(int d)48)))%)

V3: 63 बाइट्स

(fn[s](reduce #(+(* %1 2)%2)(map #(Integer/parseInt(str %))s)))

-42 बाइट्स (!) अन्य उत्तरों को देखकर। मेरा "ज़िपिंग" स्पष्ट रूप से बहुत भोला था। वर्तमान स्थान की शक्ति में 2 को बढ़ाने के बजाय, फिर इसे वर्तमान अंक से गुणा करना और संचायक में परिणाम जोड़ना, यह सिर्फ संचायक को 2 से गुणा करता है, वर्तमान अंक पर जोड़ता है, फिर इसे संचायक में जोड़ता है। बिट को दाढ़ी बनाने के लिए रिडक्शन फंक्शन को एक मैक्रो में बदल दिया।

@Nimi, और @ अदनान को धन्यवाद!

Ungolfed:

(defn to-dec [binary-str]
  (reduce (fn [acc digit]
            (+ (* acc 2) digit))
          (map #(Integer/parseInt (str %)) binary-str)))

V2: 105 बाइट्स

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range)(reverse %)))

-9 बाइट्स स्ट्रिंग को उल्टा करके इसलिए मुझे एक अजीब अवरोही सीमा बनाने की आवश्यकता नहीं है।

V1: 114 बाइट्स

खैर, मैं निश्चित रूप से नहीं जीत रहा हूँ! मेरे बचाव में, यह पहला कार्यक्रम है जो मैंने कभी लिखा है जो आधारों के बीच परिवर्तित होता है, इसलिए मुझे यह सीखना था कि यह कैसे करना है। यह भी मदद नहीं करता है कि Math/powएक डबल रिटर्न देता है जिसे से परिवर्तित करने की आवश्यकता होती है, और Integer/parseIntएक चरित्र को स्वीकार नहीं करता है, इसलिए अंक को पारित होने से पहले लपेटने की आवश्यकता होती है।

#(reduce(fn[a[p d]](+ a(*(Integer/parseInt(str d))(long(Math/pow 2 p)))))0(map vector(range(dec(count %))-1 -1)%))

स्थान संख्या का प्रतिनिधित्व करने वाले एक अवरोही सूचकांक के साथ स्ट्रिंग को ज़िप करता है। परिणामी सूची पर कम कर देता है।

Ungolfed:

(defn to-dec [binary-str]
  (reduce (fn [acc [place digit]]
            (let [parsed-digit (Integer/parseInt (str digit))
                  place-value (long (Math/pow 2 place))]
              (+ acc (* parsed-digit place-value))))
          0
          (map vector (range (dec (count binary-str)) -1 -1) binary-str)))

Comments

#(reduce(fn[a b](+(* a 2)(-(int b)48)))0 %)संशोधित संस्करण। mapकोड के सीधे भाग में स्थानांतरित reduce, पूर्णांक पार्सिंग विधि, शॉर्टहैंड लैम्ब्डा सिंटैक्स के साथ बाहरी फ़ंक्शन करें।

— क्लिफरॉट

@cliffroot intको पार्स करने के लिए इस्तेमाल किया जा सकता है !? मैं हर चुनौती को 10 बाइट्स की तरह पूरा करूँगा।

— १६

ओह, मैं देख रहा हूं कि आप क्या कर रहे हैं। एससी कोड लेना, फिर मूल्य प्राप्त करने के लिए घटाना। मुझे लगता है कि यह केवल चुनिंदा परिस्थितियों में ही काम करेगा। ओह ठीक है, टिप के लिए धन्यवाद।

— कारकेजेनिकेट

Answer 27

पर्ल, 21 19 16 + 4 = 20 बाइट्स

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

-F -p(अतिरिक्त स्थान सहित) के साथ चलाएँ F। फ़ंक्शन का उपयोग करके पाइप मानecho -n

$\+=$_+$\for@F}{

ऐसे दोड़ो echo -n "101010" | perl -F -pE '$\+=$_+$\for@F}{'

मुझे लगता है कि यह @ दादा के उत्तर से पर्याप्त रूप से भिन्न है कि यह अपनी प्रविष्टि का गुण रखता है।

स्पष्टीकरण:

-F                              #Splits the input character by character into the @F array
-p                              #Wraps the entire program in while(<>){ ... print} turning it into
while(<>){$\+=$_+$\for@F}{print}
                   for@F        #Loops through the @F array in order ($_ as alias), and...
          $\+=$_+$\             #...doubles $\, and then adds $_ to it (0 or 1)...
while(<>){              }       #...as long as there is input.
                         {print}#Prints the contents of $_ (empty outside of its scope), followed by the output record separator $\

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

Comments

और भी छोटा:perl -F -pE '$\+=$_+$\for@F}{'

— दादा

मुझे ईमानदारी से हंसी आई कि यह अब कितना छोटा है। धन्यवाद।

— गेब्रियल बेनामी

हाँ, यह बहुत साफ है, अच्छी तरह से किया!

— दादा

Answer 28

आर (32-बिट), 64 बाइट्स

फ़ंक्शन के लिए इनपुट को चरित्र के रूप में दिया जाना चाहिए। R के आधार कार्य 32-बिट पूर्णांक का समर्थन करते हैं।

इनपुट:

# 32-bit version (base)
f=function(x)sum(as.double(el(strsplit(x,"")))*2^(nchar(x):1-1))
f("1")
f("10")
f("101010")
f("1101111111010101100101110111001110001000110100110011100000111")

आउटपुट:

> f("1")
[1] 1
> f("10")
[1] 2
> f("101010")
[1] 42
> f("1101111111010101100101110111001110001000110100110011100000111")
[1] 2.016121e+18

आर (64-बिट), 74 बाइट्स

फ़ंक्शन के लिए इनपुट को चरित्र के रूप में दिया जाना चाहिए। पैकेजbit64 का उपयोग 64-बिट पूर्णांक के लिए किया जाना है।

इनपुट:

# 64-bit version (bit64)
g=function(x)sum(bit64::as.integer64(el(strsplit(x,"")))*2^(nchar(x):1-1))
g("1")
g("10")
g("101010")
g("1101111111010101100101110111001110001000110100110011100000111")

आउटपुट:

> g("1")
integer64
[1] 1
> g("10")
integer64
[1] 2
> g("101010")
integer64
[1] 42
> g("1101111111010101100101110111001110001000110100110011100000111")
integer64
[1] 2016120520371234567

Comments

आप कर सकते हैं: बाइट्स के एक जोड़े को बचाने के el(strsplit(x,""))बजाय strsplit(x,split="")[[1]]।

— बिलीवॉब

आपका बहुत बहुत धन्यवाद! विशेष रूप से elसमारोह के लिए - मुझे इसकी जानकारी नहीं थी।

— djhurio

Answer 29

दलयोग एपीएल , 12 बाइट्स

(++⊢)/⌽⍎¨⍞

⍞ स्ट्रिंग इनपुट प्राप्त करें

⍎¨ प्रत्येक वर्ण को संख्या में बदलें

⌽ उलटा

(... )/संख्याओं के बीच निम्न फ़ंक्शन डालें

 ++⊢ तर्कों का योग प्लस सही तर्क

---

ngn मुंडा 2 बाइट्स।

Answer 30

k, 8 बाइट्स

हास्केल उत्तर के रूप में एक ही विधि।

{y+2*x}/

उदाहरण:

{y+2*x}/1101111111010101100101110111001110001000110100110011100000111b
2016120520371234567