Votre tâche consiste à décomposer un nombre en utilisant le format ci-dessous.

Ceci est similaire à la conversion de base, sauf qu'au lieu de répertorier le digitsdans la base, vous répertoriez le values, de sorte que la liste s'additionne à l'entrée.

Si la base donnée est n, alors chaque numéro de la liste doit être sous la forme de k*(n**m), où 0<=k<net mest unique dans la liste.

Spécifications

• Tout format d'entrée / sortie raisonnable. Votre programme / fonction prend 2 entrées et sort une liste.
• La liste de sortie peut être dans n'importe quel ordre.
• 0 peut être exclu ou inclus.
• Les premiers 0sont autorisés.
• Les fonctions intégrées sont autorisées .

Cas de 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]

Notation

C'est du code-golf . La solution la plus courte en octets gagne.

Gelée , 7 octets

lr0⁹*×b

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

Comment ça fonctionne

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 octets

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

Gelée, 12 octets

bLR’*@€U
b×ç

Peut être waaaay plus court ...

Essayez-le en ligne!

Pyth - 12 11 octets

Juste un FGITW, peut être plus court.

.e*b^Qk_jEQ

Suite de tests .

J, 20 19 octets

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

Usage

   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

Explication

[(]*(^<:@#\.))#.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 octets

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

Un bloc sans nom qui attend la base et le numéro en haut de la pile (dans cet ordre) et les remplace par la liste des chiffres (y compris les zéros internes, sans zéros non significatifs).

Testez-le ici.

Explication

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 octets

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

Python 2, 44 octets

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

Sorties du moins significatif au plus, avec de nombreux zéros supplémentaires.

Pour produire du plus significatif au moins:

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

Recurse, en supprimant à plusieurs reprises des chiffres navec divmod tout en augmentant le multiplicateur de valeur de position c.

Rubis, 35 34 octets

Ceci est un port de réponse Python xnor , mais il imprime nparfois si le cas de test 727 20imprime 7, 320, 400et 724 0s. Suggestions de golf bienvenues.

Edit: 1 octet grâce à Jordan.

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

Mathematica, 12 octets (non concurrent)

Je me demande si Wolfram Research a créé cette fonction après avoir vu le défi du PO!

NumberExpand

Cela a été introduit dans la version 11.0 (août 2016).

Mathematica, 46 octets

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

Explication:

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

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

Dans [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

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

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

Raquette, 82 octets

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

Je suis un gagnant (!)

JavaScript (ES7), 68 octets

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

Tester

Tester les utilisations Math.powpour la compatibilité du navigateur.

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 octets

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

Juste pour le plaisir :) Il pourrait être plus joué au golf, mais je ne sais pas trop comment.

ES7, 66 octets

Si ES7 est autorisé, alors:

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

O , 17 octets

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

Deux notes:

1. Le troisième cas de test ne fonctionne pas en raison d'un bogue avec la conversion de base. Voir phase / o # 68 .

2. Cela ne fonctionne pas dans l'interpréteur en ligne. bn'avait pas encore été mis en œuvre.

> <>, 28 octets

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

Attend que les valeurs d'entrée soient présentes sur la pile au démarrage du programme.

Comme> <> n'a pas d'objets de liste, la sortie est présentée comme une liste de valeurs séparées par des sauts de ligne, avec les «unités» sur la première ligne. Un exemple de course:

Input: 
11 2

Ouput:
1
2
0
8

@OP, si ce n'est pas un format de sortie acceptable, faites-le moi savoir et je modifierai la réponse en conséquence.

PHP, 55 octets

Utilise l'encodage Windows-1252.

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

Courez comme ceci ( -dajouté pour l'esthétique uniquement):

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 octets

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

En fait, 17 octets (non concurrents)

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

Essayez-le en ligne!

Cette soumission n'est pas en concurrence car la ♀commande a été ajoutée après ce défi.

Explication:

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

Wa-:Pa%oo*:b

Le faire à l'ancienne s'est avéré être plus court que d'utiliser l' TBopérateur de conversion de base. Le code exécute une boucle while jusqu'à ce que a(le nombre) soit 0. À chaque itération, il l'imprime a%oet le soustrait a. oest préinitialisé 1et multiplié par b(la base) à chaque itération. (Cette approche conserve tous les 0s et ajoute également un leader 0.)

Essayez-le en ligne!