Somma di poteri di 2

31

La sfida

Dato un input intero xdove 1 <= x <= 255, restituisce i risultati dei poteri di due che quando sommati danno x.

Esempi

Dato l'input:

86

Il tuo programma dovrebbe produrre:

64 16 4 2

Ingresso:

240

Produzione:

128 64 32 16

Ingresso:

1

Produzione:

1

Ingresso:

64

Produzione:

64

L'output può contenere zeri se la somma potenza di due non è presente nella somma.

Ad esempio, l'input 65potrebbe essere in uscita 0 64 0 0 0 0 0 1.

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua.

code-golf  binary  code-golf  sequence  integer  chess  code-golf  number  arithmetic  matrix  code-golf  code-golf  combinatorics  grid  set-partitions  code-golf  array-manipulation  graph-theory  code-golf  number  code-golf  string  decision-problem  code-golf  matrix  cellular-automata  3d  code-challenge  restricted-source  printable-ascii  code-golf  board-game  code-golf  geometry  grid  code-golf  word-puzzle  code-golf  matrix  sorting  code-golf  code-golf  string  decision-problem  code-golf  matrix  cellular-automata  code-golf  decision-problem  code-golf  math  number  arithmetic  restricted-source  code-golf  code-golf  number  integer  matrix  code-golf  date  code-golf  matrix  code-golf  sequence  combinatorics  chemistry  code-golf  array-manipulation  popularity-contest  code-golf  code-golf  natural-language  code-golf  number  integer  sorting  substitution  code-golf  string  number  date  encode  code-golf  decision-problem  code-golf  string  subsequence  code-golf  string  alphabet  code-golf 
— SpookyGengar
fonte
5
L'elenco deve essere ordinato dal più alto al più basso?
— Adám,
2
Possiamo produrre degli zeri ridondanti?
— Jonathan Allan,
4
RE: "ordinati dal più alto al più basso" perché aggiungere una restrizione che non faceva parte della sfida e invalida la maggior parte delle risposte esistenti? (E che dire di little-endian ?!) + invalida la mia risposta Python poiché i set non hanno alcun ordine.
— Jonathan Allan,
5
@JonathanAllan Ho rimosso la limitazione. Lo terrò a mente la prossima volta che posterò un'altra domanda: sono ancora abbastanza nuovo in questo. :)
— SpookyGengar,
6
Penso che potresti voler affermare che qualsiasi potere di due può essere usato una sola volta. Altrimenti qualcuno potrebbe produrre "1 1 1" per l'ingresso 3.
— Black Owl Kai

Risposte:

38

JavaScript (ES6), 28 byte

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

Provalo online!

— Arnauld
fonte
9
Sei l'unica persona al mondo che può farmi votare risposte JavaScript!
— sergiol
4
@sergiol, perché normalmente non dovresti votare una soluzione JS? Una buona soluzione è una buona soluzione indipendentemente dalla lingua utilizzata o da chi l'ha pubblicata.
— Shaggy
@Shaggy Perché Arnauld sembra l'unica persona a fare tali soluzioni Javascript. Le sue risposte sono puro genio!
— sergiol
3
@sergiol Grazie per il complimento, ma non è del tutto vero. Sono regolarmente superato da risposte più intelligenti - e questo è ciò di cui tratta questo sito. ^^
— Arnauld
@Oliver non ne sono sicuro. Sembra che gli zeri iniziali (prima del 128) siano vietati. Altrimenti, un'altra possibile variante è f=n=>n&&f(n&~-n)+[,n&-n].
— Arnauld,
12

Pure Bash , 20

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

Provalo online!

Spiegazione

          {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
— Trauma digitale
fonte
12

Gelatina , 4 byte

-2 poiché potremmo generare zeri al posto di potenze inutilizzate di 2 :)

Ḷ2*&

Provalo online!

Come?

Ḷ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]
— Jonathan Allan
fonte
11

Gelatina , 6 byte

BUT’2*

Provalo online!

Spiegazione

MA qui c'è una spiegazione (nota: avevo ipotizzato che potremmo produrre solo i poteri di 2 stessi e nient'altro):

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]

"Prova" che funziona correttamente. La rappresentazione standard di un numero intero X nella base 2 è un elenco {x1,x2,x3,⋯,xn} , dove xi∈{0,1},∀i∈1,n¯ , tale che:

X=∑i=1nxi⋅2n−i
Gli indicii tali chexi=0 ovviamente non hanno alcun contributo, quindi siamo interessati solo a trovare quelli tali chexi=1 . Poiché sottrarrei dan non è conveniente (i poteri di due hanno tutti esponenti del modulon−i , dovei è un indice di un1 ), invece di trovare gli indici di verità in questo elenco, li invertiamo e li troviamo "indietro" conUT. Ora che abbiamo trovato gli indici corretti, tutto ciò che dobbiamo fare è aumentare2 a quei poteri.

— Mr. Xcoder
fonte
1
"Solo ASCII" ’
— Laggiù
1
@EriktheOutgolfer Immagino BUT2*Hche funzionerebbe comunque.
— Mr. Xcoder,
1
Abbastanza impressionante che funzioni con un input di 302231454903657293676544.
— Michael Karas,
8

APL (Dyalog Extended) , 7 byte SBCS

Funzione prefisso tacito anonimo. Richiede l'indicizzazione basata su 0 ( ⎕IO←0).

2*⍸⍢⌽⍤⊤

Provalo online!

2 due
* elevato alla potenza di
⍸ i ɩ ndices in cui il vero
⍢ , mentre
⌽ invertito
⍤ della
⊤ rappresentazione binaria

— Adamo
fonte
8

Mazza 0,2, 3 byte

⡔⡸⢣

Si decomprime in {intLiteral[2],call[NumberExpand,2]}.

Sledgehammer è un compressore per il codice Wolfram Language che utilizza Braille come tabella codici. La dimensione effettiva di quanto sopra è 2,75 byte, ma a causa delle regole correnti su meta, il riempimento al byte più vicino viene conteggiato nella dimensione del codice.

— lirtosiast
fonte
2
Eh! Piccolo linguaggio pulito e tutti i personaggi sono in realtà stampabili.
— LegionMammal978,
E ora non riesco a togliermi dalla mente la canzone di Peter Gabriel ...
— Digital Trauma,
8

05AB1E , 3 byte

Ýo&

La risposta di Jelly al porto di @JonathanAllan , quindi assicurati di votarlo!

Contiene zeri (inclusi -load di--zero finali).

Provalo online o verifica tutti i casi di test .

Spiegazione:

Ý      # 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)
— Kevin Cruijssen
fonte
1
... che cosa?! Mai visto onestamente bitwise andusato in Osabie. Ben fatto.
— Magic Octopus Urn
@MagicOctopusUrn In effetti anche io non lo uso molto spesso. Non riesco nemmeno a trovare un'altra risposta in cui ho usato &. XD Ho usato Bitwise-XOR un paio di volte, come qui o qui e Bitwise-NOT una volta qui (che in seguito ho rimosso di nuovo dopo aver giocato a golf ulteriormente ..). Io uso Bitwise-AND, XOR, OR, NOT, SHIFT, ecc. Abbastanza spesso in Java, ma in 05AB1E non così tanto. :)
— Kevin Cruijssen,
7

R , 27 23 byte

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

Provalo online!

Codice non spiegato e spiegazione:

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 grazie a @Kirill L.
— digEmAll
fonte
1
23 byte con bit a bit e.
— Kirill L.
@KirillL .: geniale!
— digEmAll
7

C # (compilatore interattivo Visual C #) , 29 byte

Contiene 5 caratteri non stampabili.

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

Spiegazione

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

Provalo online!

— Incarnazione dell'ignoranza
fonte
Ma abbiamo bisogno di sbarazzarci di zeri, come n=>new int[8].Select((j,i)=>1<<i&n).Where(i=>i!=0)La parte prima Whereè di cinque byte più breve tra
— polfosol ఠ_ఠ
@polfosolThe output may contain zeros
— Jo King
2
@JoKing Still, n=>new int[8].Select((j,i)=>1<<i&n)è lungo 35 byte e non avremo bisogno di ulteriori flag e codifiche di testo.
— polfosol ఠ_ఠ
1
L'uso dei caratteri ascii 0-7 dovrebbe essere più breve, ad es. n=>"INSERT ASCII HERE".Select(a=>1<<a&n)Ma sono su un dispositivo mobile che non può visualizzare o digitare caratteri non stampabili, quindi dovrò aspettare fino a quando non torno a casa per aggiornare la risposta
— Incarnazione dell'ignoranza il
6

C # (compilatore interattivo Visual C #) , 38 byte

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

Provalo online!

— dana
fonte
— ASCII il
1
Fallisce per ingressi 1, 2, 4, 8, 16, ecc (il x>ydovrebbe essere x>=yinvece).
— Kevin Cruijssen,
1
@ASCIIOnly - Te lo dico io, l' operatore di campo sarà dolce :)
— Dana il
@ ASCII-only Nel frattempo, puoi usare il flag /u:System.Linq.Enumerablee provare questo per 31 byte
— Incarnazione dell'ignoranza il
@EmbodimentofIgnorance sicuro. ma preferirei non elencare la lingua come "C # /u:System.Linq.Enumerable": P
— ASCII il
5

05AB1E, 7 byte

2вRƶ<oò

spiegazione:

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

Provalo online!

— Jackson
fonte
Funziona anche con input di 302231454903657293676544
— Michael Karas,
5

C (clang) , 133 110 63 58 byte

Soluzione a 58 byte grazie a @ceilingcat .

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

Provalo online!

— un aracnide di pietra
fonte
In C89, è possibile dichiarare like main(){}e il tipo restituito per impostazione predefinita è int. Lo stesso vale per le variabili di portata globale. Inoltre, almeno su normali implementazioni come clang, printf e scanf funzionano senza prototipi. Ovviamente ricevi avvisi, ma è ancora valido C89 (forse) o almeno K&R C per essere dichiarati implicitamente. I tipi di oggetti C che passi come args definiscono il modo in cui vengono passati, quindi a char*e int*funzionerà semplicemente senza troncare i puntatori a 32 bit su x86-64 o altro. (Le promozioni con argomenti predefiniti si verificano, come per le funzioni variadiche che sono comunque.)
— Peter Cordes
Or is this aiming to be valid C11 with no undefined behaviour? If so, proudly proclaim it. :) And BTW, writing a function that takes an output array as an arg would probably be smaller. Anyway, see Tips for golfing in C
— Peter Cordes
You can use bitwise & to check if a bit is set. Like y&(1<<x)&&printf("%d ",1<<x);. Or to not skip zeros, just printf("%d ", y&(1<<x)). Or instead of counting bit positions, use x=256 and x>>=1 to shift the mask. main(y){int x=256;for(scanf("%d",&y);x>>=1;)printf("%d ",y&x);} 63 bytes Try it online! clang will even compile that with -std=c11
— Peter Cordes
— ceilingcat
4

MATL, 5 bytes

BPfqW

Try it online!

Explanation

Considera l'input 86come esempio.

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]
— Luis Mendo
fonte
4

Perl 6 , 16 12 bytes

-4 byte grazie a Jonathan Allan

*+&2**all ^8

Provalo online!

Restituisce un All Junction con 8 elementi. Si tratta di un modo piuttosto non standard di restituzione, ma in genere le giunzioni possono agire come ordinate (almeno fino a quando non viene implementata la creazione automatica di testi) ed è possibile estrarre i valori da una.

Spiegazione:

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

Japt, 8 5 byte

Æ&2pX

Provalo

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

Alternativa

Suggerito da Oliver per evitare le 0s nell'output usando il -mfflag.

N&2pU

Provalo

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
— Shaggy
fonte
1
Nice one. You can do N&2pU with -mf to avoid the 0s
— Oliver
4

K (oK), 19 16 bytes

-3 bytes thanks to ngn!

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

Try it online!

oK does not have power operator, that's why I need a helper function {*/x#2} (copy 2 x times and reduce the resulting list by multiplication)

— Galen Ivanov
fonte
you can omit the { x}
— ngn
@ngn Thanks! I tried it and it worked, but I wasn't sure it is acceptible.
— Galen Ivanov
4

Alchemist, 125 bytes

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

Try it online! or Test every input!

Explanation

_->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
— ASCII-only
fonte
4

PHP, 41 39 bytes

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

Try it online!

Or 38 with no fun >>= operator and PHP 5.6+:

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

Or 36 with little-endian ("0 2 4 0 16 0 64 0") output:

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

Really I just wanted to use the >>= operator, so I'm sticking with the 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
— 640KB
fonte
4

TSQL, 43 39 bytes

Can't find a shorter fancy solution, so here is a standard loop. -4 bytes thanks to MickyT and KirillL

DECLARE @y int=255

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

Try it out

— t-clausen.dk
fonte
using the bitwise and (&) you can save a few with the following ,@ int=128s:print @y&@ set @/=2IF @>0GOTO s. This is hinted by @KirillL for the R answer
— MickyT
@MickyT that worked like a charm. Thanks a lot
— t-clausen.dk
3

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

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

Port of @Arnauld's JavaScript (ES6) answer, so make sure to upvote him!

Try it online.

Explanation:

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`
— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.