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

Question

बीएमओ 2 2009 से चौथी समस्या से प्रेरित ।

इनपुट या पैरामीटर के रूप में एक सकारात्मक पूर्णांक n को देखते हुए, सकारात्मक पूर्णांक की संख्या लौटाएं जिनके द्विआधारी निरूपण n के बाइनरी विस्तार में ब्लॉक के रूप में होते हैं ।

उदाहरण के लिए, 13 -> 6 क्योंकि 13 में बाइनरी 1101 है और इसमें सब्सट्रिंग है 1101, 110, 101, 11, 10, 1। हम उन बाइनरी संख्याओं की गणना नहीं करते हैं जो शून्य से शुरू होती हैं और हम स्वयं शून्य की गणना नहीं करते हैं।

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

13 -> 6
2008 -> 39
63 -> 6
65 -> 7
850 -> 24
459 -> 23
716 -> 22
425 -> 20
327 -> 16

आप निम्न में से किसी के रूप में n में ले सकते हैं :

• पूर्णांक
• बाइनरी प्रतिनिधित्व के लिए सत्य / झूठे मूल्यों की एक सूची
• बाइनरी प्रतिनिधित्व के लिए एक स्ट्रिंग
• एक आधार 10 स्ट्रिंग (हालांकि मुझे यकीन नहीं है कि कोई भी ऐसा क्यों करेगा)

अपने कोड को यथासंभव छोटा करें।

Comments

क्या आप 63-> 5 की पुष्टि कर सकते हैं और 6 की नहीं? बिन (६३) = ११११११ -> छह अलग-अलग

— नॉनजेरो सब्सट्रिंग

सम्बंधित। (सब्सट्रेटिंग के बजाय बाद के उपयोगों और अग्रणी शून्य की उपेक्षा नहीं करता है।)

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

@dylnan टाइपो। फिक्स्ड।

— 0WJYxW9FMN

@MartinEnder क्या यह इस साइट पर बने रहने के लिए पर्याप्त है या क्या मैं इसे डुप्लिकेट के रूप में हटा दूंगा? मुझे लगता है कि यह पर्याप्त रूप से अलग है, लेकिन आप मुझे करने से बहुत बेहतर जानते हैं।

— 0WJYxW9FMN

@ J843136028 इसे डुप्लिकेट नहीं बनाने के लिए बड़ा अंतर दूसरी चुनौती पर समय की पाबंदी है। तुम ठीक हो। (बस लिंक पोस्ट किया है, ताकि चुनौतियां एक-दूसरे के साइडबार में दिखाई दें।)

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

Answer 1

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

lambda n:sum(bin(i)[2:]in bin(n)for i in range(n))

चार बाइट बचाने के लिए रॉड और जोनाथन एलन को धन्यवाद।

Comments

आप +1रेंज सेbin(i)

— रॉड

वास्तव में चूंकि हम हमेशाn खुद को गिनते हैं और हमेशा0 अपनी गिनती से बाहर होते हैं , इसलिए हम हमेशा के बजाय बाहर कर सकते हैं nऔर हमेशा गिनते हैं 0(बिन (n) शुरू होता है '0b...'), इसलिए हम इसे हटा सकते हैं 1,और +1पूरी तरह से छोड़ सकते हैं और bin(i)चार बाइट को बचाने के लिए इसे ऑनलाइन आज़मा सकते हैं!

— जोनाथन एलन

Answer 2

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

ẆQSḢ

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

0S और 1s की सूची के रूप में इनपुट लेता है ।

संख्याओं के साथ इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

ẆQSḢ Argument: B = list of bits, e.g. [1, 1, 0, 1]
Ẇ    Get B's non-empty sublists (i.e. [[1], [1], [0], [1], [1, 1], [1, 0], [0, 1], [1, 1, 0], [1, 0, 1], [1, 1, 0, 1]])
 Q   Keep first occurrences (i.e. [[1], [0], [1, 1], [1, 0], [0, 1], [1, 1, 0], [1, 0, 1], [1, 1, 0, 1]])
  S  Reduce by vectorized addition (i.e. [6, 4, 1, 1])
   Ḣ Pop first element (i.e. 6)

यह काम करता है सबूत:

इस कार्यक्रम को एक इनपुट नंबर मिलता है, एन । पहली चीज जो यह उत्पाद करता है, निश्चित रूप से, एन ₂ ( एन बेस 2 में एन ) के सबस्ट्रिंग लेते हैं । इसमें 0 या 1 के साथ शुरू होने वाले डुप्लिकेट सबस्ट्रिंग शामिल हैं ।

उसके बाद, हम केवल विकल्प सूची में प्रत्येक मान की केवल पहली घटना को ध्यान में रखते हुए अनूठे सब्सट्रिंग्स लेते हैं।

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

अब, ऊपर वर्णित योग की पहली सूची में, सब्सट्रिंग के पहले बिट्स की गिनती होती है, इसलिए हम बस पॉप करते हैं और अंत में इसे वापस करते हैं।

Answer 3

ऑक्टेव , 62 61 बाइट्स

@(n)sum(arrayfun(@(t)any(strfind((g=@dec2bin)(n),g(t))),1:n))

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

व्याख्या

इनपुट के लिए n, कोड सभी संख्याओं 1को nयह देखने के लिए परीक्षण करता है कि क्या उनका बाइनरी प्रतिनिधित्व इनपुट के बाइनरी प्रतिनिधित्व का एक विकल्प है।

@(n)                                                          % Anonymous function of n
        arrayfun(                                      ,1:n)  % Map over range 1:n
                 @(t)                                         % Anonymous function of t
                         strfind(               ,    )        % Indices of ...
                                                 g(t)         % t as binary string ...
                                 (g=@dec2bin)(n)              % within n as binary string
                     any(                             )       % True if contains nonzero
    sum(                                                    ) % Sum of array

Answer 4

05AB1E , 5 बाइट्स

बाइनरी स्ट्रिंग के रूप में इनपुट लेता है।
हेडर परीक्षण की आसानी के लिए पूर्णांक इनपुट को बाइनरी में परिवर्तित करता है।

ŒCÙĀO

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

व्याख्या

Π       # push all substrings of input
 C       # convert to base-10 int
  Ù      # remove duplicates
   Ā     # truthify (convert non-zero elements to 1)
    O    # sum

Comments

आह… मुझे लगा कि मेरा फ़िल्टर स्मार्ट था। bŒʒć}Ùgलेकिन नहीं, यह बेहतर है।

— मैजिक ऑक्टोपस Urn

Answer 5

पर्ल 5 , 36 + 1 ( -p) = 37 बाइट्स

/.*(.+?)(?{$k{0|$1}++})(?!)/;$_=%k-1

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

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

Answer 6

पॉवरशेल , 103 92 82 बाइट्स

param($s)(($s|%{$i..$s.count|%{-join$s[$i..$_]};$i++}|sort -u)-notmatch'^0').count

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

की एक सरणी के रूप में इनपुट लेता है 1और 0(PowerShell में truthy और falsey)। के माध्यम से लूप $s(यानी, इनपुट ऐरे में कितने तत्व हैं)। लूप के अंदर, हम वर्तमान संख्या (तक की बचत $i) से लूप करते हैं $s.count। प्रत्येक आंतरिक लूप, हम -joinसरणी को एक स्ट्रिंग में टुकड़ा करते हैं। हम तो sortसाथ -unique ध्वज (जो की तुलना में कम है selectके साथ -unique झंडा और हम परवाह नहीं है कि क्या वे या हल कर रहे हैं नहीं), उन है कि के साथ शुरू नहीं है ले 0, और कुल मिलाकर ले .count। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

Answer 7

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

f=(s,q="0b"+s)=>q&&s.includes((q--).toString(2))+f(s,q)

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

यह संख्या और पुनरावर्ती कार्यों के साथ करने का एक दुखद प्रयास है:

f=(n,q=n)=>q&&(g=n=>n?n^q&(h=n=>n&&n|h(n>>1))(q)?g(n>>1):1:0)(n)+f(s,q-1)

पुराना दृष्टिकोण, 74 बाइट्स

s=>(f=s=>+s?new Set([+s,...f(s.slice(1)),...f(s.slice(0,-1))]):[])(s).size

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

Answer 8

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

37 बाइट बचाने के लिए @Rod को धन्यवाद!

lambda n:len({int(n[i:j+1],2)for i in range(len(n))for j in range(i,len(n))}-{0})

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

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

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

@Rod को धन्यवाद!

lambda n:len({n[i:j+1]for i in range(len(n))for j in range(i,len(n))if'1'==n[i]})

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

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

Comments

आप बाइनरी स्ट्रिंग को इनपुट के रूप में स्वीकार कर सकते हैं, आप set(...){...}xrangerange

— रॉड

आप +1रेंज से स्लाइस तक भी स्थानांतरित कर सकते हैं , और इस तरहs.startswith से स्विच कर सकते int(s,2) हैं

— रॉड

यदि आप अपने पुराने दृष्टिकोण को रखना चाहते हैं, तो आप भी उपयोग कर सकते हैं इस एक ही बाइट गिनती के लिए

— रॉड

Answer 9

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

ẆḄQṠS

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

1s और 0s की सूची के रूप में इनपुट लेता है। लिंक में पाद लेख पोस्ट के प्रत्येक उदाहरण में फ़ंक्शन को लागू करता है।

जोनाथन एलन ने बताया कि ẆḄQTL5 बाइट विकल्प है जो Tपरमाणु का उपयोग करता है जो सभी सत्य तत्वों के सूचकांकों का पता लगाता है।

व्याख्या

उदाहरण के रूप में बिन (13) = 1101 को लें। इनपुट है[1,1,0,1]

ẆḄQṠS
Ẇ       All contiguous sublists -> 1,1,0,1,11,10,01,110,101,1101 (each is represented as a list)
 Ḅ      From binary to decimal. Vectorizes to each element of the above list -> 1,1,0,1,3,2,1,6,5,13
  Q     Unique elements
   Ṡ    Sign. Positive nums -> 1 , 0 -> 0.
    S   Sum

से "सच्चाई" (इस मामले में संकेत) के विचार को लिया 05AB1E उत्तर

Comments

आप वास्तव में जेली के ट्रू इंडेक्स इंडेक्स परमाणु का उपयोग कर सकते हैं T, साथẆḄQTL

— जोनाथन एलन

Answer 10

आर , 88 77 बाइट्स

function(x)sum(!!unique(strtoi(mapply(substring,x,n<-1:nchar(x),list(n)),2)))

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

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

का उपयोग करते हुए mapply, इनपुट के सभी सब्सट्रिंग्स का एक सरणी उत्पन्न करता है। strtoiउन्हें आधार 2पूर्णांक के रूप में परिवर्तित करता है , और मैं !!परिणाम में प्रविष्टियों के तार्किक रूपांतरण ( ) का योग लेता हूं ।

Answer 11

रेटिना , 37 29 बाइट्स

.+
*
+`(_+)\1
$1#
#_
_
wp`_.*

इसे ऑनलाइन आज़माएं! मुझे सिर्फ रेटिना 1.0 के wसंशोधक को आज़माना था । संपादित करें: @MartinEnder के लिए 8 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
*

दशमलव से भिन्न में परिवर्तित करें।

+`(_+)\1
$1#
#_
_

का उपयोग करते हुए, बाइनरी में एकल से कन्वर्ट #करने के लिए 0और _1 के लिए।

wp`_.*

सबस्ट्रिंग के साथ शुरू उत्पन्न 1, मेरा मतलब है, _। wसंशोधक तो सभी सबस्ट्रिंग, बस नहीं प्रत्येक शुरू में सबसे लंबे समय तक एक से मेल खाता है _, जबकि, pसंशोधक deduplicates मैचों। अंत में जैसा कि यह अंतिम चरण है मैचों की गिनती अंतर्निहित रूप से वापस आ गई है।

Comments

आप इसके अलावा q(या p) संशोधक का उपयोग करके अंतिम तीन चरणों को एक में रोल कर सकते हैं w। आपको Cस्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है , क्योंकि यह डिफ़ॉल्ट चरण का प्रकार है यदि केवल एक ही स्रोत बचा है।

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

@MartinEnder धन्यवाद, मैं अभी भी Mडिफॉल्ट स्टेज टाइप होने का आदी हूँ !

— नील

खैर, Cथोड़े क्या Mउपयोग किया जाता है। :)

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

मुझे पता है कि यह डिफ़ॉल्ट क्यों है, यह सिर्फ स्विच करने के लिए उपयोग हो रहा है।

— नील

Answer 12

पायथ , 8 बाइट्स

l #{vM.:

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

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

.:सभी सबस्ट्रिंग्स को उत्पन्न करता है, vMप्रत्येक का मूल्यांकन करता है (अर्थात, यह प्रत्येक को बाइनरी से कनवर्ट करता है), {डुप्लिकेट्स, <space>#पहचान द्वारा फ़िल्टर और lलंबाई प्राप्त करता है।

Answer 13

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 35 बाइट्स

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

Union@Subsequences@#~Count~{1,___}&

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

Comments

क्या करता ___है?

— फ्रॉन्फ्रोग

पैटर्न मिलान, _ एक एकल आइटम है, __ एक या अधिक है, ___ 0 या अधिक है।

— केली लोल्डर

Answer 14

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

->\n{+grep {n.base(2).contains(.base: 2)},1..n}

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

Answer 15

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

~n=sum(contains.([bin(n)],bin.(1:n)))

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

की Juliafication J843136028 द्वारा अजगर जवाब का उपयोग कर .प्रसारण के साथ तत्व के लिहाज से समारोह आवेदन के लिए। ( लिंक )

Answer 16

जावा, 232 बाइट्स

String b=toBin(n);
l.add(b);
for(int i=1;i<b.length();i++){
for(int j=0;j<=b.length()-i;j++){
String t="";
if((""+b.charAt(j)).equals("0"))continue;
for(int k=0;k<i;k++){
t+=""+b.charAt(j+k);
}
if(!l.contains(t))l.add(t);
}
}
return l.size();

जहां n इनपुट है, b द्विआधारी प्रतिनिधित्व है और l सभी सबस्ट्रिंग्स की एक सूची है। पहली बार यहां पोस्टिंग, निश्चित रूप से सुधार करने की आवश्यकता है, और किसी भी गलतियों को इंगित करने के लिए स्वतंत्र महसूस करें! पठनीयता के लिए थोड़ा संपादित किया गया।

Comments

PPCG में आपका स्वागत है! पठनीयता के लिए नई सूचियों के आपके सम्मिलन के बारे में, आमतौर पर एक स्कोरिंग संस्करण होना पसंद किया जाता है, जिसमें हेडर में लिखे गए बाइट्स की मात्रा ठीक होती है, और फिर पठनीयता के लिए एक अतिरिक्त ungolfed या कम-गोल्फ संस्करण होता है।

— लैकोनी

@ लिकौनी सिर के लिए धन्यवाद! भविष्य के पदों के लिए ध्यान में रखना होगा!

— निहिलिश

String b=...,tऔर int i=...,j,kएक ही प्रकार की बार-बार घोषणा के लिए चार्ट को सहेजना। आपका कोड भी एक प्रविष्टि के रूप में अर्हता प्राप्त नहीं करेगा क्योंकि यह एक स्निपेट है, न तो एक पूर्ण कार्यक्रम और न ही एक कार्यात्मक टुकड़ा, आपको या तो एक फ़ंक्शन लिखना होगा या अपने कोड को लैम्ब्डा फॉर्म में

— लपेटना होगा

Answer 17

अटैची , 35 बाइट्स

`-&1@`#@Unique@(UnBin=>Subsets@Bin)

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

इसके तुल्य:

{#Unique[UnBin=>Subsets[Bin[_]]]-1}

व्याख्या

मैं दूसरे संस्करण की व्याख्या करूँगा, क्योंकि इसका पालन करना आसान है (स्पष्ट होना):

{#Unique[UnBin=>Subsets[Bin[_]]]-1}
{                                 }   lambda: _ = first argument
                        Bin[_]        convert to binary
                Subsets[      ]       all subsets of input
         UnBin=>                      map UnBin over these subsets
  Unique[                      ]      remove all duplicates
 #                              -1    size - 1 (since subsets is improper)

Answer 18

रूबी ४१ ३६ 27 बाइट्स

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

अल्ट्रा-अकुशल है

->n{(?1..n).count{|j|n[j]}}

आंशिक रूप से इस अजगर 3 उत्तर से प्रेरित है

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

Answer 19

जावा 8, 160 159 158 बाइट्स

import java.util.*;b->{Set s=new HashSet();for(int l=b.length(),i=0,j;i<l;i++)for(j=l-i;j>0;s.add(new Long(b.substring(i,i+j--))))s.add(0L);return~-s.size();}

बाइनरी-स्ट्रिंग के रूप में इनपुट।
एक छोटा रास्ता होना चाहिए ..>>

स्पष्टीकरण:

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

import java.util.*;          // Required import for Set and HashSet
b->{                         // Method with String as parameter and integer as return-type
  Set s=new HashSet();       //  Create a Set
  for(int l=b.length(),      //  Set `l` to the length of the binary-String
      i=0,j;i<l;i++)         //  Loop from 0 up to `l` (exclusive)
    for(j=l-i;j>0;           //   Inner loop from `l-i` down to `0` (exclusive)
      s.add(new Long(b.substring(i,i+j--))))
                             //    Add every substring converted to number to the Set
      s.add(0L);             //    Add 0 to the Set
  return~-s.size();}         //  Return the amount of items in the Set minus 1 (for the 0)

Answer 20

सी ++, 110 बाइट्स

#include<set>
std::set<int>s;int f(int n){for(int i=1;i<n;i+=i+1)f(n&i);return n?s.insert(n),f(n/2):s.size();}

यह एक पुनरावर्ती कार्य है। हम std::setडुप्लिकेट को अनदेखा करते हुए मानों को गिनने के लिए उपयोग करते हैं। बाईं ओर से दो पुनरावर्ती कॉल मास्क बिट्स (f(n&i) ) और दाएं से बंद )f(n/2) ), अंत में सभी सबस्ट्रिंग को पूर्णांक के रूप में निर्मित करते हैं।

ध्यान दें कि यदि आप इसे फिर से कॉल करना चाहते हैं, s कॉल के बीच साफ किया जाना चाहिए।

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

#include <cstdlib>
#include <iostream>

int main(int, char **argv)
{
    while (*++argv) {
        auto const n = std::atoi(*argv);
        s={};
        std::cout << n << " -> " << f(n) << std::endl;
    }
}

परिणाम

./153846 13 2008 63 65 850 459 716 425 327
13 -> 6
2008 -> 39
63 -> 6
65 -> 7
850 -> 24
459 -> 23
716 -> 22
425 -> 20
327 -> 16

Answer 21

जे , 34 बाइट्स

f=.3 :'<:#~.,(#:i.2^##:y)#.;.1#:y'

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

Answer 22

जे , 15 बाइट्स

#.\\.#@=@-.&,0:

इनपुट एक बाइनरी सूची है। इसे ऑनलाइन आज़माएं!

#.\\.               Convert every substring to decimal
         -.&,0:     Flatten and remove the 0s.        
     #@=            How many unique elements?

Answer 23

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

{+unique ~«(.base(2)~~m:ex/1.*/)}

झसे आज़माओ

विस्तारित:

{
  +                                # turn into Numeric (number of elements)
   unique                          # use only the unique ones
          ~«(                      # turn into strings
             .base(2)              # the input in base 2
                     ~~
                       m:ex/1.*/   # :exhaustive match substrings
                                )
}