#include
#include
#include 
 
// CONSTANTES
#define TAM_ARR_MAX 20
 
int main(int argc, char **argv)
{
	//DECLARACION DE  VARIABLES
	int VEC1[TAM_ARR_MAX], VEC2[TAM_ARR_MAX];
	int tam_1;
	int sumatoria;
 
	printf("#### 1 #####\n");
	tam_1 = ask_tam(); //Le pregunta al usuario que tamaño tendra el vector.
	arr_cargar(VEC1,tam_1); //El usuario Carga el vector.
	arr_mostrar(VEC1,tam_1); //Se muestra el vector Cargado
        sumatoria = rec_arr_sumatoria(VEC1,tam_1);
        // SUMATORIA DEL VECTOR EN FORMA RECURSIVA
	printf("\nLa sumatoria de los %d elementos del array es: %d",tam_1,sumatoria);
	printf("\n\n****************************\n");
 
    //Cierro main.
	//getch();
	return 0;
}	
 
/************************************/
/*            FUNCIONES             */
/************************************/
 
int ask_tam(){
	int n;
	printf("\nIngrese el tamanio que tendra el array (menor que %d):",TAM_ARR_MAX);
	do{
		scanf("%d",&n);
	}while(n

/* 
* TRABAJO PRACTICO N.2
*         (caracteres)
* Compilado con Codelite en Windows Seven 
*/
/*
 * ACLARACION:
 * El ejercicio esta hecho con \n en lugar de EOF, para facilitar el desarrollo y el testeo.
 * 
 * */
#include <stdio.h>
#include <conio.h>
#include <string.h>
 
int main(int argc, char **argv)
{
 
	char c,d,e;
	//primer ejercicio
	char ant = '\n';
	int contIguales=0;
	//segundo ejercicio
	char prim;
	int contPal=0;
	int contPrim=0;
	//tercer ejercicio
	int cont=0;
	char anteult;
	char ult;
	int cont5=0;
 
 
/*******************************************************************************************
 * 1.    Leer un texto carácter por carácter terminando en EOF. (Lo intercambio por ENTER)
 *       Contar cuántas veces aparecen dos letras iguales.
 *       Mostrarlas intercalándoles el signo “=”.
 * ****************************************************************************************/
	printf("Ingrese una frase para el primer ejercicio (contar parejas): ");
	do{
	  c = getchar();
	  if(ant==c){
	    contIguales++;
		putchar('=');
	  }
	  //Reescribo la frase.
	  putchar(c);
	  //Antes de volver a leer la guardo en anterior
	  ant = c;
	}while( c != '\n');
	printf("\n\n1) En %d oportunidades hay dos letras iguales juntas.",contIguales);
 
/********************************************************************************************
 * 2.   Ingrese un texto carácter a carácter terminado en EOF contar cuantas palabras
 *      tienen más de una vez repetida la primer letra de la primer palabra.
 * *****************************************************************************************/
	printf("\n\n*****************************************************************************");	
	printf("\n\nIngrese una frase para el segundo ejercicio (contar primer letra): ");
	do{//Que la primera venga sin espacio
	  d = getchar();
    }while(d==' ');
	//La primer letra es: prim
	prim = d;
	//LECTURA CARACTER A CARACTER
    while(d!='\n'){ 
	  if(d!=' '){
		//Control de primer letra
		if(d==prim)
			contPrim++;
	  }else{
		//si tiene mas de una vez la cuento
		if(contPrim>1){
		  contPal++;
		}
		contPrim=0;
	  }
	  //No reescribo la frase porque no hace falta modificarla
	  //putchar(d);
	  d = getchar();
	}
	if(contPrim>1)
	  contPal++;
	printf("\n\n 2) La cantidad de palabras que tienen mas de una %c es  %d.",prim,contPal);
 
 
/********************************************************************************************
 * 3.    Leer un texto carácter por carácter terminando en EOF.
 *       Contar palabras de 5 letras que terminan en “ia”.
 *       Al final de cada una de esas palabras, insertar el número “5”.
 *******************************************************************************************/
	printf("\n\n****************************************************************************");
	printf("\n\nIngrese una frase para el tercer ejercicio (ia): ");
	do{
	  e = getchar();
	  if(e==' ' || e=='\n'){
	  //cuento chars.
	    if(cont==5 && (anteult=='i' || anteult=='I') && (ult=='a' || ult=='A')){
		  cont5++;
		  putchar('5');  
	    }
		cont=0;
	  }else
	    cont++;  
	  anteult = ult;
	  ult=e;
	  putchar(e);
 
	}while( e != '\n');
	printf("\n\n 3) La cantidad de palabras terminadas en ia son: %d",cont5);
	//Cierro main.
	getch();
	return 0;
}

/* 
* TRABAJO PRACTICO N.1
*           (matrices)
* Compilado con wxDev - C++ en Windows Seven 
*/
#include <stdio.h>
#include <conio.h>
// Defino el Tamaño de la Matriz Cuadrada.
#define _TAM 3
 
//Declaracion de Funciones
void mat2_cargar(int M[_TAM][_TAM], int tm);
void mat2_mostrar(int M[_TAM][_TAM], int tm);
void mat2_traspuesta(int M[_TAM][_TAM], int tm, int T[_TAM][_TAM]);
void mat2_multiplicar(int A[_TAM][_TAM], int B[_TAM][_TAM], int tm, int C[_TAM][_TAM]);
float mat2_promDiagonales(int M[_TAM][_TAM], int tm);
int mat2_cantPrimos(int M[_TAM][_TAM], int tm);
 
/*******************************/
/***** TRABAJO PRACTICO 1 ******/
/*******************************/
 int main(){
    //clrscr();
    //Declaraciones
    int MAT[_TAM][_TAM];
    int TRAS[_TAM][_TAM];
    int MULTI[_TAM][_TAM];
    float prom=0.0;
    int primos=0;
 
    //Cargar Matriz MAT
    mat2_cargar(MAT, _TAM);
      //Mostrar Matriz MAT
      printf("\n\n** Matriz Cargada **\n");
      mat2_mostrar(MAT, _TAM);
 
    //Promedio de las Diagonales
    prom = mat2_promDiagonales(MAT, _TAM);
      printf("\n\n** Promedio de Elementos de las Diagonales de la Matriz **\n");
      printf("%.2f\n",prom);
 
    //Crear Traspuesta de Matriz MAT
    mat2_traspuesta(MAT, _TAM, TRAS);//da como resultado la matriz TRA
      //Mostrar TRA
      printf("\n** Matriz Traspuesta **\n");
      mat2_mostrar(TRAS, _TAM);
 
    //Multiplicar MAT*TRA, resultado
    mat2_multiplicar(MAT,TRAS,_TAM,MULTI);
      //Mostrar MULTI 
      printf("\n** Matriz Resultado de la multiplicacion **\n");
      mat2_mostrar(MULTI, _TAM);
    //Cantidad de Numeros primos entre los elementos de la Matriz
    primos = mat2_cantPrimos(MAT, _TAM);
      //Mostrar Numeros Primos
      printf("\n\n** Cantidad de Numeros Primos **\n");
      printf("%d",primos);
 
    getch();
    return 0;
  }
 
 
/**********************/
/***** FUNCIONES ******/
/**********************/
 
 
//Cargar Matriz Cuadrada
void mat2_cargar(int M[_TAM][_TAM], int tm){
  int i,j;  
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
      printf("%d,%d: ",i,j);
	  scanf("%d",&M[i][j]);
    }
  }
}
//Mostrar Matriz Cuadrada
void mat2_mostrar(int M[_TAM][_TAM], int tm){
  int i,j;
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
      printf("%d\t",M[i][j]);
    }
    printf("\n");
  }
}
//Sacar Traspuesta de una Matriz Cuadrada
void mat2_traspuesta(int M[_TAM][_TAM], int tm, int T[_TAM][_TAM]){
  int i,j;
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
      T[j][i] = M[i][j];
    }
  }
}
 
//Multiplicacion de matrices cuadradas.
void mat2_multiplicar(int A[_TAM][_TAM], int B[_TAM][_TAM], int tm, int C[_TAM][_TAM]){
  int i,j,k;
  int parc=0;
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
	  for(k=0;k<tm;k++){
        parc = parc + (A[i][k] * B[k][j]);
      }
      C[i][j] = parc;
      parc=0;
    }
  }
}
 
//Promedio de Diagonales
float mat2_promDiagonales(int M[_TAM][_TAM], int tm){
  int i,j;
  float cant=0.0;
  float prom=0.0;
  int sum = 0;
  int card = tm-1;
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
	  if((i==j) || (j==(card-i)) ){//Diagonal principal || secundaria
        sum = sum + M[i][j];
		cant++;
      }
	}
  }
  if(cant!=0)
    prom = sum/cant;
  return prom;
}
 
int mat2_cantPrimos(int M[_TAM][_TAM], int tm){
  int i,j,k;
  int c=0;
  int aux=0;
  for(i=0;i<tm;i++){
    for(j=0;j<tm;j++){
      if((M[i][j]==1) || (M[i][j]==2))
        c++;
      if(M[i][j]>2){
        for(k=2;k<M[i][j];k++){
          if((M[i][j]%k)==0)
	        aux++;
        }
        if(aux==0)
          c++;
        else
          aux=0;
      }
    }
  }
  return c;
}