/*
Siano assegnati da tastiera due vettori di interi vett1 e vett2 (max 50 elementi). Si progetti una funzione ALTERNA che riceva in ingresso i due vettori e restituisca un vettore vett3 costituito alternando gli elementi di vett1 e vett2 (vedi esempi). La funzione ALTERNA deve anche restituire come valore di ritorno la somma di tutti gli elementi del vettore vett3.
Progettare un programma principale (main) nel quale si stampa il vettore vett3 e il valore restituito dalla funzione ALTERNA.
Per la lettura e la stampa dei vettori utilizzare due procedure STAMPA e LEGGI.

-------------------------------------
Esempi

INPUT:
vett1 = 2 3 5 1
vett2 = 4 3 8 7

OUTPUT:
vett3 = 2 4 3 3 5 8 1 7
Somma: 33
-------------------------------------

INPUT:
vett1 = 3 5 1
vett2 = 1 2 5 5 6 3 3

OUTPUT:
vett3 = 3 1 5 2 1 5 5 6 3 3
Somma: 34
-------------------------------------

INPUT:
vett1 = 1 4 4 2 1 1 4 3
vett2 = 5 3 2 1

OUTPUT:
vett3 = 1 5 4 3 4 2 2 1 1 1 4 3
Somma: 31 

Commenti allo svolgimento
La funzione Alterna, per svolgere il suo compito, deve accettare in ingresso i due vettori vett1 e vett2 (con i relativi riempimenti), e restituire in uscita il vettore vett3 (anche questo con il suo riempimento), nonché la somma degli elementi di quest'ultimo, che è un valore appartenente ancora al tipo degli elementi del vettore.
Il prototipo per una tale funzione può essere dunque:

TElemento Alterna(const TVettore vett1, const int n1, const TVettore vett2, const int n2, TVettore vett3, int& n3);

Tra le possibili implementazioni della funzione ne vengono presentate due.

Si prelevano i valori alternativamente da vett1 e da vett2 e si inseriscono progressivamente in vett3. L'operazione di prelievo su un vettore è però subordinata al non esaurimento dei suoi elementi.
L'inserimento deve essere ripetuto n+m volte, dove n e m sono i riempimenti di vett1 e vett2; il numero di cicli da effettuare non è però n+m; questo dipende dal fatto che, fino all'esaurimento del vettore più piccolo, gli inserimenti avvengono a due alla volta per ogni iterazione del ciclo. E' giusto quindi utilizzare un ciclo while piuttosto che un ciclo for.

In definitiva, la sequenza dei passi da compiere è in linea di principio:

  while (riempimento vett3 < n+m) {
    if (vett1 non esaurito) then
        inserisci elemento corrente di vett1 in vett3;
    if (vett2 non esaurito) then
        inserisci elemento corrente di vett2 in vett3;
 }



Si calcola il minimo tra i riempimenti di vett1 (n) e vett2 (m), diciamolo min. Si effettuano poi min iterazioni iniziali che inseriscono i primi min elementi di vett1 alternati ai primi min elementi di vett2 nel vettore vett3. A questo punto uno dei due vettori è esaurito e non resta che scaricare l'altro sul vettore vett3.

In questo caso, la sequenza dei passi da compiere è in linea di principio:

    min = minimo tra n e m;

    for (i che va da 0 a min escluso) {
        inserisci elemento corrente di vett1 in vett3
        inserisci elemento corrente di vett2 in vett3
    }

    inserisci i restanti elementi di vett1 su vett3 (se ci sono);

    inserisci i restanti elementi di vett2 su vett3 (se ci sono);



In entrambi i casi la somma degli elementi può essere calcolata con una funzione del tutto generica che, dato un vettore, ne restituisca la somma dei suoi elementi. Il prototipo di una tale funzione può essere:

TElemento SommaElems(const TVettore v, const int n);

Questa funzione viene chiamata dalla funzione Alterna() alla fine dell'algoritmo. Dovendo essere visibile solo a quest'ultima non è necessario che il prototipo di SommaElems() compaia assieme agli altri. 

Nel listato che segue, le due implementazioni proposte sono implementate con le due funzioni Alterna() e Alterna2().
*/

//Listato

#include <iostream.h>
#include <stdlib.h>

const int nMax=50;
typedef int TElemento;
typedef TElemento TVettore[nMax*2]; //dimensiona i vettori in modo da contemplare
                                    //anche il caso peggiore

void Leggi(TVettore v, int& n, const int nmax);
void Stampa(const TVettore v, const int n);
TElemento Alterna(const TVettore vett1, const int n1, const TVettore vett2, const int n2, TVettore vett3, int& n3);
TElemento Alterna2(const TVettore vett1, const int n1, const TVettore vett2, const int n2, TVettore vett3, int& n3);

int main()
{
  TVettore vett1, vett2, vett3;
  int n;  //riempimento del vettore vett1
  int m;  //riempimento del vettore vett2
  int k;  //riempimento del vettore vett3
  int sum;  //valore restituito dalla funzione Alterna()

  cout << "Lettura vettore #1:\n";
  Leggi(vett1, n, nMax);
  
  cout << "Lettura vettore #2:\n";
  Leggi(vett2, m, nMax);

  sum = Alterna(vett1, n, vett2, m, vett3, k);

  cout << "Il vettore #3 e':\n  ";
  Stampa(vett3, k);

  cout << "La somma dei suoi elementi e': " << sum << endl;

  system("PAUSE");
  return 0;
}

void Leggi(TVettore vettore, int& n_elems, const int nMaxElem) {
  do {
    cout << "Inserisci il numero di elementi (max " << nMaxElem <<"): ";
    cin >> n_elems;
  } while ( (n_elems < 0) || (n_elems > nMaxElem) );

  for (int i = 0; i < n_elems; i++) {
    cout << "Inserisci l'elemento #" << i << ": ";
    cin >> vettore[i];
  }
}

void Stampa(const TVettore v, const int n) {
  cout << "  ";

  for (int i = 0; i < n; i++)
    cout << v[i] << "  ";

  cout << endl;
}

TElemento SommaElems(const TVettore v, const int n) {
  int s = 0;

  for (int i = 0; i < n; i++)
    s = s + v[i];
  
  return s;    
}

TElemento Alterna(const TVettore vett1, const int n1, const TVettore vett2, const int n2, TVettore vett3, int& n3) {
  int i = 0;
  int j = 0;
  n3 = 0;
  
  while (n3 < n1 + n2) {
    if (i < n1) {
      vett3[n3] = vett1[i];
      i++;
      n3++;
    }
    if (j < n2) {
      vett3[n3] = vett2[j];
      j++;
      n3++;
    }      
  }
  
  return SommaElems(vett3, n3);
}

TElemento Alterna2(const TVettore vett1, const int n1, const TVettore vett2, const int n2, TVettore vett3, int& n3) {
  int minlen = (n1 < n2 ? n1 : n2);  //e' lo stesso di: if (ni < n2) minlen = n1 else minlen = n2;
  n3 = 0;
  
  //preleva alternativamente gli elementi fino alla fine del vettore più corto (di lunghezza minlen)
  for (int i = 0; i < minlen; i++) {
    vett3[n3] = vett1[i];
    n3++;
    vett3[n3] = vett2[i];
    n3++;
  }
  
  //scarica, eventualmente, il primo vettore
  for (int i = minlen; i < n1; i++) { //questo ciclo viene eseguito (almeno una volta) solo se n1 > n2
    vett3[n3] = vett1[i];
    n3++;
  }
  
  //scarica, eventualmente, il secondo vettore
  for (int i = minlen; i < n2; i++) { //questo ciclo viene eseguito (almeno una volta) solo se n2 > n1
    vett3[n3] = vett2[i];
    n3++;
  }
   
  return SommaElems(vett3, n3);
}