::::::::::::::
txtstat1.cpp
::::::::::::::

/*
  txtstat1.cpp
  text statistics, array version 
*/

#include <iostream.h>
#include <ctype.h>

int main()
{
  const int ALPH_SIZE = 26; 
  int letter_count[ALPH_SIZE]; 
  char ch;
  int i; 

  // init
  for (i = 0; i < ALPH_SIZE; ++i)
    letter_count[i] = 0;

  // core
  cout << "Type input text (\\n to end)\n";
  while ((ch = char(cin.get())) != '\n') {
    if ( ch >= 'a' && ch <= 'z') { 
      i = int(ch) - int('a'); 
      letter_count[i]++; 
    }
    else if ( ch >= 'A' && ch <= 'Z') { 
      i = int(ch) - int('A'); 
      letter_count[i]++; 
    }
  }

  // output
  for (i = 0; i < ALPH_SIZE; ++i)
    cout << "letter " << char(int('a') + i) <<
      ": " << letter_count[i] << endl;
  return(0);
}


::::::::::::::
count-more.cpp
::::::::::::::

/* 
  count-more.cpp
  tema del 09 febbraio 2001

  conta elementi array con piu` di una occorrenza
  metodo: identifico la penultima occorrenza
*/

#include <iostream.h>

int count(int* array, int dim) {
  int key; 
  int count = 0, aux_count = 0;
 
  for (int i = 0; i < dim; i++) {
    key = array[i]; 
    for (int j = i+1; j < dim; j++)
      if (key == array[j]) 
	aux_count++; 
    // end if, for(j)
    if (aux_count == 1)
      count++; 
    aux_count = 0; // reset
  } // end for(i)

  return(count);
}

::::::::::::::
count-two.cpp
::::::::::::::

/* 
  count-two.cpp
  tema del 01 settembre 2000

  conta elementi array con esattamente due occorrenze
  metodo: conto ciascuna occorrenza che appare due
  volte e divido per 2 il risultato
*/

#include <iostream.h>

int count(int* array, int dim) {
  int key; 
  int count = 0, aux_count = 0;
 
  for (int i = 0; i < dim; i++) {
    key = array[i]; 
    for (int j = 0; j < dim; j++)
      if (key == array[j]) 
	aux_count++; 
    // end if, for(j)
    if (aux_count == 2)
      count++; 
    aux_count = 0; // reset
  } // end for(i)
  count /= 2; 

  return(count);
}

::::::::::::::
dec2bin.cpp
::::::::::::::

/* 
  dec2bin.cpp
  tema del 7 settembre 1999

  converte un numero intero non negativo nella corrispondente 
  rappresentazione in base binaria, indicata mediante una stringa 
  di caratteri 0 e 1.
*/

#include <iostream.h>

char* dec2bin(unsigned int n) {

  if (n == 0)
    return("0"); 
  else if (n > 0) {

    // calcolo numero di bit richiesti
    int length = 0;
    int temp = n;
    while (temp != 0) {
      length++;
      temp /= 2;
    } // end while

    // conversione
    char* res = new(char[length + 1]);
    temp = n;
    res[length] = '\0'; 
    for (int i = length-1; i >= 0; i--) {
      if (temp % 2)
	res[i] = '1'; 
      else 
	res[i] = '0'; 
      temp /= 2;
    } // end for
    return(res);
  } // end if
}

::::::::::::::
media.cpp
::::::::::::::

/* 
  media.cpp
  tema del 23 gennaio 2001

  calcola il valore medio degli elementi di un vettore a avente d
  elementi utilizzando lo schema ricorsivo seguente: 

    se d = 1, a[0] e` il valore richiesto;  
    se d > 1, la media risulta (b(d-1) + a[0])/d, 
       dove b e` il valore medio degli elementi di 
       a ad esclusione del primo elemento a[0] 
*/

#include <iostream.h>

double media(int* a, int d) {
  double res; 

  if (d == 1) 
    res = double(a[0]); 
  else if (d > 1) {
    res = media(&a[1], d-1); 
    res = res * (d - 1) + double(a[0]); 
    res = res/double(d); 
  }
  return(res);  
}

::::::::::::::
reverse.cpp
::::::::::::::

/* 
  reverse.cpp
  tema del 18 luglio 2000

  inverte l'ordine degli elementi di un vettore in ingresso 
  senza allocare memoria aggiuntiva
*/

#include <iostream.h>

void reverse(int* array, int dim) {

  int middle, temp; 
  middle = dim/2; 

  for (int i = 0; i < middle; i++) {
    temp = array[i]; 
    array[i] = array[dim - i - 1];
    array[dim - i - 1] = temp; 
  } // end for

  return;
}

::::::::::::::
riporto.cpp
::::::::::::::

/* 
  riporto.cpp
  tema del 15 settembre 2000

  Riceve in ingresso due numeri binari, rappresentati mediante due array 
  aventi entrambi la stessa lunghezza.  La funzione restituisce 1 se la 
  somma dei numeri in ingresso genera riporto sulla colonna del bit piu` 
  significativo, 0 altrimenti.
*/

#include <iostream.h>

short riporto(short* n1, short* n2, int d) {
  short somma, rip = 0; 

  for (int i = d-1; i >= 0; i--) {
    somma = n1[i] + n2[i] + rip; 
    switch (somma) {
    case 0:
      rip = 0;
      break;
    case 1:
      rip = 0;
      break;
    case 2:
      rip = 1;
      break;
    case 3:
      rip = 1;
      break;
    } // end switch
  } // end for
  return(rip);
}


::::::::::::::
crypt.cpp
::::::::::::::

/* 
  crypt.cpp
  tema del 18 giugno 2001

  restituisce una stringa crittografata ottenuta scambiando la 
  prima vocale con l'ultima, la seconda vocale con la penultima, ecc.
*/

#include <iostream.h>
#include <ctype.h>

short iscons(char ch) {
  // controlla se ch e` una consonante
  if (!isalpha(ch))
    return(0); 
  else if (ch == 'a' || ch =='A' ||
           ch == 'e' || ch =='E' ||
           ch == 'i' || ch =='I' ||
           ch == 'o' || ch =='O' ||
           ch == 'u' || ch =='U')
    return(0); 
  else 
    return(1); 
}

void swap (char* str, int left, int right) {
  // scambia due elementi di un array
  int temp; 
  temp = str[left]; 
  str[left] = str[right];
  str[right] = temp; 
  return; 
}

char* crypt(const char* str) {
  int length = 0;   
  while (str[length] != '\0')
    length++;
  length++; // per il terminatore

  char* tstr = new(char[length]); 
  for (int i = 0; i < length; i++)
    tstr[i] = str[i]; 
  // end for -- ho copiato anche '\0'

  int left = 0, right = length - 2; 
  while (left < right) {
    while (iscons(tstr[left]) && left < right)
      left++; 
    while (iscons(tstr[right]) && left < right)
      right--; 
    if (left < right) {
      swap(tstr, left, right);
      left++; 
      right--; 
    } // end if
  } // end while 
  return(tstr);
}

::::::::::::::
find.cpp
::::::::::::::

/* 
  find.cpp
  tema del 13 luglio 2001

  Ricerca una stringa pattern all'interno di una stringa text restituendo
  1 se la ricerca ha successo, 0 altrimenti.  Come caso speciale, la 
  funzione restituisce 1 se la stringa pattern ha lunghezza zero, e 
  restituisce 0 se la stringa text ha lunghezza inferiore a quella 
  della stringa pattern.
*/

#include <iostream.h>

short find(const char* text, const char* pattern) {

  int t_length = 0, p_length = 0;
  while (text[t_length] != '\0')
    t_length++;
  while (pattern[p_length] != '\0')
    p_length++;

  if (p_length == 0) 
    return(1); 
  else if (p_length > t_length)
    return(0); 
  else {
    short match; 
    for (int t = 0; t <= t_length - p_length; t++) {
      match = 1; 
      for (int p = 0; match == 1 && p < p_length; p++)
	if (pattern[p] != text[t + p])
	  match = 0;  // end for(p)
      if (match == 1)
	return(1); 
    } // end for(t)
    return(0); // tutte le ricerche sono fallite
  } // end if 
}

::::::::::::::
make-name.cpp
::::::::::::::

/* 
  make-name.cpp
  tema del 21 settembre 2001

  trasforma in maiuscoli tutti i caratteri in una stringa 
  in posizione immediatamente successiva ad uno spazio ed 
  elimina tutti gli spazi
*/

#include <iostream.h>

char capital(char ch) {
  if (ch >= 'a' && ch <= 'z')
    ch = ch + ('A' - 'a'); 
  return(ch); 
}

char* make_name(const char* str) {

  int spaces = 0;
  int length = 0; 
  while (str[length] != '\0') {
    length++;
    if (str[length] == ' ')
      spaces++; 
  } // end while

  char* str1 = new(char[length - spaces +1]); 
  int i, i1 = 0; 
  char ch; 
  for (i = 0; i < length; i++)
    if (str[i] != ' ') {
      ch = str[i]; 
      if (i > 0 && str[i-1] == ' ')
	ch = capital(ch); 
      str1[i1] = ch; 
      i1++; 
    } // end if, end for
  str1[i1] = '\0'; 

  return(str1);
}

::::::::::::::
mirror.cpp
::::::::::::::

/* 
  mirror.cpp
  tema del 30 giugno 2000

  restituisce una stringa formata dalla stringa in ingresso concatenata 
  con la sua inversa
*/

#include <iostream.h>

char* mirror(const char* str) {

  int length = 0;   
  while (str[length] != '\0')
    length++;

  char* rstr = new(char[2*length + 1]); 
  for (int i = 0; i < length; i++)
    rstr[i] = str[i]; 
  for (int i = 0; i < length; i++)
    rstr[length + i] = str[length - i - 1]; 
  rstr[2*length] = '\0'; 

  return(rstr);
}

::::::::::::::
scramble.cpp
::::::::::::::

/* 
  scramble.cpp
  tema del 01 settembre 2001

  restituisce una stringa riarrangiando tutti i caratteri
  presenti nella stringa in ingresso in modo tale che le 
  consonanti precedano le vocali
*/

#include <iostream.h>
#include <ctype.h>

short isvowel(char ch) {
  // controlla se ch e` una consonante
  if (!isalpha(ch))
    return(0); 
  else if (ch == 'a' || ch =='A' ||
           ch == 'e' || ch =='E' ||
           ch == 'i' || ch =='I' ||
           ch == 'o' || ch =='O' ||
           ch == 'u' || ch =='U')
    return(1); 
  else 
    return(0); 
}

char* scramble(const char* str) {
  int length = 0;   
  while (str[length] != '\0')
    length++;
  char* str1 = new(char[length + 1]); 

  int i, i1 = 0; 
  for (i = 0; i < length; i++)
    if (!isvowel(str[i])) {
      str1[i1] = str[i]; 
      i1++; 
    } // end if, end for
  for (i = 0; i < length; i++)
    if (isvowel(str[i])) {
      str1[i1] = str[i]; 
      i1++; 
    } // end if, end for
  str1[i1] = '\0'; 
  return(str1);
}