Salut a tous,
Je suis nouveau sur le forum et j'en profite donc pour me présenter:
Je m'apelle Will, j'ai 20 ans et habite Paris.Pour info je suis en premiere année de BTS info.

Passons a mon probleme; nous debutons en prog JAVA et notre prof nous a donner cet exercice (piece jointe) a faire rapidement et j'ai beau tourner le probleme dans tout les sens je n'y arrive pas ! Si quelqu'un l'a deja fait ou est pret a m'aider cele serai volontier. Je despere !

Merci a tous.

Règles du jeu : GRATTE CIEL (extrait de la revue JEUX TANGENTE)   (6 points)

 

(fournies pour la compréhension du sujet)

 

E X T R A I T         D E       L A       R E V U E

Un bloc de la ville de New York a été représenté dans une grille.Chaque case contient un immeuble de 10,20,30,40,50 ou 60 étages. Les immeubles d'une même rangée, ligne ou colonne, sont tous de tailles différentes.     Les informations données sur les bords indiquent le nombre d'immeubles visibles sur la rangée correspondante par un observateur situé à cet endroit.     1er exemple, si une ligne contient 20-40-30-10:   - 2 immeubles sont visibles à partir de la gauche(le 20 et 40)   - 3 immeubles sont visibles à partir de la droite (le 10,30 et 40).     2eme exemple si une ligne contient: 30-20-40-10   - 2 immeubles sont visibles à partir de la gauche(le 30 et 40)        le 20 n'est pas visible, il est caché par le 30   - 2 immeubles sont visibles à partir de la droite(le 10 et 40).     Retrouvez la hauteur de chaque immeuble !   Tous les problèmes ont une seule solution.   exemple:         | 4  |  1 |  3 |  2 |                      | 4  |  1 |  3 |  2 |       --+----+----+----+----+--                  --+----+----+----+----+--     2 |    |    |    |    | 2                  2 | 10 | 40 | 20 | 30 | 2     --+----+----+----+----+--     SOLUTION     --+----+----+----+----+--     3 |    |    |    |    | 1        ==>       3 | 20 | 10 | 30 | 40 | 1     --+----+----+----+----+--                  --+----+----+----+----+--     2 |    |    |    |    | 2                  2 | 30 | 20 | 40 | 10 | 2     --+----+----+----+----+--                  --+----+----+----+----+--     1 |    |    |    |    | 3                  1 | 40 | 30 | 10 | 20 | 3     --+----+----+----+----+--                  --+----+----+----+----+--       | 1  | 2  | 2  | 2  |                      | 1  | 2  | 2  | 2  |

SUJET du test:                                 durée : 2h

  Mr JAVA vient de vous recruter pour réaliser le programme qui devra générer les grilles du jeu Gratte Ciel. Pour ce faire, il vous demande de réaliser le menu suivant:

-=-=-=- Menu -=-=-=- G Générer  Gratte Ciel                 A Afficher Gratte Ciel                 B Créer    Bords du Gratte Ciel        X Afficher Gratte Ciel et bords              Z Afficher uniquement bords                      Q Quitter   Votre choix [G A B X Z Q ] ?

De 0 à 15 /20 (partie obligatoire)

De 15 à 20/20 (partie optionnelle)

NB: l'utilisateur pourra utiliser le menu jusqu'à ce qu'il décide d'arrêter(choix = 'Q')

 

Traitements attendus pour les différents choix :

1) Choix G: générer GratteCiel :

a) en fait il s'agit ici de faire saisir la dimension du tableau puis de créer les tableaux suivants : int[][] tabNY   (tableau principal)

                           et int[][] tabNSEO (tableau des bords)

 

exemple :pour une dimension de 6, un tableau de 6x6 (rappel: indice du tableau de 0 à 5):

      -le tableau sera de la forme : new int[6][6]

      -la hauteur des immeubles ira de 10 à 60(avec 60 = dimension*10)

                                                                       Page 1 / 2

   b) puis de générer (remplir) le tableau avec des nombres compris entre 10 et dimension*10, en respectant la règle suivante :

  - jamais 2 fois le même nombre sur la même ligne, ni dans la même colonne;

       ("Les immeubles d'une même rangée, ligne ou colonne, sont tous de tailles différentes")

 

NB: La méthode attendue pour « mélanger » les immeubles de hauteur différente est la suivante :

-         pour la première ligne (rappel 0), tirer un numéro de colonne au hasard afin d'y placer le 10; pour le 20 passer à la colonne suivante, si cette dernière était supérieur à la dimension, revenir en colonne 0 ;continuer pour les autres nombres jusqu'à atteindre dimension*10.

 

-         pour les lignes suivantes, décaler la position du 10 d'une colonne vers la droite ; placer les autres nombres en suivant selon le même procédé.

 

2) choix A: afficher Gratte Ciel : 

   afficher le contenu du tableau principal sous la forme:

Contenu du tableau       30 40 10 20       20 30 40 10       10 20 30 40       40 10 20 30

 

 

 

 

 

 

 

 

 

3)choix B: créer Bords du Gratte Ciel: il s'agit ici de compter pour chaque ligne   (de droite à gauche puis de gauche à droite) et pour chaque colonne(du haut vers bas puis du bas vers haut) le nombre d'immeuble visible depuis cet endroit là

 

  cf 1er et 2eme exemple des règles donnée au début dans « Extrait de la revue »

 

  NB: Pour le comptage des immeubles visibles:

   le chiffre qui est calculé en haut  (comptage de haut en bas)

   le chiffre qui est calculé en bas   (comptage du bas vers haut)

   le chiffre qui est calculé à droite (comptage de la gauche vers la droite)

   le chiffre qui est calculé à gauche (comptage de la droite vers la gauche)

 

4)X :Afficher Gratte Ciel et bords : obtenir un affichage sous la forme:

  

Afficher  Gratte Ciel et Bords          2  1  2  2    2-|30|40|10|20| -2    3-|20|30|40|10| -2    4-|10|20|30|40| -1    1-|40|10|20|30| -2        1  4  3  2

 

 

 

 

 

 

 

 

 

 

 

5)choix Z Afficher uniquement bords : obtenir un affichage sous la forme:

Afficher bords          2  1  2  2    2-|  |  |  |  | -2    3-|  |  |  |  | -2    4-|  |  |  |  | -1    1-|  |  |  |  | -2        1  4  3  2

 

 

 

 

 

 

 

 

 

 

 

                                                                        Page 2 / 2

bah c'est pas compliqué ...

tu genere les immeuble.
ensuite il suffit d'encadrer la matrice et de voir combien d'immeuble sont visible selon le sens de la matrice :

matrice 4x4

10 20 10 30
40 20 30 10
20 10 30 40
30 40 20 20

peut importe le sens du regard on vois toujours au moins le premier
puis on ne vois que ceux qui sont plus grand que le plus grande deja vus dans ce sens.

ligne 1 de gauche a droite :
1,1 est visible, max = 10
1,2 plus grand que max (20 > 10 ?) oui : max = 20, visible + 1
1,3 plus grand que max (10 > 20 ?) non: ...
1,4 plus grand que max (30 > 20 ?) oui : max = 30, visible + 1

total : plus grand = 30, visible = 3

ligne 1 de droite a gauche :
1,4 est visible, max = 30
1,3 plus grand que max (10 > 30 ?) non : ...
1,2 plus grand que max (20 > 30 ?) non : ...
1,1 plus grand que max (10 > 30 ?) non : ...

total : plus grand = 30, visible = 1

pour en deduire un programme (pseudo code) :

int function LeftToRightViewer(tableau, rowindex, indexlow, indexhigh) {
  int max=0;
  int visible=0;

  max = tableau[rowindex, indexlow];
  visible = 1;
  for(i=indexlow+1, i <= indexhigh, i++)
    if (tableau[rowindex, i] > max) {
      visible++;
      max = tableau[rowindex, i];
    }
  return(visible);
}

int fucntion RightToLeftViewer(tableau, rowindex, indexlow, indexhigh) {
  int max=0;
  int visible=0;

  max = tableau[rowindex, indexhigh];
  visible = 1;
  for(i=indexhigh-1, i >= indexlow, i--)
    if (tableau[rowindex, i] > max) {
      visible++;
      max = tableau[rowindex, i];
    }
  return(visible);
}

int function TopToBottomViewer(tableau, colindex, indexlow, indexhigh) {
  int max =0;
  int visible =0;

  max = tableau[indexlow, colindex];
  visible = 1;
  for(i=indexlow+1, i <= indexhigh, i++)
    if (tableau[i, rowindex] > max) {
      visible++;
      max = tableau[i, rowindex];
    }
  return(visible);
}

int function BottomToTopViewer(tableau, rowindex, indexlow, indexhigh) {
  int max =0;
  int visible =0;

  max = tableau[indexhigh, rowindex];
  visible = 1;
  for(i=indexhigh-1, i >= indexlow, i--)
    if (tableau[i, rowindex] > max) {
      visible++;
      max = tableau[i, rowindex];
    }
  return(visible);
}

int ml = 0; // index bas
int mh = 7; // index haut (6x6 immeubles)
int matriceimmeuble[ml..mh, ml..mh];

// le nombre d'immeuble visible est placé dans les case d'index :
// n, ml pour left to right (a gauche du tableau)
// n, mh pour right to left (a droite du tableau)
// ml, n pour top to bottom (en haut du tableau)
// mh, n pout bootom to top (en bas du tableau)

for (n=ml+1, n<=mh-1, n++) {
  matriceimmeuble[n, ml] = LeftToRightViewer(matriceimmeuble, n, ml+1, mh-1);
  matriceimmeuble[n, mh] = RightToLeftViewer(matriceimmeuble, n, ml+1, mh-1);
  matriceimmeuble[ml, n] = TopToBottomViewer(matriceimmeuble, n, ml+1, mh-1);
  matriceimmeuble[mh, n] = BottomToTopViewer(matriceimmeuble, n, ml+1, mh-1);
}


je te laisse trouver pour le reste c'est pas compliqué ...

---