daily pastebin goal
29%
SHARE
TWEET

Untitled

a guest Mar 24th, 2019 52 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * Classe permettant de gérer la grille des horaires de bus
  3.  * GestionGrilleHoraire.java                                                 02/19
  4.  */
  5. package info1.codes;
  6.  
  7.  
  8. /**
  9.  * Classe permettant de gérer la grille des horaires de bus. Les horaires de passage
  10.  * des bus sont stockés en minutes.
  11.  * La grille des horaires est un tableau à 2 dimensions comportant 10 colonnes et 50
  12.  * lignes :
  13.  *   - 10 colonnes car il y aura au plus 10 déssertes dans l'application. Sur la colonne
  14.  *      i, on trouve les horaires de passage des bus de la desserte i (celle stockée en
  15.  *      colonne i du tableau des dessertes)
  16.  *   - 50 lignes car pour une desserte donnée, il y a au plus 50 passages de bus
  17.  * Les cases non significatives de la grille seront égales à -1.
  18.  *
  19.  *
  20.  * @author INFO1
  21.  * @version 1.0
  22.  *
  23.  */
  24. public class GestionGrilleHoraire {
  25.    
  26.     private static int NB_MAX_HORAIRE_TEST = 50;
  27.     private static int NB_HORAIRE_DESSERTE_MAX = 10;
  28.    
  29.    
  30.     /*       Méthodes destinées à réaliser des affichages de la grille horaire    */
  31.     /*           (affichages utiles pour tester les autres méthodes)              */
  32.     /* ************************************************************************** */
  33.    
  34.    
  35.     /**
  36.      * Détermine si une colonne est significative dans la grille horaire
  37.      * La colonne doit exister et la valeur de sa première ligne doit être
  38.      * différente de -1
  39.      * @param grille    grille contenant les horaies en minutes
  40.      * @param colonne   colonne à tester
  41.      * @return  un booléen égal à vrai ssi la colonne est significative
  42.      */
  43.     public static boolean colonneSignificative(int[][] grille, int colonne) {
  44.         return colonne >= 0 && colonne < grille[0].length
  45.                && grille[0][colonne] != -1;
  46.     }
  47.    
  48.    
  49.     /**
  50.      * Affiche les horaires située sur une colonne précise de la grille horaire.
  51.      * Les horaires sont affichés dans le format cchcc (par exemple 10h15)
  52.      * (ne doit pas afficher la valeur non significative -1)
  53.      * @param grille      grille contenant les horaies en minutes
  54.      * @param colonne     colonne à consulter
  55.      */
  56.     public static void afficherHoraireDesserte(int[][] grille, int colonne) {
  57.          if (colonneSignificative(grille, colonne)) {
  58.             System.out.println("Colonne numero " + (colonne + 1));
  59.             for (int ligne = 0 ; ligne < grille.length; ligne++) {
  60.                 // si horaire valide affiche cchcc
  61.                 if (!OutilHoraire.convertir(grille[ligne][colonne]).equals("erreur")) {
  62.                     // mise en forme affichage
  63.                     if (ligne % 6 == 0) {
  64.                         System.out.println();
  65.                     }
  66.                     System.out.print(OutilHoraire.convertir(grille[ligne][colonne])+ "    ");
  67.                 }                              
  68.             }
  69.  
  70.             System.out.println("\n\n");
  71.         }
  72.     }
  73.    
  74.    
  75.     /**
  76.      * Affiche la grille horaire argument. Seules les valeurs significatives
  77.      * seront affichées (donc celles différentes de -1).
  78.      * Les horaires seront affichés dans le format cchcc
  79.      * Cette méthode sera utile en phase de test de l'application
  80.      * Elle vous permettra de tester plus facilement l'ajout d'une liste
  81.      * d'horaires ou la suppression d'une telle liste
  82.      * @param horaire   tableau des horaires à afficher
  83.      */
  84.     public static void afficherGrille(int[][] grille) {
  85.         for (int colonne = 0 ; colonne < grille[0].length; colonne++) {
  86.         afficherHoraireDesserte(grille, colonne);  
  87.         }
  88.     }
  89.    
  90.    
  91.     /*    Méthodes pour ajouter ou supprimer des horaires de la grille horaire    */
  92.     /* ************************************************************************** */
  93.    
  94.      
  95.     /**
  96.      * Ajoute à la grille les horaires situés dans le tableau horaire.
  97.      * Les horaires sont ajoutés sur la première colonne significative.
  98.      * @param grille         grille contenant les horaires en minutes
  99.      * @param horaire        les horaires à ajouter en minutes
  100.      * @return un booléen égal à vrai si les horaires ont pu être ajoutés
  101.      */
  102.     public static boolean ajouterHoraire(int[][] grille, int[] horaire) {
  103.         int colonne,
  104.             caseDisponible;
  105.  
  106.         /* Recherche de l'indice de la première colonne significative */
  107.         for (colonne = 0; colonne < grille.length
  108.                                     && colonneSignificative(grille,colonne); colonne++);
  109.  
  110.         /* Si pas de colonne significative */
  111.         if (colonne == grille.length)
  112.             return false;
  113.  
  114.         /* Recherche de la premère case vide */
  115.         for (caseDisponible = 0; caseDisponible < grille.length
  116.                                  && grille[caseDisponible][colonne] != -1; caseDisponible++);
  117.  
  118.         /* Si pas de case vide */
  119.         if (caseDisponible == grille.length)
  120.             return false;
  121.  
  122.         /* Ajout de l'horaire */
  123.         for (int i = 0; i < horaire.length; i++) {
  124.             grille[i + caseDisponible][colonne] = horaire[i];
  125.         }
  126.  
  127.         return true;
  128.    }
  129.    
  130.    
  131.    
  132.     /**
  133.      * Supprime de la grille horaire d'une colonne précise
  134.      * (un décalage de colonne sera effectué)
  135.      * @param horaires         grille contenant les horaires
  136.      * @param colonne          numéro de la colonne dont les horaires doivent être
  137.      *                         supprimés
  138.      * @return un booléen égal à vrai si la suppression a pu être effectuée
  139.      */
  140.     public static boolean supprimerHoraire(int[][] horaires, int colonne) {
  141.         // vérification si la colonn est valide
  142.         if (!colonneSignificative(horaires, colonne)) {  
  143.             return false;
  144.         }
  145.  
  146.         /* suppression */
  147.         for (int i = 0; i < horaires.length && horaires[i][colonne] != -1; i++) {
  148.                 horaires[i][colonne] = -1;
  149.         }
  150.  
  151.         return true;
  152.     }
  153.  
  154.     /**
  155.      * Détermine si le tableau est plein,
  156.      * si il contient des valeurs significatives
  157.      * @param horaires         tableau contenant les horaires en minutes
  158.      * @return un booléen égal à vrai si le tableau passé en argument est plein
  159.      */
  160.     public static boolean tableauHorairesDessertePlein(int[][] horaires) {
  161.         // utilisation boucle forEach
  162.         for (int[] ligne : horaires) {  
  163.             for (int valeur : ligne) {
  164.                 if (valeur == -1) {
  165.                     return false;
  166.                 }
  167.             }
  168.         }
  169.         return true;
  170.  
  171.     }
  172.        
  173.  
  174.     /*          Méthodes pour effectuer des recherches dans la grille horaire     */
  175.     /* ************************************************************************** */  
  176.    
  177.     /**
  178.      * Recherche dans la colonne argument de la grille horaire argument, le premier
  179.      * passage de bus dont l'horaire est strictement postérieur à l'horaire argument.
  180.      * L'horaire de ce passage est le résultat renvoyé par la méthode
  181.      * @param grille      grille contenant les horaies en minutes
  182.      * @param colonne     numéro de la colonne dans laquelle rechercher
  183.      * @param horaire     horaie de la recherche
  184.      * @return  l'horaire du premier passage postérieur à l'horaire argument
  185.      *          ou bien la valeur -1 si aucun passage postérieur
  186.      */
  187.     public static int rechercherProchainPassage(int [][] grille, int colonne,
  188.                                                 int horaire) {
  189.  
  190.         int horaireTrouvee;
  191.         horaireTrouvee = 0;
  192.  
  193.         if (colonne < 0 || colonne > grille[0].length) {
  194.             System.out.println("Desserte choisie invalide");
  195.             horaireTrouvee = -1;
  196.             return horaireTrouvee;
  197.         } else if (!colonneSignificative(grille, colonne)) {
  198.             System.out.println("Cette desserte est vide");
  199.             horaireTrouvee = -1;
  200.             return horaireTrouvee;
  201.         }
  202.  
  203.         for (int i = 0; i < grille.length && grille[i][colonne] != -1; i++) {
  204.             /* si heure de la colonne > horaire entrée */
  205.             if (grille[i][colonne] > horaire) {
  206.                 horaireTrouvee =  grille[i][colonne];
  207.                 return horaireTrouvee;
  208.             }
  209.         }
  210.  
  211.         return horaireTrouvee;
  212.     }
  213.    
  214.  
  215.     /**
  216.      * Recherche dans la colonne argument du tableau en argument
  217.      * les horaires comprises entre borneInf et borneSup
  218.      * @param horaires              tableau contenant les horaires en minutes
  219.      * @param colonne               numero de la colonne où il faut chercher
  220.      * @param borneIf               borne inférieure de l'intervalle
  221.      * @param borneSup              borne supérieure de l'intervalle
  222.      * @return intervalle           un tableau avec des horaires comprises
  223.      *                              entre borneIf et borneSup
  224.      */
  225.     public static int[] rechercherHoraire(int[][] horaires, int colonne,
  226.                                           int borneInf, int borneSup) {
  227.  
  228.         int[] intervalle;
  229.         intervalle = new int[horaires.length];
  230.  
  231.         /* intialisation */
  232.         for (int i = 0; i < intervalle.length; i++) {
  233.             intervalle[i] = -1;                
  234.         }
  235.  
  236.         if (colonne < 0 || horaires[0].length <= colonne) {
  237.             System.out.println("Desserte invalide");
  238.             return intervalle;
  239.         } else if (!colonneSignificative(horaires,colonne)) {
  240.             System.out.println("Desserte sans horaire");
  241.             return intervalle;
  242.         }
  243.  
  244.         for (int i = 0, j = 0; i < horaires.length; i++) {
  245.             if (borneInf <= horaires[i][colonne] && horaires[i][colonne] <= borneSup) {
  246.                 intervalle[j] = horaires[i][colonne];
  247.                 j++;
  248.             }
  249.         }
  250.  
  251.         return intervalle;
  252.     }
  253.    
  254.     /*        Méthodes pour analyser le contenu des fichiers textes               */
  255.     /*               contenant les horaires à intégrer à l'application            */
  256.     /* ************************************************************************** */
  257.    
  258.     /**
  259.      * Verifie si les horaires du tableau argument sont au format cchcc
  260.      * @param aVerfier tableau a verifier
  261.      * @return un boolean egal a vrai si le tableau argument est conforme
  262.      */
  263.     public static boolean tableauHoraireCorrect(String[] aVerifier) {
  264.        
  265.         boolean resultat = true;
  266.  
  267.         /* si horaire présente et si les horaires sont pas au format cchcc*/
  268.         if (aVerifier.length == 0 || !OutilHoraire.estValide(aVerifier[0])) {
  269.             resultat = false;
  270.             return resultat;
  271.         }
  272.  
  273.         for (int i = 0; i < aVerifier.length && resultat; i++) {
  274.             if (!OutilHoraire.estValide(aVerifier[i+1]) ||
  275.                 OutilHoraire.convertir(aVerifier[i]) >=
  276.                 OutilHoraire.convertir(aVerifier[i+1])) {
  277.                 resultat = false;
  278.             }
  279.         }
  280.         return resultat;
  281.     }
  282.  
  283.     /**
  284.      * Convertie le tableau au format cchcc en argument en un tableau d'entier
  285.      * @param aConvertir tableau contenant les horaires a convertir en entier (en minutes)
  286.      * @return horairesS tableau contenant les horaires en minutes
  287.      */
  288.     public static int[] convertirTableauHoraire(String[] aConvertir) {
  289.  
  290.         int[] horaires = new int[aConvertir.length];
  291.  
  292.         /* initialiser le tableau */
  293.         for (int i = 0; i < horaires.length; i++) {
  294.             horaires[i] = -1;                
  295.         }
  296.  
  297.         /* conversion des horaires au format cchcc en valeurs entières */
  298.         for (int i = 0; i < horaires.length; i++) {
  299.             horaires[i] = OutilHoraire.convertir(aConvertir[i]);
  300.         }
  301.  
  302.         return horaires;
  303.     }
  304. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top