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

int TriIteratif(char tab[], int taille);
int TriRecursif(char tab[], int taille);
int TriFusion(char tab1[], int taille1, char tab2[], int taille2);  //ne pas utiliser directement, ce n'est pas une fonction de tri !

int Compteur1(char tab[], int taille, int *valeurMax, int *tailleSeqMax);
int Compteur2(char tab[], int taille, int *valeurMax, int *tailleSeqMax);


int main()
{
    int i, taille;
    char *tab;

    do
    {
        system("cls");
        printf("Quelle est la taille de votre tableau ? ");
        scanf("%d", &taille);
    } while (taille<=0);

    printf("\n");
    tab = malloc(taille);

    for (i=0 ; i<taille ; i++)
    {
        printf("Case %d : ", i);
        scanf("%d", tab+i);
    }

    system("cls");
    printf("Valeurs entrees, recapitulatif :\n");
    for (i=0 ; i<taille ; i++)
        printf("%d ", tab[i]);

    printf("\n\nComptage en cours...");
    int valeur, max;
    Compteur1(tab, taille, &valeur, &max);

    printf("\nTermine ! Bilan :\nLe chiffre le plus present est le %d.\nIl apparait %d fois.\n\n", valeur, max);
    free(tab);

    return 0;
}


int TriIteratif(char tab[], int taille)
{
    if (taille <= 0 || !tab)
        return 0;

    int i,j,temp;
    for (i=0 ; i<taille ; i++)
    {
        for (j=i+1 ; j<taille ; j++)
        {
            if (tab[i]>tab[j])
            {
                temp = tab[i];
                tab[i]=tab[j];
                tab[j]=temp;
            }
        }
    }

    return 1;
}

int TriRecursif(char tab[], int taille)
{
    if (taille < 0 || !tab)
        return 0;

    if (taille <= 1)
        return 1;

    int nTaille1 = taille/2,
        nTaille2 = taille-nTaille1;

    TriRecursif(tab, nTaille1);
    TriRecursif(tab+nTaille1, nTaille2);

    TriFusion(tab, nTaille1, tab+nTaille1, nTaille2);
    return 1;
}

int TriFusion(char tab1[], int taille1, char tab2[], int taille2)
{
    if (!tab1 || taille1<0 || !tab2 || taille2<0)
        return 0;

    if (taille2==0)
        return 1;
    else if (taille1==0)
    {
        memcpy(tab1, tab2, taille2);
        return 1;
    }

    char *nTab = malloc(taille1+taille2);
    if (!nTab)
        return 0;

    int i,j=0,k=0;
    for (i=0 ; i<taille1+taille2 ; i++)
    {
        if (j<taille1 && (k>=taille2 || tab1[j]<tab2[k]))
        {
            nTab[i] = tab1[j];
            j++;
        }
        else
        {
            nTab[i] = tab2[k];
            k++;
        }
    }

    memcpy(tab1, nTab, taille1+taille2);
    free(nTab);

    return 1;
}

int Compteur1(char tab[], int taille, int *valeurMax, int *tailleSeqMax)
{
    if (!tab || taille<=0)
        return 0;
    if (!valeurMax && !tailleSeqMax)
        return 0;

    char *tab2 = malloc(taille*2);
    if (!tab2)
        return 0;
    memset(tab2, 0, taille*2);

    int i,j;
    for (i=0 ; i<taille ; i++)
    {
        j=0;
        while (tab2[2*j+1] && tab2[2*j] != tab[i])
            j++;

        tab2[2*j+1]++;
        tab2[2*j] = tab[i];
    }

    int max = tab2[1],
        valeur = tab[0];
    for (i=1 ; i<taille ; i++)
    {
        if (max<tab2[2*i+1])
        {
            max = tab2[2*i+1];
            valeur = tab2[2*i];
        }
    }

    if (tailleSeqMax)
        *tailleSeqMax = max;
    if (valeurMax)
        *valeurMax = valeur;

    free(tab2);
    return 1;
}

int Compteur2(char tab[], int taille, int *valeurMax, int *tailleSeqMax)
{
    if (!tab || taille<=0)
        return 0;
    if (!valeurMax && !tailleSeqMax)
        return 0;

    TriIteratif(tab, taille);

    int i,tot=1,max=0,valeur;
    for (i=1 ; i<=taille ; i++)
    {
        if (i==taille || tab[i] != tab[i-1])
        {
            if (max<tot)
            {
                max = tot;
                valeur = tab[i-1];
            }
            tot = 1;
        }
        else tot++;
    }

    if (valeurMax)
        *valeurMax = valeur;
    if (tailleSeqMax)
        *tailleSeqMax = max;

    return 1;
}

#include <stdio.h>

#define N   10
int main(void)
{
    int t[N] = {6, 2, 3, 6, 5, 4, 2, 6, 8, 9};

    int i, j;
    /* Valeur la plus présente */
    int vmax = t[0];
    /* Nombre d'occurrences de la valeur la plus présente */
    int max = 0;
    
    for(i = 0; i < N - 1; ++i)
    {
        int cpt = 1;
        for(j = i + 1; j < N ; ++j)
        {
            if(t[j] == t[i])
                cpt++;
        }
        if(cpt > max)
        {
            max =  cpt;
            vmax = t[i];
        }
    }

    printf("%d %d", max, vmax);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int cmp(void const *a, void const *b)
{
    const int pa = *(const int*)a;
    const int pb = *(const int*)b;
    if (pa < pb) return -1;
    if (pa > pb) return 1;
    return 0;
}
int main(void)
{
    int t[] = {6, 2, 3, 6, 5, 4, 2, 6, 8, 9};
    size_t n = sizeof t / sizeof *t;
    size_t i;
    /* Valeur la plus présente */
    int vmax;
    /* Nombre d'occurrences de la valeur la plus présente */
    int max = 1;

    qsort(t, n ,sizeof *t, cmp);

    vmax = t[0];
    for (i = 1; i < n; i++)
        if (t[i] == t[i - max])
        {
            max++;
            vmax = t[i];
        }

    printf("%d %d", max, vmax);

    return 0;
}