include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "implementaciones.c"
//#define F 20
//#define C 79
///EJERCICIO 1.16
int es_palindromo (char * i);
int es_palindromo_r (char * i, char * f);
char a_may(char);

///EJERCICIO 1.13 y 1.14
//Se tiene una matriz de char NxM donde pueden haber espacios o x que representan y delimitan lugares que no se puedenllegar. Imple,emntar una funcion recursiva que dadas las coordenadas de un casillero rellene los elementos permitidos del a matriz con el caracter #
/*
void pintar(char[F][C], int, int);
void imprimir(char [F][C]);
*/

///EJERCICIO 1.12
//Programar una funcion que reciba como parametro una longitud y a partir de este imprima todas las posibles combinaciones de letras minusculas de dicha longitud
/*
void imprimirCombinacion(unsigned int cantidad);
void combinacionRecursiva(unsigned int cantidad, char * arreglo, int i);
*/

///EJERCICIO 1.11
//Programar una funcion recursiva que ordene en forma creciente un areglo dinamico unidimensional de numeros enteros.
//Utilizar la funcion recursiva programada para retornar la posicion de memoria del valor minimo del arreglo.
//void ordenar(int vect[], int ind_izq, int ind_der);

///EJERCICIO 1.10
//A)Funcion recursiva que retorne el valor minimo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final del arreglo;
//B)Funcion recursiva que retorne la direccion del valor minimo de un arreglo unidimensional de numeros enteros, el 0 marca el final del arreglo;
//unsigned int valor_minimo (int * arreglo, int * minimo);
//unsigned int direccion_minimo (int * arreglo, int * minimo);

///EJERCICIO 1.9
//Funcion recursiva que retorne el valor maximo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final de los valores posibles;
//Funcion recursiva que retorne la direccion de memoria del valor maximo de un arreglo unidimensional dinamico de numeros enteros, el 0 marca el final de los valores posibles;
/*
int valor_maximo(int * arreglo, int * maximo);
unsigned int direccion_maximo ( int * arreglo, int * maximo);
*/

///EJERCICIO 1.8
//Crear una funcion recursiva que invierta un arreglo unidimensional de enteros de tal que su prototipo sea void invertir (int *,unsigned int);
/*
void invertir(int * arreglo, unsigned int cantidad);
*/

///EJERCICIO 1.7
//Programar una funcion recursiva para realizar la potenciacion de numeros enteros pero intentando optimizarla de modo de minimizar la cantidad de multiplicaciones totales realizadas.
/*
int potencia_optimizada(int numero1,int numero2);
*/

///Ejercicio 1.6
//Realizar una funcion recursiva que reciba como parametro un string (dado como puntero a char) que contiene un texto y que imprima dicho texto en forma inversa.
/*
void invertir_texto (char * texto,char * fin);
*/


///Ejercicio 1.4
//Crear una funcion recursiva que reciba como parametro un string (dado como puntero a char) que contiene un texto y que retorne la cantidad de caracteres que hay en dicha cadena.-
/*
unsigned int contar_caracteres (char * frase);
*/

///Ejercicio 1.5
//Crear una funcion recursiva que reciba como parametro un string (dado como un puntero a char) que contiene un texto y que retorne la cantidad de vocales que hay en este, el prototipo debe ser
//unsigned int contar_vocales (char*);
/*
unsigned int contar_vocales (char * frase);
*/

///Ejercicio 1.1 multiplicacion recursiva.-
/*
int multiplicacion_recursiva (int numero1, int numero2);
*/

///Ejercicio 1.2
//Hacer una funcion recursiva que retorne el cociente de dos numeros enteros(division entera) utilizando unicamente el operador de resta.
//Hacer otra funcion recursiva que retorne el resto de la division entera de dos numeros enteros utilizando unicamente el operador de resta.
/*
int cocienteEntero(int numero1,int numero2);
int restoEntero(int numero1, int numero2);
*/

///Ejercicio 1.3
//Programar una funcion recursiva que retorne la potencia de un numero real elevado a un numero entero.
/*
double potenciaRecursiva (double numero1, int numero2);
*/
int main()
{
    srand(time(NULL));
    ///Ejercicio 1.16


    char palindromo[]={"A rri BaL aBir rA"};
    char * i=palindromo;
    printf("%d",es_palindromo(palindromo));


    ///EJERCICIO 1.13 y 1.14
    /*
    unsigned int fila=1, columna=1;
            char arreglo[F][C]={"                                                 #############################",
                    "                                                 #                            ",
                    "                                                 #                            ",
                    "                                                 #                            ",
                    "                                                 #                            ",
                    "       ######                       ##########################################",
                    "      #     #                       #            #                 #          ",
                    "     #      #                        #           #                 #          ",
                    "    #       #                         #          #                 #          ",
                    "   #        #                          #         #                ##          ",
                    "  #         ######################################               # #          ",
                    " #                                    #                         #  #          ",
                    "#                                     #                        #   #          ",
                    "                                      #                       #    #          ",
                    "                                      #####################  #     #          ",
                    "                                                          # #      #          ",
                    "                                                          ##       #          ",
                    "                                                          #        #          ",
                    "                                                                   #          ",
                    "                                                                   ###########",
                    "                                                                              ",
                    "                                                                              ",
                    "                                                                              "};
                    imprimir(arreglo);
        pintar(arreglo, fila, columna);
        imprimir(arreglo);
    */

    ///EJERCICIO 1.12
    /*
    imprimirCombinacion(6);
    */

    ///EJERCICIO 1.11 Ordenamiento de arreglo
    /*
    int arreglo[]={9,8,7,6,5,4,3,2,1,0};
    int i;
    int * puntero=arreglo;
    ordenar(arreglo,0,9);

    for (i=0; i<10;i++)
    {
        printf("%d, ",arreglo[i]);
    }
    */

    ///EJERCICIO 1.10B Direccion del minimo de un arreglo.
    /*
    int arreglo[]={10,2,1,4,5,6,7,8,19,0};
    int * puntero=arreglo;
    int * minimo=puntero;
    printf("La direccion del valor minimo del arreglo es= %u ",direccion_minimo(puntero,minimo));
    */

    ///EJERCICIO 1.10A Valor minimo de un arreglo
    /*
    int arreglo[]={1,2,1,4,5,6,7,8,19,0};
    int * puntero=arreglo;
    int * minimo=puntero;
    printf("El valor minimo del arreglo es= %u ",valor_minimo(puntero,minimo));
    */

    ///EJERCICIO 1.9B Direccion del maximo de un arreglo
    /*
    int arreglo[]={1,2,1,4,5,6,7,8,9,0};
    int * puntero=arreglo;
    int * maximo=puntero;
    printf("La direccion del valor maximo del arreglo es= %u ",direccion_maximo(puntero,maximo));
    */

    ///EJERCICIO 1.9A Valor Maximo Arreglo
    /*
    int arreglo[]={1,2,1,4,5,6,7,8,19,0};
    int * puntero=arreglo;
    int * maximo=puntero;

    printf("El valor maximo del arreglo es= %u ",valor_maximo(puntero,maximo));
    */
    ///EJERCICIO 1.8 Invertir Arreglo
    /*
    int numeros[]={1,2,3,4,5,6,7,8,9};
    int * puntero=numeros;
    int i;
    unsigned int cantidad=9;

    printf("Los valores originales del arreglo son: ");
    for (i=0;i<cantidad;i++)
    {
        printf("%d, ",numeros[i]);
    }
    printf("\nLos valores nuevos del arreglo son: ");
    invertir(puntero,cantidad);

    for (i=0;i<cantidad;i++)
    {
        printf("%d, ",numeros[i]);
    }
    */
    ///EJERCICIO 1.7 Potencia optimizada
    /*
    int numero1=rand()%8+1;
    int numero2=rand()%8+1;
    printf("El numero 1 es: %d\n",numero1);
    printf("El numero 2 es: %d\n",numero2);
    printf("La potencia normal es: %g\n",pow(numero1,numero2));
    printf("La potencia optimizada es: %g ",potencia_optimizada(numero1,numero2));
    */

    ///Ejercicio 1.6 Invertir Arreglo Char
    /*
    char frase[]={"Esta es una frase de ejemplo"};
    char * puntero=frase;
    char * fin = frase;
    while (*fin != '\0')
    {
        fin++;
    }
    invertir_texto(puntero,fin);
    */

    ///EJERCICIO 1.4 CONTAR CARACTERES
    /*
    char frase[]={"Esta es una frase de ejemplo"};
    char * puntero=frase;
    printf("La cantidad de caracteres contenidas en la frase es de: %d",contar_caracteres(puntero));
    */

    ///EJERCICIO 1.5 CONTAR VOCALES
    /*
    char frase[]={"Esta es una frase de ejemplo"};
    char * puntero=frase;
    printf("La cantidad de vocales contenidas en la frase es de: %d",contar_vocales(puntero));
    */

    ///EJERCICIO 1.3 Potencia recursiva
    /*
    double numero1=-7.3;
    int numero2=-rand()%10;
    printf("%g\n",numero1);
    printf("%d\n",numero2);
    printf("El valor de la potencia para las dos variables es: %g\n",pow(numero1,numero2));
    printf("El valor de la potencia recursiva es: %g",potenciaRecursiva(numero1,numero2));
    */

    ///Ejercicio 1.1 producto recursivo, definicion de variables y prueba de valores.
    /*
    int numero1=-5;
    int numero2=rand()%10;
    printf("%d\n",numero1);
    printf("%d\n",numero2);
    //Ejercicio 1.1 llamado a la funcion recursiva con los valores que pueden ser cualquier numero positivo.
    printf("El valor de la multiplicacion para las dos variables es: %d\n",numero1*numero2);
    printf("El valor de la funcion recursiva para el producto es: %d\n",multiplicacion_recursiva(numero1,numero2));
    */

    ///Ejercicio 1.2 Llamado a funcion recursiva de division y resto.
    /*
    int numero1=rand()%100;
    int numero2=rand()%10+1;
    printf("El primer numero es: %d\n",numero1);
    printf("El segundo numero es: %d\n",numero2);
    printf("La division devuelve: %d\n",numero1/numero2);
    printf("El resto es: %d\n",numero1%numero2);
    printf("Recursivamente la division es: %d\n",cocienteEntero(numero1,numero2));
    printf("Recursivamente el modulo es: %d",restoEntero(numero1,numero2));
    */

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

//#define F 20
//#define C 79
///Ejercicio 1.16

int es_palindromo (char * i)
{
    char * f;
    for (f=i;*f!='\0';f++);
    return es_palindromo_r(i,f-1);
}

int es_palindromo_r (char * i, char * f)
{
    if (f<=i)
    {
        return 1;
    }
    else if (a_may(*f) != a_may(*i) && *i != ' ' && *f != ' ')
    {
        return 0;
    }
    else
    {
        if(*i==' ')
        {
            return es_palindromo_r(i+1,f);
        }
        if(*f==' ')
        {
            return es_palindromo_r(i,f-1);
        }
        return a_may(*i)==a_may(*f) && es_palindromo_r(i+1,f-1);
    }
}

char a_may(char x)
{
    if (x >='a' && x <= 'z')
        return x-('a'-'A');
    return x;
}



///EJERCICIO 1.13 y 1.14
/*
void pintar(char mat[F][C], int x, int y)
{

    if(x<F && x>=0 && y<C-1 && y>=0 && mat[x][y]==' ')
    {
        mat[x][y]='X';
        pintar(mat, x, y+1);
        pintar(mat, x+1, y);
        pintar(mat, x, y-1);
        pintar(mat, x-1, y);
        pintar(mat, x+1, y+1);
        pintar(mat, x-1, y+1);
        pintar(mat, x-1, y-1);
        pintar(mat, x+1, y-1);
    }
}

void imprimir(char m[F][C])
{
    unsigned int i,j;

    for(i=0;i<F;i++)
    {
        for(j=0;j<C;j++)
        {
            printf("%c", m[i][j]);
            _sleep(5);
        }
        printf("\n");
    }

}
*/

///EJERCICIO 1.12
/*
void imprimirCombinacion(unsigned int cantidad)
{
    char * arreglo;
    arreglo=malloc(sizeof(char)*cantidad+1);
    arreglo[cantidad]='\0';
    combinacionRecursiva(cantidad,arreglo,0);
    free(arreglo);
}

void combinacionRecursiva(unsigned int cantidad, char * arreglo, int i)
{
    char c;
    if(cantidad!=0)
    {
        for (c='a';c<='z';c++)
        {
            arreglo[i]=c;
            combinacionRecursiva(cantidad-1,arreglo,i+1);
        }
    }
    else
    {
        printf("%s\n",arreglo);
    }
}
*/

///EJERCICIO 1.11
/*
void ordenar (int vect[], int ind_izq, int ind_der)
{
    int i, j;  //variables indice del vector
    int elem;  //contiene un elemento del vector
    i = ind_izq;
    j = ind_der;
    elem = vect[(ind_izq+ind_der)/2];
    do
    {
        while (vect[i] < elem) //recorrido del vector hacia la derecha
            i++;
        while (elem < vect[j]) // recorrido del vector hacia la izquierda
            j--;
        if (i <= j) // intercambiar
        {
            int aux; // variable auxiliar
            aux = vect[i];
            vect[i] = vect[j];
            vect[j] = aux;
            i++;
            j--;
        }
    }
    while (i <= j);
    if (ind_izq < j)
    {
        ordenar (vect, ind_izq, j);   //Llamadas recursivas
    }
    if (i < ind_der)
    {
        ordenar (vect, i, ind_der);
    }
}
*/
///IMPLEMENTACION 1.10B
/*
unsigned int direccion_minimo(int * arreglo, int * minimo)
{
    if ( *arreglo==0)
    {
        return minimo;
    }
    else if ( *minimo > *arreglo)
    {
        minimo=arreglo;
        direccion_minimo(arreglo+1,minimo);
    }
    else
    {
        direccion_minimo(arreglo+1,minimo);
    }
}
*/

///IMPLEMENTACION 1.10A
/*
unsigned int valor_minimo(int * arreglo, int * minimo)
{
    if ( *arreglo==0)
    {
        return *minimo;
    }
    else if ( *minimo > *arreglo)
    {
        minimo=arreglo;
        valor_minimo(arreglo+1,minimo);
    }
    else
    {
        valor_minimo(arreglo+1,minimo);
    }
}
*/

///IMPLEMENTACION 1.9B
/*
unsigned int direccion_maximo ( int * arreglo, int * maximo)
{
    if (*arreglo == 0)
    {
        return maximo;
    }
    else
    {
        if(*arreglo>*maximo)
        {
            maximo=arreglo;
            direccion_maximo(arreglo+1,maximo);
        }
        else
        {
            direccion_maximo(arreglo+1,maximo);
        }
    }
}
*/

///IMPLEMENTACION 1.9A
/*
int valor_maximo(int * puntero, int * maximo)
{
    if (*puntero == 0)
    {
        return *maximo;
    }
    else
    {
        if(*puntero>*maximo)
        {
            maximo=puntero;
            valor_maximo(puntero+1,maximo);
        }
        else
        {
            valor_maximo(puntero+1,maximo);
        }
    }
}
*/

///IMPLEMENTACION 1.8
/*
void invertir (int * puntero, unsigned int cantidad)
{
    int auxiliar;
    if(cantidad<=1)
    {
        return 0;
    }
    else
    {
        auxiliar=*(puntero+cantidad-1);
        *(puntero+cantidad-1)=*puntero;
        *puntero=auxiliar;
        invertir(puntero+1,cantidad-2);
    }
}
*/



///IMPLEMENTACION 1.7
/*
int potencia_optimizada(int numero1, int numero2)
{
    if(numero2==1)
    {
        return numero1;
    }
    else
    {
        if(numero2%2!=0)
        {
            return numero1*numero1*potencia_optimizada(numero1,(numero2-1)/2);
        }
        else
        {
            return numero1*potencia_optimizada(numero1,(numero2/2));
        }
    }
}
*/

///IMPLEMENTACION EJERCICIO 1.6
/*
void invertir_texto (char * texto,char * fin)
{
    if (texto==fin)
    {
        return 0;
    }
    else
    {
        fin--;
        printf("%c",*fin);
        invertir_texto(texto,fin);
    }
}
*/

///IMPLEMENTACION DE EJERCICIO 1.4
/*
unsigned int contar_caracteres(char * puntero)
{
    if (*puntero == '\0')
    {
        return 0;
    }
    else if (*puntero >= 'a' && *puntero <= 'z' || *puntero >= 'A' && *puntero <= 'Z')
    {
        return 1+contar_caracteres(puntero+1);
    }
    else
    {
        return contar_caracteres(puntero+1);
    }
}
*/

///Implementacion de ejercicio 1.5
/*
unsigned int contar_vocales (char * puntero)
{
    if(*puntero == '\0')
    {
        return 0;
    }
    else if (*puntero == 'a' || *puntero == 'e' || *puntero == 'i'|| *puntero == 'o' || *puntero == 'u' ||*puntero == 'A' || *puntero == 'E' || *puntero == 'I'|| *puntero == 'O' || *puntero == 'U' )
    {
        return 1+contar_vocales(puntero+1);
    }
    else
    {
        return contar_vocales(puntero+1);
    }
}
*/

///IMPLEMENTACION DE EJERCICIO 1.3

/*
double potenciaRecursiva (double numero1, int numero2)
{
    if (numero2==1)
    {
        return numero1;
    }
    else if(numero1!=0 && numero2 == 0)
    {
        return 1;
    }
    else if (numero1 == 0 && numero2 <=0)
    {
        return 0;
    }
    else if (numero2<0 && numero1 != 0)
    {
        return potenciaRecursiva(1/numero1,-numero2);
    }
    else
    {
        return numero1*potenciaRecursiva(numero1,numero2-1);
    }
}
*/

/// Implementacion de producto recursivo ejercicio 1.1.
/*
int multiplicacion_recursiva (int numero1, int numero2)
{
    if(numero2==0)
    {
        return 0;
    }
    else if (numero2<0)
    {
        return -numero1+multiplicacion_recursiva(numero1,numero2+1);
    }
    else
    {
        return numero1+multiplicacion_recursiva(numero1,numero2-1);
    }
}
*/

///Implementacion de ejercicio 1.2

/*int cocienteEntero(int numero1,int numero2)
{
    if (numero1==0 || numero2==0)
    {
        return 0;
    }
        if (numero1<numero2)
        {
            return 0;
        }
        else
        {
            return 1+cocienteEntero(numero1-numero2,numero2);
        }
}

int restoEntero(int numero1,int numero2)
{
    if (numero1==0 || numero2 == 0)
    {
        return 0;
    }
    else if (numero1<numero2)
    {
        return numero1;
    }
    else
    {
        return restoEntero(numero1-numero2,numero2);
    }
}
*/