Il tuo compito è di scomporre un numero usando il formato seguente.

Questo è simile alla conversione di base, tranne per il fatto che invece di elencare la digitsnella base, si elenca la values, in modo tale che la lista si sommi all'input.

Se la base data è n, quindi ogni numero nell'elenco deve essere nella forma di k*(n**m), dove 0<=k<ned mè univoco in tutto l'elenco.

Specifiche

• Qualsiasi ragionevole formato di input / output. Il tuo programma / funzione accetta 2 input e genera un elenco.
• L'elenco di output può essere in qualsiasi ordine.
• 0 può essere escluso o incluso.
• 0Sono ammessi leader .
• Sono ammessi gli incorporati .

Casi test

number base   converted list
input1 input2 output
123456 10     [100000,20000,3000,400,50,6] or [6,50,400,3000,20000,100000]
11     2      [8,2,1] or [0,0,0,0,8,0,2,1]
727    20     [400,320,7]
101    10     [100,1] or [100,0,1]

punteggio

Questo è code-golf . Vince la soluzione più breve in byte.

Gelatina , 7 byte

lr0⁹*×b

Provalo online! o verifica tutti i casi di test .

Come funziona

lr0⁹*×b  Main link. Arguments: x (integer), n (base)

l        Compute the logarithm of x to base n.
 r0      Range; yield all non-negative integers less than the logarithm, in
         decreasing order.
   ⁹*    Elevate n to all integers in that range.
      b  Yield the list of base-n digits of x.
     ×   Multiply each digit by the corresponding power of n.

JavaScript (ES6), 47 byte

f=(n,b,p=1,q=b*p)=>[...n<q?[]:f(n,b,q),n%q-n%p]
document.write("<pre>"+
[ [ 123456, 10 ], [ 11, 2 ], [ 727, 20 ], [ 101, 10 ] ]
.map(c=>c+" => "+f(...c)).join`\n`)

Gelatina, 12 byte

bLR’*@€U
b×ç

Può essere più breve ...

Provalo online!

Pyth - 12 11 byte

Solo un FGITW, può essere più breve.

.e*b^Qk_jEQ

Test Suite .

J, 20 19 byte

[(]*(^<:@#\.))#.inv

uso

   f =: [(]*(^<:@#\.))#.inv
   10 f 123456
100000 20000 3000 400 50 6
   2 f 11
8 0 2 1
   20 f 727
400 320 7
   10 f 101
100 0 1

Spiegazione

[(]*(^<:@#\.))#.inv
              #.      Given a base and list of digits in that base,
                      converts it to an integer in base 10
                inv   Power conjunction by -1, creates an inverse
                      Now, this becomes a verb that given a base and an integer in base 10,
                      creates a list of digits in that base representing it
[                     Select the base and pass it along
         #\.          Tally each suffix of the list of base digits,
                      Counts down from n to 1
      <:              Decrements each value
        @             More specifically, decrement is composed with the tally and applied
                      together on each suffix
     ^                Raises each value x using base^x
  ]                   Selects the list of base digits
   *                  Multiply elementwise between each base power and base digit

CJam, 16 byte

{1$b\1$,,f#W%.*}

Un blocco senza nome che prevede la base e il numero in cima allo stack (in quell'ordine) e li sostituisce con l'elenco delle cifre (inclusi gli zeri interni, senza zeri iniziali).

Provalo qui.

Spiegazione

1$  e# Copy base b.
b   e# Compute base-b digits of input number.
\   e# Swap digit list with other copy of b.
1$  e# Copy digit list.
,   e# Get number of digits M.
,   e# Turn into range [0 1 ... M-1].
f#  e# Map b^() over this range, computing all necessary powers of b.
W%  e# Reverse the list of powers.
.*  e# Multiply each digit by the corresponding power.

TSQL, 68 byte

DECLARE @ INT=123456,@z INT=10
DECLARE @l INT=1WHILE
@>0BEGIN PRINT @%@z*@l SELECT @/=@z,@l*=@z END

Python 2, 44 byte

lambda n,b:[n/b**i%b*b**i for i in range(n)]

Output dal meno significativo al più, con molti zero in più.

Per produrre il più significativo al minimo:

f=lambda n,b,c=1:n*[1]and f(n/b,b,c*b)+[n%b*c]

Richiama, togliendo ripetutamente le cifre ncon divmod mentre ridimensionando il moltiplicatore del valore del luogo c.

Rubino, 35 34 byte

Questo è un porto di risposta Python xnor , ma esso stampa ngli orari in modo che i test case 727 20stampa 7, 320, 400, e 724 0s. Suggerimenti di golf benvenuti.

Modifica: 1 byte grazie a Jordan.

->n,b{n.times{|i|p n/b**i%b*b**i}}

Mathematica, 12 byte (non concorrenti)

Mi chiedo se Wolfram Research abbia creato questa funzione dopo aver visto la sfida del PO!

NumberExpand

Questo è stato introdotto nella versione 11.0 (agosto 2016).

Mathematica, 46 byte

DiagonalMatrix@IntegerDigits@##~FromDigits~#2&

Spiegazione:

In [1]: = IntegerDigits [123456,10]                                                

Out [1] = {1, 2, 3, 4, 5, 6}

In [2]: = DiagonalMatrix @ IntegerDigits [123456,10] // MatrixForm                   

Out [2] // MatrixForm = 1 0 0 0 0 0

                    0 2 0 0 0 0

                    0 0 3 0 0 0

                    0 0 0 4 0 0

                    0 0 0 0 5 0

                    0 0 0 0 0 6

In [3]: = DiagonalMatrix @ IntegerDigits [123456,10] ~ FromDigits ~ 10                   

Out [3] = {100000, 20000, 3000, 400, 50, 6}

Racchetta, 82 byte

(define(d n b[a'()])(if(< n 1)a(d(/ n b)b(cons(*(modulo(floor n)b)(length a))a))))

Sono un vincitore (!)

JavaScript (ES7), 68 byte

n=>b=>(c=[...n.toString(b)]).map(d=>b**--p*parseInt(d,b),p=c.length)

Test

Test utilizza Math.powper la compatibilità del browser.

f=n=>b=>(c=[...n.toString(b)]).map(d=>Math.pow(b,--p)*parseInt(d,b),p=c.length)
document.write("<pre>"+
[ [ 123456, 10 ], [ 11, 2 ], [ 727, 20 ], [ 101, 10 ] ]
.map(c=>c+" => "+f(c[0])(c[1])).join`\n`)

JavaScript, 75 byte

(a,b)=>[...a.toString(b)].reverse().map(($,_)=>Math.pow(b,_)*parseInt($,b))

Solo per divertimento :) Potrebbe essere più giocato a golf, ma non sono troppo sicuro di come.

ES7, 66 byte

Se ES7 è consentito, allora:

(a,b)=>[...a.toString(b)].reverse().map(($,_)=>b**_*parseInt($,b))

O , 17 byte

jQb`S/l{#Qn^*p}d

Due note:

1. Il terzo caso di test non funziona a causa di un bug con la conversione di base. Vedi fase / o # 68 .

2. Questo non funziona nell'interprete online. bnon era ancora stato implementato.

> <>, 28 byte

:&\
&*>:{:}$%:n$}-:0=?;ao$&:

Si aspetta che i valori di input siano presenti nello stack all'avvio del programma.

Poiché> <> non ha oggetti elenco, l'output viene presentato come un elenco di valori separato da nuova riga, con le "unità" sulla prima riga. Una corsa di esempio:

Input: 
11 2

Ouput:
1
2
0
8

@OP, se questo non è un formato di output accettabile, fammi sapere e modificherò la risposta di conseguenza.

PHP, 55 byte

Utilizza la codifica Windows-1252.

for($n=$argv[1];$d+$n-=$d=$n%$argv[2]**++$i;)echo$d,~Ó;

Esegui in questo modo ( -daggiunto solo per l'estetica):

php -d error_reporting=30709 -r 'for($n=$argv[1];$d+$n-=$d=$n%$argv[2]**++$i;)echo$d,~Ó; echo"\n";' 123056 10

C #, 77 byte

IEnumerable _(int n,int b){int m=1;while(n>0){yield return n%b*m;n/=b;m*=b;}}

In realtà, 17 byte (non concorrenti)

;a¡;lrR(♀ⁿ@♂≈♀*;░

Provalo online!

Questa presentazione non è competitiva perché il ♀comando è stato aggiunto dopo questa sfida.

Spiegazione:

;a¡;lrR(♀ⁿ@♂≈♀*;░
                   initial stack: [b n] (b = base, n = number)
;                  dupe b
 a                 invert stack
  ¡                n as a base-b integer
   ;lrR            dupe, length, range, reverse
       (♀ⁿ         raise b to each power in range
          @♂≈      create list of integers from base-b string
             ♀*    pairwise multiplication
               ;░  filter out zeroes

Pip , 13 byte

Wa-:Pa%oo*:b

Farlo alla vecchia maniera si è rivelato più breve rispetto all'utilizzo TBdell'operatore di conversione di base. Il codice esegue un ciclo while fino a quando a(il numero) è 0. Ad ogni iterazione, lo stampa a%oe lo sottrae a. oviene preinizializzato 1e moltiplicato per b(la base) per ogni iterazione. (Questo approccio mantiene tutti i 0secondi e aggiunge anche un vantaggio 0.)

Provalo online!