Bonsoir,
comment afficher un tab2D de tab2D en C ?

En fait, je voudrait sa :

111 111 111 111
111 111 111 111
111 111 111 111

111 111 111 111
111 111 111 111
111 111 111 111

Sachant que chaque carré de 1 represent un tableau 2D de 3*3 et le dessin total est representé par un tab 2D de 4*2

Ce qui nous donne : case Grille [4][2]

case est un structure qui contient un int tab[3][3]

Comment afficher correctement ma matrice sur la console?
J'ai fait un fonction avec 4 for imbriqué mais cela m'affiche toute les cases les une derriere les autres.

Je t'ai fais ça en Java, mais bon c'est laid toutes ces boucles for

http://pastebin.com/gGCiMcnW

Si tu veux faire ça dans un autre langage oublie pas que system.out.println() fait automatiquement un saut à la ligne, alors que system.out.print n'en fait pas !

Et au lieu de petitTab[j][l] tu peux mettre case[i][k][j][l]

Avec i la ième ligne et k la k-ième colonne du grand tableau [4],[2].

Et avec j la j-ième ligne de chaque petit tableau, et l sa l-ième colonne (donc les tab 3x3).

Voilà, c'est pas optimisé, c'est moche, mais ça m'a amusé de réfléchir à ton problème Toujours marrant de jouer avec des boucles for.

(Et bravo à moi pour la magnifique faute dans LE commentaire du code )

Au fait, désolé pour le triple post, mais ta variable c'est case ou Grille ? Parce qu'il y a pas de majuscule au début des noms de variable. Si c'est Grille, alors mets en minuscule !

Dis tu pourrait poster le code ici stp, j'arrive pas a eller sur le site.
Je code en C :

struct case{
char tab[3][3];
};

typedef struct case case;

case grille[4][5];

Ah mais le code que tu m'a fait n'est pas ce que je voulait, toi tu m'affiche un simple tableau 2D, alors que moi dans chaque case d'un tableau 2d, j'ai un autre tableau 2D

Et je veux sa en fait :

AAA BBB CCC DDD
AAA BBB CCC DDD
AAA BBB CCC DDD

EEE FFF GGG HHH
EEE FFF GGG HHH
EEE FFF GGG HHH

III JJJ KKK LLL
III JJJ KKK LLL
III JJJ KKK LLL

Chaque carré est un tableau 2D qui est defini par :
struct case{
tab[3][3]
};

Le tout est un tableau 2D qui est defini par
struct case grille[4][3]

C'est ce que j'ai fais...

Imaginons tes petits tableaux 3x3 sous cette forme :

A1 A2 A3
B1 B2 B3
C1 C2 C3

Tu cherches à afficher

A1A2A3 A1A2A3 A1A2A3 A1A2A3
B1B2B3 B1B2B3 B1B2B3 B1B2B3
C1C1C3 C1C2C3 C1C2C3 C1C2C3

A1A2A3 A1A2A3 A1A2A3 A1A2A3
B1B2B3 B1B2B3 B1B2B3 B1B2B3
C1C1C3 C1C2C3 C1C2C3 C1C2C3

Avec des espaces entre chaque case. Et sachant que chaque tableau 3x3 est différent des autres. Je me trompe ?

Si c'est bien ça, alors mon code convient.

Pour être plus précis, relis ce que j'ai écris sur les 4 indices utilisés dans mes 4 boucles for.

"Avec i la ième ligne et k la k-ième colonne du grand tableau [4],[2].

Et avec j la j-ième ligne de chaque petit tableau, et l sa l-ième colonne (donc les tab 3x3). "

Tu as donc struct case grille[i][k]
Et chaque petit tableau : tab[j][l]

Je suis quasiment certain que c'est ce que tu cherches

Oui en fait j'avait une boucle for a decaler plus haut dans mon code quoi. Merci
Probleme resolu alors bonne soirée

sinon les fonctions c'est cool

J'aurais besoin d'une aide sur un algo pour un jeu qui concerne justement le tableau ci dessus.
ENT
ENT
ENT
ABA ABA AAA ABA
ABA ABA AAA BAB
ABA ABA AAA BAB

ABA ABA AAA ABA
ABA ABA BBA BAB
ABA ABA ABA BAB
ARR
ARR
ARR

Chaque carré est un tableau 2D qui est defini par :
struct case{
tab[3][3]
};

Le tout est un tableau 2D qui est defini par
struct case grille[4][3]

Comment verifier que le chemin de ENT jusqua ARR est correct?
Sachant que l'on a le droit de passer que par les case ou il y a une B sinon on n'est bloqué, c'est un genre de labyrinthe en fait ou a represente des murs et B le chemin.

Sachant que les cases ne sont pas toujours dans cet ordre, comment determiner si le chemin partant de ENT jusqu'a ARR est correct

C'est vraiment pas clair. Je sais pas pour les autres, mais là j'y vois aucun chemin. Déjà faut comprendre où est l'entrée et où est la sortie, c'est-à-dire quelle case précise de ton tableau [4][3][3][3] (qui au passage ressemble là à un tableau [4][2][3][3]) a le rôle d'entrée ou de sortie.

Ensuite, dans ce contexte, je ne vois vraiment pas l'utilité d'utiliser une structure, donc un tableau de 4 dimensions. Ca embrouille plus qu'autre chose. Si tu veux faire un labyrinthe par ce biais, fait ça dans un simple tableau à deux dimensions, et tu t'y déplaces point par point, un point étant défini par les coordonnées x et y. Pour te déplacer, tu peux incrémenter soit x, soit y, mais pas les deux. Et seulement si tab[x+1, y] ou tab[x, y+1] est égal à un chemin praticable.

Si tu utilises un tableau de 4 dimensions pour un problème qui n'a besoin que de deux dimensions, tu te compliques inutilement la tâche.

En fait, j'ai pas tout representer sur le dessin.
J'ai une grille qui fait [6][4], la premiere ligne me permet de fixer l'entrée et la derniere l'arrivée.
Le reste represente le jeu, avec pour chaque case de grille un autre tableau 2D de [3][3].

Pour chaque case ou j'utilise un tableau [3][3], il y a deux lettre possible, b pour blanc(indique le chemin) et v pour vert(indique les haies d'un labyrinthe).
Chaque case forme alors un motif correspondant a une case du labyrinthe.

Il faudrait l'algo qui me permettrai en connaisant la case d'ntrée et la case de sortie de determiner si une partie est fini et donc qu'un chemin permetant d'aller de l'entrée a la sortie existe.

C'est plus clair?

Qui aurait une reponse svp ?
Je trouve nul part quelqu'un qui utlilis un tableau 2 dimensions de structure qui contient elle meme un tableau 2D

Je ne comprends toujours pas l'utilité de ta structure case, plutôt qu'un tout bête tableau 2 dimensions dont la première ligne sert d'entrée et la dernière ligne sert de sortie. Pour le coup, j'avoue que j'ai pas envie de me fatiguer à réfléchir à un algo qui switch entre tes 4 dimensions là où 2 suffisent

clairement, tu devrais revoir ta modélisation pour faire un truc aussi simple. Et au passage une recherche de chemin dans un tableau en 4D ça risque d'être vraiment pas rigolo (alors qu'en 2D c'est pas très dur)

J'ai reussi a simplifier ma modelisation et j'ai desormais un tableau 2d de [18][15]
Exemple:

______ddd______
______ddd______
______ddd______
xxxllxxxlxllxxx
lxlxxxllxxlxlxx
lllxxlllxlxllxx
lxxxxxxxxlxlxll
xlxxxlxxxllxlll
llxlxlxxxxlxlxl
lxlxxxxlxxxlxlx
xxlxllxllllxlll
llxlxllxxlxxxll
lxxxxxlxllxllll
xxxlxllxlxxxlxl
xxxlllxlxllxxll
______aaa______
______aaa______
______aaa______

Sachant que les _ sont en fait le caractere ' ', on peut passer par les l (chemin) et les x sont des murs.

Quel algo pour determiner si on peut rallier la sortie depuis l'entrée?

Implémente l'algorithme A*. Il y a pas mal d'explications sur le web, celle-la en est une parmi d'autres : http://www.playeradvance.org/forum/showthread.php?t=27815