Bei der langen Multiplikation bleiben nach der Multiplikation der Zahlen die Teilprodukte übrig, bei dieser Herausforderung geben Sie diese Teilprodukte aus.

Da eine lange Multiplikation lang ist, muss der Code zum Ausgleich so kurz wie möglich sein.

Beispiele

34, 53
102, 1700

48, 38 
384, 1440

361, 674
1444, 25270, 216600

0, 0
0

1, 8
8

Spezifikationen

• Die Eingabe / Ausgabe kann in jedem vernünftigen Format erfolgen, z. B. in Form eines Arrays, einer durch Kommas getrennten Zeichenfolge (oder einem anderen Trennzeichen, das keine Ziffer ist), einer Liste, Funktionsargumenten usw.
• Teilprodukte müssen in aufsteigender Reihenfolge sein.
• Wenn es sich um ein Teilprodukt handelt 0, können Sie wählen, ob Sie es ausgeben möchten oder nicht.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Gelee, 10 Bytes

DU×µLR’⁵*×

Probieren Sie es online!

Wie es funktioniert

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

Testsuite

Nimmt Eingabe-Newline getrennt, z

361
674

Erläuterung:

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

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

Erläuterung

Gibt ein Array von Teilprodukten als Zahlen zurück.

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

Prüfung

Test verwendet, Math.powanstatt **es in Standard-Browsern zum Laufen zu bringen.

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←⊖⍎¨⍕⍵}

Dies ist eine dyadische Funktion, die Ganzzahlen links und rechts akzeptiert und ein Array zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Erläuterung:

             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

Code:

VDgUSXFTNmY**=\

Erläuterung:

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

Dies definiert eine Funktion cso, dass sie 2Argumente akzeptiert und die Funktion die Teilprodukte druckt.

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

Der Compiler (5.1.0) arbeitet in Matlab und in Octave.

Jede Nummer wird in einer separaten Zeile eingegeben.

Beispiel

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

Erläuterung

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 weniger (drop the .show), wenn ich die zweite Zahl als String nehmen kann.

Anwendungsbeispiel: g 361 674-> [1444,25270,216600].

Multiplizieren Sie jede Ziffer auf der Rückseite ymit xund skalieren Sie mit 10^iwo i = 0,1,2,....

Edit: Danke an @ Mauris für 3 Bytes!

Julia, 50 49 Bytes

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

Dies ist eine Funktion, die zwei ganze Zahlen akzeptiert und ein ganzzahliges Array zurückgibt.

Die digitsFunktion gibt ein Array der Ziffern der eingegebenen Ganzzahl in umgekehrter Reihenfolge zurück. Wir erhalten den Index und die Wertepaare unter Verwendung enumerateund Berechnung der Teilprodukte als erste Eingabe , multipliziert mit den Ziffern mal 10, die zur Potenz des Ziffernindex - 1 erhoben werden.

Dank Dennis ein Byte gespart!

Python 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

Nimmt Eingaben vor, wobei das erste Element eine Ganzzahl und das zweite eine Zeichenfolge ist (z 34 "53". B. ). Vorschläge sind willkommen, da sie sicherlich kürzer sein können. Vielen Dank an Dennis für das Speichern von zwei Bytes.

Probieren Sie es online aus.

Erläuterung

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

Kein Aufreihen, nur Rechnen. Das kleinste Teilprodukt wird dem Rest rekursiv vorangestellt, wobei die letzte Ziffer von babgeschnitten wird und ein Multiplikator von 10 angewendet wird. Die Operator-Rangfolge funktioniert gut.

𝔼𝕊𝕄𝕚𝕟, 11 Zeichen / 23 Byte (nicht wettbewerbsfähig)

ᴙíⓢⓜî*$*Ⅹⁿ_

Try it here (Firefox only).

Beim Codieren der Lösung für dieses Problem wurde ein Fehler gefunden ...

Erläuterung

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

Erläuterung:

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)

Kein Aufreihen, nur Rechnen. Hängt das kleinste Teilprodukt rekursiv an den Rest an, wobei die letzte Ziffer von babgeschnitten und ein Multiplikator von 10 angewendet wird.