Calculando a Moda, Tenenbaum 1.2.1 b

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "funcoes.h"
#include "Teste_unitario/Teste_Moda_121b.h"
/*
Exercício 1.2.1 b.
A MODA de um vetor de números é o número m no vetor que é  repetido  com  maior
frequencia. Se mais de um número for repetido com freqüência máxima igual,  não
existirá uma moda. Escreva uma função em C que aceite um  vetor  de  números  e
retorne a moda ou uma indicação de que a moda não existe.

Fonte: Estruturas de Dados Usando C - Tenembaum, pg53 - 54.

Autor da solução: Renato de Pierri
https://github.com/renatopierri/algoritmos/tree/main/Tenembaum_moda_1_2_1_b

Para simplificar, ao inves de inserir manualmente os valores no array optei por
gerar automaticamente os valores do array.

Essa funcao "calcula_moda" faz o calculo apenas de numeros positivos.
Caso a serie nao tenha um valor para a moda, a funcao retornara o valor "-1".

funcoes.h tem as configuracoes da aplicacao e de teste, conforme abaixo:

QUANTIDADE: Nr de elementos na serie.
DADOS:      Nr de dados que serao gerados aleatoriamente para calcular a moda.
DEBUG:      0 - Operacao normal, 1 - Modo de testes.
CONTINUO:   0 - Roda uma vez,    1 - Modo continuo.

//Parametros de teste
#define ITENS 5     - Numero de itens a serem gerados.
#define TAMANHO 100 - Número de valores da serie a serem analisados.
*/

int main(){

    int limite, tamanho_valores, moda = 0;
    int valores[QUANTIDADE]={0};
    moda--;
    limite = QUANTIDADE - 1;
    tamanho_valores = sizeof(valores)/sizeof(int);
    do{
        if(DEBUG == 0){
            gera_aleatorio(valores,tamanho_valores,DADOS);
            moda = calcula_moda(valores,limite);
            zera_valores(valores,tamanho_valores);
        }else{
            printf("Rodando testes\n");
            RunAllTests();
            system("pause");
        }
    }while(CONTINUO == 1);
    return 0;
}

#ifndef FUNCOES_H_INCLUDED
#define FUNCOES_H_INCLUDED

/*
funcoes.h tem as configuracoes da aplicacao e de teste, conforme abaixo:

QUANTIDADE: Nr de elementos na serie.
DADOS:      Nr de dados que serao gerados aleatoriamente para calcular a moda.
DEBUG:      0 - Operacao normal, 1 - Modo de testes.
CONTINUO:   0 - Roda uma vez,    1 - Modo continuo.

//Parametros de teste
#define ITENS 5     - Numero de itens a serem gerados.
#define TAMANHO 100 - Número de valores da serie a serem analisados.
*/

#define QUANTIDADE 10
#define DADOS 100
#define DEBUG 0
#define CONTINUO 1

#define ITENS 5
#define TAMANHO 100

void gera_aleatorio(int valores[],int tamanho, int quantidade);
void zera_valores(int valores[],int tamanho);
int calcula_moda(int valores[],int limite);

#endif // FUNCOES_H_INCLUDED

#ifndef FUNCOES_C_INCLUDED
#define FUNCOES_C_INCLUDED

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "funcoes.h"
#include "Teste_unitario/CuTest.h"
#include "Teste_unitario/Teste_Moda_121b.h"

void gera_aleatorio(int valores[],int tamanho, int quantidade){
    int controle;
    int temp;
    for(controle = 0;controle<quantidade;controle++){
        temp = rand() % tamanho;
        valores[temp]=(valores[temp])+1;
    }
}

void zera_valores(int valores[],int tamanho){
    int controle;
    for (controle = 0;controle<tamanho;controle++){
        valores[controle] = 0;
    }
}

int calcula_moda(int valores[],int limite){
    int contagem, controle, moda = 0;
    char status[11];
    moda = 0;
    contagem = valores[0];

    //Calculando a moda
    for (controle = 1;controle <=limite ;controle ++){
        if(contagem == valores[controle]){
            strcpy(status,"nao existe");
        }
        if(contagem < valores[controle]){
            contagem = valores[controle];
            moda = controle;
            strcpy(status,"valida");
        }
    }

    // Imprimindo o resultado
    printf("Os valores sao: ");
    for(controle = 0; controle <=limite;controle++){
        printf("%03i\t",controle);
    }
    printf("\n");

    printf("A contagem  eh: ");
    for(controle = 0; controle <=limite;controle++){
        printf("%03i\t",valores[controle]);
    }
    printf("\n\n");

    if(strcmp(status,"nao existe")){
        printf("A moda eh o valor %02i, com %03i contagens, status: %s\n",moda,contagem,status);
    }else{
        printf("Moda %s.\n", status);
        moda = -1;
    }

    printf("\n\n");
    if(DEBUG == 0){
        system("pause");
    }
    system("cls");
    return  moda;
}
#endif // FUNCOES_C_INCLUDED

#ifndef TESTE_MODA_121B_H_INCLUDED
#define TESTE_MODA_121B_H_INCLUDED
#include "../funcoes.h"
#include "CuTest.h"
CuSuite*StrUtilGetSuite();
void RunAllTests(void);

// Testes unitarios

void Teste_Gera_Aleatorio(CuTest *tc);
void Teste_Zera_Valores(CuTest *tc);
void Teste_Calcula_Moda(CuTest *tc);
void Teste_Calcula_Moda_Erro(CuTest *tc);

#endif // TESTE_MODA_121B_H_INCLUDED

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "Teste_Moda_121b.h"
#include "../funcoes.h"

CuSuite* StrUtilGetSuite();

void RunAllTests(void){
    CuString* output = CuStringNew();
    CuSuite* suite = CuSuiteNew();
    CuSuiteAddSuite(suite, StrUtilGetSuite());
    CuSuiteRun(suite);
    CuSuiteSummary(suite, output);
    CuSuiteDetails(suite, output);
    printf ("%s\n\n", output->buffer);
}

void Teste_Gera_Aleatorio(CuTest *tc){
    CuString* str = CuStringNew();
    int valores[ITENS];
    int tamanho = sizeof(valores)/sizeof(valores[0]) ;
    int quantidade = 100;
    int total;
    int controle;
    char resp1[10];
    char resp2[10];
    for (controle = 0;controle < tamanho; controle ++){
        valores[controle] = 0;
    }
    gera_aleatorio(valores, tamanho, quantidade);
    for (controle = 0;controle < tamanho; controle ++){
        total = total + valores[controle];
    }
    sprintf(resp1,"%i",(int)total);
    sprintf(resp2,"%i",(int)quantidade);
    CuStringAppend(str,resp1);
    CuAssertStrEquals(tc,resp2 , str->buffer);
}

void Teste_Zera_Valores(CuTest *tc){
    CuString* str = CuStringNew();
    int valores[TAMANHO];
    int tamanho = sizeof(valores)/sizeof(valores[0]);
    int controle;
    char resp1[TAMANHO+1]={'\0'};
    char resp2[TAMANHO+1]={'\0'};
    char temp[2];
    gera_aleatorio(valores, tamanho, 200);
    zera_valores(valores,tamanho);
    for(controle = 0;controle < tamanho;controle++){
        sprintf(temp,"%i",(int)valores[controle]);
        strcat(resp1,temp);
        strcat(resp2,"0");
    }
    CuStringAppend(str,resp1);
    CuAssertStrEquals(tc,resp2 , str->buffer);
}

void Teste_Calcula_Moda(CuTest *tc){
    CuString* str = CuStringNew();
    int valores[10]={5,8,6,3,1,1,20,3,4,4};
    int limite = 9;
    int resultado = 0;
    char resp1[3]={'\0'};
    resultado = calcula_moda(valores,limite);
    sprintf(resp1,"%i",(int)resultado);
    CuStringAppend(str,resp1);
    CuAssertStrEquals(tc, "6", str->buffer);
}

void Teste_Calcula_Moda_Erro(CuTest *tc){
    CuString* str = CuStringNew();
    int valores[10]={5,8,6,20,1,1,20,3,4,4};
    int limite = 9;
    int resultado = 0;
    char resp1[3]={'\0'};
    resultado = calcula_moda(valores,limite);
    sprintf(resp1,"%i",(int)resultado);
    CuStringAppend(str,resp1);
    CuAssertStrEquals(tc, "-1", str->buffer);
}

CuSuite*StrUtilGetSuite(){
    CuSuite* suite = CuSuiteNew();

    SUITE_ADD_TEST(suite,Teste_Gera_Aleatorio);
    SUITE_ADD_TEST(suite,Teste_Zera_Valores);
    SUITE_ADD_TEST(suite,Teste_Calcula_Moda);
    SUITE_ADD_TEST(suite,Teste_Calcula_Moda_Erro);
}