如果在其二进制表示形式的任何两个连续1之间至少存在K 0，则正整数N为K-稀疏。

因此，数字1010101为1稀疏，而101101不是。

您的任务是找到给定输入数字的下一个1稀疏数字。例如，如果输入为12（0b1100），则输出应为16（0b10000），如果输入为18（0b10010），则输出应为20（0b10100）。

最小的程序或函数（以字节为单位）获胜！不允许出现标准漏洞。

Pyth，9个字节

• 从@alephalpha 借用x & (x*2) != 0算法
• 从@Jakube 借用Pyth样板

我对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个字节

DigitalTrauma节省了3个字节。

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

Mathematica，41个 30字节

感谢MartinBüttner，节省了11个字节。

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

Perl，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 12为基数的表示形式的间隔成员数的或减，即应用于递增自变量的幂限制。

我基本上计算是否1 1在输入的base-2表示形式中发生。如果是这样，我将增加输入。这被置于功率限制之下，这意味着将应用它，直到结果不再更改为止。

Javascript，25 19

使用以下事实：对于1稀疏二进制数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字节

感谢MartinBüttner保存9个字节，Pietu1998保存4个字节！

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

工作原理：只要当前数字不是1稀疏，它就会运行一个for循环a + 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->...do 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

一如既往地欢迎提出建议和/或问题！

> <>（Fish），31 + 3 = 34字节

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

用法：

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

为-v标志添加了3个字节。

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个字节）

Python，39岁 33字节

在这里尝试：http : //repl.it/gpu/2

以lambda形式表示（感谢xnor打高尔夫球）：

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

事实证明，标准函数语法一次比lambda短！

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

Java，33个字节。

在此答案中使用方法

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

蒂奥

Ruby，44岁

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

很基本。具有无限循环和正则表达式的lambda，用于测试二进制表示形式。我希望loop产生和索引号。

Matlab（ 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来自各种答案的答案（我认为是尼克的第一个答案）与nutki的 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)

Stax，5 个字节

╦>ù╤x

运行并调试

使用此过程可以工作。输入从堆栈顶部开始。

• 递增并复制两次。
• 将堆栈顶部减半。
• 按位和堆栈中的前两个元素。
• 如果结果为真（非零），则重复整个程序。