Citation : crys'

Jaloyan1 : je ne comprend pas trop ta réaction : réécrire strlen est un jeu d'enfant, idem pour isupper ou islower. Il faut juste aller jeter un coup d'œil à la table ASCII et c'est codé en deux temps trois mouvements. Vraiment, cet exercice est simple et très utile (manipulation de char et de tableau de char), l'idée n'est pas de moi mais bien du posteur (Invading).
Cet exercice vous permet donc, comme dit précédemment, de vous entraîner à la manipulation du type char mais aussi, ne l'oublions pas, de vous familiariser avec la norme ASCII. Que demander de plus ?

Citation : yoch

Perso, je recommanderais de faire l'exercice sans regarder la table ASCII (eh oui, c'est possible). Le code sera bien meilleur (plus portable surtout).

Citation : yoch

Perso, je recommanderais de faire l'exercice sans regarder la table ASCII (eh oui, c'est possible). Le code sera bien meilleur (plus portable surtout).

Citation : Invading

La correction tient sur environ 50 lignes je dirais, ce qui n'est pas énorme hein

char *strcapitalize(char *tab);

Citation : GurneyH

char *strcapitalize(char *tab);

char strcapitalize(char *tab);

char *strcapitalize(char *tab);

Citation : invading

Ce n'est qu'un exemple de prototype. Du moment qu'il affiche ce qu'il faut, c'est bon =)

char *strcapitalize(char *tab);

void strcapitalize(char *tab);

char *sStrCapitalize(char *tab);

printf("%s", zStrCapitalize(string));

Citation : GurneyH

oups, on a pas le droit à printf...

int main()
{
   char s[]={"sAlUt tOi !!"};
   printf(s); // ou printf("%s",s) pour ceux qui préfère : affiche "sAlUt tOi !!"
   printf("\n\n");
   printf(strcapitalize(s)); // affiche "Salut toi !!"
   return 0;
}

int main()
{
   char s[]={"sAlUt tOi !!"};
   printf(s);
   printf("\n\n");
   strcapitalize(s);
   printf(s);
   return 0;
}

Citation

bon,
merci pour ta reponse.
je ranges cela dans une petite case, pour comprendre ultérieurement.....
@+

...
sStrCapitalize(string);
printf("%s", string);

Citation : crys'

Curieux, ma fonction tient en 9 lignes (avec accolade) et l'ensemble du code fait 17 lignes (et fonctionne parfaitement).

Citation : DzEt4

Euh, c'est bien beau de le faire en peu de ligne, moi si je veut je le fais en une ligne (et ça fonctionne très bien, je l'ai fait pour voir) mais se sera absolument illisible et incompréhensible

Correction pour zTri

void tri_bulles(int* tab, size_t taille)
{
    unsigned short tab_en_ordre = 0;
    unsigned i;
    int temp;
    while(!tab_en_ordre) // ou while(tab_en_ordre==0)
    {
        tab_en_ordre = 1;
        for(i=0 ; i < taille-1 ; i++)
        {
            if(tab[i] > tab[i+1])
            {
                temp = tab[i];
                tab[i] = tab[i+1];
                tab[i+1] = temp;
                tab_en_ordre = 0;
            }
        }
        taille--;
    }
}

void tri_selection(int* tab, size_t taille)
{
    unsigned fin = taille-1, i, plus_grand;
    int temp;
    while(fin > 0)
    {
        plus_grand = 0;
        for(i = 1 ; i <= fin ; i++)
        {
            if(tab[i] > tab[plus_grand])
                plus_grand = i;
        }
        temp = tab[fin];
        tab[fin] = tab[plus_grand];
        tab[plus_grand] = temp;
        fin--;
    }
}

void tri_insertion(int* tab, size_t taille)
{
    unsigned i, j;
    int element_a_inserer, temp;
    for(i = 1; i < taille; i++)
    {
        element_a_inserer = tab[i];
        for(j = 0; j < i; j++)
        {
            if (element_a_inserer < tab[j])
            {
                temp = element_a_inserer;
                element_a_inserer = tab[j];
                tab[j] = temp;
            }
        }
        tab[i] = element_a_inserer;
    }
}

#include <stdio.h>
#include <time.h>

int main(void)
{
   clock_t t1, t2;
   t1 = clock();
   maFonctionDeTri(blabla...);
   t2 = clock();
   // Merci à yoch pour l'astuce 
   printf(" Temps d'exécution : %.3lf secondes \n", (double)(t2-t1)/CLOCKS_PER_SEC);
   return 0;
}

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

void tri_bulles(int* tab, size_t taille)
{
    unsigned short tab_en_ordre = 0; // booléen
    unsigned i;
    int temp;
    while(!tab_en_ordre) // ou while(tab_en_ordre==0)
    {
        tab_en_ordre = 1;
        for(i=0 ; i < taille-1 ; i++)
        {
            if(tab[i] > tab[i+1]) // comparaison des éléments adjascents
            {   // échange :
                temp = tab[i];
                tab[i] = tab[i+1];
                tab[i+1] = temp;
                tab_en_ordre = 0;
            }
        }
        taille--;
    }
}

void tri_selection(int* tab, size_t taille)
{
    unsigned fin = taille-1, i, plus_grand;
    int temp;
    while(fin > 0) // Tant que la zone de travail n'est pas nulle
    {
        plus_grand = 0;
        for(i = 1 ; i <= fin ; i++)
        {   // trouver le plus grand nombre :
            if(tab[i] > tab[plus_grand])
                plus_grand = i;
        } // échange :
        temp = tab[fin];
        tab[fin] = tab[plus_grand];
        tab[plus_grand] = temp;
        fin--;
    }
}

void tri_insertion(int* tab, size_t taille)
{
    unsigned i, j;
    int element_a_inserer, temp;
    for(i = 1; i < taille; i++)
    { // [boucle d'itération sur le tableau]
        element_a_inserer = tab[i];
        for(j = 0; j < i; j++)
        {  // [boucle d'insertion]
            if (element_a_inserer < tab[j])
            {   // échange :
                temp = element_a_inserer;
                element_a_inserer = tab[j];
                tab[j] = temp;
            }
        }
        tab[i] = element_a_inserer;
    }
}

void charger_tableau(int* sauvegarde, int* tab, size_t taille)
{
    unsigned i;
    for(i=0 ; i<taille ; i++)
        tab[i] = sauvegarde[i];
}

int hasard(int min, int max) // fonction de Natim pour les nombres aléatoires
{
    return (int)(min+((float)rand()/RAND_MAX*(max-min+1)));
}

int main(void)
{
   srand(time(NULL));

   int* tab = NULL;
   int* sauvegarde = NULL;
   int taille;
   unsigned i;
   clock_t t1, t2; // Pour le chrono

   printf(" [zTri] Comparatif de tris \n\n"
          " Choisissez une taille pour le tableau a trier : ");
   scanf("%d",&taille);
   getchar(); // avaler le '\n' 

   tab = malloc(sizeof(int)*taille);
   sauvegarde = malloc(sizeof(int)*taille);
   /* On crée un tableau de sauvegarde pour qu'un tri suivant un autre
      n'ai pas affaire à un tableau trié mais le même qu'au début
      du programme */

   if(tab == NULL || sauvegarde == NULL)
        return 1; // au cas où les malloc échouent

   for(i=0 ; i<taille ; i++)
       sauvegarde[i] = tab[i] = hasard(0,taille+5000);

///////////////////////////////////////////////////////////////
   printf("\n Tri a bulles en cours... ");
   t1 = clock();
   tri_bulles(tab,taille);
   t2 = clock();
   printf(" %.3lf secondes \n", (double)(t2-t1)/CLOCKS_PER_SEC);
   charger_tableau(sauvegarde,tab,taille);
///////////////////////////////////////////////////////////////
   printf("\n Tri par selection en cours... ");
   t1 = clock();
   tri_selection(tab,taille);
   t2 = clock();
   printf(" %.3lf secondes \n", (double)(t2-t1)/CLOCKS_PER_SEC);
   charger_tableau(sauvegarde,tab,taille);
///////////////////////////////////////////////////////////////
    printf("\n Tri par insertion en cours... ");
   t1 = clock();
   tri_insertion(tab,taille);
   t2 = clock();
   printf(" %.3lf secondes \n\n", (double)(t2-t1)/CLOCKS_PER_SEC);
///////////////////////////////////////////////////////////////

   free(tab);
   free(sauvegarde);

   printf(" Appuyez sur entrer pour quitter...");
   getchar();
   return 0;
}

Citation : Goost

Si je peux pinailler je dirais que le formateur pour les int est d (dans ton scanf) et qu'il serait mieux de mette int main (void) plutôt que int main ().

Citation : crys'

Pour les implémentations, je peux vous conseiller ceci :

Citation : crys'

void tri_selection(int* tab, size_t taille)
{
    unsigned fin = taille-1, i, plus_grand;
   /* */
}

Citation : crys'

Ensuite pour compter le temps d'exécution des trois tris, je conseillais d'utiliser clock() et ce de la manière suivante :

#include <stdio.h>
#include <time.h>

   /*  code coupé */
   printf(" Temps d'exécution : %.3lf secondes \n", (double)(t2-t1)/CLK_TCK);

Citation : Goost

...je pense que le peu de réponse est entièrement de la faute de yoch qui a fait peur à tout le monde

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include <string.h>

#define swap(p1,p2,sz)          {                               \
                                    size_t j;                   \
                                    for (j=0; j<sz; j++)        \
                                    {                           \
                                        char ptmp = *(p1+j);    \
                                        *(p1+j) = *(p2+j);      \
                                        *(p2+j) = ptmp;         \
                                    }                           \
                                    NB_PERMUTATIONS++;          \
                                }

/* Va. globale pour compter les permutations */
size_t NB_PERMUTATIONS;

/* Structure pour les tests */
typedef struct
{
    /* pointeur de fonction */   
    void (*fn) (void*, size_t, size_t, int (*)(const void*, const void*));
    const char* nom;
} TRI;

void my_triselection (void *base, size_t nmemb, size_t size, int (*compar)(const void*, const void *))
{
    char *debut = base;
    char *fin;
    char* ptr;
    char* max;
    for (fin = (char*)base+(size*(nmemb-1)); fin > debut; fin -= size)
    {
        max = fin;
        for (ptr=fin-size; ptr>=debut; ptr-=size)
        {
            if (compar(ptr, max) > 0)
            {
                max = ptr;
            }
        }
        if (max != fin)
        {
            /* On permute */
            swap (max, fin, size);
        }
    }
}

void my_tribulle (void *base, size_t nmemb, size_t size, int (*compar)(const void*, const void *))
{
    char *debut = base;
    char *fin = (char*)base+(size*(nmemb-1));
    char *ptr1, *ptr2;
    int continuer = 1;
    while (continuer)
    {
        continuer = 0;
        for (ptr1=debut, ptr2=debut+size; ptr2<=fin; ptr1+=size, ptr2+=size)
        {
            if (compar(ptr1, ptr2) > 0)
            {
                continuer = 1;
                /* On permute */
                swap (ptr1, ptr2, size);
            }
        }
    }
}

void my_triinsertion (void *base, size_t nmemb, size_t size, int (*compar)(const void*, const void *))
{
    char *debut = base;
    char* suiv;
    char *ptr;
    char *fin = (char*)base+(size*(nmemb-1));
    char tmp[100];
    int inserer;
    for (suiv = debut+size; suiv <= fin; suiv += size)
    {
        inserer = 0;
        for (ptr = debut; ptr < suiv && !(inserer = compar(ptr, suiv) > 0); ptr += size);
        if (inserer)
        {
            memcpy(tmp, suiv, size);
            memmove(ptr+size, ptr, suiv-ptr);
            memcpy(ptr, tmp, size);
            NB_PERMUTATIONS += (suiv-ptr)/size;
        }
    }
}

static int compare (void const *a, void const *b)
{
    int const *pa = a;
    int const *pb = b;
    /* evaluer et retourner l'etat de l'evaluation (tri croissant) */
    return *pa - *pb;
}

#define TABSIZE 10000
#define TABSIZEMAX 15000
#define NB_METHODES 3

int main (void)
{
    size_t i, j, n, x;
    int tab[TABSIZE] = {0};
    int tab2[TABSIZEMAX] = {0};

    TRI Tri[NB_METHODES];
    Tri[0].fn = my_triselection, Tri[1].fn = my_tribulle, Tri[2].fn = my_triinsertion;
    Tri[0].nom = "my_triselection", Tri[1].nom = "my_tribulle", Tri[2].nom = "my_triinsertion";

    clock_t t1, t2;
    srand(time(NULL));

    for (j=0; j<NB_METHODES; j++)
    {
        puts("-----------------");
        /* Test de validite de l'algo */
        int testtab[] = { 9, -1, 2, 6, -3, 7, 10, -8, -4, 0, -2, 4, -9, -7, 8, 6, 1, -5 };
        int expected_result[] = { -9, -8, -7, -5, -4, -3, -2, -1, 0, 1, 2, 4, 6, 6, 7, 8, 9, 10 };
        Tri[j].fn(testtab, sizeof testtab / sizeof *testtab, sizeof *testtab, compare);
        assert ( !memcmp(testtab,expected_result, sizeof testtab) );
        printf("%s OK !\n\n", Tri[j].nom);

        /* Initialise un tableau trié */
        for (n=0; n<TABSIZE; n++)
        {
            tab[n] = n;
        }
        printf("tri %s en cours sur %d entiers tries...\n", Tri[j].nom, TABSIZE);
        NB_PERMUTATIONS = 0;
        t1 = clock();
        Tri[j].fn(tab, sizeof tab / sizeof *tab, sizeof *tab, compare);
        t2 = clock();
        printf(" %.3lfs - %u permutations\n\n", (double) (t2-t1)/CLOCKS_PER_SEC, NB_PERMUTATIONS);

        /* Initialise un tableau trié a l'envers */
        for (n=0, i=TABSIZE; n<TABSIZE; i--, n++)
        {
            tab[n] = i;
        }
        printf("tri %s en cours sur %d entiers tries a l'envers...\n", Tri[j].nom, TABSIZE);
        NB_PERMUTATIONS = 0;
        t1 = clock();
        Tri[j].fn(tab, sizeof tab / sizeof *tab, sizeof *tab, compare);
        t2 = clock();
        printf(" %.3lfs - %u permutations\n\n", (double) (t2-t1)/CLOCKS_PER_SEC, NB_PERMUTATIONS);

        /* Initialise le tableau aleatoire */
        for (n=0 ; n<TABSIZEMAX ; n++)
        {
            tab2[n] = rand() % TABSIZEMAX;
        }
        printf("tri %s en cours sur %d entiers aleatoires...\n", Tri[j].nom, TABSIZEMAX);
        NB_PERMUTATIONS = 0;
        t1 = clock();
        Tri[j].fn(tab2, sizeof tab2 / sizeof *tab2, sizeof *tab2, compare);
        t2 = clock();
        printf(" %.3lfs - %u permutations\n\n", (double) (t2-t1)/CLOCKS_PER_SEC, NB_PERMUTATIONS);
    }
    return 0;
}

-----------------
my_triselection OK !

my_triselection en cours sur 10000 entiers tries...
 0.421s - 0 permutations

my_triselection en cours sur 10000 entiers tries a l'envers...
 0.454s - 5000 permutations

my_triselection en cours sur 10000 entiers aleatoires...
 0.421s - 9991 permutations

-----------------
my_tribulle OK !

my_tribulle en cours sur 10000 entiers tries...
 0.000s - 0 permutations

my_tribulle en cours sur 10000 entiers tries a l'envers...
 1.907s - 49995000 permutations

my_tribulle en cours sur 10000 entiers aleatoires...
 1.718s - 25043131 permutations

-----------------
my_tri_insertion OK !

my_tri_insertion en cours sur 10000 entiers tries...
 0.485s - 0 permutations

my_tri_insertion en cours sur 10000 entiers tries a l'envers...
 0.078s - 0 permutations

my_tri_insertion en cours sur 10000 entiers aleatoires...
 0.250s - 0 permutations


Process returned 0 (0x0)   execution time : 5.734 s
Press any key to continue.

void my_triselection (void *base, size_t nmemb, size_t size, int (*compar)(const void*, const void *))
{
    char *debut = base;
    char *fin;
    char* ptr;
    for (fin = (char*)base+(size*(nmemb-1)); fin >= debut; fin -= size)
    {
        for (ptr=fin-size; ptr>=debut; ptr-=size)
        {
            if (compar(ptr, fin) > 0)
            {
                swap (ptr, fin, size);
            }
        }
    }
}