In uzun çarpma , sayılar çarpılarak sonra, size çıkış o kısmi ürünler olacak bu mücadelede, kısmi ürünlerle bırakılır.

Uzun çarpma uzun olduğundan, kodunuzu telafi etmek için olabildiğince kısa olması gerekir.

Örnekler

34, 53
102, 1700

48, 38 
384, 1440

361, 674
1444, 25270, 216600

0, 0
0

1, 8
8

Özellikler

• Girdi / Çıktı, dizi, virgülle ayrılmış dize (veya basamak olmayan herhangi bir sınırlayıcı), liste, işlev bağımsız değişkenleri vb. Gibi makul bir biçimde olabilir.
• Kısmi ürünler artan sırada olmalıdır.
• Kısmi bir ürünse 0, çıktısını almak isteyip istemediğinizi seçebilirsiniz.

Bu kod golf bayt en kısa kodu kazanır!

Jöle, 10 bayt

DU×µLR’⁵*×

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

.e**Qsb^Tk_w

Test odası

Girdi satırsonunu ayırır, örn.

361
674

Açıklama:

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

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

ES6 (56 bayt)

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

açıklama

Kısmi ürün dizisini sayı olarak döndürür.

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

Ölçek

Test, standart tarayıcılarda çalışmasını sağlamak Math.powyerine kullanır **.

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 Bayt

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

APL, 21 bayt

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

Bu, sol ve sağdaki tam sayıları kabul eden ve bir dizi döndüren ikili bir işlevdir. Bunu çağırmak için bir değişkene atayın.

Açıklama:

             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 bayt

Kod:

VDgUSXFTNmY**=\

Açıklama:

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 bayt

DcGHKjHTFNJlK*G*@Kt-JN^TN

Bu, bir işlevi bağımsız değişkenleri ckabul edecek şekilde tanımlar 2ve işlev kısmi ürünleri yazdırır.

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 bayt

ij48-tn:1-P10w^**P

Derleyici (5.1.0) Matlab ve Octave çalışır.

Her sayı ayrı bir satıra girilir.

Misal

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

açıklama

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 bayt

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

.showİkinci sayıyı dize olarak alabilirsem 5 bayt daha az (bırak ).

Kullanım örneği: g 361 674 ->[1444,25270,216600] .

Bir ters çarpın her basamak yilex birlikte ve ölçek10^ii = 0,1,2,... .

Düzenleme: @Mauris'e 3 bayt için teşekkürler!

Julia, 50 49 bayt

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

Bu, iki tamsayıyı kabul eden ve bir tamsayı dizisi döndüren bir işlevdir.

digitsİşlev tersten giriş tamsayı en basamak dizisi döndürür. Biz endeksi, değer çiftlerini kullanarak olsunenumerate alırız ve kısmi ürünleri ilk giriş sayısı olarak basamak sayısı 10'un basamağın indeksinin gücüne yükseltilmiş olarak hesaplar - 1.

Dennis sayesinde bir bayt kurtardı!

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 bayt

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

İlk öğe bir tamsayı ve ikincisi bir dize (örn. 34 "53") Olacak şekilde girdi alır . Daha kısa olabileceğinden emin olduğum için öneriler bekliyoruz. Dennis'e iki bayt kaydettiği için teşekkürler.

Çevrimiçi deneyin.

açıklama

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 bayt

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

Dizgi yok, sadece aritmetik. En küçük kısmi ürünü, son basamağının bkesildiği ve 10 çarpanının uygulandığı geri kalan kısmına yinelemeli olarak ekler . Operatör önceliği iyi çalışıyor.

𝔼𝕊𝕄𝕚𝕟, 11 karakter / 23 bayt (rekabetçi değil)

ᴙíⓢⓜî*$*Ⅹⁿ_

Try it here (Firefox only).

Bu sorunun çözümünü kodlarken bir hata buldum ...

açıklama

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

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

Açıklama:

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 bayt

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

Dizgi yok, sadece aritmetik. En küçük kısmi ürünü, son basamağının bkesildiği ve 10'un bir çarpanının uygulandığı geri kalan kısmına tekrar tekrar ekler .