Untitled

How to multiply int arrays? [closed]
int* multi(int* tab1, int*tab2, int dlugoscTab1, int dlugoscTab2)
{
    int* A; // long value
    int dlugoscA;

        int* B; // short value
        int dlugoscB;

        int *W;  // result
        int dlugoscW;

    if (dlugoscTab1 >= dlugoscTab2){

    dlugoscW = dlugoscTab1*2;

    A = new int[dlugoscTab1];
    dlugoscA = dlugoscTab1;
    //rewrite array1
    for (int i =0 ; i <dlugoscTab1; i++) A[i] = tab1[i];
    B = new int[dlugoscTab1];
    dlugoscB = dlugoscTab1;
    //rewrite array2
    for (int i =0 ; i <dlugoscTab1-dlugoscTab2; i++) B[i] = 0;
    for (int i =dlugoscTab1-dlugoscTab2 ; i <dlugoscTab1 ;  i++) B[i] = tab2[i-(dlugoscTab1-dlugoscTab2)];

    //AAAAAAAABBB
    }else if(dlugoscTab1 < dlugoscTab2 ){

    dlugoscW = dlugoscTab2*2;

    A = new int[dlugoscTab2];//long
    dlugoscA = dlugoscTab2;
    for (int i =0 ; i <dlugoscTab2;i++) A[i] = tab2[i];

    B = new int[dlugoscTab2]; //short
    dlugoscB = dlugoscTab2;

    for (int i =0 ; i < ( dlugoscTab2-dlugoscTab1 ); i++) B[i] = 0;
    for (int i = ( dlugoscTab2-dlugoscTab1 ); i <dlugoscTab2 ;  i++) B[i ] = tab1[i-(dlugoscTab2-dlugoscTab1)];


    }

    W = new int[dlugoscW];
    int tmp;

    for(int i = 0 ; i < dlugoscW ; i++)
    {

    //algorithm :
    W[dlugoscW  -i -1] += (A[dlugoscA  -i -1] * B[dlugoscB  -i -1] ); // Here is a problem.


    }

    W[0] = tmp;
    return W;
}

#include <cassert>
#include <cstdlib>
#include <vector>
#include <iostream>

typedef std::vector<int> number;

number multiply(const number & a, const number & b) {
    number c(a.size()+b.size());
    // multiply
        for (unsigned int i=0; i<a.size(); ++i) { // i indexes a
            for (unsigned int j=0; j<b.size(); ++j) { // j indexes b
                int prev = c[i+j];
                c[i+j] += a[i]*b[j];
                assert(c[i+j] > prev); // check for overflow
        }
    }
    // ripple carry -- we can do it all at once since
    // even a 32 bit int can fit the carries for
    // a 5,000 digit x 5,000 digit multiply
    // (exactly sqrt(2^31/9^2) digits on each operand IIRC)
    int carry = 0;
    for (unsigned int i=0; i <c.size(); ++i) {
        c[i] += carry;
        ldiv_t dt = ldiv(c[i], 10);
        carry = dt.quot;
        c[i] = dt.rem;
    }
    return c;
}

number load(int q)
{
    number n;
    assert(q>0);
    while (q) {
        ldiv_t dt = ldiv(q, 10);
        n.push_back(dt.rem);
        q = dt.quot;
    }
    return n;
}

std::ostream & operator<<(std::ostream & str, const number & n)
{
    for (int i = n.size()-1; i >= 0; i--) {
        str << n[i];
    }
    return str;
}

unsigned long store(const number & n)
{
    unsigned long q = 0;
    for (int i = n.size()-1; i >= 0; i--) {
        unsigned long prev = q;
        q = q*10 + n[i];
        assert(prev < q); // check for overflow
    }
    return q;
}

int main()
{
    number a = load(369);
    number b = load(4914);
    number c = multiply(a, b);
    assert(store(c) == 1813266);
    std::cout << c << std::endl;
    return 0;
}