बाइनरी सबस्ट्रिंग का योग

Question

यह चुनौती सरल है, एक दशमलव संख्या दी गई है, बाइनरी में कनवर्ट करें और बाइनरी नंबर के उप-स्ट्रिंग के योग की गणना करें, जिसकी लंबाई मूल संख्या से कम है। यहाँ एक उदाहरण है:

Input:
  11
Binary:
  11 -> 1011
Substrings:
  101 = 5
  011 = 3
  10  = 2
  01  = 1
  11  = 3
  1   = 1
  0   = 0
  1   = 1
  1   = 1
Sum:
  5+3+2+1+3+1+0+1+1=17
Output:
  17

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

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड!

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

2  => 1
3  => 2
4  => 3
5  => 5
6  => 7
7  => 9
8  => 7
9  => 10
10 => 14
11 => 17

Comments

उत्सुकता से, पूर्ण-लंबाई के विकल्प का बहिष्करण एक महत्वपूर्ण अतिरिक्त चुनौती है।

— पीटर टेलर

Answer 1

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

BṡRḄFS_

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

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

BṡRḄFS_  Main link. Input: n

B        Convert n to base 2.
  R      Yield [1, ..., n].
 ṡ       Get all overlapping slices of lengths 1 to n.
         This yields empty arrays if the slice size is longer than the binary list.
   Ḅ     Convert each binary list to integer.
    F    Flatten the resulting, nested list.
     S   Compute the sum of the result.
      _  Subtract n from the sum.

Comments

क्या एन्कोडिंग आपको उस प्रोग्राम के लिए 1 बाइट / चार देता है?

— टोबी स्पाईट

@TobySpeight जेली अपने स्वयं के कोड पृष्ठ

— एक स्पेगेटो

Answer 2

अजगर, १०

sPiR2.:.BQ

इसे ऑनलाइन आज़माएं या टेस्ट सूट चलाएं

स्पष्टीकरण:

sPiR2.:.BQ    ##   Q = eval(input())
       .BQ    ##   get binary string of Q
     .:       ##   get all substrings of that
  iR2         ##   convert them all to base 10
sP            ##   sum all but the last element, which is the input number

Answer 3

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

6 बाइट बचाने में मेरी मदद करने के लिए डेनिस को चिल्लाओ!

q~:Q{)Q2bew2fb~}%1bQ-

केवल सीजेएम (टीआईओ पर उपलब्ध) के नवीनतम संस्करण के साथ काम करता है। इसे ऑनलाइन आज़माएं !

पुराना संस्करण:

qi2b_,,0-\f{ew}{{2b}%}%e_:+

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

Answer 4

पायथन 3, 111 वर्ण

N=bin(int(input()))[2:];L=len(N);r=range;print(sum(int(n,2)for n in[N[j:j+i]for i in r(1,L)for j in r(L-i+1)]))

संपादित करें : स्पष्टीकरण:

N=bin(int(input()))[2:]

इनपुट स्ट्रिंग को एक इंट में बदलें, फिर एक बाइनरी स्ट्रिंग के लिए इंट और उसके पहले दो वर्णों को हटा दें, क्योंकि binविधि स्ट्रिंग के प्रारूप में रिटर्न करती है0b...

बाइनरी स्ट्रिंग के सभी सब्सट्रेटिंग लें, उन्हें दशमलव का उपयोग करके कन्वर्ट करें int(n, 2)और उन्हें योग करें।

[N[j:j+i]for i in r(1,L)for j in r(L-i+1)]

सभी सबस्ट्रिंग की एक सूची है। Ungolfed संस्करण:

def all_substrings(N):
    result = []
    for i in range(1, len(N)):
        for j in range(len(N) - i + 1):
            result.append(N[j:j+i])
    return result

उम्मीद है की यह मदद करेगा।

Answer 5

CJam (22 बाइट्स)

वर्तमान सीजेएम उत्तर की तुलना में यह एक बाइट लंबा है, लेकिन दृष्टिकोण शायद कुछ अन्य भाषाओं के लिए काफी लाभप्रद रूप से अनुकूलित हो सकता है।

3,ri_2b_,,:).*\+fbW%:-

ऑनलाइन डेमो

विश्लेषण

मान लीजिए कि प्रश्न थे

बाइनरी नंबर के उप-स्ट्रिंग के योग की गणना करें

बिट के बिना

जिसकी लंबाई मूल संख्या से कम है

फिर यह दिखाना बहुत मुश्किल नहीं है कि सबसे महत्वपूर्ण बिट कुल वजन के साथ होता है 1*(2^B-1)जहां Bबिट्स की संख्या होती है; दूसरा-सबसे महत्वपूर्ण बिट कुल वजन के साथ होता है 2*(2^(B-1)-1); नीचे बथ-सबसे महत्वपूर्ण बिट, जो कुल वजन के साथ होता है B*(2^1-1)।

अब मूल संख्या के घटाव को ध्यान में रखते हुए x, हम योग के साथ समाप्त होते हैं

sum_i (x & 2^i) * 2^i * 2*(B-i)  -  sum_i (x & 2^i) * (B-i)  -  x

विच्छेदन

3,        e# Put [0 1 2] on the stack - we'll need it later
ri_       e# Get the input x and copy it
2b        e# Convert the copy to base 2
_,,:).*   e# Pointwise multiply by 1 plus the index
\+        e# Append x to the resulting array, giving A
fb        e# Map a base conversion
W%:-      e# Reverse and fold a subtraction

बेस 2 में रूपांतरण मुख्य योग प्लस का पहला भाग देता है x; आधार 1 को दूसरा भाग प्लस देता है x; और बेस 0 के लिए बस देता है x, इसलिए बेस -1 को xएस -2 से घटाकर रद्द कर दिया जाता है, और बेस 0 को घटाकर वांछित परिणाम दिया जाता है।

Answer 6

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

n=>[...n.toString(2)].map(c=>[...s+=c].map((_,i)=>n-='0b'+s.slice(i)),s='')|-n

बाहरी बाइनरी प्रतिनिधित्व के mapप्रमुख substrates बनाता है n; आंतरिक एक अग्रणी सब्सट्रिंग के अनुगामी पदार्थों को निकालता है, इस प्रकार मूल बाइनरी प्रतिनिधित्व सहित सभी संभावित सबस्ट्रिंग को कवर करता है।

प्रत्येक विकल्प को बाइनरी बैक से दशमलव में परिवर्तित किया जाता है और मूल इनपुट से घटाया जाता है क्योंकि यह उन्हें एक साथ जोड़ने और मूल इनपुट को घटाने से थोड़ा कम होता है।

Answer 7

मैथेमेटिका, 73 70 बाइट्स

Tr[FromDigits[#,2]&/@StringCases[#~IntegerString~2,__,Overlaps->All]]&

समारोह। Integer-> पूर्णांक

Comments

एक दयालु गणितज्ञ के पास उपनिवेशवादियों से निपटने के लिए महान उपकरण नहीं हैं।

— एक सीमन्स

Answer 8

६४, रेटिना

.*
$*
+`(1+)\1
$1a
a1
1
r&!M`.*
&!M`.*
^.*

+`1(a*)\b
a$.1$*1;
;

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

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

Answer 9

सी, 71 बाइट्स

f(n){int a=0,m=0,i;for(;++m<n;m+=m)for(i=n;i+i>m;i/=2)a+=i&m;return a;}

हम एक संचायक aऔर मुखौटा बनाए रखते हैं m। मुखौटा 1 से शुरू होता है और बाहरी लूप के आसपास हर बार एक सा लंबा हो जाता है। आंतरिक लूप में, iइनपुट की एक कॉपी क्रमिक रूप से सही स्थानांतरित की जाती है जब तक कि यह मास्क से छोटा नहीं होता है, हर बार नकाबपोश मूल्य को जमा करता है।

परीक्षण कार्यक्रम

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
    while (*++argv) {
        int n = atoi(*argv);
        printf("%d -> %d\n", n, f(n));
    }
    return 0;
}

परीक्षण उत्पादन

./73793 $(seq 0 11)
0 -> 0
1 -> 0
2 -> 1
3 -> 2
4 -> 3
5 -> 5
6 -> 7
7 -> 9
8 -> 7
9 -> 10
10 -> 14
11 -> 17

Answer 10

सी #, 148 बाइट्स

int x(int i){int s,r=0,j=i,p=System.Convert.ToString(i,2).Length+1,k;for(;--p>-1;){k=j;s=-1;for(;++s<p;)r+=(k>>=1);j=(i&((1<<p-1)-1))<<1;}return r;}

या, यदि मैं "स्थैतिक System.Math का उपयोग करके" आयात जोड़ता हूं; फिर 138 के साथ

int x(int i){int s,r=0,j=i,p=(int)Round(Log(i,2)+1.49,0),k;for(;--p>-1;){k=j;s=-1;for(;++s<p;)r+=(k>>=1);j=(i&((1<<p-1)-1))<<1;}return r;}

C # जैसी OOP भाषाएँ ऐसी दौड़ को नहीं जीतेंगी, लेकिन मैं इसे वैसे भी आज़माना चाहता था। यहाँ एक अधिक सुशोभित संस्करण + परीक्षक है।

class Program
{
    // Tester: 50 bytes
    static void Main(string[] args)
    {
        int i=2;
        do System.Console.WriteLine($"{i} -> {x(i++)}"); while (i < 12);
        System.Console.Read();
    }
    // Function: 65 bytes (size according to ILDASM.exe)
    static int x(int iOrg)
    {
        int pos, shift, retVal=0, iPrev=iOrg, iTemp;
        pos = System.Convert.ToString(iOrg, 2).Length;
        do {
            iTemp = iPrev; shift = 0;
            do retVal += (iTemp >>= 1); while (++shift < pos);
            iPrev = (iOrg & ((1 << pos - 1) - 1)) << 1;
        } while (--pos > -1); 
        return retVal;
    }
}

जब तक शिफ्ट + 1 छोटा नहीं हो जाता तब तक नेस्टेड डू-आईट्यूड iTemp की राइट-शिफ्टेड वैल्यू (इसे असाइन करने के बाद) जोड़ देता है। अगली पंक्ति iPrev के अगले स्थानांतरित मूल्य की गणना करती है

x1 = 1 << p -1; // 1 << 4 -1 = 8 [1000]
x2 = x1 - 1;    // 8 -  1 = 7    [0111]
x3 = i & x2;    // 1011 & 0111 = 0011 
x4 = x3 << 1;   // 0011 << 1 = 00110
i2 = x4;

X1 und x2 मास्क की गणना करता है, x3 इसे लागू करता है और फिर इसे बाएं-शिफ्ट करता है, क्योंकि अंतिम अंक हमेशा गिरा होता है। 11 के लिए, यह इस तरह दिखता है:

START -> _1011[11]
101
10
1   -->  X0110[6], r=0+5+2+1=8
 011
 01
 0  -->  XX110[6], r=8+4=12
  11
  1 -->  XXX10[2], r=12+4=16
   1 ->  XXXX0[X], r=16+1=17

Comments

मुझे पता है, सी # में ज्यादातर जवाब सी # के रूप में अच्छी तरह से काम करते हैं (@ टोनी-स्पाइट ने समस्याओं के बिना काम किया), लेकिन मैं इस उद्देश्य को धता बताऊंगा। इसके अलावा, मैंने टिप्पणियों (अच्छी तरह से, बोल्ड हेडर को छोड़कर) को तब तक नहीं देखा जब तक कि मैं खुद को समाप्त नहीं कर लेता, इसलिए इसे "सी" की तरह करने का कोई खतरा नहीं था।

— DW.com

Answer 11

PowerShell v2 +, 138 बाइट्स

param($a)$a=[convert]::ToString($a,2);(($b=$a.length-1)..1|%{$l=$_;0..($b-$l+1)|%{[convert]::ToInt32($a.substring($_,$l),2)}})-join'+'|iex

Ooof। बाइनरी से / के लिए यह रूपांतरण महंगा है।

इनपुट लेता है $a, फिर बाइनरी प्रतिनिधित्व में बदलने के लिए .NET कॉल[convert]::ToString($a,2) का उपयोग करता है । वहां से, हम दो छोरों के माध्यम से जाते हैं - पहला पीछे की ओर से स्ट्रिंग के अंत में पीछे की ओर गिना जाता है 1, और दूसरा पीछे से मायने रखता है 0। (पहला यह है कि एक विकल्प को खींचने के लिए कितना लंबा है, और दूसरा विकल्प को शुरू करने के लिए स्ट्रिंग में कहाँ का सूचकांक है।) हम $lआंतरिक लूप से गुजरने के लिए रास्ते में एक सहायक स्थापित करते हैं ।

आंतरिक लूप के अंदर, हम आधार से पूर्णांक में उपयुक्त में बदलने के लिए एक और .NET कॉल[convert]::ToInt32() का उपयोग करते हैं। उनमें से प्रत्येक को फिर पाइपलाइन पर छोड़ दिया गया है। हम उन सभी को Parens के साथ और उन्हें एक साथ encapsulate करते हैं , फिर उस toss (short for और इसी तरह ish ) को टॉस करते हैं ।.substring()2()-join+iexInvoke-Expressioneval

_{मुझे लगता है कि यह तकनीकी रूप से .NET कॉल को ठीक से कॉल करने के लिए v2 या नए की आवश्यकता है।}