Dodawanie dwóch tablic od końca

hej! mam napisać dodawanie dwóch tablic, dodając od końca. Tablice są rózne, jedna ma 5 elementów, druga 2. Nie mogę niestety włapać błędu. Wynik powinien być taki: 1 2 3 5 7 a wychodzi mi: 1 0 0 8 4 2 :(

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int dl1 = 5;
    int dl2 = 2;

    // 1 2 3 5 7

    int tab1[5] = {1,2,3,4,5};
    int tab2[2] = {1,2};

    int tab3[5] = {0,0,0,0,0};

    int ma = max(dl1, dl2);
    int mi = min(dl1, dl2);

    for(int i=mi; i>=0; i--)
        tab3[i] = tab1[i] + tab2[i];

    if(dl1 < dl2)
    {
        for(int i=dl1;i>=dl2;i--)
            tab3[i] = tab2[i];
    }

      if(dl2<dl1)

      {

          for(int i=dl2;i>=dl1;i--)
             tab3[i] = tab1[i];

      }

      for(int i=5; i>=0; i--)
      {
          cout << tab3[i] << " ";
      }
      cout << "\n\n";

    return 0;
}

for(int i = size_jedna-1, int j = size_druga-1,
    int k = 0; i >= 0 || j >= 0; --i, --j, ++k)
{
    int tmp1 = i < 0 ? 0 : tab1[i];
    int tmp2 = j < 0 ? 0 : tab2[j];
    tab3[k] = tmp1+tmp2;
}

Mniej-wiecej cos takiego. <nie testowane="testowane">

1. Nie ma sprawdzania rozmiaru tablicy 3, mozesz sobie dopisac.
2. inicjalizacja zmiennych na ostatni indeks.
3. sprawdzenie warunku, czy obie tablicy juz zostaly skopiowane.
4. jesli wartosc iteratora (zmiennej i badz j) jest mniejsza od zera to ustawia wartosc tmp na 0, jesli nie to ustawia na wartosc w tablicy o tym indeksie.
5. dodaje do pozycji k (dodawanie jest od poczatku, wiec musisz je sobie zmienic, takich hack :P)
6. kod nie jest ladny, ale ogolny patent juz masz.

Trochę jako ciekawostka, poniższe jest nieco dłuższe niż to co podał @n0name_l wyżej ale w większości przypadków działa szybciej.

int size_min=size_jedna<size_druga?size_jedna:size_druga,size_max=size_jedna>size_druga?size_jedna:size_druga;
for(int i=1;i<=size_min;++i) tab3[size_max-i]=tab1[size_jedna-i]+tab2[size_druga-i];
for(int i=size_min+1;i<=size_jedna;++i) tab3[size_max-i]=tab1[size_jedna-i];
for(int i=size_min+1;i<=size_druga;++i) tab3[size_max-i]=tab2[size_druga-i];

W przypadku jeżeli robimy to od przodu wygląda nieco bardziej strawnie:

int size_min=size_jedna<size_druga?size_jedna:size_druga;
for(int i=0;i<size_min;++i) tab3[i]=tab1[i]+tab2[i];
for(int i=size_min;i<size_jedna;++i) tab3[i]=tab1[i];
for(int i=size_min;i<size_druga;++i) tab3[i]=tab2[i];

dzieki, dziala:)

 
#include <iostream>
#include <algorithm>

using namespace std;
 
template <typename InputIterator>
void sum_from_end(InputIterator ffirstInIterator, InputIterator flastInInterator, InputIterator sfirstInIterator, InputIterator slastInInterator)
{
    InputIterator it = std::max(--ffirstInIterator - flastInInterator, --sfirstInIterator - slastInInterator) 
		== ffirstInIterator - flastInInterator ? ffirstInIterator : sfirstInIterator;
    InputIterator it2 = it == ffirstInIterator ? sfirstInIterator : ffirstInIterator;

    InputIterator st = it == ffirstInIterator ? flastInInterator : slastInInterator;
    InputIterator st2 = it == ffirstInIterator ? slastInInterator : flastInInterator;

    while(it != st - 1)
      *it-- += it2 != st2 - 1 ? 
	*it2-- : 0;
}

int main()
{
    int tab1[] = {1, 2, 3, 4, 5};
    int tab2[] = {1, 2, 3};

    sum_from_end(tab2 + 3, tab2, tab1 + 5, tab1);

    for(auto i : tab1)
       cout << i << " ";
    cout << endl;

    return 0;
}

Znów podaliście kod, który jest tak nieczytelny i tak nie wiadomo co robi, że głowa boli.

Dlaczego nie normalnie? To jest rozwiązanie całkowicie wprost, bez żadnego kombinowania, prościej się nie da. Najpierw dodajemy ile się da a potem kopiujemy resztę z dłuższej. Żadnej magii.

  const std::size_t min_size = std::min(size_t1, size_t2);
  const std::size_t max_size = std::max(size_t1, size_t2);
  
  for (std::size_t i = 0; i < min_size; ++i) {
    result[max_size - i - 1] = t1[size_t1 - i - 1] + t2[size_t2 - i - 1];      
  }
  
  const int *longer = (size_t1 >= size_t2) ? t1 : t2;
  const std::size_t difference = max_size - min_size;
  
  std::copy_backward(longer, longer + difference, result + difference);

Jeżeli chodzi o szybkość, jest tak samo, jak poprzednim razem. Zwykły, prosty i czytelny kod C++ jest szybszy:

h4xi0r1:
1604 ms
h4xi0r2:
609 ms
plain c++:
316 ms

(GCC 4.7.2, -O2 -march=native, Phenom II 3.2 GHz)