Dans une longue multiplication , après avoir multiplié les nombres, vous vous retrouvez avec les produits partiels, dans ce défi, vous sortirez ces produits partiels.

Parce que la multiplication longue est longue, pour compenser votre code devra être aussi court que possible.

Exemples

34, 53
102, 1700

48, 38 
384, 1440

361, 674
1444, 25270, 216600

0, 0
0

1, 8
8

Caractéristiques

• L'entrée / sortie peut être dans n'importe quel format raisonnable tel qu'un tableau, une chaîne séparée par des virgules (ou tout autre délimiteur qui n'est pas un chiffre), une liste, des arguments de fonction, etc.
• Les produits partiels doivent être en ordre croissant.
• S'il s'agit d'un produit partiel 0, vous pouvez choisir de le sortir ou non.

C'est le code-golf donc le code le plus court en octets gagne!

Gelée, 10 octets

DU×µLR’⁵*×

Essayez-le en ligne!

Comment ça fonctionne

DU×µLR’⁵*×  Left argument: multiplier -- Right argument: multiplicant

D           Convert the multiplier to base 10 (array of digits).
 U          Reverse the array.
  ×         Multiply each digit by the multiplicant.
   µ        Begin a new, monadic chain. Argument: A(array of products)
    L       Get the length of A.
     R      Turn length l into [1, ..., l].
      ’     Decrement to yield [0, ..., l-1].
       ⁵*   Compute 10**i for each i in that range.
         ×  Hook; multiply the powers of ten by the corresponding elements of A.

Pyth, 12 octets

.e**Qsb^Tk_w

Suite de tests

Prend la nouvelle ligne d'entrée séparée, par exemple

361
674

Explication:

.e**Qsb^Tk_w
                Implicit: Q = eval(input()),T = 10
           w    Input the second number as a string.
          _     Reverse it.
.e              Enumerated map, where b is the character and k is the index.
     sb         Convert the character to an int.
   *Q           Multiply by Q.
  *    ^Tk      Multiply by T ^ k. (10 ^ index)

JavaScript (ES7), 48 octets

(a,b)=>[...b+""].reverse().map((d,i)=>10**i*a*d)

ES6 (56 octets)

(a,b)=>[...b+""].reverse().map((d,i)=>a*d+"0".repeat(i))

Explication

Renvoie un tableau de produits partiels sous forme de nombres.

(a,b)=>
  [...b+""]    // convert the multiplier to an array of digits
  .reverse()   // reverse the digits of the multiplier so the output is in the right order
  .map((d,i)=> // for each digit d of the multiplier
    10**i      // get the power of ten of the digit
      *a*d     // raise the product of the digit to it
  )

Tester

Testez les utilisations Math.powau lieu de **pour le faire fonctionner dans les navigateurs standard.

var solution = (a,b)=>[...b+""].reverse().map((d,i)=>Math.pow(10,i)*a*d)

A = <input type="text" id="A" value="361" /><br />
B = <input type="text" id="B" value="674" /><br />
<button onclick="result.textContent=solution(+A.value,+B.value)">Go</button>
<pre id="result"></pre>

Lua, 72 68 octets

b=arg[2]:reverse()for i=1,#b do print(arg[1]*b:sub(i,i)*10^(i-1))end

APL, 21 octets

{⍺×x×10*1-⍨⍳≢x←⊖⍎¨⍕⍵}

Il s'agit d'une fonction dyadique qui accepte des entiers à gauche et à droite et renvoie un tableau. Pour l'appeler, affectez-le à une variable.

Explication:

             x←⊖⍎¨⍕⍵} ⍝ Define x to be the reversed digits of the right input
     10*1-⍨⍳≢         ⍝ Generate all 10^(1-i) for i from 1 to the number of digits
{⍺×x×                 ⍝ Multiply the right input by the digits and the powers of 10

05AB1E , 15 octets

Code:

VDgUSXFTNmY**=\

Explication:

VDgUSXFTNmY**=\

V                 # Assign the input to Y
 D                # Duplicate of input, because the stack is empty
  g               # Pushes the length of the last item
   U              # Assign the length to X
    S             # Split the last item
     X            # Pushes X (length of the last item)
      F           # Creates a for loop: for N in range(0, X)
       TNm        # Pushes 10 ^ N
          Y       # Pushes Y (first input)
           *      # Multiplies the last two items
            *     # Multiplies the last two items
             =    # Output the last item
              \   # Discard the last item

Pyth, 26 octets

DcGHKjHTFNJlK*G*@Kt-JN^TN

Cela définit une fonction ctelle qu'elle accepte des 2arguments et la fonction imprime les produits partiels.

DcGHKjHTFNJlK*G*@Kt-JN^TN
DCGH                      Define function c(G, H)
    KjHT                  Set K to the list of digits converting H to base 10
        FNJlK             Set J to the length of K and loop with variable N
                          (Implicit: print)
             *G*@Kt-JN    Calculates the partial product
                      ^TN Raising it to the appropriate power of 10

MATL , 18 octets

ij48-tn:1-P10w^**P

Le compilateur (5.1.0) fonctionne dans Matlab et dans Octave.

Chaque numéro est entré sur une ligne distincte.

Exemple

>> matl ij48-tn:1-P10w^**P
> 361
> 674
1444  25270 216600

Explication

i           % input first number (say 361)
j           % input second number, interpreted as a string (say '674')
48-         % subtract '0' to obtain vector of figures (gives [6 7 4])
tn:1-P      % vector [n-1, ... 1, 0] where n is the number of figures (gives [2 1 0])
10w^        % 10 raised to that, element-wise (gives [100 10 1])
*           % multiply, element-wise (gives [600 70 4])
*           % multiply (gives 361*[600 70 4], or [216600 25270 1444])
P           % flip vector ([1444 25270 216600]). Implicitly display

Haskell, 60 57 54 octets

g x=zipWith(\b->(x*10^b*).read.pure)[0..].reverse.show

5 octets de moins (déposez le .show) si je peux prendre le deuxième nombre sous forme de chaîne.

Exemple d'utilisation: g 361 674-> [1444,25270,216600].

Multipliez chaque chiffre de l'inverse de yavec xet mettez à l'échelle 10^ioù i = 0,1,2,....

Edit: Merci à @Mauris pour 3 octets!

Julia, 50 49 octets

f(a,b)=[a*d*10^~-i for(i,d)=enumerate(digits(b))]

Il s'agit d'une fonction qui accepte deux entiers et renvoie un tableau d'entiers.

La digitsfonction renvoie un tableau des chiffres de l'entier d'entrée dans l'ordre inverse. Nous obtenons l'index, les paires de valeurs en utilisant enumerateet calculons les produits partiels comme la première entrée multipliée par les chiffres multipliés par 10 augmentée à la puissance de l'index du chiffre - 1.

Enregistré un octet grâce à Dennis!

Python 2, 61

def p(a,b):
 j=0
 while b>0:
  print`b%10*a`+j*'0';b/=10;j+=1 

CJam, 19 ans 17 octets

q~W%eef{~~A@#**}p

Prend l'entrée avec le premier élément étant un entier et le second une chaîne (par exemple 34 "53" ). Les suggestions sont les bienvenues, car je suis sûr qu'elles peuvent être plus courtes. Merci à Dennis d'avoir économisé deux octets.

Essayez-le en ligne.

Explication

q~    e# Get input and evaluate it, x and "y"
W%    e# Reverse y so it will be properly sorted
ee    e# Enumerate through y with each character and its index
f{    e# For each digit in y...
  ~~  e# Convert the digit to an integer on the stack
  A@# e# Take 10 to the power of y's index
  **  e# Multiply all three together to get the final result
}
p     e# Print the array

Haskell, 37 octets

a%0=[]
a%b=b`mod`10*a:(a*10)%div b 10

Pas de stringification, juste de l'arithmétique. Ajoute récursivement le plus petit produit partiel au reste, où le dernier chiffre de best tronqué et un multiplicateur de 10 est appliqué. La priorité de l'opérateur fonctionne bien.

𝔼𝕊𝕄𝕚𝕟, 11 caractères / 23 octets (non concurrentiel)

ᴙíⓢⓜî*$*Ⅹⁿ_

Try it here (Firefox only).

Trouvé un bug lors du codage de la solution à ce problème ...

Explication

          // Implicit: î = input 1, í = input 2
ᴙíⓢ      // reverse í and split it into an array
ⓜî*$*Ⅹⁿ_ // multiply î by each individual digit in í and put in previous array
          // implicit output

Japt , 28 octets

I=[]Vs w m@IpApY+1 /A*U*X};I

Explication:

I=[]Vs w m@IpApY+1 /A*U*X};I
I=[]                         //that's simple, init an array I
    Vs                       //take the second input and convert to string
       w                     //reverse it and...
         m@              }   //...map through the chars; X is a char, Y is counter
           Ip............    //push the following value into I...
             ApY+1 /A*U*X    //10^(Y+1)/10*U*X, U is the first input
                           I //output the resulting array

Python 2, 42 octets

f=lambda a,b:b*[0]and[b%10*a]+f(a*10,b/10)

Pas de stringification, juste de l'arithmétique. Ajoute récursivement le plus petit produit partiel au reste, où le dernier chiffre de best tronqué et un multiplicateur de 10 est appliqué.