จำนวนเต็มบวก N คือK -sparse หากมีอย่างน้อยK 0s ระหว่าง 1s สองใด ๆ ที่ต่อเนื่องกันในการแทนค่าฐานสอง

ดังนั้นหมายเลข 1010101 นั้นคือ 1-sparse แต่ไม่ใช่ 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 ไบต์

นี่เป็นโปรแกรมไพ ธ อนที่สมบูรณ์ที่อ่านเป็น 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 ไบต์

บันทึกแล้ว 11 ไบต์ด้วย Martin Büttner

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

สิ่งนี้จะประเมินเป็นฟังก์ชัน monadic ลองที่นี่ การใช้งาน:

   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 ตัวอักษร

คำกริยา monadic แก้ไขการเชื่อฟังกฎ

(+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สมาชิกของช่วงเวลาในการเป็นตัวแทนฐาน 2 ของการโต้แย้งว่ากับขีด จำกัด พลังงานที่ใช้กับอาร์กิวเมนต์ที่เพิ่มขึ้น

ฉันคำนวณโดยทั่วไปหาก1 1เกิดขึ้นในการเป็นตัวแทนฐาน 2 ของการป้อนข้อมูล ถ้าเป็นเช่นนั้นฉันจะเพิ่มอินพุต สิ่งนี้อยู่ภายใต้ขีด จำกัด พลังงานซึ่งหมายความว่าจะถูกนำไปใช้จนกว่าผลลัพธ์จะไม่เปลี่ยนแปลงอีกต่อไป

Javascript, 25 19

ใช้ความจริงที่ว่าสำหรับเลขฐานสองแบบกระจัดกระจายx&2*x == 0:

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

JavaScript (ES6), 39 43

ไม่มี regexp ไม่มีสตริงวนซ้ำ:

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 เมื่อฉันพบมันให้ข้ามไปยังหมายเลขถัดไป เวอร์ชันเรียกซ้ำมาโดยตรงจากเวอร์ชันที่วนซ้ำ

Ungolfedและชัดเจนยิ่งขึ้น ในการตีกอล์ฟส่วนที่ยากที่สุดคือการรวมลูปด้านในและด้านนอก (ต้องเริ่มต้นที่ 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 ไบต์

ขอบคุณ Martin Büttnerสำหรับการบันทึก 9 ไบต์และ Pietu1998 สำหรับ 4 ไบต์!

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

วิธีการทำงาน: มันforวนรอบเริ่มต้นจากa + 1ตราบใดที่หมายเลขปัจจุบันไม่ 1-sparse และถ้าเป็นเช่นนั้นวงถูกขัดจังหวะและจะส่งกลับจำนวนปัจจุบัน เพื่อตรวจสอบว่าเป็นจำนวน 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-sparse ที่สูงที่สุดถัดไป จะเรียกมันว่าให้มันชื่อเช่นและทำf=n->...f(12)

คำอธิบาย Ungolfed +:

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}

สกาลา 65 ไบต์

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

(หากจำเป็นต้องใช้ฟังก์ชั่นที่มีชื่อโซลูชั่นจะมีขนาด 69 ไบต์)

Python ขนาด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;}

TIO

ทับทิม, 44

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

ค่อนข้างธรรมดา แลมบ์ดาพร้อมวงวนไม่สิ้นสุดและ regexp เพื่อทดสอบการแทนค่าฐานสอง ฉันหวังว่าจะ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

Japtet, 8 ไบต์

_&ZÑ}fUÄ

เปิดใช้งานออนไลน์

เยลลี่ขนาด 7 ไบต์

‘&Ḥ¬Ɗ1#

โปรแกรมเต็มรูปแบบที่ยอมรับจำนวนเต็มเดียวที่ไม่เป็นลบซึ่งจะพิมพ์จำนวนเต็มบวก (เป็นลิงก์ monadic ที่ให้ผลลัพธ์รายการที่มีจำนวนเต็มบวกเดียว)

ลองออนไลน์!

อย่างไร?

เริ่มต้นที่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

เรียกใช้และแก้ไขข้อบกพร่อง

มันทำงานโดยใช้ขั้นตอนนี้ อินพุตเริ่มต้นที่ด้านบนของสแต็ก

• เพิ่มและคัดลอกสองครั้ง
• ลดครึ่งหนึ่งลงบนสุดของสแต็ก
• องค์ประกอบสองบิตและบนสุดในกองซ้อน
• หากผลลัพธ์เป็นจริง (ไม่เป็นศูนย์) ให้ทำซ้ำโปรแกรมทั้งหมด