Вдохновлен четвертой проблемой от BMO2 2009 .

Учитывая положительный целое число п в качестве входных данных или параметра, возвращает количество положительных целых чисел, двоичное представление встречается в виде блоков в двоичном разложении п .

Например, 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

Вы можете взять в п , как и любой из следующих условий :

• целое число
• список истинных / ложных значений для двоичного представления
• строка для двоичного представления
• базовая строка 10 (хотя я не уверен, почему кто-то сделал бы это)

Сделайте ваш код как можно короче.

Python 3, 54 50 байт

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

Спасибо Роду и Джонатану Аллану за сохранение четырех байтов.

Желе , 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)

Доказательство того, что это работает:

Эта программа получает номер входа, N . Первое, что делает этот продукт, это, конечно, взять подстроки N ₂ ( N в базе 2 ). Это включает повторяющиеся подстроки, начинающиеся с 0 или 1 .

После этого мы просто берем уникальные подстроки, сохраняя только первое вхождение каждого значения в списке подстрок.

Затем эта программа суммирует первые элементы списков, затем вторые элементы, затем третий, четвертый и т. Д., И если один из списков не имеет такого элемента 0, предполагается. Что задача задает эффективно? Сколько уникальных подстрок, начинающихся с 1, имеет это число в двоичной форме? , Поскольку каждый первый элемент, который должен быть подсчитан, есть 1, мы можем просто суммировать вместо фильтрации соответствующие подстроки.

Теперь первый элемент результирующего списка суммирования, описанного выше, содержит количество первых битов подстрок, поэтому мы просто извлекаем и, наконец, возвращаем его.

Октава , 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

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

Perl 5 , 36 + 1 ( -p) = 37 байт

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

Попробуйте онлайн!

Принимает ввод в виде двоичной строки.

PowerShell , 103 92 82 байта

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

Попробуйте онлайн!

Принимает входные данные в виде массива 1и 0(правда и ложь в PowerShell). Циклы $s(то есть, сколько элементов во входном массиве). Внутри цикла мы выполняем цикл от текущего номера (сохраненного как $i) до $s.count. В каждом внутреннем цикле мы -joinсрезаем массив в строку. Затем мы sortс -uфлагом nique (который короче, чем selectс -uфлагом nique, и нам все равно, отсортированы они или нет), берем те, которые не начинаются 0, и берем общее .count. Это осталось на конвейере и вывод неявный.

JavaScript (ES6), 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

Также принимает входные данные в виде двоичной строки.

Python 2 ,  118  81 байт

Спасибо @Rod за сохранение 37 байт!

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

Принимает ввод в виде двоичной строки.

Попробуйте онлайн!

Python 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]})

Принимает ввод в виде двоичной строки.

Попробуйте онлайн!

Желе , 5 байт

ẆḄQṠS

Попробуйте онлайн!

Вводит в виде списка 1 и 0. Нижний колонтитул в ссылке применяет функцию к каждому из примеров в посте.

Джонатан Аллан указал, что ẆḄQTL это 5-байтовая альтернатива, которая использует Tатом, который находит индексы всех истинных элементов.

объяснение

В качестве примера возьмем bin (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

R , 88 77 байт

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

Попробуйте онлайн!

Принимает ввод в виде двоичной строки.

используя mapply, генерирует массив всех подстрок ввода. strtoiпреобразует их как базовые 2целые числа, и я беру сумму логического преобразования ( !!) записей в результате.

Сетчатка , 37 29 байт

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

Попробуйте онлайн! Я просто должен был попробовать Retina 1.0w модификатор . Изменить: Сохранено 8 байт благодаря @MartinEnder. Объяснение:

.+
*

Преобразовать из десятичной в одинарную.

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

Преобразовать из унарной в двоичную, используя #для 0и_ для 1.

wp`_.*

Создайте подстроки, которые начинаются с 1, я имею в виду _. wМодификатор затем сопоставляет все подстроки, а не только самый длинный по одному на каждом запуске _, в то время как pмодификатора дедуплицирует матчей. Наконец, так как это последний этап, количество совпадений возвращается неявно.

Pyth , 8 байт

l #{vM.:

Попробуй это здесь!

Принимает ввод в виде двоичной строки.

.:генерирует все подстроки, vMоценивает каждую (то есть конвертирует каждую из двоичных), {дедуплицирует, <space>#фильтрует по тождественности и lполучает длину.

Wolfram Language (Mathematica) , 35 байт

Подсчет уникальных подпоследовательностей двоичного представления, которые начинаются с единицы, хотя я не уверен, что этот код даже нуждается в объяснении.

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

Попробуйте онлайн!

Perl 6 , 47 байт

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

Попробуйте онлайн!

Юлия 0,6 , 37 байт

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

Попробуйте онлайн!

Juliafication ответа Python по J843136028, использующий .для поэлементного применения функции с вещанием. ( ссылка )

Java, 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 - список всех подстрок. При первом размещении здесь обязательно нужно улучшиться, и не стесняйтесь указывать на любые ошибки! Слегка отредактировано для удобства чтения.

Атташе , 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)

Рубин 41 36 27 байт

Принимает двоичную строку в качестве ввода

Ультра неэффективно

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

Отчасти вдохновлен этим ответом на Python 3

Попробуйте онлайн!

Java 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)

C ++, 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

J , 34 байта

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

Попробуйте онлайн!

J 15 байт

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

Ввод представляет собой двоичный список. Попробуйте онлайн!

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

Perl 6 , 34 байта

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

Проверь это

Expanded:

{
  +                                # 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
                                )
}