Các thách thức

Cho một đầu vào số nguyên xtrong đó 1 <= x <= 255, trả về kết quả của lũy thừa của hai mà khi tổng cộng đưa ra x.

Ví dụ

Đưa ra đầu vào:

86

Chương trình của bạn sẽ xuất ra:

64 16 4 2

Đầu vào:

240

Đầu ra:

128 64 32 16

Đầu vào:

1

Đầu ra:

1

Đầu vào:

64

Đầu ra:

64

Đầu ra có thể chứa các số không nếu công suất nhất định của hai không có trong tổng.

Ví dụ, đầu vào 65có thể đầu ra 0 64 0 0 0 0 0 1.

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

JavaScript (ES6), 28 byte

f=n=>n?[...f(n&~-n),n&-n]:[]

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

Bash thuần khiết , 20

echo $[2**{7..0}&$1]

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

Giải trình

          {7..0}     # Brace expansion: 7 6 5 4 3 2 1 0
       2**{7..0}     # Brace expansion: 128 64 32 16 8 4 2 1
       2**{7..0}&$1  # Brace expansion: 128&n 64&n 32&n 16&n 8&n 4&n 2&n 1&n (Bitwise AND)
     $[2**{7..0}&$1] # Arithmetic expansion
echo $[2**{7..0}&$1] # and output

Thạch , 4 byte

-2 vì chúng ta có thể xuất số không thay cho quyền hạn không sử dụng là 2 :)

Ḷ2*&

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

Làm sao?

Ḷ2*& - Link: integer, n         e.g. 10
Ḷ    - lowered range of n            [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9]
 2*  - two to the power of           [  1,  2,  4,  8, 16, 32, 64,128,256,512]
   & - bit-wise and                  [  0,  2,  0,  8,  0,  0,  0,  0,  0,  0]

Thạch , 6 byte

BUT’2*

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

Giải trình

NHƯNG đây là một lời giải thích (lưu ý: Tôi đã giả định rằng chúng ta chỉ có thể tự tạo ra sức mạnh của 2 và không có gì khác):

BUT’2* – Monadic link. Takes a number N as input. Example: 86
B      – Convert N to binary.                              [1, 0, 1, 0, 1, 1, 0]
 U     – Reverse.                                          [0, 1, 1, 0, 1, 0, 1]
  T    – Truthy indices.                                   [2, 3, 5, 7]
   ’   – Decrement.                                        [1, 2, 4, 6]
    2* – Raise 2 to that power.                            [2, 4, 16, 64]

$X$$\{x_1, x_2, x_3,\cdots, x_n\}$$x_i\in\{0,1\},\:\forall\:\: i\in\overline{1,n}$

Python , 35 byte

lambda n:[n&2**i for i in range(8)]

Little endian với số không ở mức 2 không được sử dụng.

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

APL (Dyalog Extended) , 7 byte ^SBCS

Chức năng tiền tố ẩn danh. Yêu cầu lập chỉ mục dựa trên 0 ( ⎕IO←0).

2*⍸⍢⌽⍤⊤

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

2 hai
* lũy thừa của
⍸ các ɩ ndices nơi đúng
⍢ thời gian
⌽ đảo ngược
⍤ của
⊤ các đại diện nhị phân

Sledgehammer 0,2, 3 byte

⡔⡸⢣

Giải nén thành {intLiteral[2],call[NumberExpand,2]}.

Sledgehammer là một máy nén cho mã Wolfram Language sử dụng chữ nổi làm trang mã. Kích thước thực tế ở trên là 2,75 byte, nhưng do các quy tắc hiện hành về meta, việc đệm vào byte gần nhất được tính theo kích thước mã.

05AB1E , 3 byte

Ýo&

Cảng @JonathanAllan 's Jelly câu trả lời , vì vậy hãy chắc chắn để upvote anh ta!

Chứa các số không (bao gồm cả các số không theo sau).

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ý      # Create a list in the range [0, (implicit) input]
       #  i.e. 15 → [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
       #  i.e. 16 → [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
 o     # Take 2 to the power of each value
       #  → [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768]
       #  → [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536]
  &    # Bitwise-AND each value with the (implicit) input
       # 15 → [1,2,4,8,0,0,0,0,0,0,0,0,0,0,0,0]
       # 16 → [0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0]
       # (and output the result implicitly)

Catholicon , 3 byte

ṫĊŻ

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

Giải trình:

ṫ       Decompose         into the largest values where:
 Ċ               the input
  Ż       the bit count is truthy (equal to one)

Ngôn ngữ Wolfram (Mathicala) , 17 byte

#~NumberExpand~2&

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

Mathicala lại đình công.

R , 27 23 byte

bitwAnd(scan(),2^(7:0))

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

Mã không được kiểm soát và giải thích:

A = scan()         # get input number A from stdin
                   # e.g. A = 65

bitwAnd( A , 2^(7:0))  # bitwise AND between all powers of 2 : 2^7 ... 2^0 and A
                       # and implicitly print the result
                       # e.g. B = bitwAnd(65, c(128,64,32,16,8,4,2,1)) = c(0,64,0,0,0,0,0,1)

• 4 byte nhờ @Kirill L

C # (Trình biên dịch tương tác Visual C #) , 29 byte

Chứa 5 ký tự không thể in.

n=>"€@ ".Select(a=>a&n)

Giải trình

//Lambda taking one parameter 'n'
n=>
//String with ASCII characters 128, 64, 32, 16, 8, 4, 2, and 1
"€@ "
//Iterate through all the chars of the above string and transform them to
.Select(a=>
//A bitwise AND operation between the integer value of the current char and the input value
a&n)

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

C # (Trình biên dịch tương tác Visual C #) , 38 byte

x=>{for(int y=8;y-->0;Print(x&1<<y));}

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

C (gcc) , 39 byte

f(n){for(;n;n&=n-1)printf("%d ",n&-n);}

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

05AB1E, 7 byte

2вRƶ<oò

giải trình:

2в        convert input to binary array
R         reverse array
ƶ<        multiply each item by it's index and subtract 1
oò        2^item then round down

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

Haskell , 29 byte

(mapM(\n->[0,2^n])[7,6..0]!!)

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

Ruby , 25 byte

->n{8.times{|i|p n&2**i}}

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

C (tiếng kêu) , 133 110 63 58 byte

Giải pháp 58 byte nhờ @ceilingcat .

x=256;main(y){for(scanf("%d",&y);x/=2;)printf("%d ",y&x);}

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

MATL , 5 byte

BPfqW

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

Giải trình

Hãy xem xét đầu vào 86là một ví dụ.

B    % Implicit input. Convert to binary (highest to lowest digits)
     % STACK: [1 0 1 0 1 1 0]
P    % Flip
     % STACK: [0 1 1 0 1 0 1]
f    % Find: indices of nonzeros (1-based)
     % STACK: [2 3 5 7]
q    % Subtract 1, element-wise
     % STACK: [1 2 4 6]
W    % Exponential with base 2, element-wise. Implicit display
     % STACK: [2 4 16 64]

Perl 6 , 16 12 byte

-4 byte nhờ Jonathan Allan

*+&2**all ^8

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

Trả về một All Junction với 8 phần tử. Đây là một cách quay trở lại không chuẩn, nhưng nhìn chung, các nút có thể hoạt động theo thứ tự (ít nhất là cho đến khi tự động đọc được thực hiện) liệt kê và có thể trích xuất các giá trị từ một.

Giải trình:

*+&              # Bitwise AND the input with
   2**           # 2 raised to the power of
      all ^8     # All of the range 0 to 7

Japt, 8 5 byte

Æ&2pX

Thử nó

Æ&2pX     :Implicit input of integer U
Æ         :Map each X in the range [0,U)
 &        :  Bitwise AND of U with
  2pX     :  2 to the power of X

Thay thế

Được đề xuất bởi Oliver để tránh 0s trong đầu ra sử dụng -mfcờ.

N&2pU

Thử nó

N&2pU     :Implicitly map each U in the range [0,input)
N         :The (singleton) array of inputs
 &        :Bitwise AND with
  2pX     :2 to the power of U
          :Implicitly filter and output

05AB1E , 9 byte

Ýoʒ›}æʒOQ

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

Điều này cũng đúng với 6 byte, nhưng nó không hoàn thành đúng lúc trên TIO cho 86:

05AB1E , 6 byte

ÝoæʒOQ

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

Julia 0,6 , 13 byte

n->n&2.^(0:7)

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

CJam , 12 byte

{:T{2\#T&}%}

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

K (oK) , 19 16 byte

-3 byte nhờ ngn!

{*/x#2}'&|(8#2)\

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

oK không có powertoán tử, đó là lý do tại sao tôi cần một hàm trợ giúp {*/x#2}(sao chép 2 xlần và giảm danh sách kết quả bằng cách nhân)

Nhà giả kim , 125 byte

_->In_x+128a+m
m+x+a->m+b
m+0x+a->n+a
m+0a->o+Out_b+Out_" "
n+b->n+x+c
n+0b+a->n+c
n+0a->p
o+b->o+c
o+0b->p
p+2c->p+a
p+0c->m

Hãy thử trực tuyến! hoặc Kiểm tra mọi đầu vào!

Giải trình

_->In_x+128a+m           # Initialize universe with input, 128a (value to compare to) and m (state)
m+x+a->m+b               # If c has been halved, subtract min(a, x) from a and x and put its value into b
m+0x+a->n+a              # If x < a, continue to state n
m+0a->o+Out_b+Out_" "    # Else print and continue to state o
n+b->n+x+c               # Add min(a, x) (i.e. x) back to x, and add it to c (we're collecting a back into c)
n+0b+a->n+c              # Then, add the rest of a to c
n+0a->p                  # Then, go to state p
o+b->o+c                 # Add min(a, x) (i.e. a) to c - x _is_ greater than a and so contains it in its binary representation, so we're not adding back to x
o+0b->p                  # Then, go to state p
p+2c->p+a                # Halve c into a
p+0c->m                  # Then go to state m

PHP ,41 39 byte

for($c=256;$c>>=1;)echo$argv[1]&$c,' ';

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

Hoặc 38 không có >>=toán tử thú vị và PHP 5.6+:

for($x=8;$x--;)echo$argv[1]&2**$x,' ';

Hoặc 36 với đầu ra little endian ("0 2 4 0 16 0 64 0"):

while($x<8)echo$argv[1]&2**$x++,' ';

Thực sự tôi chỉ muốn sử dụng >>=toán tử, vì vậy tôi gắn bó với 39 .

Các xét nghiệm:

$php pow2.php 86
0 64 0 16 0 4 2 0

$php pow2.php 240
128 64 32 16 0 0 0 0

$php pow2.php 1
0 0 0 0 0 0 0 1

$php pow2.php 64
0 64 0 0 0 0 0 0

$php pow2.php 65
0 64 0 0 0 0 0 1

TSQL, 43 39 byte

Không thể tìm thấy một giải pháp ưa thích ngắn hơn, vì vậy đây là một vòng lặp tiêu chuẩn. -4 byte nhờ MickyT và KirillL

DECLARE @y int=255

,@ int=128s:PRINT @y&@ SET @/=2IF @>0GOTO s

Dùng thử

Python 2 , 43 40 byte

f=lambda n,p=1:n/p*[1]and f(n,p*2)+[p&n]

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

C # (Trình biên dịch tương tác Visual C #), 33 byte

n=>{for(;n>0;n&=n-1)Print(n&-n);}

Cảng @Arnauld JavaScript (ES6) câu trả lời 's , vì vậy hãy chắc chắn để upvote anh ta!

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

Giải trình:

n=>{            // Method with integer parameter and no return-type
  for(;n>0      //  Continue looping as long as `n` is larger than 0:
      ;         //    After every iteration:
       n&=n-1)  //     Bitwise-AND `n` by `n-1`
    Print(      //   Print with trailing newline:
      n&-n);}   //    `n` bitwise-AND `-n`