Citation : yoch

for (ptr1=debut, ptr2=debut+size; ptr2<=fin; ptr1+=size, ptr2+=size)
{
}

for (ptr1=debut;ptr1<=fin;ptr1 ++)
{
}

• Étape initiale : On met debut dans ptr1 et debut+size dans ptr2
• La condition d'arrêt est si ptr2>fin est vrai
• À chaque tour de boucle : On incrémente ptr1 et ptr2 de size

Citation : crys'

Cette boucle peut donc êter analysée ainsi :

• Étape initiale : On met debut dans ptr1 et debut+size dans ptr2
• La condition d'arrêt est si ptr2<=fin est vrai
• À chaque tour de boucle : On incrémente ptr1 et ptr2 de size

for (ptr1=debut, ptr2=debut+size; ptr2<=fin; ptr1+=size, ptr2+=size)
{
}

Citation : Yoch

Merci crys' !

Citation : crys'
Cette boucle peut donc êter analysée ainsi :

Étape initiale : On met debut dans ptr1 et debut+size dans ptr2
La condition d'arrêt est si ptr2<=fin est vrai
À chaque tour de boucle : On incrémente ptr1 et ptr2 de size


Je dirais plutôt 'tant que ptr2<=fin est vrai'.

ptr1 <-- debut
pour ptr2 variant de [ debut + size , fin ] par pas de size faire
    {
      ....................
       Corps de la boucle
      ....................
      ptr1 < --- ptr1 + size
    }

Citation : zx-spectrum

pour reformuler le code ci dessus cela veut dire :

ptr1 <-- debut
pour ptr2 variant de [ debut + size , fin ] par pas de size faire
    {
      ....................
       Corps de la boucle
      ....................
      ptr1 < --- ptr1 + size
    }

Citation : zx-spectrum

Dans le nouveau excercice, a t on le droit d'utiliser la
bibliotheque standart ctype.h ?

char c = 'A';
if(c >= 65 && c <= 90)
    printf("%c est majuscule \n",c);
else if(c >= 97 && c <= 122)
    printf("%c est minuscule \n",c);

char c = 'X';

printf("%c est ", c);

if (c >= 'A' && c <= 'Z')
    printf("majuscule\n");

else if (c >= 'a' && c <= 'z')
    printf("miniscule\n");

else if (c >= '0' && c <= '9')
    printf("un nombre\n");

else
    printf("un symbole\n");

#include <stdio.h>

int main(void)
{
    printf ("'%c' vaut %d", 'A', 'A');
    return 0;
}

'A' vaut 65

Citation : crys'

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;
    }
}

Citation : yoch

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 = base+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;
        }
    }
}

Citation : yoch

- Je crois qu'il est normal qu'un tri générique cède en performances a un tri plus ciblé. C'est surtout du aux appels a la fonction compar.

Citation : yoch

- Le tri insertion est limité par la taille de son buffer, on peut facilement corriger cela avec malloc...

Citation : candide

L'affectation suiv = base+size est incorrecte car base est de type void *.

for (suiv = debut+size; suiv <= fin; suiv += size)

Citation : candide

L'usage de memmove est discutable : d'un côté, on copie tout un bloc d'un seul coup (ce qui est plus rapide de la faire morceau par morceau) mais de l'autre memmove effectue (en principe) 2 fois plus que de copies que nécessaire.

void *my_memmove (void *dest, const void *src, size_t n)
{
    char* a = dest;
    const char* b = src;
    if (a < b)
    {
        while (n--)
            *a++ = *b++;
    }
    else if (a > b)
    {
        a += n, b += n;
        while (n--)
            *--a = *--b;
    }
    return dest;
}

Citation : candide

En fait, à mon avis un bon appel de tri fait qu'on n'a jamais besoin d'un grand buffer. Si on a un tableau d'éléments qui sont de grandes tailles et que l'on doit trier, il est très maladroit de trier directement les éléménts, il vaut mieux déplacer les adresses. Donc, on utilisera le même genre de fonction de comparaison que l'on utilise quand on veut trier des chaines de caractères.

#include <stdio.h>

int main(void)
{
    char  tab1[][7] = { "blabla", "bliblo" };
    char* tab2[]    = { "blabla", "bliblo" };
    printf("sizeof tab1 : %u, sizeof *tab1 : %u\n", sizeof tab1, sizeof *tab1);
    printf("sizeof tab2 : %u, sizeof *tab2 : %u\n", sizeof tab2, sizeof *tab2);
    return 0;
}

sizeof tab1 : 14, sizeof *tab1 : 7
sizeof tab2 : 8, sizeof *tab2 : 4

• Le premier est un tableau au sens propre du terme. La taille du tableau dépend de la taille des éléments (nb_elems * size_elems );
• Le second est un tableau d'adresses. Il contient simplement les adresses des éléments du tableau. La taille d'un tel tableau sera toujours de nb_elems * size_pointeur .

Citation : zx-spectrum

voyons :
deplacer des elements (E1 et E2 par ex) je comprends que cela doit être cela
Temp <-- E1
E1 <-- E2
E2 <-- Temp

déplacer les adresses ?

/* http://mapage.noos.fr/emdel/qsort.htm */
#include <stdio.h>
#include <stdlib.h>

/* affichage du tableau */
static void aff (int *a, size_t n)
{
   size_t i;
   for (i = 0; i < n; i++)
   {
      printf ("%3d", a[i]);
   }
   printf ("\n");
}

/* fonction utilisateur de comparaison fournie a qsort() */
static int compare (void const *a, void const *b)
{
   /* definir des pointeurs type's et initialise's
      avec les parametres */
   int const *pa = a;
   int const *pb = b;

   /* evaluer et retourner l'etat de l'evaluation (tri croissant) */
   return *pa - *pb;
}

int main (void)
{
/* tableau a trier */
   int tab[] = { 4, 6, -3, 4, 7 };

/* affichage du tableau dans l'etat */
   aff (tab, sizeof tab / sizeof *tab);

   qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, compare);

/* affichage du tableau apres le tri */
   aff (tab, sizeof tab / sizeof *tab);

   return 0;
}

qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, compare);

struct toto {int x; int tab[2000];};

Citation : moi meme :

voyons :
deplacer des elements (E1 et E2 par ex) je comprends que cela doit être cela
Temp <-- E1
E1 <-- E2
E2 <-- Temp

déplacer les adresses ?

long *temp;
long E1,E2;

temp <-- &E1
&E1  <-- &E2
&E2  <-- temp

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




int main(void)
{

    int x,y;
    int *p1=&x;
    int *p2=&y;
    int *p3;


    x=1;
    y=2;
    printf("\n\n x=%d        y=%d ",*p1,*p2);

    // echange par pointeur

    p3 = p1;
    p1 = p2;
    p2 = p3;

    printf("\n\n x=%d        y=%d ",*p1,*p2);

    return 0;
}

Citation : yoch

Pas grave !

Supposons que tu ais une liste de 10000 éléments de 1 Ko chacun a trier.

Il est beaucoup plus efficace de créer un index d'adresses et de le trier, ce qui représente un volume de permutations de 10000 * 4 octets (un pointeur fait généralement 4 octets), que de trier les données directement, ce qui ferait un volume de permutations de 10000 * 1000 octets...

void affichage_binaire(const unsigned int n)
{
    if (n > 1)
        affichage_binaire(n/2);
    putchar('0'+n%2);
    
}

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

int affichage_binaire(const unsigned int n)
{
    if (n > 1)
        affichage_binaire(n/2);
    putchar('0'+n%2);
    return (n%2);
}


int main(int argc, char *argv[])
{   
    int lol = 0;

    affichage_binaire(5);
    printf("\n\n");
    lol = affichage_binaire(20); 
    printf("\n\n");
    system("Pause");
    return 0;
}

Citation : khaledbenamor

Le langage C est un langage :
- Simple
- Fort
- Trés fort

Citation : ttthebest

Comme prochain exercice je propose un exercice d'algorithmique : calculer le PGCD deux de entiers naturels aléatoires avec l'algorithme d'Euclide (niveau en maths de 3e).