Позитивне ціле число N є K -розрізним, якщо в його бінарному поданні є принаймні K 0s між будь-якими двома послідовними 1s.

Отже, число 1010101 є 1-малим, тоді як 101101 - ні.

Ваше завдання - знайти наступний 1-розрядний номер для даного вхідного номера. Наприклад, якщо вхід 12 ( 0b1100), вихід повинен бути 16 ( 0b10000), а якщо вхід 18 ( 0b10010), вихід повинен бути 20 ( 0b10100).

Найменша програма чи функція (у байтах) виграє! Стандартні лазівки заборонені.

Pyth, 9 байт

• Запозичення x & (x*2) != 0алгоритму від @alephalpha
• Запозичення котла Pyth від @Jakube

Моя перша спроба Pyth:

f!.&TyThQ

Спробуйте тут

               implicit: Q = input()            
f      hQ      find the first integer T >= Q + 1, 
               that satisfies the condition:
 !.&TyT        T & (T * 2) is 0

CJam, 14 11 байт

3 байти збережено завдяки DigitalTrauma.

l~{)___+&}g

Перевірте це тут.

Пояснення

l~          "Read and eval input.";
  {      }g "Do while...";
   )_       "Increment and duplicate (call this x).";
     __+    "Get two more copies and add them to get x and 2x on the stack.";
        &   "Take their bitwise AND. This is non-zero is as long as x's base-2
             representation contains '11'.";

Це залишає останнє число в стеку, яке друкується автоматично в кінці програми.

Python 2, 44 байти

Це повна програма python, яка читає на n і друкує відповідь. Я думаю, що це досить добре в конкурсі з читання.

n=input()+1
while'11'in bin(n):n+=1
print n

Результати тесту:

$ echo 12 | python soln.py 
16
$ echo 18 | python soln.py 
20

Pyth, 12 11 байт

f!}`11.BThQ

Спробуйте в Інтернеті: компілятор / виконавець Pyth .

               implicit: Q = input()            
f        hQ    find the first integer T >= Q + 1, 
               that satisfies the condition:
 !}`11.BT         "11" is not in the binary representation of T

Математика, 41 30 байт

Збережено 11 байт завдяки Мартіну Бюттнеру.

#+1//.i_/;BitAnd[i,2i]>0:>i+1&

Перл, 31

#!perl -p
sprintf("%b",++$_)=~/11/&&redo

Або з командного рядка:

 perl -pe'sprintf("%b",++$_)=~/11/&&redo' <<<"18"

APL, 18 байт

1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2}

Це оцінюється до монадичної функції. Спробуйте тут. Використання:

   1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2} 12
16

Пояснення

1∘+                    ⍝ Increment the input ⍺
   ⍣{            }     ⍝ until
     ~∨/               ⍝ none of
        2∧/            ⍝ the adjacent coordinates contain 1 1 in
           ⍺⊤⍨⍺⍴2      ⍝ the length-⍺ binary representation of ⍺.

J, 20 символів

Монадійське дієслово. Виправлено до дотримання правил.

(+1 1+./@E.#:)^:_@>:

Пояснення

Спочатку це дієслово з пробілами, а потім трохи менше гольфу:

(+ 1 1 +./@E. #:)^:_@>:
[: (] + [: +./ 1 1 E. #:)^:_ >:

Прочитайте:

    ]                             The argument
      +                           plus
        [: +./                    the or-reduction of
               1 1 E.             the 1 1 interval membership in
                      #:          the base-2 representation of the argument,
[: (                    )^:_      that to the power limit of
                             >:   the incremented argument

Аргумент плюс або зменшення 1 1належності інтервалу в представленні аргументу base-2, що до межі потужності, застосованої до посиленого аргументу.

Я в основному обчислюю, якщо це 1 1відбувається в представленні бази-2 введення. Якщо це так, я збільшую вхід. Це ставиться під обмеження потужності, а це означає, що воно застосовується, поки результат більше не зміниться.

Javascript, 25 19

Використовуючи той факт, що для дворозрядного двійкового числа x&2*x == 0:

f=x=>x++&2*x?f(x):x

JavaScript (ES6), 39 43

Немає регулярного вираження, жодних рядків, рекурсивних:

R=(n,x=3)=>x%4>2?R(++n,n):x?R(n,x>>1):n

Ітеративна версія:

F=n=>{for(x=3;x%4>2?x=++n:x>>=1;);return n}

Це дуже просто, просто скориставшись правою зміною, щоб знайти послідовність 11. Коли я знайду його, перейдіть до наступного номера. Рекурсивна версія безпосередньо виводиться з ітеративної.

Безумовно і більш очевидно. Для гольфу найскладніша частина - це злиття внутрішньої та зовнішньої петлі (потрібно починати x до 3 на початку)

F = n=>{
  do {
    ++n; // next number
    for(x = n; x != 0; x >>= 1) {
      // loop to find 11 in any position
      if ((x & 3) == 3) { // least 2 bits == 11
        break;
      }
    }
  } while (x != 0) // if 11 was found,early exit from inner loop and x != 0
  return n
}

Python 2, 37 байт

f=input()+1
while f&2*f:f+=1
print f

Використовується логіка x & 2*x == 0для 1-розрядного числа.
Завдяки @Nick та @CarpetPython

JavaScript, 75 66 62 байт

Дякуємо Мартіну Бюттнеру за збереження 9 байт та Pietu1998 за 4 байти!

function n(a){for(a++;/11/.test(a.toString(2));a++);return a;}

Як це працює: він працює a for цикл, починаючи з a + 1тих пір, поки поточне число не є 1-розрідженим, і якщо він є, цикл переривається і він повертає поточне число. Щоб перевірити, чи число є 1-розрядним, воно перетворює його у бінарне та перевіряє, чи не містить воно 11.

Код без гольфу:

function nextOneSparseNumber(num) {
    for (num++; /11/.test(num.toString(2)); num++);
    return num;
}

Джулія, 40 байт

n->(while contains(bin(n+=1),"11")end;n)

Це створює анонімну функцію, яка приймає одне ціле число як вхідне і повертає наступне найвище 1-розрядне ціле число. Щоб зателефонувати, дайте ім’я, наприклад f=n->..., і зробітьf(12) .

Недоліки + пояснення:

function f(n)

    # While the string representation of n+1 in binary contains "11",
    # increment n. Once it doesn't, we've got the answer!

    while contains(bin(n += 1), "11")
    end

    return(n)
end

Приклади:

julia> f(12)
16

julia> f(16)
20

Пропозиції та / або питання вітаються як завжди!

> <> (Риба) , 31 + 3 = 34 байти

1+:>:  4%:3(?v~~
;n~^?-1:,2-%2<

Використання:

>python fish.py onesparse.fish -v 12
16

Для банера додано 3 байти -v.

JavaScript (ECMAScript 6), 40

Рекурсією:

g=x=>/11/.test((++x).toString(2))?g(x):x

JavaScript, 56

Те ж без функцій стрілок.

function f(x){return/11/.test((++x).toString(2))?f(x):x}

Scala, 65 байт

(n:Int)=>{var m=n+1;while(m.toBinaryString.contains("11"))m+=1;m}

(якщо потрібна названа функція, рішення складе 69 байт)

Пітон, 39 33 байт

Спробуйте тут: http://repl.it/gpu/2

У лямбда-формі (завдяки xnor за гольф):

f=lambda x:1+x&x/2and f(x+1)or-~x

Синтаксис стандартної функції за один раз виявився коротшим, ніж лямбда!

def f(x):x+=1;return x*(x&x*2<1)or f(x)

Java, 33 байти.

У цій відповіді використовується метод

n->{for(;(n++&2*n)>0;);return n;}

ТІО

Рубі, 44

->(i){loop{i+=1;break if i.to_s(2)!~/11/};i}

Досить базовий. Лямбда з нескінченною петлею і повторною експлікацією для перевірки бінарного подання. Я бажаю, щоб це loopдало і номер індексу.

Матлаб ( 77 74 байт)

m=input('');for N=m+1:2*m
if ~any(regexp(dec2bin(N),'11'))
break
end
end
N

Примітки:

• Досить числа тестів , m+1щоб 2*m, де mзнаходиться вхід.
• ~any(x)є, trueякщо xмістить усі нулі або якщо xвін порожній

C (32 байти)

f(int x){return 2*++x&x?f(x):x;}

Рекурсивна реалізація того ж алгоритму, як і багато інших відповідей.

Perl, 16 байт

Поєднуючи x&2*xрізні відповіді (я думаю , що перший Нік ) з результатами нуті redo :

perl -pe'++$_&2*$_&&redo'

Випробувано на Полуниці 5.26.

Japt, 8 байт

_&ZÑ}fUÄ

Запустити його в Інтернеті.

Желе , 7 байт

‘&Ḥ¬Ɗ1#

Повна програма, що приймає єдине невід'ємне ціле число, яке друкує додатне ціле число (як монадичне посилання воно дає список, що містить одне додатне ціле число).

Спробуйте в Інтернеті!

Як?

Починаючи з v=n+1та збільшуючи, двічі vзміщуйте кожен біт вгору на одне місце, біт-розумно І, vа потім виконайте логічне НЕ перевірити, чи vє 1- розрядний, поки не знайдеться таке число.

‘&Ḥ¬Ɗ1# - Main Link: n   e.g. 12
‘       - increment           13
     1# - 1-find (start with that as v and increment until 1 match is found) using:
    Ɗ   -   last three links as a dyad:
  Ḥ     -   double v
 &      -   (v) bit-wise AND (with that)
   ¬    -   logical NOT (0->1 else 1)
        - implicit print (a single item list prints as just the item would)

Стакс , 5 байт

╦>ù╤x

Запустіть і налагоджуйте його

Це працює за допомогою цієї процедури. Вхід починається зверху стека.

• Збільшити та скопіювати двічі.
• Половину половини укладаємо.
• Побітові та верхні два елементи на стеку.
• Якщо результат простий (не нульовий), повторіть всю програму.