Discussion :

[scary]

Bonsoir,

Voila j'ai coder ce petit morceau de code dont le but est d'avoir un inverse symétrique 3 par 3 dans un tableau, je ne sais pas si je me suis bien expliqué, je vais donc vous donner un exemple qui seras beaucoup plus parlant:

Admettons le tableau suivant: (chaque chiffre représente une case)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1 2 3 4 5 6 7 8 9 10 11 12

Le résultat du code sera:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

10 11 12 7 8 9 4 5 6 1 2 3

J'espère que ceci est déjà plus clair, mais si besoin n'hésitez surtout pas à demander plus de détails. Le code est donc celui-ci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <stdio.h>
#include <stdlib.h>
 
int main (void)
{
    int *Buffer;
    int *newBuffer;
    int d = 0;
    int f = 11;
    int i;
 
    Buffer = malloc (12 * sizeof (int));
    newBuffer = malloc (12* sizeof (int));
 
    if (Buffer != NULL || newBuffer != NULL)
    {
        Buffer[0] = 1;
        Buffer[1] = 2;
        Buffer[2] = 3;
        Buffer[3] = 4;
        Buffer[4] = 5;
        Buffer[5] = 6;
        Buffer[6] = 7;
        Buffer[7] = 8;
        Buffer[8] = 9;
        Buffer[9] = 10;
        Buffer[10] = 11;
        Buffer[11] = 12;
 
        while (d < 12)
        {
            newBuffer[d] = Buffer[f-2];
            newBuffer[d+1] = Buffer[f-1];
            newBuffer[d+2] = Buffer[f];
            f -= 3;
            d += 3;
        }
 
        for (i=0;i<12;i++)
        {
            printf ("%d ", newBuffer[i]);
        }
        printf ("\n");
        free (Buffer);
        free (newBuffer);
    }
    else
    {
        printf ("Allocation memoire impossible");
        free (Buffer);
        free (newBuffer);
        exit (1);
    }
 
    return 0;
}

Je voulais donc savoir si il y a des optimisations possibles pour arriver au même résultat. Merci d'avance

[SofEvans]

J'ai plusieurs remarque sur ton code :

Tu utilise l'allocation dynamique, mais ca ne sert a RIEN.
Tu ne retient pas la taille du tableau et tes boucle for parcourront toujours 12 fois et non tailleTableauFois.
Dans ton cas, autant mettre un define ou 12 partout et faire des tableau statique.


Tu utilise 2 tableau, alors que 1 tableau est suffisant. Il s'agit du principe de permutation circulaire (c'est un de ses noms) ou il suffit de declarer une troisieme variable temporaire.

En cas d'erreur du malloc, tu utilise printf. Ca n'informe pas de la cause. C'est bien de tester, mais faut aussi afficher pourquoi ca va pas.
Donc, utilise perror pour ca.


Ensuite, c'est quoi ca ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
        Buffer[0] = 1;
        Buffer[1] = 2;
        Buffer[2] = 3;
        Buffer[3] = 4;
        Buffer[4] = 5;
        Buffer[5] = 6;
        Buffer[6] = 7;
        Buffer[7] = 8;
        Buffer[8] = 9;
        Buffer[9] = 10;
        Buffer[10] = 11;
        Buffer[11] = 12;

Une boucle, et en limite la tailleTableau.


Bon, ce que j'ai fait, c'est une structure et 4 fonction associé. Ca peut te sembler tirer par les cheveux ou meme sortir un marteau piqueur pour ecraser une mouche, mais dans le main, c'est plus clair tout d'un coup.

Autre chose, j'ai un peu tasser tout dans la fonction permuter, donc ca peut etre deroutant au premier abord.
Le principe est simple.

On prend TailleTableau, on divise par 3. On obtient le nombre de bloc de trois.
Ensuite, c'est simple, on fait un permutation circulaire, c'est a dire qu'on va s'arreter a la moitier des bloc et que le 1er est echanger avec le dernier, le 2eme avec l'avant dernier etc etc

donc, tailleTableau/3 = nombre de bloc
tailleTableau/3/2 = nombre de bloc a permuter.

Voici mon code, avec toutes les remarque faites avant.
Bonne lecture.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct Tableau1D
{
    int *Buffer;
    int taille;
} Tableau1D;
 
void Tableau1D_Initialiser (Tableau1D* LeTableau, int longueur);
void Tableau1D_Detruire (Tableau1D* LeTableau);
 
void Tableau1D_Afficher (Tableau1D* LeTableau);
void Tableau1D_PermuterPar3 (Tableau1D* LeTableau);
 
 
int main (void)
{
    Tableau1D LeTableau;
    Tableau1D_Initialiser (&LeTableau, 15);
 
 
    Tableau1D_Afficher (&LeTableau);
    Tableau1D_PermuterPar3 (&LeTableau);
    Tableau1D_Afficher (&LeTableau);
 
 
    Tableau1D_Detruire (&LeTableau);
    return EXIT_SUCCESS;
}
 
void Tableau1D_Initialiser (Tableau1D* LeTableau, int longueur)
{
    int i;
 
    if (longueur%3 != 0)
    {
        printf("la taille doit etre un multiple de 3\nArret du programme\n\n");
        exit (EXIT_FAILURE);
    }
 
    LeTableau->Buffer = malloc (longueur * sizeof (int));
    if (LeTableau->Buffer == NULL)
    {
        perror("Allocation memoire impossible");
        exit (EXIT_FAILURE);
    }
 
    LeTableau->taille = longueur;
 
    for (i=0 ; i<longueur ; i++)
        LeTableau->Buffer[i] = i+1;
}
 
void Tableau1D_Detruire (Tableau1D* LeTableau)
{
    free (LeTableau->Buffer);
}
 
void Tableau1D_Afficher (Tableau1D* LeTableau)
{
    int i;
    for (i=0 ; i<LeTableau->taille ; i++)
    {
        if (i%3 == 0 && i!=0)
            printf (" ");/* Juste un petit espace pour demarquer un peu les bloc de trois */
        printf ("%d ", LeTableau->Buffer[i]);
    }
    printf ("\n\n");
}
 
void Tableau1D_PermuterPar3 (Tableau1D* LeTableau)
{
    int i;
    for (i=0 ; i<(LeTableau->taille/3)/2 ; i++)
    {
        int j;
        for (j=0 ; j<3 ; j++)
        {
            int temp = LeTableau->Buffer[i*3+j];
            LeTableau->Buffer[i*3+j] = LeTableau->Buffer[LeTableau->taille - 3 - i*3 +j];
            LeTableau->Buffer[LeTableau->taille - 3 - i*3 +j] = temp;
        }
    }
 
}

[scary]

Merci, en effet c'est mieux je pense que je prendrais ta version Merci encore

[diogene]

@SofEvans : Une remarque :

Ensuite, c'est simple, on fait un permutation circulaire, ....

Ce n'est pas une permutation circulaire.

[SofEvans]

Hum, le fait d'echanger la valeur de deux variable via une troisieme temporaire, mon prof de C a dit que c'etait une permutation circulaire.

Bon, ici, j'en fait trois, mais sinon, tu appele ca comment ? ca a un nom ?

(dès que j'ai vu que diogene a repondu a un de mes post, j'ai direct penser : j'ai fait quoi comme boulette encore ? )

[diogene]

Hum, le fait d'echanger la valeur de deux variable via une troisieme temporaire, mon prof de C a dit que c'etait une permutation circulaire.
...

Ta phrase

Ensuite, c'est simple, on fait un permutation circulaire, c'est a dire qu'on va s'arreter a la moitier des bloc et que le 1er est echanger avec le dernier, le 2eme avec l'avant dernier etc etc

semblait qualifier la transformation du tableau, pas le mécanisme de permutation de deux éléments, d'où ma remarque.

(dès que j'ai vu que diogene a repondu a un de mes post, j'ai direct penser : j'ai fait quoi comme boulette encore ? )