#include <stdio.h>
#include <conio.h>
#include <string.h>
 
// 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<1);
	return n;
}
 
void arr_mostrar(int X[TAM_ARR_MAX], int n){
	int i;
	printf("\n");
	for(i=0;i<n;i++){
		printf("[%d]:%d",i,X[i]);
		if(i<n)
			printf("; ");
	}
	printf("\n");
}
void arr_cargar(int X[TAM_ARR_MAX], int n){
	int i;
	for(i=0;i<n;i++){
		printf("\nIngrese [%d]:",i);
		scanf("%d",&X[i]);
	}
}
int rec_arr_sumatoria(int X[], int i){
	if(i==0)
		return 0;
	else	
		return rec_arr_sumatoria(X,i-1)+X[i-1];
}

/* 
* 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;
}

function isRut($value=''){
       if(empty($value))
	   {
           return false;
       }
       $RegExp = '/^([0-9])+\-([kK0-9])+$/';
       if (!preg_match($RegExp, $value)){
           return false;
       }
       $RUT  = explode("-",$value);
       $elRut = $RUT[0];
       $factor = 2;
       $suma = 0;
     for($i=strlen($elRut)-1; $i>=0; $i--){
           $factor = ($factor > 7) ? 2 : $factor;
           $suma += ((int)$elRut{$i}) * ((int)$factor++ );
     }
       $ret = true;
       $dv = 11 - ($suma % 11);
       if($dv == 11){
           $dv = 0;
       }else if ($dv == 10){
           $dv = "k";
       }
       if($dv != strtolower($RUT[1]) ){
           $ret = false;
       }
       return $ret;
}

function isRut(value){
		   if(value == ''){
			   return false;
		   }
		   var rexp = new RegExp(/^([0-9])+\-([kK0-9])+$/);
		   if(!value.match(rexp)){
			   return false;
		   }
		   var RUT  = value.split("-");
		   var elRut = RUT[0];
		   var factor = 2;
		   var suma = 0;
		   var dv;
		   for(i=(elRut.length-1); i>=0; i--){
			   factor = factor > 7 ? 2 : factor;
			   suma += parseInt(elRut[i])*parseInt(factor++);
		   }
		   var ret = true;
		   dv = 11 -(suma % 11);
		   if(dv == 11){
			   dv = 0;
		   }else if (dv == 10){
			   dv = "k";
		   }
		   if(dv != RUT[1].toLowerCase()){
			   ret= false;
		   }
		   return ret
	   }

/**
 * Returns string with newline formatting converted into HTML paragraphs.
 *
 * @author Michael Tomasello <miketomasello@gmail.com>
 * @copyright Copyright (c) 2007, Michael Tomasello
 * @license http://www.opensource.org/licenses/bsd-license.html BSD License
 * 
 * @param string $string String to be formatted.
 * @param boolean $line_breaks When true, single-line line-breaks will be converted to HTML break tags. 
               //Jinglero: Cuando sea true, los saltos de lineas seran simples saltos de lineas, si es false, el salto de linea se convertira en parrafo. 
 * @param boolean $xml When true, an XML self-closing tag will be applied to break tags (<br />).
 * @return string
 */
function nl2p($string, $line_breaks = true, $xml = true)
{
    // Remove existing HTML formatting to avoid double-wrapping things
    $string = str_replace(array('<p>', '</p>', '<br>', '<br />'), '', $string);
 
    // It is conceivable that people might still want single line-breaks
    // without breaking into a new paragraph.
    if ($line_breaks == true)
        return '<p>'.preg_replace(array("/([\n]{2,})/i", "/([^>])\n([^<])/i"), array("</p>\n<p>", '<br'.($xml == true ? ' /' : '').'>'), trim($string)).'</p>';
    else 
        return '<p>'.preg_replace("/([\n]{1,})/i", "</p>\n<p>", trim($string)).'</p>';
}

function nameDia($ano,$mes,$dia)
{
	$nameDias[] = 'Domingo';
	$nameDias[] = 'Lunes';
	$nameDias[] = 'Martes';
	$nameDias[] = 'Miercoles';
	$nameDias[] = 'Jueves';
	$nameDias[] = 'Viernes';
	$nameDias[] = 'Sabado';
	// 0->domingo	 | 6->sabado
	$dia= date("w",mktime(0, 0, 0, $mes, $dia, $ano));
	return $nameDias[$dia];
}

 /*
 * daysInMonth($month, $year)
 * Devuelve la cantidad de dias que tiene un mes en un año determinado.
 *
 * $month: numero de mes (integers 1-12)
 * $year: numero de año (any integer) ('aaaa')
 *
 * Prec: $month y $year deben ser integer.
 * Post: none
 */
  function daysInMonth($month, $year)
  {
  // Calculo la cantidad de dias en el mes
  return $month == 2 ? ($year % 4 ? 28 : ($year % 100 ? 29 : ($year % 400 ? 28 : 29))) : (($month - 1) % 7 % 2 ? 30 : 31);
  }