Một số nguyên dương N là K- thưa thớt nếu có ít nhất K 0 giữa hai số 1 liên tiếp bất kỳ trong biểu diễn nhị phân của nó.

Vì vậy, số 1010101 là 1 thưa thớt trong khi 101101 thì không.

Nhiệm vụ của bạn là tìm số 1 thưa thớt tiếp theo cho số đầu vào đã cho. Ví dụ: nếu đầu vào là đầu ra 12 ( 0b1100) thì phải là 16 ( 0b10000) và nếu đầu vào là 18 ( 0b10010) thì đầu ra là 20 ( 0b10100).

Chương trình hoặc chức năng nhỏ nhất (tính bằng byte) sẽ thắng! Sơ hở tiêu chuẩn không được phép.

Bình thường, 9 byte

• Mượn x & (x*2) != 0thuật toán từ @alephalpha
• Mượn nồi hơi Pyth từ @Jakube

Nỗ lực đầu tiên của tôi tại Pyth:

f!.&TyThQ

Hãy thử nó ở đây

               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 byte

3 byte được lưu nhờ DigitalTrauma.

l~{)___+&}g

Kiểm tra nó ở đây.

Giải trình

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'.";

Điều này để lại số cuối cùng trên ngăn xếp được in tự động vào cuối chương trình.

Python 2, 44 byte

Đây là một chương trình python hoàn chỉnh đọc bằng n và in câu trả lời. Tôi nghĩ rằng nó làm khá tốt trong cuộc thi phụ dễ đọc.

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

Kết quả kiểm tra:

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

Bình thường, 12 11 byte

f!}`11.BThQ

Dùng thử trực tuyến: Trình biên dịch / thực thi 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

Toán học, 41 30 byte

Đã lưu 11 byte nhờ Martin Büttner.

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

Perl, 31

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

Hoặc từ dòng lệnh:

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

APL, 18 byte

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

Điều này đánh giá một chức năng đơn âm. Hãy thử nó ở đây. Sử dụng:

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

Giải trình

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

J, 20 ký tự

Một động từ đơn âm. Cố định tuân theo các quy tắc.

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

Giải trình

Đầu tiên, đây là động từ có khoảng trắng và sau đó ít chơi gôn hơn một chút:

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

Đọc:

    ]                             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

Đối số cộng với hoặc giảm số lượng 1 1thành viên khoảng trong biểu diễn cơ sở 2 của đối số, với giới hạn công suất được áp dụng cho đối số tăng.

Về cơ bản, tôi tính toán nếu 1 1xảy ra trong biểu diễn cơ sở-2 của đầu vào. Nếu có, tôi tăng đầu vào. Điều này được đặt trong một giới hạn năng lượng, có nghĩa là nó được áp dụng cho đến khi kết quả không thay đổi nữa.

Javascript, 25 19

Sử dụng thực tế là, đối với số nhị phân 1 thưa thớt , x&2*x == 0:

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

JavaScript (ES6), 39 43

Không regrec, không có chuỗi, đệ quy:

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

Phiên bản lặp:

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

Rất đơn giản, chỉ cần sử dụng dịch chuyển đúng để tìm một chuỗi 11. Khi tôi tìm thấy nó, hãy bỏ qua số tiếp theo. Phiên bản đệ quy được lấy trực tiếp từ phiên bản lặp.

Ung dung và rõ ràng hơn. Để chơi gôn, phần khó nhất là hợp nhất các vòng bên trong và bên ngoài (phải bắt đầu x đến 3 khi bắt đầu)

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 byte

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

Đã sử dụng logic x & 2*x == 0cho số 1 thưa thớt.
Cảm ơn @Nick và @CarpetPython.

JavaScript, 75 66 62 byte

Cảm ơn Martin Büttner vì đã lưu 9 byte và Pietu1998 cho 4 byte!

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

Cách thức hoạt động: nó chạy một forvòng lặp bắt đầu từ a + 1chừng nào số hiện tại không phải là 1 thưa thớt, và nếu có, vòng lặp bị gián đoạn và nó trả về số hiện tại. Để kiểm tra xem một số có thưa thớt không, nó chuyển đổi nó thành nhị phân và kiểm tra xem nó có chứa hay không 11.

Mã không chơi gôn:

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

Julia, 40 byte

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

Điều này tạo ra một hàm ẩn danh chấp nhận một số nguyên duy nhất làm đầu vào và trả về số nguyên 1 thưa nhất tiếp theo. Để gọi nó, đặt tên cho nó, ví dụ f=n->..., và làm f(12).

Ungolfed + giải thích:

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

Ví dụ:

julia> f(12)
16

julia> f(16)
20

Gợi ý và / hoặc câu hỏi luôn được chào đón!

> <> (Cá) , 31 + 3 = 34 byte

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

Sử dụng:

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

3 byte được thêm cho -vcờ.

JavaScript (ECMAScript 6), 40

Bằng cách đệ quy:

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

JavaScript, 56

Tương tự không có chức năng mũi tên.

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

Scala, 65 byte

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

(nếu một chức năng được đặt tên là bắt buộc, giải pháp sẽ là 69 byte)

Python, 39 33 byte

Dùng thử tại đây: http://repl.it/gpu/2

Ở dạng lambda (nhờ xnor để chơi gôn):

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

Cú pháp hàm tiêu chuẩn hóa ra lại ngắn hơn lambda một lần!

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

Java, 33 byte.

Sử dụng phương pháp trong câu trả lời này

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

TIO

Hồng ngọc, 44

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

Khá cơ bản. Một lambda với một vòng lặp vô hạn và một biểu thức chính quy để kiểm tra biểu diễn nhị phân. Tôi muốn rằng loopmang lại và chỉ số số.

Matlab ( 77 74 byte)

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

Ghi chú:

• Nó đủ để kiểm tra số m+1đến 2*m, đâu mlà đầu vào.
• ~any(x)là truenếu xchứa tất cả các số không hoặc nếu xtrống

C (32 byte)

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

Thực hiện đệ quy của cùng một thuật toán như rất nhiều câu trả lời khác.

Perl, 16 byte

Kết hợp x&2*xcác câu trả lời khác nhau (tôi nghĩ đầu tiên của Nick ) với năng suất của nutki redo :

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

Thử nghiệm ở Dâu 5.26.

Japt, 8 byte

_&ZÑ}fUÄ

Chạy nó trực tuyến.

Thạch , 7 byte

‘&Ḥ¬Ɗ1#

Một chương trình đầy đủ chấp nhận một số nguyên duy nhất, không âm, in một số nguyên dương (dưới dạng liên kết đơn, nó mang lại một danh sách chứa một số nguyên dương duy nhất).

Hãy thử trực tuyến!

Làm sao?

Bắt đầu từ v=n+1và tăng dần, tăng gấp đôi vđể dịch chuyển từng bit lên một vị trí và bit khôn ngoan VÀ với vvà sau đó thực hiện logic KHÔNG để kiểm tra nếu vlà 1 thưa cho đến khi tìm thấy một số như vậy.

‘&Ḥ¬Ɗ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 byte

╦>ù╤x

Chạy và gỡ lỗi nó

Nó hoạt động bằng cách sử dụng thủ tục này. Đầu vào bắt đầu trên đỉnh của ngăn xếp.

• Tăng và sao chép hai lần.
• Giảm một nửa trên cùng của ngăn xếp.
• Bitwise - và hai yếu tố hàng đầu trên ngăn xếp.
• Nếu kết quả là trung thực (khác không) lặp lại toàn bộ chương trình.