Big integer multiplication

Question

Your challenge (if you choose to accept it) is to implement big integer multiplication in the shortest code possible.

Rules:

• Take two integers (decimal form) as ASCII strings from the command line parameters of your program. If your language doesn't support command line parameters, I'll accept stdin or similar input mechanisms.
• Output should be in ASCII decimal form, via a standard output mechanism (e.g. stdout)
• Must support both positive and negative integers, as well as zero.
• Must support any length integer integers up to 2**63 characters long, or at least the maximum you can store in memory.
• You may not use any in-built classes or functionality that handles big integers.
• The largest data type you may use is a 64-bit unsigned integer.
• You may not use floating point operations.
• You do not have to implement checks for valid inputs.

Example:

> multiply.exe 1234567890 987654321
1219326311126352690

Enjoy :)

Answer 1

APL (124 120 116)

This is way too long. It does grade school multiplication.

N←{↓⌽↑⌽¨⍵}⋄S↓'-',A/⍨∨\×A←{∨/M←9<T←0,⍵:∇(1⌽M)+T-M×10⋄⍵}⊃+/N↑⍨⌿2L⍴E,(L-1)+⍳L←⊃⍴E←⌽Y∘ר⊃X Y←N⍎¨¨A~¨'-'⊣S←1≠+/'-'∊¨A←⍞⍞

Explanation:

• N←{↓⌽↑⌽¨⍵}: N is a function that, given a vector of vectors, makes all the vectors the same length, padding with zeroes at the front. It does this by reversing all inner vectors (⌽¨), turning the vector of vectors into a matrix (↑), reversing this matrix (⌽), and turning it back into a vector of vectors (↓).
• S←1≠+/'-'∊¨A←⍞⍞: Read two lines of input, as characters (⍞⍞), store them in A, and count how many minuses there are in the input. S is zero or one depending on whether the result will be positive.
• X Y←N⍎¨¨A~¨'-': In A (our input) without (~) the minuses, evaluate each separate character (⍎¨¨), run it through the N function and save the two vectors in X and Y. If the input was 123 32, we now have X=1 2 3 Y=0 3 2.
• L←⊃⍴E←⌽Y∘ר⊃X Y: For each digit in the first vector, produce a vector with the digits from the second vector multiplied by that digit. Reverse this vector of vectors so that the least significant one is at the front. Store this vector in E and its length in L.
• +/N↑⍨⌿2L⍴E,(L-1)+⍳L: Shift all of these vectors left, padding with zeroes on the right, by their index. Run them through N again so that they're all the same length. Then add all these vectors together. I.e.:

       1 2 3
         3 2
      ------
       2 4 6 (shift 0)
     3 6 9   (shift 1)
    --------
    3 8 13 6 (before carry)
     3 9 3 6 (after carry)

• A←{∨/M←9<T←0,⍵:∇(1⌽M)+T-M×10⋄⍵}: Carry the ones. As long as there are still 'digits' higher than 10 (∨/M←9<T←0,⍵), add one to the next significant digit (∇(1⌽M)+T) and remove 10 from the offending digit (-M×10).
• '-',A/⍨∨\×A: Remove any leading zeroes from the result vector, and add a minus in front.
• S↓: Remove S characters from the front, i.e. if the result is supposed to be positive then remove the minus again.

Answer 2

Javascript, 147 chars

a=prompt(b=prompt(j=c=[]))
for(i=a.length;j--||(j=b.length,n=0,i--);)c[i+j]=(n=~~c[i+j]+n/10+~~b[j-1]*~~a[i]|0)%10
" -"[10>a[0]^10>b[0]]+c.join("")

Answer 3

Scala 567 519

type I=List[Long]
type S=String
object C extends App{
def g(l:I,s:I=Nil,i:Long=0L):I=if(l.isEmpty)(i/10::i%10::s).dropWhile(_==0)else
g(l.tail,(l(0)+i)%10::s,(l(0)+i)/10)
def m(p:S,q:S)=g((p.reverse.zipWithIndex.map{a=>q.reverse.zipWithIndex.map(b=>((""+a._1).toLong*(""+ b._1).toLong,a._2+b._2))}.flatten.groupBy(_._2).map(m=>(m._1,m._2.map(_._1)sum))).toList.sortBy(_._1).map(_._2)).mkString
def f(s:S,t:S)=(if((s+t).matches("[^-]*-[^-]*"))"-"else"")+m(s.filter(_!='-'),t.filter(_!='-'))
println(f(args(0),args(1)))
}

updated: Use some Longs for intermediate values, while in fact long Ints passed as Strings can't exceed the length of Int.MaxValue.

Far away from the APL-range, this compilable Scala code multiplies 2 ints of 100digits in about a second on a 7 y'o machine.

I have an ungolfed version which doesn't work :) . Method m seemed to work with a loop, but only because for some map sizes, the map was sorted in the way the g-Method expected the values.

Of course I can sort it, but then I got problems with leading/trailing zeros, or 1-digit values. I tried with ("12345").map in the REPL, and it worked quickly, so I made a test how far I could golf the loop-version, and got nearly the same result - 143 chars here, 145 chars there, so I took my working solution.

So how does the code work: 3 methods:

• f) evaluate sign with regex, to append it in the end, and remove the - when calling b)
• m) zips both Strings with indexes, mupltiplies each digit with each and sums their indexes. Then groups by index sum, sorts by index sum, sums the values therein. Hands the List of values to c)
• g) takes the number, and keeps the last digit. Divides the rest and adds it to the head of the rest of the list, which gets proceeded the same way until empty.

From the REPL, multiplying 1234567890 987654321 The first column from below shows the result digit calculated, except the leading digit which is the overflow from the last computation, and is in column 2.

Replaying:
sum((p.reverse.zipWithIndex.map{a=>q.reverse.zipWithIndex.map(b=>((""+a._1).toInt*(""+ b._1).toInt,a._2+b._2))}.flatten.groupBy(_._2).map(m=>(m._1,m._2.map(_._1)sum))).toList.sortBy(_._1).map(_._2)).mkString.reverse
    0  : 0  ::  List(9, 26, 50, 80, 115, 154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    9  : 0  ::  List(26, 50, 80, 115, 154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    6  : 2  ::  List(50, 80, 115, 154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    2  : 5  ::  List(80, 115, 154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    5  : 8  ::  List(115, 154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    3  : 12  ::  List(154, 196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    6  : 16  ::  List(196, 240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    2  : 21  ::  List(240, 285, 240, 196, 154, 115, 80, 50, 26, 9)
    1  : 26  ::  List(285, 240, 196, 154, 115, 80, 50, 26, 9)
    1  : 31  ::  List(240, 196, 154, 115, 80, 50, 26, 9)
    1  : 27  ::  List(196, 154, 115, 80, 50, 26, 9)
    3  : 22  ::  List(154, 115, 80, 50, 26, 9)
    6  : 17  ::  List(115, 80, 50, 26, 9)
    2  : 13  ::  List(80, 50, 26, 9)
    3  : 9  ::  List(50, 26, 9)
    9  : 5  ::  List(26, 9)
    1  : 3  ::  List(9)
    2  : 1  ::  List()
    res45: String = 1219326311126352690

...321 * ...890 leads to

index   Product of 
sum     Digits
0 =>             1*0 =>      0 => 0 
1 =>       2*0 + 1*9 =>    0+9 => 9 
2 => 3*0 + 2*9 + 1*8 => 0+18+8 =>26 

Ungolfed version:

object BigMul extends App {
   // i is the overrun from the previous value 
  def oSum (l: List[Int], sofar: List[Int] = Nil, i: Int=0): List[Int] = {
    /*
    println (sofar + " <- " + (i/10) + "  : " + (({
        if (l.isEmpty) 0 else l.head} +i) %10) + "  ::  " + {
      if (l.isEmpty) "()" else l.tail} )
    */
    if (l.isEmpty) (i / 10 :: i%10 :: sofar).dropWhile (_==0)  else 
    oSum (l.tail, (l.head + i) % 10 :: sofar, (l.head + i) / 10) 
  }

  // works, but not really ungolfed:
  /* well, yes, this is mapple-di-map
  def mul (p:String,q:String)=
    osum ((p.reverse.zipWithIndex.map {a=>
          q.reverse.zipWithIndex.map (b=>
       (("" + a._1).toInt * ("" + b._1).toInt, a._2 + b._2))}.
       flatten.groupBy (_._2).map (m=>
         (m._1, m._2.map (_._1)sum))).
         toList.sortBy (_._1).map (_._2)).mkString
  */
  // buggy version, but nearly there:
  def mul (s: String, t: String) = {
    val li = for (i <- (s.size -1 to 0 by -1);
      j <- (t.size -1 to 0 by -1);
       a=("" + s(i)).toInt;
      b=("" + t(j)).toInt) 
        yield (a*b, i + j) 
    osum ((li groupBy (_._2)).toList.sortBy (_._1).
      map (_._2.map (_._1).sum)).
      init.mkString.reverse+"0"
  }

  def signedMul (s: String, t: String) = (s(0), t(0)) match {
    case ('-', '-') => mul (s.tail, t.tail)
    case ('-',   _) => "-"+ mul (s.tail, t) 
    case (  _, '-') => "-"+ mul (s, t.tail) 
    case (  _,   _) => mul (s, t) 
  }

  println (signedMul (args (0), args (1)))
}

Answer 4

C# 619 585

using System.Linq;class P{static void Main(string[] a){var p=new P();string m=p.S(a[0]),n=p.S(a[1]);var l=m.Length+n.Length;var r=p.s+p.C(Enumerable.Range(0,l).Reverse().Select(j=>n.Reverse().Select((y,i)=>(p.C(m.Reverse().Select(z=>(y-48)*(z-48)).ToArray())+new string('0',i)).PadLeft(l,'0')).Select(s=>s[j]-48).Sum()).ToArray()).TrimStart('0');System.Console.WriteLine(r!=""?r:"0");}string C(int[]e){var i=0;var r="";foreach(var z in e.Select(z=>z+i)){i=z/10;r=z%10+r;}return i+r;}string s="";string S(string a){if(!a.StartsWith("-"))return a;s=s==""?"-":"";return a.Substring(1);}}

Test link: http://ideone.com/ghY9G0 (with a small modification: in ideone the input is taken from stdin, as I don't think it's possible to pass command line args).

Answer 5

GolfScript, 117 chars

-1%" "/~0{1$)\;45={)2%\);\}*}:l~@\l@@""\{15&2$0\{15&2$*+@.!{"\0"+}*(@+@\.10/\10%}%[\](\+@;\;\0\+\}/\;{`+}*\{"-"+}*-1%

Two numbers (optional '-'-sign is supported) separated by space must be given on STDIN. Unfortunately the result printed to STDOUT may have leading zeros.

It is a direct approach implemented in golfscript so it should still be possible to golf this program further.

Answer 6

Python, 327

This is utterly terrible. Utterly utterly terrible. I could probably tighten it up (performance- and golf-wise) by implementing proper addition. Instead, I use successive addition & subtraction, brainfuck style. UTTERLY. TERRIBLE. But I guarantee I never blow the 64-bit limit, unlike some other solutions I'm not going to mention. (only... I already commented on them, and I think I just mentioned them)

import sys
a,b=sys.argv[1:]
s=a[0]<'0'
t=b[0]<'0'
a=a[s:][::-1]
b=b[t:][::-1]
a,b=(map(int,x)for x in(a,b))
def x(c,y,r):
 k=0
 while not-1<c[k]-y<10:c[k]=r;k+=1
 c[k]-=y
 if c[-1]<1:c.pop()
e=[]
a*=1-([0]in(a,b))
while a:
 x(a,1,9);d=b[:]
 while d:x(d,1,9);e+=[0];x(e,-1,0)
print'-'*(s^t)+''.join(map(str,e[::-1]+[0]*(e==[])))

Answer 7

Python, 174 Chars (Positive Only)

import sys
a,b=sys.argv[1:]
l=len(a+b)
x=map(int,a[::-1]+'0'*l+b)
i=r=0
t=""
while i<l:r+=sum(x[i-j]*x[-1-j]for j in range(i+1));t=str(r%10)+t;r/=10;i+=1
print t.lstrip('0')

Answer 8

Haskell, 240 bytes

[d]!n=0#map(*d)n;(d:r)!n=0#(zipWith(+)([d]!n++cycle[0])$0:r!n);0#[]=[];z#[]=[z];z#(x:r)=mod(z+x)10:div(z+x)10#r;r=reverse;l=r.map(read.pure).show.abs;a?b|(a<0)/=(b<0)='-'|0<1=' ';main=do[a,b]<-map read<$>getArgs;putStr$a?b:r(l a!l b>>=show)

Try it online!

Could probably be quite a bit shorter but for the rather inconvenient IO format. Implements the "elementary school" multiplication algorithm, storing and processing numbers as lists of ints, representing each digit of a number.