Estructuras I Práctica 1

    ///EJERCICIO 1:

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

void bubble_sort(float arreglo[], size_t longitud) {
    int iter, i;
    for (iter = 0 ; iter < longitud - 1 ; iter++) {
        for (i = 0 ; i < longitud - iter - 1; i++) {
            if (arreglo[i] > arreglo[i + 1]) {
                float aux = arreglo[i];
                arreglo[i] = arreglo[i + 1];
                arreglo[i + 1] = aux;
}}}}

float mediana(float *arreglo, size_t longitud){
    float *nuevo = (float*) malloc (sizeof(float)*longitud);
    int i;

    for(i=0; i<longitud;i++)
        nuevo[i]=arreglo[i];
    bubble_sort(nuevo,longitud);

    if(longitud%2)
        return nuevo[longitud/2];
    else
        return (nuevo[longitud/2-1] + nuevo[longitud/2])/2;}



int main(){
    float a[]={5,4,1,2,3}, b[]={4.1,0,-1,9};
    printf("%f\n%f",mediana(a,5),mediana(b,4));
    return 0;
}


///EJERCICIO 2
/// No hice la parte B porque no sabía cuáles operaciones contar.

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

int string_len (char* str){
    int i;
    for(i=0;str[i]!='\0';i++);
    return i;}


void string_reverse(char* str){
    char aux;
    int i,j;
    for(i=0,j=string_len(str)-1;i<j;i++,j--){
        aux=str[i];
        str[i]=str[j];
        str[j]=aux;}}


size_t string_concat(char* str1, char* str2, size_t max){
    int i, largoStr1=string_len(str1),largoStr2=string_len(str2);
    for(i=0;i<largoStr2 && largoStr1+i<max;i++)
        str1[largoStr1+i]=str2[i];
    str1[largoStr1+i]='\0';
    return i;}


int string_compare(char* str1, char* str2){
    int i, largoStr1=string_len(str1);
    for(i=0;i<largoStr1 && tolower(str1[i])==tolower(str2[i]);i++);
    if (tolower(str1[i])<tolower(str2[i]))
        return -1;
    if (tolower(str1[i])==tolower(str2[i]))
        return 0;
        return 1;}


int string_subcadena(char* str1, char* str2){
    int i,j,largoStr1=string_len(str1),largoStr2=string_len(str2), flag=1;
    for(i=0;i<=largoStr1-largoStr2;i++){
        if(str1[i]==str2[0]){
            flag=1;
            for(j=0;j<largoStr2;j++)
                if(str1[i+j]!=str2[j]){
                    flag=0;
                    break;
                }
             if(flag) return i;
        }
    }
    return -1;}


void string_cat(char* str1, char* str2){
    int i, largoStr1=string_len(str1),largoStr2=string_len(str2);
    for(i=0;i<largoStr2;i++)
        str1[largoStr1+i]=str2[i];
    str1[largoStr1+i]='\0';}


void string_unir(char* arregloStrings[], size_t capacidad, char* sep, char* res){
    int i, largoSep=string_len(sep);
    res[0]='\0';
    string_cat(res,arregloStrings[0]);
    for(i=1;i<capacidad;i++){
        string_cat(res,sep);
        string_cat(res,arregloStrings[i]);
    }
}


int main(){
    char a1[]="Hoi", a2[]="Pepe", a3[]="The", a4[]="Frog", b[]=" ";
    char *a[]={a1,a2,a3,a4};
    char c[]="Lalalala";
    string_unir(a,4,b,c);
    printf("%s",c);
    return 0;
}


/// EJERCICIOS 3 Y 4

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

typedef struct {
int* direccion;
size_t capacidad;
} ArregloEnteros;


ArregloEnteros* arreglo_enteros_crear(size_t capacidad){
    ArregloEnteros* dir = (ArregloEnteros*) malloc (sizeof(ArregloEnteros));
    dir->capacidad=capacidad;
    dir->direccion = (int*) malloc (sizeof(int)*capacidad);
    return dir;}


void arreglo_enteros_destruir(ArregloEnteros* arreglo){
    free(arreglo->direccion);
    free(arreglo);}


int arreglo_enteros_leer(ArregloEnteros* arreglo, size_t pos){
    return arreglo->direccion[pos];}


void arreglo_enteros_escribir(ArregloEnteros* arreglo, size_t pos, int dato){
    arreglo->direccion[pos]=dato;}


size_t arreglo_enteros_capacidad(ArregloEnteros* arreglo){
    return arreglo->capacidad;}


void arreglo_enteros_imprimir_en_pantalla(ArregloEnteros arreglo){
    int i;
    for(i=0;i<arreglo.capacidad;i++)
        printf("%d\n", arreglo.direccion[i]);}


void arreglo_enteros_ajustar(ArregloEnteros* arreglo, size_t capacidad){
    arreglo->direccion = realloc (arreglo->direccion, sizeof(int) * capacidad);
    arreglo->capacidad = capacidad;}


void arreglo_enteros_insertar(ArregloEnteros* arreglo, size_t pos, int dato){
    int i;
    if(pos<arreglo->capacidad){
    arreglo_enteros_ajustar(arreglo, arreglo->capacidad+1);
    for(i=arreglo->capacidad-1;i>pos;i--)
        arreglo->direccion[i]= arreglo->direccion[i-1];

    arreglo->direccion[pos] = dato;
    }}

void arreglo_enteros_eliminar(ArregloEnteros* arreglo, size_t pos){
    int i;

    for(i=pos;i<(arreglo->capacidad-1);i++)
        arreglo->direccion[i]=arreglo->direccion[i+1];

    arreglo_enteros_ajustar(arreglo, arreglo->capacidad-1);}


int main(){
    ArregloEnteros* inicio=arreglo_enteros_crear(10);
    int i;
    for(i=0;i<inicio->capacidad;i++){
        arreglo_enteros_escribir(inicio,i,i);
    }
    arreglo_enteros_imprimir_en_pantalla(*inicio);

    for(i=0;i<5;i++)
        arreglo_enteros_insertar(inicio, i, i-9);

    printf("\n\n");
    arreglo_enteros_imprimir_en_pantalla(*inicio);

    for(i=5;i<8;i++){
        arreglo_enteros_eliminar(inicio, i);
    }
    printf("\n\n");
    arreglo_enteros_imprimir_en_pantalla(*inicio);

    arreglo_enteros_destruir(inicio);
    return 0;
}


///EJERCICIO 5

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

typedef struct{
    float **arreglo;
    size_t alto, ancho;
    }Matriz_bi;


typedef struct{
    float *arreglo;
    size_t alto, ancho;
    }Matriz_uni;


///Funciones de Matriz_bi
Matriz_bi* matriz_bi_crear(size_t alto, size_t ancho){
    int i;
    Matriz_bi* puntero = (Matriz_bi*) malloc (sizeof(Matriz_bi));
    puntero->alto = alto;
    puntero->ancho = ancho;
    puntero->arreglo = (float **) malloc (sizeof(float *) * alto);
    for(i=0; i<alto; i++)
        puntero->arreglo[i] = (float *) malloc (sizeof(float) * ancho);
    return puntero;}


void matriz_bi_destruir (Matriz_bi* matriz){
    int i;
    for(i=0; i<matriz->alto; i++)
        free(matriz->arreglo[i]);
    free(matriz->arreglo);
    free(matriz);}


void matriz_bi_escribir (Matriz_bi* matriz, size_t fila, size_t columna, float dato){
    if(fila < matriz->alto && columna < matriz->ancho)
        matriz->arreglo[fila][columna]=dato;}


void matriz_bi_mostrar (Matriz_bi matriz){
    int i,j;
    for(i=0;i<matriz.alto;i++){
        for(j=0;j<matriz.ancho;j++)
            printf("%f\t",matriz.arreglo[i][j]);
        printf("\n");
    }
}

void matriz_bi_intercambiar_filas (Matriz_bi* matriz, size_t fila1, size_t fila2){
    if(fila1<matriz->alto && fila2<matriz->alto){
        int i;
        float auxiliar;
        for(i=0;i<matriz->ancho;i++){
            auxiliar = matriz->arreglo[fila1][i];
            matriz->arreglo[fila1][i] = matriz->arreglo[fila2][i];
            matriz->arreglo[fila2][i] = auxiliar;
        }
    }
}


Matriz_bi* matriz_bi_sumar (Matriz_bi* matriz1, Matriz_bi* matriz2){
    if (matriz1->ancho == matriz2->ancho && matriz1->alto == matriz2->alto){
        Matriz_bi * matrizSuma = matriz_bi_crear(matriz1->alto, matriz1->ancho);
        int i, j;
        for(i=0, j=0; i < matrizSuma->alto; j++){
            matrizSuma->arreglo[i][j] = matriz1->arreglo[i][j] + matriz2->arreglo[i][j];
            if( j == matrizSuma->ancho-1){
                i++;
                j=-1;
            }
        }
        return matrizSuma;
    }
    return NULL;
}


Matriz_bi* matriz_bi_multiplicar (Matriz_bi* matriz1, Matriz_bi* matriz2){
    if (matriz1->ancho == matriz2->alto){
        Matriz_bi * matrizProd = matriz_bi_crear(matriz1->alto, matriz2->ancho);
        int i, j, indiceProducto;
        float acumulador;
        for(i=0, j=0; i < matrizProd->alto; j++){
            acumulador=0;
            for(indiceProducto = 0; indiceProducto < matriz1->ancho; indiceProducto++)
                acumulador += matriz1->arreglo[i][indiceProducto] * matriz2->arreglo[indiceProducto][j];
            matrizProd->arreglo[i][j] = acumulador;
            if( j == matrizProd->ancho-1){
                i++;
                j=-1;
            }
        }
        return matrizProd;
    }
    return NULL;
}




///Funciones de Matriz_uni
Matriz_uni* matriz_uni_crear (size_t alto, size_t ancho){
    Matriz_uni* puntero = (Matriz_uni*) malloc (sizeof(Matriz_uni));
    puntero->alto = alto;
    puntero->ancho = ancho;
    puntero->arreglo = (float *) malloc (sizeof(float) * ancho * alto);
    return puntero;}


void matriz_uni_destruir (Matriz_uni* matriz){
    free(matriz->arreglo);
    free(matriz);}


void matriz_uni_escribir (Matriz_uni* matriz, size_t fila, size_t columna, float dato){
    if(fila < matriz->alto && columna < matriz->ancho)
            matriz->arreglo[matriz->ancho*fila + columna] = dato;}


void matriz_uni_mostrar (Matriz_uni matriz){
    int i;
    for(i=0;i<(matriz.alto * matriz.ancho); i++){
        printf("%f\t",matriz.arreglo[i]);
        if(i%matriz.ancho == matriz.ancho-1)
            printf("\n");}}


void matriz_uni_intercambiar_filas (Matriz_uni* matriz, size_t fila1, size_t fila2){
    if(fila1<matriz->alto && fila2<matriz->alto){
        int i;
        float auxiliar;
        for(i=0;i<matriz->ancho;i++){
            auxiliar = matriz->arreglo[matriz->ancho * fila1 + i];
            matriz->arreglo[matriz->ancho * fila1 + i] = matriz->arreglo[matriz->ancho * fila2 + i];
            matriz->arreglo[matriz->ancho * fila2 + i] = auxiliar;
        }
    }
}


Matriz_uni* matriz_uni_sumar (Matriz_uni* matriz1, Matriz_uni* matriz2){
    if (matriz1->ancho == matriz2->ancho && matriz1->alto == matriz2->alto){
        Matriz_uni * matrizSuma = matriz_uni_crear(matriz1->alto, matriz1->ancho);
        int i;
        for(i=0; i < matrizSuma->alto * matrizSuma->ancho; i++)
            matrizSuma->arreglo[i] = matriz1->arreglo[i] + matriz2->arreglo[i];
        return matrizSuma;
    }
    return NULL;
}


Matriz_uni* matriz_uni_multiplicar (Matriz_uni* matriz1, Matriz_uni* matriz2){
    if (matriz1->ancho == matriz2->alto){
        Matriz_uni * matrizProd = matriz_uni_crear(matriz1->alto, matriz2->ancho);
        int i, indiceProducto;
        float acumulador;
        for(i=0; i < matrizProd->alto * matrizProd->ancho; i++){
            acumulador=0;
            for(indiceProducto = 0; indiceProducto < matriz1->ancho; indiceProducto++)
                acumulador += matriz1->arreglo[i / matrizProd->ancho + indiceProducto] * matriz2->arreglo[i % matrizProd->ancho + indiceProducto * matrizProd->ancho];
            matrizProd->arreglo[i] = acumulador;
        }
        return matrizProd;
    }
    return NULL;
}



int main(){
    int i;
    Matriz_bi* matricita_bi = matriz_bi_crear(2,3), *matricita_bi2 = matriz_bi_crear(3,5), *matricita_bi_suma, *matricita_bi_producto;
    Matriz_uni* matricita_uni = matriz_uni_crear(2,3), *matricita_uni2 = matriz_uni_crear(3,5), *matricita_uni_suma, *matricita_uni_producto;

    for(i=0;i<6;i++){
        matriz_bi_escribir(matricita_bi, i/3, i%3, i*2);
        matriz_uni_escribir(matricita_uni, i/3, i%3, i*2);}

    for(i=0;i<15;i++){
        matriz_bi_escribir(matricita_bi2, i/5, i%5, i*10);
        matriz_uni_escribir(matricita_uni2, i/5, i%5, i*10);}



    printf("MATRIZ BIDIMENSIONAL: \n");
    matriz_bi_mostrar(*matricita_bi);

    printf("\nDespués de los swaps: \n");
    matriz_bi_intercambiar_filas(matricita_bi, 0, 2);
    matriz_bi_intercambiar_filas(matricita_bi, 1, 0);
    matriz_bi_mostrar(*matricita_bi);

    printf("\nSumada con sí misma: \n");
    matricita_bi_suma = matriz_bi_sumar (matricita_bi, matricita_bi);
    matriz_bi_mostrar(*matricita_bi_suma);

    matricita_bi_producto = matriz_bi_multiplicar(matricita_bi,matricita_bi);
    if (matricita_bi_producto == NULL) printf("\nNo permite multiplicar una matriz rectangular con si misma.\n");
    printf("\nMatriz 1: \n");
    matriz_bi_mostrar(*matricita_bi);
    printf("\nMatriz 2: \n");
    matriz_bi_mostrar(*matricita_bi2);
    printf("\nEl producto de ellas es: \n");
    matricita_bi_producto = matriz_bi_multiplicar(matricita_bi,matricita_bi2);
    matriz_bi_mostrar(*matricita_bi_producto);




    printf("\n\nMATRIZ UNIDIMENSIONAL: \n");
    matriz_uni_mostrar(*matricita_uni);

    printf("\nDespués de los swaps: \n");
    matriz_uni_intercambiar_filas(matricita_uni, 0, 2);
    matriz_uni_intercambiar_filas(matricita_uni, 1, 0);
    matriz_uni_mostrar(*matricita_uni);

    printf("\nSumada con sí misma: \n");
    matricita_uni_suma = matriz_uni_sumar (matricita_uni, matricita_uni);
    matriz_uni_mostrar(*matricita_uni_suma);

    matricita_uni_producto = matriz_uni_multiplicar(matricita_uni,matricita_uni);
    if (matricita_uni_producto == NULL) printf("\nNo permite multiplicar una matriz rectangular con si misma.\n");
    printf("\nMatriz 1: \n");
    matriz_uni_mostrar(*matricita_uni);
    printf("\nMatriz 2: \n");
    matriz_uni_mostrar(*matricita_uni2);
    printf("\nEl producto de ellas es: \n");
    matricita_uni_producto = matriz_uni_multiplicar(matricita_uni,matricita_uni2);
    matriz_uni_mostrar(*matricita_uni_producto);


    matriz_bi_destruir(matricita_bi);
    matriz_bi_destruir(matricita_bi2);
    matriz_bi_destruir(matricita_bi_suma);
    matriz_bi_destruir(matricita_bi_producto);
    matriz_uni_destruir(matricita_uni);
    matriz_uni_destruir(matricita_uni2);
    matriz_uni_destruir(matricita_uni_suma);
    matriz_uni_destruir(matricita_uni_producto);
}



/* EJERCICIO 5-B
La matriz unidimensional necesita de menos punteros para su utilización, aunque la implementación de algunas funciones
puede resultar más engorrosa, además que necesita alocar todos los datos consecutivos en la memoria.
La matriz bidimensional requiere de una mayor cantidad de memoria dado que necesita un puntero para cada fila.
Sin embargo, cada una de las filas puede estar en lugares de la memoria diferentes a las demás.
*/