Le défi

Étant donné une entrée entière xoù 1 <= x <= 255, renvoyer les résultats de puissances de deux qui, une fois sommées, donnent x.

Exemples

Compte tenu de l'entrée:

86

Votre programme devrait produire:

64 16 4 2

Contribution:

240

Sortie:

128 64 32 16

Contribution:

1

Sortie:

1

Contribution:

64

Sortie:

64

La sortie peut contenir des zéros si la puissance certaine de deux n'est pas présente dans la somme.

Par exemple, saisissez 65 peut sortir 0 64 0 0 0 0 0 1.

Notation

C'est le golf de code , donc la réponse la plus courte dans chaque langue l'emporte.

JavaScript (ES6), 28 octets

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

Essayez-le en ligne!

Pure Bash , 20

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

Essayez-le en ligne!

Explication

          {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

Gelée , 4 octets

-2 puisque nous pouvons produire des zéros à la place des puissances inutilisées de 2 :)

Ḷ2*&

Essayez-le en ligne!

Comment?

Ḷ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]

Gelée , 6 octets

BUT’2*

Essayez-le en ligne!

Explication

MAIS voici une explication (note: j'avais supposé que nous ne pouvions sortir que les puissances de 2 elles-mêmes et rien d'autre):

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]

"Preuve" que cela fonctionne correctement. La représentation standard d'un entier $X$ dans la base 2 est une liste $\{x_1, x_2, x_3,\cdots, x_n\}$ , où $x_i\in\{0,1\},\:\forall\:\: i\in\overline{1,n}$ , tel que:

Python , 35 octets

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

Little-endian avec des zéros à des puissances inutilisées de 2.

Essayez-le en ligne!

APL (Dyalog Extended) , ^SBCS 7 octets

Fonction de préfixe tacite anonyme. Nécessite une indexation basée sur 0 ( ⎕IO←0).

2*⍸⍢⌽⍤⊤

Essayez-le en ligne!

2 deux
* élevé à la puissance de
⍸ la ɩ ndices où vrai
⍢ alors
⌽ inversé
⍤ de
⊤ la représentation binaire

Sledgehammer 0,2, 3 octets

⡔⡸⢣

Se décompresse en {intLiteral[2],call[NumberExpand,2]} .

Sledgehammer est un compresseur pour le code Wolfram Language utilisant le braille comme page de codes. La taille réelle de ce qui précède est de 2,75 octets, mais en raison des règles actuelles sur les méta, le remplissage à l'octet le plus proche est compté dans la taille du code.

05AB1E , 3 octets

Ýo&

Port de @JonathanAllan 's Jelly answer , alors assurez-vous de lui donner un vote positif!

Contient des zéros (y compris des charges de zéros de fin).

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Ý      # 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 octets

ṫĊŻ

Essayez-le en ligne!

Explication:

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

Wolfram Language (Mathematica) , 17 octets

#~NumberExpand~2&

Essayez-le en ligne!

Mathematica frappe à nouveau.

R , 27 23 octets

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

Essayez-le en ligne!

Code déroulé et explication:

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 octets grâce à @Kirill L.

C # (Visual C # Interactive Compiler) , 29 octets

Contient 5 caractères non imprimables.

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

Explication

//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)

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 38 octets

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

Essayez-le en ligne!

C (gcc) , 39 octets

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

Essayez-le en ligne!

05AB1E, 7 octets

2вRƶ<oò

explication:

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

Essayez-le en ligne!

Haskell , 29 octets

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

Essayez-le en ligne!

Ruby , 25 octets

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

Essayez-le en ligne!

C (bruit) , 133 110 63 58 octets

Solution de 58 octets grâce à @ceilingcat .

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

Essayez-le en ligne!

MATL , 5 octets

BPfqW

Essayez-le en ligne!

Explication

Considérez l'entrée 86comme un exemple.

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 octets

-4 octets grâce à Jonathan Allan

*+&2**all ^8

Essayez-le en ligne!

Renvoie une jonction All avec 8 éléments. Il s'agit d'un moyen de retour plutôt non standard, mais généralement, les jonctions peuvent agir comme des listes ordonnées (au moins jusqu'à ce que la lecture automatique soit implémentée) et il est possible d'extraire les valeurs d'une liste.

Explication:

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

Japt, 8 5 octets

Æ&2pX

L'essayer

Æ&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

Alternative

Suggéré par Oliver pour éviter les 0s dans la sortie en utilisant l' -mfindicateur.

N&2pU

L'essayer

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 octets

Ýoʒ›}æʒOQ

Essayez-le en ligne!

Ceci est également correct pour 6 octets, mais il ne se termine pas à temps sur TIO pour 86:

05AB1E , 6 octets

ÝoæʒOQ

Essayez-le en ligne!

Julia 0,6 , 13 octets

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

Essayez-le en ligne!

CJam , 12 octets

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

Essayez-le en ligne!

K (oK) , 19 16 octets

-3 octets grâce à ngn!

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

Essayez-le en ligne!

oK n'a pas d' poweropérateur, c'est pourquoi j'ai besoin d'une fonction d'aide {*/x#2}(copiez 2 xfois et réduisez la liste résultante par multiplication)

Alchimiste , 125 octets

_->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

Essayez-le en ligne! ou Testez chaque entrée!

Explication

_->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 octets

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

Essayez-le en ligne!

Ou 38 sans >>=opérateur amusant et PHP 5.6+:

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

Ou 36 avec sortie little-endian ("0 2 4 0 16 0 64 0"):

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

Vraiment, je voulais juste utiliser l' >>=opérateur, donc je m'en tiens au 39 .

Tests:

$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 octets

Impossible de trouver une solution de fantaisie plus courte, alors voici une boucle standard. -4 octets grâce à MickyT et KirillL

DECLARE @y int=255

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

Essaye le

Python 2 , 43 40 octets

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler), 33 octets

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

Port de la réponse JavaScript (ES6) de @Arnauld , alors assurez-vous de voter pour lui!

Essayez-le en ligne.

Explication:

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`