Hôm qua trong khi chơi với con tôi tôi nhận thấy số trong xe lửa đồ chơi của nó:

Vậy ta có

Vì vậy, thách thức đơn giản: đưa ra một số không âm làm đầu vào, trả về các giá trị trung thực và falsey nhất quán thể hiện việc có hay không biểu diễn chuỗi của số (trong cơ sở 10 và không có số 0 đứng đầu) bằng cách nào đó có thể được chia thành các số có lũy thừa bằng 2 .

Ví dụ:

4281      truthy (4-2-8-1)
164       truthy (16-4 or 1-64)
8192      truthy (the number itself is a power of 2)
81024     truthy (8-1024 or 8-1-02-4)
101       truthy (1-01)
0         falsey (0 cannot be represented as 2^x for any x)
1         truthy
3         falsey
234789    falsey
256323    falsey (we have 256 and 32 but then 3)
8132      truthy (8-1-32)

Tests for very large numbers (not really necessary to be handled by your code):
81024256641116  truthy (8-1024-256-64-1-1-16)
64512819237913  falsey

Đây là môn đánh gôn , vì vậy có thể mã ngắn nhất cho mỗi ngôn ngữ sẽ giành chiến thắng!

05AB1E , 9 8 byte

Ýos.œåPZ

-1 byte nhờ @Emigna bằng cách sử dụng Z(tối đa) cho danh sách 0 và 1 để bắt chước một anylệnh cho 1(trung thực).

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm . (LƯU Ý: Trong тtiêu đề là 100chỉ nhận được 100 công suất đầu tiên của 2 số, thay vì công suất đầu vào đầu tiên của 2 số. Nó cũng hoạt động với công suất đầu vào là 2, nhưng khá kém hiệu quả và có thể thời gian chờ trên TIO nếu đầu vào đủ lớn.)

Giải trình:

Ý            # Create a list in the range [0,n], where n is the (implicit) input
             # (or 100 in the TIO)
             #  i.e. 81024 → [0,1,2,3,...,81024]
 o           # Raise 2 to the `i`'th power for each `i` in the list
             #  → [1,2,4,8,...,451..216 (nr with 24391 digits)]
  s          # Swap to take the input
   .œ        # Create each possible partition of this input
             #  i.e. 81024 → [["8","1","0","2","4"],["8","1","0","24"],...,["8102","4"],["81024"]]
     å       # Check for each if it's in the list of powers of 2
             #  → [[1,1,0,1,1],[1,1,0,0],...,[0,1],[0]]
      P      # Check for each inner list whether all are truthy
             #  → [0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
       Z     # Take the maximum (and output implicitly)
             #  → 1 (truthy)

JavaScript (Node.js) , 54 byte

f=(v,o=10)=>v&v-1|!v?v>o?f(v%o)&f(v/o|0)|f(v,o*10):0:1

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

JavaScript (Node.js) , _{69 64} 58 byte

f=(x,m=10,q=!(x%m&x%m-1|!x))=>x<m?q:q&&f(x/m|0)||f(x,10*m)

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

Nhập dưới dạng số. Phần logic khá phức tạp, vì vậy không biết làm thế nào để gỡ rối nó và thoát khỏi q.

-11 byte bằng cách đánh golf kiểm tra sức mạnh của 2.

JavaScript (Node.js) , 75 69 byte

-6 byte cảm ơn @Arnauld. Hỗ trợ tối đa 32 bit

f=x=>+x?[...x].some((_,i)=>(y=x.slice(0,++i))&~-y?0:f(x.slice(i))):!x

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

Nhập dưới dạng một chuỗi.

Thạch , 9 byte

ŒṖḌl2ĊƑ€Ẹ

Kiểm tra bộ thử nghiệm!

Thay thế

Không hoạt động cho các trường hợp thử nghiệm lớn do các vấn đề chính xác.

ŒṖḌæḟƑ€2Ẹ

Kiểm tra bộ thử nghiệm!

Làm sao?

Chương trình tôi

ŒṖḌl2ĊƑ€Ẹ     Full program. N = integer input.
ŒṖ            All possible partitions of the digits of N.
  Ḍ           Undecimal (i.e. join to numbers).
   l2         Log2. Note: returns (-inf+nanj) for 0, so it doesn't fail.
     ĊƑ€      For each, check if the logarithm equals its ceil.
        Ẹ     Any. Return 0 if there are no truthy elements, 1 otherwise.

Chương trình II

ŒṖḌæḟƑ€2Ẹ     Full program. N = integer input.
ŒṖ            All possible partitions of the digits of N.
  Ḍ           Undecimal (i.e. join to numbers).
     Ƒ€       For each partition, check whether its elements are invariant under...
   æḟ  2      Flooring to the nearest power of 2.
        Ẹ     Any. Return 0 if there are no truthy elements, 1 otherwise.

Python 2 , 72 70 byte

f=lambda n,m=10:n>=m/10and(n%m&n%m-1<1and(n/m<1or f(n/m))or f(n,m*10))

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

JavaScript, 59 byte

s=>eval(`/^(${(g=x=>x>s?1:x+'|0*'+g(x+x))(1)})+$/`).test(s)

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

Xây dựng một regex giống như /^(1|0*2|0*4|0*8|0*16|0*32|…|0*1)+$/sức mạnh của 2, và thử nghiệm nó s.

Tất nhiên, chỉ hoạt động với độ chính xác của số JavaScript, cuối cùng: các thuật ngữ trong biểu thức chính quy sẽ trông giống như 1.2345678e30(hoặc Inf). Nhưng vì sức mạnh của 2 rất dễ thể hiện chính xác trong dấu phẩy động, nên chúng sẽ không bao giờ là số nguyên sai , điều này sẽ không đủ tiêu chuẩn, tôi nghĩ vậy.

@tsh lưu 14 byte. Không!

Python 2 , 85 byte

f=lambda n:bin(int(n)).count('1')==1or any(f(n[:i])*f(n[i:])for i in range(1,len(n)))

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

Perl 6 , 28 24 23 byte

-4 byte nhờ Jo King

{?/^[0*@(2 X**^32)]+$/}

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

Tay cầm có sức mạnh lên tới 2 ³¹ .

APL (NARS), 154 ký tự, 308 byte

∇r←f w;g;b;z;k
   g←{⍵≤0:1⋄t=⌊t←2⍟⍵}⋄→A×⍳∼w≤9⋄r←g w⋄→0
A: z←w⋄b←0⋄k←1
B: b+←k×10∣z⋄z←⌊z÷10
   →C×⍳∼g b⋄r←∇z⋄→0×⍳r
C: k×←10⋄→B×⍳z≠0
   r←0
∇
h←{⍵=0:0⋄f ⍵}

Chức năng cho bài tập đó là h. Thuật toán dường như không theo cấp số nhân hoặc giai thừa ... kiểm tra:

  h¨ 4281 164 8192 81024 101 
1 1 1 1 1 
  h¨ 0 1 3 234789 256323 8132
0 1 0 0 0 1 
  h 81024256641116
1
  h 64512819237913
0

Python 2 , 57 byte

f=lambda n,k=10:k<11*n>n%k&n%k-1<(n<k)|f(n/k)|f(n,10*k)*n

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

Python 2 , 86 byte

lambda n:re.match('^(%s)*$'%'|'.join('0*'+`1<<k`for k in range(n)),`n`)and 0;import re

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

Ruby , 55 byte

->n{a=*b=1;a<<b*=2until b>n;n.to_s=~/^(0*(#{a*?|}))*$/}

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

Đầu ra là 0nếu đúng và nilnếu sai.

Ruby , 49 byte

->n{n.to_s=~/^(0*(#{(0..n).map{|x|2**x}*?|}))*$/}

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

Chỉ hoạt động trong lý thuyết. Mất mãi mãi cho các giá trị lớn củan

PHP, 101 byte

Cant dường như có được điều này dưới 100; nhưng tôi có thể lấy nó tới 100 nếu 101là trường hợp giả.

function f($s){for($x=.5;$s>=$x*=2;)if(preg_match("/^$x(.*)$/",$s,$m)?!~$m[1]||f(+$m[1]):0)return 1;}

trả lại $NULL$ cho giả và $1$cho sự thật Hãy thử trực tuyến .

các biến thể:

for($x=.5;$s>=$x*=2;)
while($s>=$x=1<<$i++)   # yields notices "undefined variable $i"

?!~$m[1]||f(+$m[1]):0
?~$m[1]?f(+$m[1]):1:0

PHP 5 trở lên, 95 byte

function f($s){while($s>=$x=1<<$i++)if(ereg("^$x(.*)$",$s,$m)?$m[1]>""?f(+$m[1]):1:0)return 1;}

Màu đỏ , 212 211 byte

func[n][g: func[x][(log-2 do x)% 1 = 0]repeat i 2 **((length? s: form n)- 1)[b: a:
copy[] k: i foreach c s[append b c if k % 2 = 0[alter a g rejoin b
b: copy[]]k: k / 2]append a g form c if all a[return on]]off]

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

Một bài nộp dài khác, nhưng tôi không hài lòng lắm, vì không có sẵn để tìm tất cả các chuỗi con trong Red.

Dễ đọc hơn:

f: func [ n ] [
    g: func [ x ] [ (log-2 do x) % 1 = 0 ]
    repeat i 2 ** ((length? s: form n) - 1) [
        b: a: copy []
        k: i
        foreach c s [
            append b c
            if k % 2 = 0 [ 
                append a g rejoin b
                b: copy []
            ]
            k: k / 2 
        ]
        append a g form c
        if all a[ return on ]
    ]
    off
]

Tiên đề, 198 byte

G(a)==(a<=1=>2>1;x:=log_2 a;x=floor x)
F(n)==(n<=9=>G n;z:=n;b:=0;k:=1;repeat(b:=b+k*(z rem 10);z:=z quo 10;if G b and F z then return 2>1;k:=k*10;z<=0=>break);1>1)
H(n:NNI):Boolean==(n=0=>1>1;F n)

ungolf và kiểm tra

g(a)==(a<=1=>2>1;x:=log_2 a;x=floor x)
f(n)==
   n<=9=>g n
   z:=n;b:=0;k:=1
   repeat
      b:=b+k*(z rem 10);z:=z quo 10;
      if g b and f z then return 2>1
      k:=k*10
      z<=0=>break
   1>1
h(n:NNI):Boolean==(n=0=>1>1;f n)

(15) -> [[i,h i] for i in [4281,164,8192,81024,101]]
   (15)  [[4281,true],[164,true],[8192,true],[81024,true],[101,true]]
                                                      Type: List List Any
(16) -> [[i,h i] for i in [0,1,3,234789,256323,8132]]
   (16)  [[0,false],[1,true],[3,false],[234789,false],[256323,false],[8132,true]]
                                                      Type: List List Any
(17) -> [[i,h i] for i in [81024256641116, 64512819237913]]
   (17)  [[81024256641116,true],[64512819237913,false]]
                                                      Type: List List Any
(18) -> h 44444444444444444444444444
   (18)  true
                                                            Type: Boolean
(19) -> h 44444444444444444128444444444
   (19)  true
                                                            Type: Boolean
(20) -> h 4444444444444444412825444444444
   (20)  false
                                                            Type: Boolean
(21) -> h 2222222222222244444444444444444412822222222222210248888888888882048888888888888888
   (21)  true
                                                            Type: Boolean
(22) -> h 222222222222224444444444444444441282222222222225128888888888882048888888888888888
   (22)  true
                                                            Type: Boolean

Japt -!, 12 byte

Đưa đầu vào dưới dạng một chuỗi.

ÊÆòXÄÃex_&ZÉ

Thử nó

C # 157 byte

bool P(string s,int i=1)=>i>=s.Length?((Func<ulong,bool>)((x)=>(x!=0)&&((x&(x-1))==0)))(ulong.Parse(s)):(P(s,i+1)||(P(s.Substring(0,i))&&P(s.Substring(i))));

Bạn có thể dùng thử trực tuyến

APL (NARS), 70 ký tự, 140 byte

P←{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}
f←{⍵=0:0⋄∨/∧/¨y=⌊y←2⍟⍎¨¨P⍕⍵}

kiểm tra:

  f¨ 4281 164 8192 81024 101
1 1 1 1 1 
  f¨ 0 1 3 234789 256323 8132
0 1 0 0 0 1 
  f 126
0

tôi không cố gắng thực hiện các số lớn khác ... tôi phải lưu ý rằng P không phải là phân vùng bình thường, nhưng nó là một phân vùng trong đó tất cả các phần tử là tập hợp con có thành viên liên tiếp, ví dụ

  ⎕fmt P 'abc'
┌4──────────────────────────────────────────────────┐
│┌1─────┐ ┌2─────────┐ ┌2─────────┐ ┌3─────────────┐│
││┌3───┐│ │┌2──┐ ┌1─┐│ │┌1─┐ ┌2──┐│ │┌1─┐ ┌1─┐ ┌1─┐││
│││ abc││ ││ ab│ │ c││ ││ a│ │ bc││ ││ a│ │ b│ │ c│││
││└────┘2 │└───┘ └──┘2 │└──┘ └───┘2 │└──┘ └──┘ └──┘2│
│└∊─────┘ └∊─────────┘ └∊─────────┘ └∊─────────────┘3
└∊──────────────────────────────────────────────────┘

lưu ý rằng không có phần tử ((ac) (b)) hoặc tốt hơn ,, ('ac') 'b'

  ⎕fmt ,,¨('ac')'b'
┌2─────────┐
│┌2──┐ ┌1─┐│
││ ac│ │ b││
│└───┘ └──┘2
└∊─────────┘

POSIX ERE, 91 byte

(0*([1248]|16|32|64|128|256|512|1024|2048|4096|8192|16384|32768|65536|131072|262144|524288))+

Điều này là hoàn toàn gian lận, dựa trên văn bản số lượng lớn (không thực sự cần thiết để được xử lý bởi mã của bạn) trong câu hỏi; nó xử lý tất cả các giá trị trong phạm vi kích thước của các ví dụ. Rõ ràng có thể được mở rộng lên đến phạm vi đầy đủ của các loại số nguyên 32 hoặc 64 bit với chi phí kích thước. Tôi chủ yếu viết nó như là một minh chứng về cách vấn đề tự nhiên phù hợp với công cụ. Một bài tập thú vị sẽ được viết lại dưới dạng chương trình tạo ERE cho phạm vi tùy ý sau đó khớp với nó.

C (gcc) , -DA=asprintf(&c,+ 108 = 124 byte

p,c;f(a,i){c="^(0*(1";for(i=0;i<31;)A"%s|%d",c,1<<++i);A"%s))+$",c);regcomp(&p,c,1);a=!regexec(&p,a,0,0,0);}

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

Điều này xây dựng một regex của các quyền hạn từ 2 đến 2 ** 32, và sau đó khớp chuỗi đầu vào với nó.

Powershell, 56 byte

$x=(0..63|%{1-shl$_})-join'|0*'
"$args"-match"^(0*$x)+$"

Kịch bản thử nghiệm:

$f = {

    $x=(0..63|%{1-shl$_})-join'|0*'
    "$args"-match"^(0*$x)+$"

}

@(
    ,(4281            ,$true)
    ,(164             ,$true)
    ,(8192            ,$true)
    ,(81024           ,$true)
    ,(101             ,$true)
    ,(0               ,$false)
    ,(1               ,$true)
    ,(3               ,$false)
    ,(234789          ,$false)
    ,(256323          ,$false)
    ,(8132            ,$true)
    ,("81024256641116"  ,$true)
    ,("64512819237913"  ,$false)
) | % {
    $n, $expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result <- $n"
}

Đầu ra:

True: True <- 4281
True: True <- 164
True: True <- 8192
True: True <- 81024
True: True <- 101
True: False <- 0
True: True <- 1
True: False <- 3
True: False <- 234789
True: False <- 256323
True: True <- 8132
True: True <- 81024256641116
True: False <- 64512819237913

Giải trình:

Xây dựng một biểu thức chính như ^(0*1|0*2|0*4|0*8|0*16|0*32|…)+$sức mạnh của 2 và kiểm tra nó trên các đối số.

JavaScript (Node.js) , 56 byte

f=(x,c=v=1)=>x<v?x.match('^('+c+')+$'):f(x,c+'|'+(v*=2))

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