Partage

zTransforme

16 Mai - 31 Mai

1 2 >>

16 mai 2010 à 13:42:25

Bonjour,

Vous pouvez proposez ici vos solutions pour l'exercice zTransforme.
Si vous avez besoin de conseils ou encore de poser des questions c'est ici aussi.

Bonne chance.

meteor2

16 mai 2010 à 13:53:05

Ouais...j'ai fait le numéro 1:

#include <stdio.h>

int tableau[1000][1000];

int main(void)
{
    int nbLignes, nbColonnes, i, j;
    scanf("%d%d", &nbLignes, &nbColonnes);

    for(i=0; i<nbLignes; i++)
        for(j=0; j<nbColonnes; j++)
            scanf("%d", &tableau[i][j]);

    for(i=0; i<nbColonnes; i++)
    {
        for(j=0; j<nbLignes; j++)
            printf("%d ", tableau[j][i]);
        printf("\n");
    }

    return 0;
}

Krosian : Oui on pourrait sécurisé la saisie, mais il me semble que ce n'est pas vraiment le but.

J'aime bien ce genre d'exercice, c'est un très bon entraînement d'algorithmique

krosian

16 mai 2010 à 13:58:23

Il faudrai aussi vérifier que i et j ne dépassent jamais 999 (ou allouer dynamiquement le tableau).

Lithrein

16 mai 2010 à 18:14:35

@meteor2:
Pourquoi tu déclares le tableau comme une variable globale alors qu'il n'y aucune raison de le faire.
Ensuite pour sécuriser la saisie, j'ai proposé une fonction.
Sinon dans l'ensemble, c'est bien.

Lithrein.

meteor2

16 mai 2010 à 18:34:29

Citation : Lithrein

Ensuite sécuriser la saisie, j'ai proposé une fonction.

Tu veux parler de ça?

/**
 * \brief vide le buffer clavier
 */
void
clear_stdin (void) {
    int c;
    while((c = getchar()) != '\n' && c != EOF);
}

/**
 * \brief Récupère un entier de manière sécurisée
 *
 * @param msg  : const char *
 * @return val : int
 */
int
get_i (const char * msg) {
    int val;

    if (msg != NULL)    /* S'il y a un message on l'affiche */
        printf("%s", msg);

    while (scanf("%d", &val) != 1) { /* Tant que val ne contient pas un entier */
        puts("Veuillez entrer un nombre entier");
        clear_stdin();
    }
    clear_stdin();

    return val;
}

Personnellement je trouve que c'est une mauvaise idée. Le code est très dur à comprendre, il est presque aussi compliqué que l'exercice en lui-même. Bien sûr on n'aura qu'à copier/coller bêtement...mais ce n'est pas bien. (perso j'ai mis 2 min à comprendre à quoi pouvait correspondre le paramètre const char* msg :-°

).
Sinon il faudrait décider quel est le but de cet exercice : manipulation de tableaux 2D, ou manipulation de la saisie sécurisée (mouai).

Citation : Lithrein

@meteor2:
Pourquoi tu déclares le tableau comme une variable globale alors qu'il n'y aucune raison de le faire.

Et pourquoi pas? Bon je l'ai fait pour de bonnes raisons : pour le mettre en valeur, c'est plus clair je trouve.
Et si jamais je voulais l'utiliser dans des fonctions, j'aurai été coincé. (c'est surtout pour cette raison).

Lithrein

16 mai 2010 à 18:49:16

Le but de l'exercice est bien les tableaux 2D, la saisie sécurisée est un plus qui permet de ne pas avoir de surprise en cas d'entrée mal formatée. Ensuite, la fonction que j'ai donnée est juste un plus qui permet de récupérer un entier de manière sûre sans ce casser la tête mais personne n'a obligation de l'utiliser.

meteor2

16 mai 2010 à 19:03:49

Oui, tu as raison (je sais pas pourquoi je m'étais mis dans la tête que c'était quelque chose d'obligatoire), je trouve que c'est bien de donner une méthode qui permette de faire une bonne saisie (je me contredis un peu du coup).
Sinon c'est dommage qu'il n'y ait pas un niveau pour ceux qui sont plus avancés

Lithrein

16 mai 2010 à 19:13:21

C'est vrai que cette fois ci les exercices ne sont pas très dur mais pour un débutant, il faut déjà pas mal réfléchir pour réussir l'exercice.

Si tu veux un exercice plus dur, tu peux toujours t'amuser avec zJustificator.

GurneyH

16 mai 2010 à 22:10:48

Citation : meteor2

Oui, tu as raison (je sais pas pourquoi je m'étais mis dans la tête que c'était quelque chose d'obligatoire), je trouve que c'est bien de donner une méthode qui permette de faire une bonne saisie (je me contredis un peu du coup).
Sinon c'est dommage qu'il n'y ait pas un niveau pour ceux qui sont plus avancés .

La preuve lorsque c'est facile, les avancés participent!

@meteor2: Le précédent était trop simple? Pourquoi tu n'as pas participé?

Pour les personnes pleines de certitudes -> proposez des exercices!
Et les corrections qui vont bien...

C'est très facile de critiquer! Pondre quelque chose c'est déjà un autre niveau...
Pas trop pour toi, cette colère météor2, mais franchement, vous avez un don pour dégouter, c'est impressionnant!:

Zeste de Savoir, le site qui en a dans le citron !

meteor2

16 mai 2010 à 22:47:42

Alors oui, j'aurai pu participer (l'algorithme en lui même était interessant), mais le truc qui m'a fait fuir c'est l'entrée, avec les paramètres du main (je ne maîtrise pas trop).

Je ne critiquais pas du tout pour ma part, je trouve que c'est une très bonne initiative ces exercices, d'ailleurs je participe dès que je peux!

Pouet_forever

16 mai 2010 à 22:52:29

Citation : meteor2

mais le truc qui m'a fait fuir c'est l'entrée, avec les paramètres du main (je ne maîtrise pas trop).

Justement, c'est l'occasion d'apprendre/se perfectionner. :'(

Adroneus

16 mai 2010 à 23:33:00

ma solution pour les exos 1 & 2, un peu plus... longue

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

void            clear_stdin(void)
{
    int         c;

    c = 0;
    while (c != '\n' && c != EOF)
        c = getchar();
}

void            *alloc_mem(size_t size, char const * const msg)
{
     void       *ptr;

     ptr = malloc(size);
     if (!ptr)
          {
            printf("%s %s", msg, strerror(errno));
            exit(EXIT_FAILURE);
          }
     return (ptr);
}

void            print_tab_reversed(int **tab, size_t col, size_t row)
{
     size_t     i;
     size_t     j;

     i = 0;
     while (++i <= col)
          {
            j = 0;
            while (++j <= row)
                printf("%d ", tab[j - 1][i - 1]);
            putchar('\n');
          }
}

int             **init_tab(size_t col, size_t row)
{
     int        **tab;
     size_t     iter;

     tab = alloc_mem(row * sizeof(int *), "Alloc rows");
     iter = 0;
     while (++iter <= row)
          tab[iter - 1] = alloc_mem(col * sizeof(int), "Alloc col");
     return (tab);
}

void            fill_tab(int **tab, size_t col, size_t row)
{
    size_t      i;
    size_t      j;

    i = 0;
    while (++i <= row)
        {
            j = 0;
            while (++j <= col)
                scanf("%d", &tab[i - 1][j - 1]);
        }
    clear_stdin();
}

void            free_tab(int **tab, size_t row)
{
    size_t      i;

    i = 0;
    while (++i <= row)
         {
            free(tab[i - 1]);
            tab[i - 1] = NULL;
         }
    free(tab);
    tab = NULL;
}

void            reverse_lines(int **tab, size_t row)
{
    int         **copy;
    int         iter;

    copy = alloc_mem(row * sizeof(int *), "Alloc mem for copy ");
    iter = row;
    while (--iter >= 0)
        copy[row - iter - 1] = tab[iter];
    while (++iter < (signed)row)
        tab[iter] = copy[iter];
    free(copy);
}

int             main(void)
{
    int         **tab;
    size_t      col;
    size_t      row;

    scanf("%u %u", (unsigned *)&row, (unsigned *)&col);
    clear_stdin();
    tab = init_tab(col, row);
    fill_tab(tab, col, row);
    reverse_lines(tab, row); /* Remove this line for the Exo 1 */
    print_tab_reversed(tab, col, row);
    free_tab(tab, row);
    return (EXIT_SUCCESS);
}

ichigo11

17 mai 2010 à 20:43:09

Heyo!

Je viens de le faire aussi, un peu plus lite que celui d'androneus dont je ne comprend pas la moitié. :lol:

Il a l'air de bien fonctionner.

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

void init_tab(int tab[],int ligne,int col)
{
    int cpt,temp=ligne*col;
    int nb=0; /*mettre nb=ligne-1 pour le second exo*/
    for(cpt=0;cpt<ligne*col;cpt++)
    {
        scanf("%d",&tab[nb]);
        nb+=ligne;
	if(nb>=temp)
	  nb=nb%temp+1; /*remplacer le +1 par -1 pour le second exo*/
    }
}

void affiche_tab(int tab[],int ligne,int col)
{
    int i=0,j,nb=ligne*col;
    printf("\n");
    while(i<nb)
    {
      for(j=0;j<ligne;j++)
      {
	printf("%d ",tab[i]);
	i++;
      }
      printf("\n");
    }
}


int main(void)
{
    int ligne,col;
    int *tab=NULL;
    scanf("%d %d",&ligne,&col);
    tab=malloc(ligne*col*sizeof(int));
    if(tab==NULL)
        exit(0);
    init_tab(tab,ligne,col);
    affiche_tab(tab,ligne,col);
    free(tab);
    return 0;
}

Et voilà le 3e

#include <stdio.h>
#include <stdlib.h>
#define NB 9

int main(void)
{
    int i,j;
    for(i=1;i<=NB;i++)
    {
        for (j=1;j<NB;j++)
        {
            if((i==j)||(abs(1-i)==abs(NB-j)))
                printf("#-");
            else
                printf("%d-",j);
        }
        if((i==j)||(abs(1-i)==abs(NB-j)))
            printf("#");
        else
            printf("%d",j);
        printf("\n");
    }
    return 0;
}

Adroneus

18 mai 2010 à 23:55:53

Exo 3

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

void            clear_stdin(void)
{
    int         c;

    c = 0;
    while (c != '\n' && c != EOF)
        c = getchar();
}

void            *alloc_mem(size_t size, char const * const msg)
{
     void       *ptr;

     ptr = malloc(size);
     if (!ptr)
          {
            printf("%s %s", msg, strerror(errno));
            exit(EXIT_FAILURE);
          }
     return (ptr);
}

int             **init_tab(size_t size)
{
     int        **tab;
     size_t     iter;

     tab = alloc_mem(size * sizeof(int *), "Alloc rows");
     iter = 0;
     while (++iter <= size)
          tab[iter - 1] = alloc_mem(size * sizeof(int), "Alloc col");
     return (tab);
}

void            fill_tab(int **tab, size_t size)
{
    size_t      i;
    size_t      j;

    i = 0;
    while (++i <= size)
        {
            j = 0;
            while (++j <= size)
                tab[j - 1][i - 1] = i;
        }
}

void            free_tab(int **tab, size_t size)
{
    size_t      i;

    i = 0;
    while (++i <= size)
         {
            free(tab[i - 1]);
            tab[i - 1] = NULL;
         }
    free(tab);
    tab = NULL;
}

void            print_tab(int **tab, size_t size)
{
    size_t      i;
    size_t      j;

    i = 0;
    while (++i <= size)
        {
            j = 0;
            while (++j <= size)
                {
                    if (i == j || j == size - i + 1)
                        putchar('#');
                    else
                        printf("%d", tab[i - 1][j - 1]);
                    if (j != size)
                        putchar('-');
                }
            putchar('\n');
        }
}

int             main(void)
{
    int         **tab;
    size_t      size;

    scanf("%u", (unsigned *)&size);
    clear_stdin();
    tab = init_tab(size);
    fill_tab(tab, size);
    print_tab(tab, size);
    free_tab(tab, size);
    return (EXIT_SUCCESS);
}

Edit ah... vi c'est vrai, si on atteint les 35 ca va afficher des '#' la ou il faut pas... bon ben jvais remedier a toussa

ouala!

Jvais surement me mettre a zJustify... mais po tout dsuite...

Edit et c'quoi que tu comprends pas? mon code se veut simple...

candide

19 mai 2010 à 0:33:06

Citation : Adroneus

mon code se veut simple...

Et qu'est-ce que ce serait s'il se voulait compliqué

Mon avis perso : je trouve ton code atrocement compliqué et j'imagine très bien le mal qu'un débutant voire le débutant avancé aura à le comprendre. Juste un exemple, ta fonction print_tab_reversed (idem pour fill_tab) est compliquée à loisir, tu as mis une boucle while là où il faudrait typiquement mettre une boucle for.

En plus tu fais des casts un peu partout, les casts il faut bien les peser et les sous-peser, les spécialistes te diront qu'il faut caster avec parcimonie.

Tiens je sais pas pourquoi tu mets des parenthèses dans tes return.

Adroneus

19 mai 2010 à 0:53:37

Concernant tes deux remarques, si je te reponds, ca va lancer un debat sur la norme EPITECH

Edit : qui je pense n'a pas lieu d'etre, apres ca n'joute certes pas grand chose a la complexite de mon code... quelles seraient tes autres remarques?

et pis j'ai mis que 3 casts...

candide

19 mai 2010 à 2:05:40

Citation : Adroneus

Concernant tes deux remarques, si je te reponds, ca va lancer un debat sur la norme EPITECH

T'appliques la Norme Epitech ? Elle préconise de changer tous les for en while ? Use idioms for consistency.

Citation : Adroneus

quelles seraient tes autres remarques?

Ce qui l'emporte ici pour moi est l'excessive complexité de ton code et qui pourrait laisser penser aux débutants voire aux débutants avancés que le C serait abscons et compliqué ce qui à mon avis n'est pas vrai, le C c'est la cimplicité

Après, à des détails près, ton code me semble correct. Mais quand même, par exemple ta fonction reverse_lines est compliquée et peu cohérente avec les autres fonctions.

*) D'abord, tu t'embrouilles avec tes size_t qui t'obligent à caster (au risque de faire n'importe quoi car un cast peut-être destructif). Personnellement, je suis contre ce recours aveugle aux size_t parce qu'ils sont non signés et donc que cela peut introduire des conversions non souhaitables en présence de signé. Et de toute façon, je pense que pour arriver à ce que tu voulais faire, tu pouvais t'y prendre autrement (il fallait pas utiliser :

while (--iter >= 0)

qui peut introduire une valeur négative) et à nouveau, je sais pas pourquoi tu utilises des while à la place de for.

*) Ensuite, j'ai pas compris la nécessité d'allouer pour un nouveau tableau qui ne va pas contenir le résultat attendu vu qu'il faut qu'il passe par ta fonction de transposition. Il était plus simple d'écrire directement une fonction qui affichait la rotation de 90°.

Et cela montre l'ambiguïté de l'exo : cela n'a aucun intérêt de faire afficher, dans les vrais programmes, on affiche tout à la fin (si on affiche d'ailleurs), en général, on a plutôt besoin d'accéder voire de stocker (à la rigueur avec sprintf).

Adroneus

19 mai 2010 à 7:46:14

Je prends en compte tes remarques tres pertinentes et je modifierai mon code en consequence

merci. Ensuite, oui j'applique la norme pitek

vu que je suis admis je m'y suis mis, seule la boucle while est autorisee (quoique j'ai un doute sur la boucle do while, mais je ne l'utilise pas par quetion de gout... ce qui fait que je me retrouve avec while

)

Pouet_forever

19 mai 2010 à 7:57:13

Est-ce que tu as vraiment besoin d'un tableau ? C'est ça la question.

Marc Mongenet

19 mai 2010 à 9:56:44

Citation : GurneyH

<citation rid="4979614">Pour les personnes pleines de certitudes -> proposez des exercices!

Ce n'est pas de saison, mais je proposerais volontiers zSapinNoel: une fonction qui dessine un sapin de taille paramétrée. En 2, une fonction qui place N boules sur le sapin. On peut proposer l'exercice en ASCII art ou avec une bibliothèque graphique.

void dessinerSapin(int hauteur_triangle, int hauteur_tronc);
Exemple de sortie de dessinerSapin(4, 2) :

$ ./sapin.exe 4 2
   #
  ###
 #####
#######
   |
   |
$

Adroneus

19 mai 2010 à 11:06:43

AI-je vraiment besoin d'un tableau... oui..
Pour le sapin de noel

C'est un exo de pitek apres le premier week end de la piscine \o/
Si tu veux tu peux venir en discuter sur le topic principal, faudra voir avec Lithrein parce qu'il comptait poster un exo zString-like...

Marc Mongenet

19 mai 2010 à 13:29:33

Citation : Adroneus

Pour le sapin de noel C'est un exo de pitek apres le premier week end de la piscine \o/

Je crois que c'est un classique. J'ai aussi eu cet exercice au début de mes études. Il permet de s'entrainer sur les boucles avec un résultat visuel.

candide

19 mai 2010 à 13:46:33

Citation : Marc Mongenet

Ce n'est pas de saison, mais je proposerais volontiers zSapinNoel:

On dira que c'est un parapluie: tout à fait de saison

Citation : Marc Mongenet

void dessinerSapin(int hauteur_triangle, int hauteur_tronc);
Exemple de sortie de dessinerSapin(4, 2) :
$ ./sapin.exe 4 2
   #
  ###
 #####
#######
   |
   |
$

les entrées/sorties + la ligne de commande : ça vire à l'obsession.

Citation : Marc Mongenet

Je crois que c'est un classique.

C'est un exo ultra classique (beaucoup de livres le proposent) et pas forcément bon pour apprendre le C. Et puis il y a sans doute plusieurs façons de le faire sans compter que la spécification du programme n'est pas clairement formulée. Sans compter aussi que ça laisse acréditer cette idée fausse :

afficher serait programmer.

Non, l'affichage est volatile et l'affichage est dans la vie réelle une fin ultime, quelque chose qui vien en bout de course et est souvent optionnel. J'ai d'ailleurs lontemps cru que tout fichier C devait comprendre une déclaration de l'entête stdio.h . Non, ce qui compte c'est d'accéder, de stocker et transmettre des données. D'ailleurs, tout ce qui est entrée/sortie ne fait pas partie du langage, ça fait partie de la bibliothèque standard.

Lithrein

19 mai 2010 à 14:37:01

Jje rappelle que l'allocation dynamique n'est pas nécessaire car l'énoncé garantit que le tableau maximum que l'on peut vous passez à 1000 lignes et 1000 colonnes. (De plus les opérations d'allocations mémoire ont un coût non négligeable)

A propos de mon projet sur un exercice std::string-like, je ne le prévoit en fait pas pour tout de suite. J'aimerais d'abord proposer des vrais exercices pour débutants car pour l'exercice il faut introduire la notion d'ADT et je veux que ce soit bien fait.
Pour le sapin, l'idée est à garder. Mais d'abord je prévois quelques exercices sans entrées/sorties.

@Ichigo11

Dans l'ensemble c'est bien.

Les seuls conseils que je pourrais de donner son d'aérer un peu plus. (Bien séparer chaque partie du code, déclarations/coeur de la fonction, respecter les règles de typographie : après la virgule un espace, ... (Mais ce sont des détails))

Ensuite quand tu veux afficher un seul caractère privilégie `putchar' à `printf', quand tu peux te passer d'inclure certains fichiers ne t'en prive pas. Par exemple, 'stdlib.h' est inutile dans ton exercice 3.

Dernièrement, les valeurs absolu sont inutiles dans l'exercice, tu peux faire sans en modifiant un petit peu tes conditions.

@Adroneus

Je t'invite à jeter un oeil au principe KISS qui vaut le coup d'être appliqué quand on le peut.

Pour la norme EPITECH, libre à toi de l'appliquer. (Je souhaite juste que ça ne parte pas en live sur la mise de parenthèses abusives, la boucle for interdite, ou encore l'opérateur virgule)

Pour les remarques, je commence par ta solution pour l'exercice 3: On va dire que tu te complique la vie inutilement car il n'y a pas besoin de tableau.

Je te propose donc de le refaire en sachant que le nombre de lignes de code que requiert l'exercice quelque soit ton style de présentation est inférieur à 30. (Avec un recours abusif aux opérateurs 'déconseillés'(virgule et ternaire) on peut descendre à 7 lignes)

Ensuite pour les autres exercices, tu te compliques pas mal la vie. Définir une fonction d'allocation mémoire c'est cool mais là ça ne sert à rien, généralement, on définit ce genre de fonctions pour optimiser l'allocation mémoire (SLAB allocation) ou pour faire un mini ramasse-miettes en utilisant des fonctions qui appellent (c|m)alloc et free à notre place et qui gardent les adresses allouées dans une liste pour éviter les fuites de mémoires. Mais cela n'est absolument pas nécessaire dans ce cas là. Bien que ce soit mieux pour pouvoir réutiliser les fonctions plus tard, l'utilisation d'un tableau pour stocker la transformée du tableau initial n'est pas obligatoire.

Mon conseil serait donc que tu simplifies ta solution (tout en utilisant des tableaux statiques).

Adroneus

19 mai 2010 à 16:42:07

Mouais mais je voulais aller un peu plus loin que l'enonce en lui meme, c'est si genant que ca que mes tableaux soient dynamiques? ensuite j'ai fait une fonction a part parce que 1 tache == 1 fonction, comme ca, allocation et verification du succes (ou non) de l'alloc... Ensuite, quand j'y repense... oui j'ai fait trop complique... je reverrai ca demain (pas le temps aujourd'hui

)

candide

19 mai 2010 à 22:35:05

Citation : Adroneus

Mouais mais je voulais aller un peu plus loin que l'enonce en lui meme, c'est si genant que ca que mes tableaux soient dynamiques?

Non, mais cela participe d'une logique d'apprentissage surenchériste en sorte que le débutant se dit qu'il est impossible de faire en C une chose simple simplement. Or dans le problème posé, on n'a pas besoin de faire de tableaux dynamiques surtout pour traiter un tableau 2x3 à afficher en console même si je sais bien que c'est juste pour montrer un exemple que tu as fait comme tu as fait. D'une façon générale, j'ai constaté que des débutants voire de moins débutants finissaient par faire un usage systématique (pour ne pas dire irréfléchi) d'allocations dynamiques. Or, le processus d'allocation dynamique

*) réclame plus de connaissance et plus de vigilance pour être réalisé sans erreur,
*) a un coût d'exécution non négligeable : un malloc, un realloc ont un coût qui peut être très pénalisant et qui lorsqu'ils sont répétés un grand nombre de fois peuvent faire préférer une allocation non dynamique.

GurneyH

20 mai 2010 à 5:59:58

Bonjour,
Les 3 exercices dans un même fichier source, on choisit en modifiant le #define du début.

J'ai vraiment eu la flemme de faire le moindre début de saisie sécurisée. :-°

donc attention! On lit le tableau sous la forme donnée par Lithrein.

Désolé pour le tableau en static, mais 1000 * 1000 c'était ou static, ou global, ou dynamique, il a fallu trancher.

#include <stdio.h>

#define MAX_SIZE    1000

#define EXO3 /* EXO1, EXO2 ou EXO3 */

/* On englobe notre tableau et ses dimensions dans un structure */
typedef struct tableau2D
{
    int tab[MAX_SIZE][MAX_SIZE];
    int nl, nc;
}Tableau2d;


void swap ( int *a, int *b )
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

/* zTranforme. Exercice1 */
void inverse ( Tableau2d *t )
{
    int l, c;
    for ( l = 0; l < t->nl; l++ )
        for ( c = l; c < t->nc; c++ )
            swap ( &t->tab[c][l], &t->tab[l][c] );
    swap ( &t->nl, &t->nc );
}

/* zTransforme. Exercice 2 */
void miroirH ( Tableau2d *t )
{
    int l, c, k;
    for ( l = 0; l < t->nl; l++ )
        for ( c = 0, k = t->nc - 1; c < k; c++, k-- )
            swap ( &t->tab[l][c], &t->tab[l][k] );
}


void rotate90 ( Tableau2d *t )
{
    inverse ( t );
    miroirH ( t );
}

/* Fonctions communes aux 2 premiers exercices */
void afficher ( Tableau2d *t )
{
    int l, c;
    for ( l = 0; l < t->nl; l++ )
    {
        for ( c = 0; c < t->nc; c++ )
            printf ( "%d ", t->tab[l][c] );
        puts ( "" );
    }
    puts ( "" );
}



void lire ( Tableau2d *t )
{
    int l, c;
    scanf ( "%d %d", &t->nl, &t->nc );
    
    for ( l = 0; l < t->nl; l++ )
        for ( c = 0; c < t->nc; c++ )
            scanf ( "%d", &t->tab[l][c] );
}

/* zTransforme. Exercice 3 */
void exercice3 ( int sz )
{
    int l, c;
    for ( l = 0; l < sz; l++ )
    {
        for ( c = 0; c < sz; c++ )
            if ( l == c || c == sz - 1 - l )/* if ( l == c || c == sz - 1 - l || l == sz - 1 - c ) pfff */
            {
                putchar ( '#' );
                putchar ( ' ' );
            }
            else
                printf ( "%d ", c + 1 );
        puts ( "" );
    }
}



int main ( void )
{
    static Tableau2d t2d;
#ifdef EXO1
    lire ( &t2d );
    inverse ( &t2d );
    afficher ( &t2d );
#endif
#ifdef EXO2
    lire ( &t2d );
    rotate90 ( &t2d );
    afficher ( &t2d );
#endif
#ifdef EXO3
#define SIZE    9
    exercice3 ( SIZE );
#endif
    
    return 0;
}

edit: :

Zeste de Savoir, le site qui en a dans le citron !

Pouet_forever

20 mai 2010 à 7:58:23

Dis moi, c'est pas la même chose ça : c == sz - 1 - l || l == sz - 1 - c ?

GurneyH

20 mai 2010 à 8:02:01

Citation : Pouet_forever

Dis moi, c'est pas la même chose ça : c == sz - 1 - l || l == sz - 1 - c ?

<math>$c == sz - 1 - l\\0 == sz - 1 - l - c\\l == sz - 1 - c$</math>

Bah si... J'ai été un peu vite. :'(

Zeste de Savoir, le site qui en a dans le citron !

candide

20 mai 2010 à 14:05:57

Citation : Pouet_forever

Dis moi, c'est pas la même chose ça : c == sz - 1 - l || l == sz - 1 - c ?

De toute façon, il devrait être interdit pour un codeur d'utiliser la lettre l en solo, le risque de mauvaise lecture et de confusion avec 1 (= un) ou | (trait vertical) est trop grand. Le composeur <math>$\LaTeX$</math>
le sait puisqu'il permet d'utiliser une lettre spéciale ("ell") : <math>$"\ell"$</math>

Citation : GurneyH

Bonjour,
Les 3 exercices dans un même fichier source, on choisit en modifiant le #define du début.</secret>

Bon moi j'ai nettoyé tes macros et fonctions pour ne garder que l'exo 1 (le reste, on brode sur le même thème) ce qui donne le code suivant :

#include <stdio.h>
#define MAX_SIZE    1000

/* On englobe notre tableau et ses dimensions dans un structure */
typedef struct tableau2D
{
    int tab[MAX_SIZE][MAX_SIZE];
    int nl, nc;
}Tableau2d;


void swap ( int *a, int *b )
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

/* zTranforme. Exercice1 */
void inverse ( Tableau2d *t )
{
    int l, c;
    for ( l = 0; l < t->nl; l++ )
        for ( c = l; c < t->nc; c++ )
            swap ( &t->tab[c][l], &t->tab[l][c] );
    swap ( &t->nl, &t->nc );
}

/* Fonctions communes aux 2 premiers exercices */
void afficher ( Tableau2d *t )
{
    int l, c;
    for ( l = 0; l < t->nl; l++ )
    {
        for ( c = 0; c < t->nc; c++ )
            printf ( "%d ", t->tab[l][c] );
        puts ( "" );
    }
    puts ( "" );
}


void lire ( Tableau2d *t )
{
    int l, c;
    scanf ( "%d %d", &t->nl, &t->nc );
    
    for ( l = 0; l < t->nl; l++ )
        for ( c = 0; c < t->nc; c++ )
            scanf ( "%d", &t->tab[l][c] );
}


int main ( void )
{
    static Tableau2d t2d;

    lire ( &t2d );
    inverse ( &t2d );
    afficher ( &t2d );

    return 0;
}

Ensuite, je redirige les entrées vers le fichier t suivant :

candide@~$ cat t
4 3
1 2 3
4 5 6
0 2 9
3 4 7
candide@~$

Et j'exécute :

candide@~$ c99 transpose_Gurney.c 
candide@~$ ./x <t
1 4 0 0 
2 5 2 0                                                                                                       
3 6 9 0 
                                                                                                              
candide@~$

Y'a pas un blème ?

1 2 >>

zTransforme

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.

× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.

zTransforme

16 Mai - 31 Mai

@Ichigo11

@Adroneus

zTransforme

Supprimer

Modérer

Signaler le message aux modérateurs