PREGUNTA 2, GUÍA 4, MÓDULO 3 FINALIZADA, C (gcc)

PREGUNTA 2, GUÍA 4, MÓDULO 3 FINALIZADA

/*
 *                                 __  __
 *                          #######(.)(.)#######    |WENNAAAAAAAAAAA CABREEEEEEETOOOOSSSS!!!!!|
 *                                /  ()  \          |AYAYAYYAYAAIIIIIIIIIIIIIIII!!!!!!!!!     |
 *                          __    \ '--' /     __
 *                         {  |_____"""" _____|  }
 *                          \                   / 
 *                           """"""       """"""
 *                              /           \
 *                              \           /
 *                              /           \
 *                             /      /\     \
 *                        ____/      /  \     \____
 *                       {          |    |         }
 *                       """"""""""""    """"""""""
 */
 
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>

typedef struct
{
    char mail[321];
    char domain[256];    
}users;

typedef struct
{
    char dominio[256];
    unsigned short frequency;
}domains;

// -----------------Prototypes----------------------

void findDomain ( char *, char * );
int compareDomains( const void *, const void * );
void lowerCase( char * );
void output( const users *, domains *, int );
int compareFrequency( const void *, const void* );

// ---------------Main Program-----------------------

int main(void)
{
    // 'typeDomain' representará un vector que almacenará los mail de los usuarios y sus dominios.
    users typeDomain[10000];
    // 'arrayDomains' representará un vector que almacenará los dominios de los mails con su respectiva frecuencia.
    domains arrayDomains[10000];
    
    short i;
    // 'total' representará el total de elementos de 'typeDomain'.
    short total;

// --------------------------Input----------------------
    i = 0;
    while ( i < 10000)
    {
        scanf("%320s", typeDomain[i].mail);
        if ( strcmp(typeDomain[i].mail, "FIN") == 0)
            break;
        i++;
    }
    
    // -----------------------Process-----------------------
    
    total = i;
    // proceso para encontrar el dominio de los mails de los usuarios, para lo cual en cada iteración se llamará a 'findDomain'.
    for (i = 0 ; i < total ; i++)
        findDomain(typeDomain[i].mail, typeDomain[i].domain);
    // proceso para verificar si un dominio está en mayúscula, para lo cual en cada iteración se llamará a la función 'lowerCase'.
    for (i = 0 ; i < total  ; i++)
        lowerCase(typeDomain[i].domain);
    // Proceso para ordenar los elementos de 'typeDomain', de menor a mayor en función de su dominio.
    qsort(typeDomain, total, sizeof(users), compareDomains);
    
    // ---------------------Output-------------------------
    output( typeDomain, arrayDomains, total);
    return 0;
}

// --------------------------------------Functions-------------------------------------------

/* -------------------------------------Procedimiento output---------------------------------
 * Propósito: Mostrar por pantalla los dominios ordenados en función de su frecuencia.
 * Argumentos: 'type' que representa el vector 'typeDomains', 'array' que representa el vector 'arrayDomains' y 'total'.
 */
void output( const users *type, domains *array, int total)
{
    short i;
    // 'j' representará el indice del vector 'array'.
    short j = 0;
    // 'sum' representará la frecuencia de cada dominio.
    unsigned short sum = 1;
    
    /*
     * Proceso para verificar si los dominios adyacentes del vector 'type' son iguales.
     */
    for (i = 0 ; i < total  ; i++)
    {
        // Verificar si los dominios adyacentes son iguales.
        if ( strcmp( type[i].domain, type[i + 1].domain) == 0)
            sum ++;
        else
        {
            strcpy(array[j].dominio, type[i].domain);
            array[j].frequency = sum;
            sum = 1;
            j ++;
        }
    }
    
    total = j;
   
    /* Proceso para ordenar los elementos del vector 'array' en función del campo 'frecuency', es decir, de las frecuencias 
     * de los dominios.
     */
    qsort(array, total, sizeof(domains), compareFrequency);
    
    // Mostrar por pantalla.
    printf("DOMINIOS DIFERENTES ENCONTRADOS\n");
    printf("===============================\n");
    for (i = 0 ; i < j ; i++)
        printf("%s %hu\n", array[i].dominio, array[i].frequency);
    
}

/* -------------------------Procedimiento findDomain-------------------------------
 * Propósito: encontrar el dominio de un correo electrónico. Ejemplo: 
 * pedro@hotmail.com, el dominio es: hotmail.com 
 * 
 * Argumentos: 'mail', que representará el mail a analizar su dominio y 'domain', que representará el dominio del mail.
 */
void findDomain ( char *mail, char *domain)
{
    char *pointer;
    pointer = mail;
    pointer = strchr(mail, '@');
    strcpy(domain, pointer + 1);
}
/* -------------------------Función compareDomains-------------------------------
 * Propósito: Comparar un dominio que servirá de pivote con otro dominio que servirá de elemento para
 * efectuar el quicksort.
 */
int compareDomains( const void *pivot, const void *element )
{
    users *ptrPivot = (users *) pivot;
    users *ptrElement = (users *) element;
    return strcmp( ( ptrPivot -> domain ), ( ptrElement -> domain ) );
}
/* -------------------------Función compareFrequency-------------------------------
 * Propósito: Comparar una frecuencia de un dominio que servirá de pivote con otra frecuencia que servirá de elemento para
 * efectuar el quicksort.
 */
int compareFrequency( const void *pivot, const void *element )
{
    domains *ptrPivot = (domains *) pivot;
    domains *ptrElement = (domains *) element;
    
    return (ptrElement -> frequency) - (ptrPivot -> frequency);
}
/* -------------------------Procedimiento lowerCase-------------------------------
 * Propósito: En caso de que un dominio este escrito en mayúscula, el procedimiento transformara el dominio a minúscula.
 * ejemplo: GMAIL.COM  (process)  gmail.com
 *                     ------->  
 * Argumento: dominio.
 */
void lowerCase( char *domain)
{
    while ( *domain != '\0')
    {
        if ( isupper( *domain ) )
            *domain = tolower(*domain);
        domain ++;
    }
}


run \| edit \| history \| help	0