En la multiplicación larga , después de multiplicar los números, te quedan los productos parciales, en este desafío obtendrás esos productos parciales.

Debido a que la multiplicación larga es larga, para compensar su código tendrá que ser lo más corto posible.

Ejemplos

34, 53
102, 1700

48, 38 
384, 1440

361, 674
1444, 25270, 216600

0, 0
0

1, 8
8

Especificaciones

• La entrada / salida puede estar en cualquier formato razonable, como matriz, cadena separada por comas (o cualquier otro delimitador que no sea un dígito), lista, argumentos de función, etc.
• Los productos parciales deben estar en orden creciente.
• Si es un producto parcial 0, puede elegir si desea generarlo o no.

Este es el código de golf, ¡el código más corto en bytes gana!

Jalea, 10 bytes

DU×µLR’⁵*×

Pruébalo en línea!

Cómo funciona

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 bytes

.e**Qsb^Tk_w

Banco de pruebas

Toma entrada nueva línea separada, por ejemplo

361
674

Explicación:

.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 bytes

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

ES6 (56 bytes)

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

Explicación

Devuelve una matriz de productos parciales como números.

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

Prueba

La prueba se usa en Math.powlugar de **hacerlo funcionar en navegadores estándar.

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 bytes

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

APL, 21 bytes

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

Esta es una función diádica que acepta enteros a la izquierda y a la derecha y devuelve una matriz. Para llamarlo, asígnelo a una variable.

Explicación:

             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 bytes

Código:

VDgUSXFTNmY**=\

Explicación:

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 bytes

DcGHKjHTFNJlK*G*@Kt-JN^TN

Esto define una función ctal que acepta 2argumentos, y la función imprime los productos parciales.

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 bytes

ij48-tn:1-P10w^**P

El compilador (5.1.0) funciona en Matlab y en Octave.

Cada número se ingresa en una línea separada.

Ejemplo

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

Explicación

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 bytes

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

5 bytes menos (suelte el .show) si puedo tomar el segundo número como una cadena.

Ejemplo de uso: g 361 674-> [1444,25270,216600].

Multiplica cada dígito del reverso de ycon xy escala con 10^idónde i = 0,1,2,....

Editar: ¡Gracias a @Mauris por 3 bytes!

Julia, 50 49 bytes

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

Esta es una función que acepta dos enteros y devuelve una matriz de enteros.

La digitsfunción devuelve una matriz de dígitos del entero de entrada en orden inverso. Obtenemos el índice, los pares de valores usando enumeratey calculamos los productos parciales como la primera entrada multiplicada por los dígitos multiplicados por 10 elevado a la potencia del índice del dígito - 1.

¡Ahorré un byte gracias a Dennis!

Pitón 2, 61

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

CJam, 19 17 bytes

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

Toma entrada con el primer elemento como un entero y el segundo como una cadena (por ejemplo 34 "53") Las sugerencias son bienvenidas, ya que estoy seguro de que puede ser más corto. Gracias a Dennis por guardar dos bytes.

Pruébalo en línea.

Explicación

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 bytes

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

Sin encordado, solo aritmética. Precede recursivamente el producto parcial más pequeño al resto, donde bse trunca el último dígito de y se aplica un multiplicador de 10. La precedencia del operador funciona bien.

𝔼𝕊𝕄𝕚𝕟, 11 caracteres / 23 bytes (no competitivo)

ᴙíⓢⓜî*$*Ⅹⁿ_

Try it here (Firefox only).

Encontró un error al codificar la solución a este problema ...

Explicación

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

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

Explicación:

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 bytes

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

Sin encordado, solo aritmética. Agrega recursivamente el producto parcial más pequeño al resto, donde bse trunca el último dígito de y se aplica un multiplicador de 10.