Multiply two numbers I am trying to implement multiplication of two numbers without using the * operator, as a practice for programming interviews. I have written two functions. 

1) Using Long Multiplication

    static int MultiplyTwoNumbers(int num1,int num2)
    {
        List&lt;int&gt; leftnumber = new List&lt;int&gt;();
        do
        {
            leftnumber.Add(num1% 10);
            num1/= 10;
        } while (num1!=0);

        List&lt;int&gt; rightnumber = new List&lt;int&gt;();

        do
        {
            rightnumber.Add(num2% 10);
            num2/= 10;
        } while (num2!= 0);


        int result = 0;
        int counter = 1;
        for (int i = 0; i &lt;leftnumber.Count; i++)
        {
            int tempresult = 0;
            int carry = 0;
            int innercounter = counter;
            for (int j = 0; j&lt;rightnumber.Count; j++)
            {
                int tempVal = leftnumber[i] * rightnumber[j];
                tempVal += carry;
                if (tempVal / 10 != 0)
                {
                    carry = tempVal / 10;
                    tempVal = tempVal % 10;
                }
                tempresult = tempresult + (innercounter * tempVal);
                innercounter = innercounter * 10;
            }

            result +=tempresult;
            counter = counter * 10;
        }

        return result;



    }


2) using Addition

  static int multiplicationUsingAdd(int num1,int num2)
    {
        int result = 0;
        for (int i = 0; i &lt; num2; i++)
        {
            int temp=result+ num1;
            result = temp;
        }
        return result;
    }


Which one is better and how can I improve it ?
You seem to be very much over-complicating this. Here is an efficient solution:

Assuming a and b are positive numbers and the result is a valid 32-bit integer value

public int Multiply(int a, int b)
{
    if (a &lt; 0 || b &lt; 0)
        throw new ArgumentException("Numbers must be positive");

    var min = Math.Min(a, b);
    var max = Math.Max(a, b);

    if (min == 0 || max == 0)
        return 0;
    else if (min == 1)
        return max;

    int s = min &gt;&gt; 1;
    int halfProduct = Multiply(s, max);

    if (min % 2 == 0)
        return halfProduct + halfProduct;
    return halfProduct + halfProduct + max;
}


So what is happening here? First we need to sort these by the smaller and larger numbers, this reduces the number of iterations required. If either of the numbers is zero, then we return zero (since x*0 == 0). If the minimum number is 1, then we return max (since x*1 == x). 

Now we can apply the shift operator since shifting one to the right divides the number by 2. By recursion we keep doing this until Multiply returns 0 or max. We can then determine the value if min is even by adding the two half-products or if min is odd by adding the two half products and max. 

Again, even in your original solution this will break for negative numbers. You can code around that by switching the sign (Math.Abs) and swapping the sign at the end (0 - return value, unless both are negative then you leave it positive). I'll leave that as an exercise for you.