Une aide pour la correction de test if()
Répondre à la discussion
Affichage des résultats 1 à 17 sur 17

Une aide pour la correction de test if()



  1. #1
    saniadaff

    Une aide pour la correction de test if()


    ------

    Bonsoir tout le monde; dans l’exécution de mon programme PegaleNP il y a un test if qui ne fonctionne pas alors que le résultat devrait être correct vue l'exemple de trace élucider ici:

    on comprend la trace même si je n'ai pas pu intercepter le début de l’exécution;

    Code:
    Veuillez saisir le nombre d’étudiants :
    15
    Veuillez saisir le nombre pair d’étudiant incompatible :
    7
    Veuillez saisir le nombre d’étudiants à sélectionner par pair :
    10
    ------Menu principal ---------
       1. Liste d’étudiants     
     2.Liste d’étudiants incompatibles  
      3. Sélection d’étudiants  
               4.Quitter      
          Taper votre choix : 
    Veuillez respecter le menu!
    ------Menu principal ---------
       1. Liste d’étudiants     
     2.Liste d’étudiants incompatibles  
      3. Sélection d’étudiants  
               4.Quitter      
          Taper votre choix : 
    1
    Veuillez saisir l’Id de l’étudiants :
    001
    Veuillez saisir l’Id de l’étudiants :
    002
    Veuillez saisir l’Id de l’étudiants :
    003
    Veuillez saisir l’Id de l’étudiants :
    004
    Veuillez saisir l’Id de l’étudiants :
    005
    Veuillez saisir l’Id de l’étudiants :
    006
    Veuillez saisir l’Id de l’étudiants :
    007
    Veuillez saisir l’Id de l’étudiants :
    008
    Veuillez saisir l’Id de l’étudiants :
    009
    Veuillez saisir l’Id de l’étudiants :
    010
    Veuillez saisir l’Id de l’étudiants :
    011
    Veuillez saisir l’Id de l’étudiants :
    012
    Veuillez saisir l’Id de l’étudiants :
    013
    Veuillez saisir l’Id de l’étudiants :
    014
    Veuillez saisir l’Id de l’étudiants :
    015
    ------Menu principal ---------
       1. Liste d’étudiants     
     2.Liste d’étudiants incompatibles  
      3. Sélection d’étudiants  
               4.Quitter      
          Taper votre choix : 
    2
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    001
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    003
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    005
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    007
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    009
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    011
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    013
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    015
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    014
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    002
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    010
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    004
    Veuillez saisir l’Id de l’étudiant1 incompatible:
    012
    Veuillez saisir l’Id de l’étudiant2 incompatible:
    006
    ------Menu principal ---------
       1. Liste d’étudiants     
     2.Liste d’étudiants incompatibles  
      3. Sélection d’étudiants  
               4.Quitter      
          Taper votre choix : 
    3
    
    -----------------
    idRecherché a été trouvé: 002
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 4
    002 = 014 ET  013 != 002 OU  002 = 002 ET  013 != 014
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 5
    -----------------
    idRecherché a été trouvé: 005
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 1
    005 = 005 ET  006 != 007 OU  005 = 007 ET  006 != 005
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 1
    -----------------
    idRecherché a été trouvé: 009
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 2
    009 = 009 ET  012 != 011 OU  009 = 011 ET  012 != 009
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 5
    -----------------
    idRecherché a été trouvé: 010
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 5
    010 = 010 ET  009 != 004 OU  010 = 004 ET  009 != 010
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 0
    -----------------
    idRecherché a été trouvé: 007
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 1
    007 = 005 ET  012 != 007 OU  007 = 007 ET  012 != 005
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 6
    -----------------
    idRecherché a été trouvé: 003
     tabEtudInc[0][0] 001
     tabEtudInc[0][1] 003
     tabEtudInc[1][0] 005
     tabEtudInc[1][1] 007
     tabEtudInc[2][0] 009
     tabEtudInc[2][1] 011
     tabEtudInc[3][0] 013
     tabEtudInc[3][1] 015
     tabEtudInc[4][0] 014
     tabEtudInc[4][1] 002
     tabEtudInc[5][0] 010
     tabEtudInc[5][1] 004
     tabEtudInc[6][0] 012
     tabEtudInc[6][1] 006
    indice : 0
    003 = 001 ET  006 != 003 OU  003 = 003 ET  006 != 001
    Compteur: 1
    tabEtudSelectCopy: 008
    tabEtudSelectCopy: 014
    nb: 8
    -----------------
    Voici le test if

    Code:
    if(((id1 == tabEtudInc[Indice][0]) && (id2 != tabEtudInc[Indice][1])) 
    || ((id1 == tabEtudInc[Indice][1]) && (id2 != tabEtudInc[Indice][0]))) {
    		                  // Si le couplage est possible alors on les tire tous les deux
    		                  tabTirage[0][0] = id1;
    		                  tabTirage[0][1] = id2;
    		                  tabEtudCopy.remove(nb);
    		                  Ajouter = true;
    		                  compteur++;// trace
    		                  System.out.println("Compteur: "+compteur);// pr la trace
    		               }
    		               else {
    Ce test est il fausse?

    Ou c'est une erreur technique de java?

    Dans certains endroits du code j'avais utilisé while qui n'a pratiquement pas fonctionné mais en transformant en do....while ça marché ; la question est pourquoi cet état de fait?

    Ici, dans if il accède une seule fois et fait un tirage sans mettre Ajouter à vrai et sans incrémenter le compteur aussi alors que le compteur me sert de moyen pour déterminer la complexité; pour les autres fois ils ne n’accède pas et reste planter dans la boucle.

    Merci pour votre aide

    -----
    Dernière modification par saniadaff ; 20/09/2022 à 02h08.

  2. #2
    umfred

    Re : Une aide pour la correction de test if()

    quand tu utilises un while, il faut que la condition de celui-ci soit vrai pour y rentrer. En faisant le do..while, tu fais au moins une fois le code de la boucle car pas de condition pour y rentrer.
    quand à ton if, il faudrait, je pense la boucle entière (voir un peu avant); peut-être une histoire d'initialisation/mise à jour de variables ou de test de la boucle entourant le if

  3. #3
    vgondr98

    Re : Une aide pour la correction de test if()

    Quel est le type de id1 et de id2 ? String ou int ?

  4. #4
    saniadaff

    Re : Une aide pour la correction de test if()

    id1 et id2 sont String;

    je reviens pour remettre le code

  5. A voir en vidéo sur Futura
  6. #5
    saniadaff

    Re : Une aide pour la correction de test if()

    je reviens en vois ci donc:

    Code:
     // Sélection par tirage au sort ________________________________________________________________
    		   public static void Selection(String [][] tabEtudSelect, String [][]tabEtud,
    		      String [][]tabEtudInc, Scanner keby,String clobalId) {
    		      int n = tabEtud.length;
    		      int Indice=0; // indice de id incompatible necessaire pour le test de compatibilité		     
    		      Boolean Ajouter = false;                   // Si Ajouter = vrai sortir du while
    		      String[][] tabTirage = new String[1][2];   // 2x tirés, rangés et remplacés au tirage suivant
    		      // Mets la liste étudiant dans ArrayList pour faciliter le traitement
    		      ArrayList<String> tabEtudCopy = new ArrayList< String > (); 
    		      // Récupère les selections et à la sortie recopierra dans tabEtudSelect
    		      ArrayList<String> tabEtudSelectCopy = new ArrayList< String > ();
    		      int c = tabEtudSelect.length/2; // Nombre de chambres, doit être = m / 2 et m = tabEtudSelect.length
    		      for(int i = 0; i < n; i++) {
    		         tabEtudCopy.add(tabEtud[i][0]); // Transfert de la liste étudiant dans la copie
    		      }	 	     		      
    		      String id1;
    		      String id2;		      
    		      String idRe;
    		      int inRe;
    		      /*Saisie des étudiants  dans des chambres; i=0 une chmbre donc deux étudiants; i=1 une seconde
    		      chambre donc deux "tudiants encore ainsi de suite*/
    		      loop:
    		      for(int i = 0; i < c; i++)  {
    		         Ajouter = false;                        // Chaque ajout egal vrai pour sortir du do while		         
    		         do {
    		            Random random = new Random();        // Tirage au sort ou nombre aleatoire
    		            int nb;
    		            n  = tabEtudCopy.size();            // Determine le nombre elements dans etudiant
    		   		 if(n == 1){ 
    		   			 id1 = tabEtudCopy.get(n);          // il est le seul à être logé	dans une chambre 		 		   			
    		   			 break loop;                       //fin de selection	
    		   		 } else {
    		            nb = random.nextInt(n);              // Choix dans l'intervale  0 et n
    		            id1= tabEtudCopy.get(nb);            // Si id1 retenu, l'etudiant sera selectionné		            
    		            clobalId = id1;                      //clobalId est un string car c'est id1 declaré comme variable clobale
    		            idRe = recherche(tabEtudInc,clobalId); // id1 dans liste d'incompatibilié ?		          
    		            if(idRe == "-1") {		            	
    		               // Sinon alors il est ajouté
    		               tabTirage[0][0] = id1;            // Il est rangé dans le tirage
    		               tabEtudCopy.remove(nb);           // Oté du tableau pour ne pas retomber sur le même
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);
    		               tabTirage[0][1] = id2;            // Son binomme est aussi tiré
    		               tabEtudCopy.remove(nb);
    		               Ajouter = true;                   // Pour sortir du while, aller dans la chambre suivante		              
    		            }
    		            else {           			            			            	            	
    		            	// Sinon alors on cherche le second et on vérifie s'il sont incompatibles
    		               inRe = recherche2(tabEtudInc,clobalId); // avant on cherche son indice  d'incompatibilié ?
    		               Indice =inRe;
    		               tabEtudCopy.remove(nb);           // Evidemment il faut supprimer id1 avant
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);	              		                  	            		               
    		               if(((id1 == tabEtudInc[Indice][0]) && (id2 != tabEtudInc[Indice][1])) 
    		                 || ((id1 == tabEtudInc[Indice][1]) && (id2 != tabEtudInc[Indice][0]))) {
    		                          // Si le couplage est possible alors on les tire tous les deux
    		                          tabTirage[0][0] = id1;
    		                          tabTirage[0][1] = id2;
    		                          tabEtudCopy.remove(nb);
    		                          Ajouter = true;
    		                       }
    		               else 		            	   
    		            	   tabEtudCopy.add(id1); 
    		            	  
    		               
    		               /* Si le duo n'est pas possible, on remet dans la table tabEtudCopy l'id1 qui a
    		                  été supprimé pour recommencer sans changer de chambre. Ajouter reste false */
    		            }
    		   		    }
    		         } while(Ajouter == false);
    		         // Les deux tirés sont rangés dans la selection
    		         n = tabEtudSelectCopy.size();
    		         tabEtudSelectCopy.add(tabTirage[0][0]);
    		         tabEtudSelectCopy.add(tabTirage[0][1]);
    		      }
    		      /* récupére la selection en tableau static si le travail est fini 
    		      et tabEtudSelectCopy aura une taille = 2*c   */		      
    		      int j = 0;
    		      for(String elem:tabEtudSelectCopy) {       // Tiens on repasse de c à m !
    		         tabEtudSelect[j][0] = elem;             // Récupération
    		         System.out.println("tabEtudSelect: "+elem);
    		         j++;
    		      }
    		   }
    tout le code ici:

    Code:
     // Sélection par tirage au sort ________________________________________________________________
    		   public static void Selection(String [][] tabEtudSelect, String [][]tabEtud,
    		      String [][]tabEtudInc, Scanner keby,String clobalId) {
    		      int n = tabEtud.length;
    		      int Indice=0; // indice de id incompatible necessaire pour le test de compatibilité		     
    		      Boolean Ajouter = false;                   // Si Ajouter = vrai sortir du while
    		      String[][] tabTirage = new String[1][2];   // 2x tirés, rangés et remplacés au tirage suivant
    		      // Mets la liste étudiant dans ArrayList pour faciliter le traitement
    		      ArrayList<String> tabEtudCopy = new ArrayList< String > (); 
    		      // Récupère les selections et à la sortie recopierra dans tabEtudSelect
    		      ArrayList<String> tabEtudSelectCopy = new ArrayList< String > ();
    		      int c = tabEtudSelect.length/2; // Nombre de chambres, doit être = m / 2 et m = tabEtudSelect.length
    		      for(int i = 0; i < n; i++) {
    		         tabEtudCopy.add(tabEtud[i][0]); // Transfert de la liste étudiant dans la copie
    		      }	 	     		      
    		      String id1;
    		      String id2;		      
    		      String idRe;
    		      int inRe;
    		      /*Saisie des étudiants  dans des chambres; i=0 une chmbre donc deux étudiants; i=1 une seconde
    		      chambre donc deux "tudiants encore ainsi de suite*/
    		      loop:
    		      for(int i = 0; i < c; i++)  {
    		         Ajouter = false;                        // Chaque ajout egal vrai pour sortir du do while		         
    		         do {
    		            Random random = new Random();        // Tirage au sort ou nombre aleatoire
    		            int nb;
    		            n  = tabEtudCopy.size();            // Determine le nombre elements dans etudiant
    		   		 if(n == 1){ 
    		   			 id1 = tabEtudCopy.get(n);          // il est le seul à être logé	dans une chambre 		 		   			
    		   			 break loop;                       //fin de selection	
    		   		 } else {
    		            nb = random.nextInt(n);              // Choix dans l'intervale  0 et n
    		            id1= tabEtudCopy.get(nb);            // Si id1 retenu, l'etudiant sera selectionné		            
    		            clobalId = id1;                      //clobalId est un string car c'est id1 declaré comme variable clobale
    		            idRe = recherche(tabEtudInc,clobalId); // id1 dans liste d'incompatibilié ?		          
    		            if(idRe == "-1") {		            	
    		               // Sinon alors il est ajouté
    		               tabTirage[0][0] = id1;            // Il est rangé dans le tirage
    		               tabEtudCopy.remove(nb);           // Oté du tableau pour ne pas retomber sur le même
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);
    		               tabTirage[0][1] = id2;            // Son binomme est aussi tiré
    		               tabEtudCopy.remove(nb);
    		               Ajouter = true;                   // Pour sortir du while, aller dans la chambre suivante		              
    		            }
    		            else {           			            			            	            	
    		            	// Sinon alors on cherche le second et on vérifie s'il sont incompatibles
    		               inRe = recherche2(tabEtudInc,clobalId); // avant on cherche son indice  d'incompatibilié ?
    		               Indice =inRe;
    		               tabEtudCopy.remove(nb);           // Evidemment il faut supprimer id1 avant
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);	              		                  	            		               
    		               if(((id1 == tabEtudInc[Indice][0]) && (id2 != tabEtudInc[Indice][1])) 
    		                 || ((id1 == tabEtudInc[Indice][1]) && (id2 != tabEtudInc[Indice][0]))) {
    		                          // Si le couplage est possible alors on les tire tous les deux
    		                          tabTirage[0][0] = id1;
    		                          tabTirage[0][1] = id2;
    		                          tabEtudCopy.remove(nb);
    		                          Ajouter = true;
    		                       }
    		               else 		            	   
    		            	   tabEtudCopy.add(id1); 
    		            	  
    		               
    		               /* Si le duo n'est pas possible, on remet dans la table tabEtudCopy l'id1 qui a
    		                  été supprimé pour recommencer sans changer de chambre. Ajouter reste false */
    		            }
    		   		    }
    		         } while(Ajouter == false);
    		         // Les deux tirés sont rangés dans la selection
    		         n = tabEtudSelectCopy.size();
    		         tabEtudSelectCopy.add(tabTirage[0][0]);
    		         tabEtudSelectCopy.add(tabTirage[0][1]);
    		      }
    		      /* récupére la selection en tableau static si le travail est fini 
    		      et tabEtudSelectCopy aura une taille = 2*c   */		      
    		      int j = 0;
    		      for(String elem:tabEtudSelectCopy) {       // Tiens on repasse de c à m !
    		         tabEtudSelect[j][0] = elem;             // Récupération
    		         System.out.println("tabEtudSelect: "+elem);
    		         j++;
    		      }
    		   }
    Dernière modification par saniadaff ; 20/09/2022 à 19h41.

  7. #6
    vgondr98

    Re : Une aide pour la correction de test if()

    Avec des Strings il faut utiliser la méthode .equals() et pas == pour tester une égalité.
    https://www.w3schools.com/java/ref_string_equals.asp

  8. #7
    saniadaff

    Re : Une aide pour la correction de test if()

    Mr vgondr98 merci c'était ça le problème;

    Merci tous les deux;

    Pour boucler sur ça, je voudrais avoir votre conclusion sur sa complexité càc s'il est polynomial?

    tout le code:

    Code:
    package PegaleNP;
    import java.util.*;
    public class PegaleNP {	
    	 //______________________________________________________________________________________________
    	   public static void main(String[] args ) {
    	      Scanner keby = new Scanner(System.in);	
    	      System.out.println("Veuillez saisir le nombre d’étudiants :");
    	      // Liste des étudiants
    	      int n = keby.nextInt();
    	      String[][] tabEtud = new String[n][4];     // Une structure ou class aurait été préférable
    	      System.out.println("Veuillez saisir le nombre pair d’étudiant incompatible :");
    	      // Liste de paires étudiants incompatible dans le même dortoir
    	      int n1 = keby.nextInt();
    	      String [][] tabEtudInc = new String[n1][2];
    	      System.out.println("Veuillez saisir le nombre d’étudiants à sélectionner par pair :");
    	      // 2 étudiants par chambre soit 2*nombres de chambres (mais c ressaisi plus loin !)
    	      int m = keby.nextInt();
    	      String [][] tabEtudSelect = new String[m][2];	       
    	      String  clobalId  = "001"; // globalId ? C'est un nombre pourquoi String ?
    	      String  choix;                   // Pourquoi utiliser String ?
    	      do {
    	         System.out.println("------Menu principal ---------");
    	         System.out.println("   1. Liste d’étudiants     "); 
    	         System.out.println(" 2.Liste d’étudiants incompatibles  ");
    	         System.out.println("  3. Sélection d’étudiants  ");
    	         System.out.println("           4.Quitter      ");
    	         System.out.println("      Taper votre choix : ");
    	          choix = keby.nextLine();	        
    	         switch(choix) { 
    	            case "1": saisieEtudiant (tabEtud, keby);      
    	               break;
    	            case "2": saisieIncompatibilite (tabEtudInc, keby);   
    	               break;
    	            case "3": Selection(tabEtudSelect, tabEtud , tabEtudInc , keby, clobalId);
    	               break; 
    	            default : System.out.println("Veuillez respecter le menu!");
    	         }
    	      } while(choix != "4");
    	   }
    	 
    	   //______________________________________________________________________________________________
    	   public static  void saisieEtudiant(String [][] tabEtud, Scanner keby) {
    		      int n = tabEtud.length; 
    		      int i = 0;		      
    		      do { // C'est un do while qui mime exactement un for
    		         System.out.println("Veuillez saisir l’Id de l’étudiants :");
    		         tabEtud[i][0] = keby.nextLine();		         
    		        /* System.out.println("Veuillez saisir le nom de l’étudiants :");
    		         tabEtud[i][1] = keby.nextLine();		         
    		         System.out.println("Veuillez saisir le prénom de l’étudiants :");
    		         tabEtud[i][2] = keby.nextLine();		         
    		         System.out.println("Veuillez saisir l’adresse de l’étudiants :");
    		         tabEtud[i][3] = keby.nextLine(); */		        
    		         i = i + 1;
    		      } while (i < n);
    		   }
    		 
    		   //______________________________________________________________________________________________
    		   public static void saisieIncompatibilite(String [][] tabEtudInc, Scanner keby) {
    		      int n = tabEtudInc.length;		     
    		      int i = 0;
    		      do {
    		         System.out.println("Veuillez saisir l’Id de l’étudiant1 incompatible:");
    		         tabEtudInc[i][0] = keby.nextLine();		        
    		         System.out.println("Veuillez saisir l’Id de l’étudiant2 incompatible:");
    		         tabEtudInc[i][1] = keby.nextLine();		         
    		         i = i + 1;
    		      } while(i < n);    
    		   }
    		 
    		   // Sélection par tirage au sort ________________________________________________________________
    		   public static void Selection(String [][] tabEtudSelect, String [][]tabEtud,
    		      String [][]tabEtudInc, Scanner keby,String clobalId) {
    		      int n = tabEtud.length;
    		      int Indice=0; // indice de id incompatible necessaire pour le test de compatibilité		     
    		      Boolean Ajouter = false;                   // Si Ajouter = vrai sortir du while
    		      String[][] tabTirage = new String[1][2];   // 2x tirés, rangés et remplacés au tirage suivant
    		      // Mets la liste étudiant dans ArrayList pour faciliter le traitement
    		      ArrayList<String> tabEtudCopy = new ArrayList< String > (); 
    		      // Récupère les selections et à la sortie recopierra dans tabEtudSelect
    		      ArrayList<String> tabEtudSelectCopy = new ArrayList< String > ();
    		      int c = tabEtudSelect.length/2; // Nombre de chambres, doit être = m / 2 et m = tabEtudSelect.length
    		      for(int i = 0; i < n; i++) {
    		         tabEtudCopy.add(tabEtud[i][0]); // Transfert de la liste étudiant dans la copie
    		      }	 	     		      
    		      String id1;
    		      String id2;		      
    		      String idRe;
    		      int inRe;
    		      /*Saisie des étudiants  dans des chambres; i=0 une chmbre donc deux étudiants; i=1 une seconde
    		      chambre donc deux "tudiants encore ainsi de suite*/
    		      loop:
    		      for(int i = 0; i < c; i++)  {
    		         Ajouter = false;                        // Chaque ajout egal vrai pour sortir du do while		         
    		         do {
    		            Random random = new Random();        // Tirage au sort ou nombre aleatoire
    		            int nb;
    		            n  = tabEtudCopy.size();            // Determine le nombre elements dans etudiant
    		   		 if(n == 1){ 
    		   			 id1 = tabEtudCopy.get(n);          // il est le seul à être logé	dans une chambre 		 		   			
    		   			 break loop;                       //fin de selection	
    		   		 } else {
    		            nb = random.nextInt(n);              // Choix dans l'intervale  0 et n
    		            id1= tabEtudCopy.get(nb);            // Si id1 retenu, l'etudiant sera selectionné		            
    		            clobalId = id1;                      //clobalId est un string car c'est id1 declaré comme variable clobale
    		            idRe = recherche(tabEtudInc,clobalId); // id1 dans liste d'incompatibilié ?		          
    		            if(idRe == "-1") {		            	
    		               // Sinon alors il est ajouté
    		               tabTirage[0][0] = id1;            // Il est rangé dans le tirage
    		               tabEtudCopy.remove(nb);           // Oté du tableau pour ne pas retomber sur le même
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);
    		               tabTirage[0][1] = id2;            // Son binomme est aussi tiré
    		               tabEtudCopy.remove(nb);
    		               Ajouter = true;                   // Pour sortir du while, aller dans la chambre suivante		              
    		            }
    		            else {           			            			            	            	
    		            	// Sinon alors on cherche le second et on vérifie s'il sont incompatibles
    		               inRe = recherche2(tabEtudInc,clobalId); // avant on cherche son indice  d'incompatibilié ?
    		               Indice =inRe;
    		               tabEtudCopy.remove(nb);           // Evidemment il faut supprimer id1 avant
    		               n   = tabEtudCopy.size();
    		               nb  = random.nextInt(n);
    		               id2 = tabEtudCopy.get(nb);	              		                  	            		               
    		               if(((id1.equals(tabEtudInc[Indice][0])) && (!id2.equals(tabEtudInc[Indice][1]))) 
    		                 || ((id1.equals(tabEtudInc[Indice][1])) && (!id2.equals(tabEtudInc[Indice][0])))) {
    		                          // Si le couplage est possible alors on les tire tous les deux
    		                          tabTirage[0][0] = id1;
    		                          tabTirage[0][1] = id2;
    		                          tabEtudCopy.remove(nb);
    		                          Ajouter = true;
    		                       }
    		               else 		            	   
    		            	   tabEtudCopy.add(id1); 
    		            	  
    		               
    		               /* Si le duo n'est pas possible, on remet dans la table tabEtudCopy l'id1 qui a
    		                  été supprimé pour recommencer sans changer de chambre. Ajouter reste false */
    		            }
    		   		    }
    		         } while(Ajouter == false);
    		         // Les deux tirés sont rangés dans la selection
    		         n = tabEtudSelectCopy.size();
    		         tabEtudSelectCopy.add(tabTirage[0][0]);
    		         tabEtudSelectCopy.add(tabTirage[0][1]);
    		      }
    		      /* récupére la selection en tableau static si le travail est fini 
    		      et tabEtudSelectCopy aura une taille = 2*c   */		      
    		      int j = 0;
    		      for(String elem:tabEtudSelectCopy) {       // Tiens on repasse de c à m !
    		         tabEtudSelect[j][0] = elem;             // Récupération
    		         System.out.println("tabEtudSelect: "+elem);
    		         j++;
    		      }
    		   }
    		 
    		   //______________________________________________________________________________________________
    		   public static String recherche(String [][]tabEtudInc, String clobalId) {
    		      int n = tabEtudInc.length;		     
    		      String sortietest="-1"; // cherche les incompatibilités, sort avec "-1" si id n'existe pas
    		      loop:
    		      for(int i = 0; i < n ; i++) {
    		         for(int j = 0; j < 2; j++ ) {
    		            if(clobalId.equals(tabEtudInc[i][j])) {     		               
    		               sortietest = tabEtudInc[i][j];
    		               break loop;
    		            }
    		         }
    		      }
    		      
    		     
    		      return sortietest   ;   
    		   }
    		   public static int recherche2(String [][]tabEtudInc, String clobalId) {
    			      int n = tabEtudInc.length;
    			      int Indice=0; // cherche son indice dans la table incompatibilité
    			     loop:
    			      for(int i = 0; i < n ; i++) {
    			         for(int j = 0; j < 2; j++ ) {
    			            if(clobalId.equals(tabEtudInc[i][j])) {	
    			               Indice = i;			              
    			               break loop;
    			            }
    			         }
    			      }		     
    			     
    			      return Indice   ;   
    			   }
    }

  9. #8
    umfred

    Re : Une aide pour la correction de test if()

    j'ai une petite interrogation:
    tu as une boucle for avec un index i qui n'est jamais utilisé dans la boucle, est-ce que c'est normal ?
    i étant le numéro de la chambre, il ne devrait pas être utilisé en tant que 1er indice de tabTirage (soit tabTirage[i][0] par exemple) ?

  10. #9
    saniadaff

    Re : Une aide pour la correction de test if()

    Bonjour et merci Monsieur umfred ;

    Le seul rôle de i est de sauter une chambre à une autre et tabTirage[][] ne stock rien en fait; à chaque passage dans do..while l'ancienne valeur est écrasée;

    mais un tableau dynamique est là pour stocker une fois sortie de la boucle do...while qui est tabEtudSelectCopy et c'est là où c'était prévu d'utiliser la tableau sélection tabEtudSelect[i][j] mais qui rendait le traitement difficile à cause de récupération du dernier élément car les tableau static renvois la taille et non le dernier élément;

    donc j'ai préféré utiliser tabEtudSelectCopy qui est dynamique puis recopier le résultat dans tabEtudSelect[i][j] après le travail;

    Merci;

    Seulement je suis toujours suspendus sur la complexité de l'algo;

    Est - ce la complexité en O (n * ln(n)) est il polynomial?

  11. #10
    umfred

    Re : Une aide pour la correction de test if()

    Citation Envoyé par saniadaff Voir le message
    Bonjour et merci Monsieur umfred ;

    Le seul rôle de i est de sauter une chambre à une autre et tabTirage[][] ne stock rien en fait; à chaque passage dans do..while l'ancienne valeur est écrasée;
    du coup pourquoi utiliser un tableau à 2 dimensions si on n'utilise pas la 2nde dimension, un tableau simple serait suffisant, non?

  12. #11
    saniadaff

    Re : Une aide pour la correction de test if()

    Bonjour Monsieur umfred

    Les étudiants sélectionnés seront chacun en binôme sur une ligne tabEtudSelect[i][j]="id_etudiant1" et "id_etudiant2" ;
    la suite serrait de trouver ou rechercher ses id dans le tableau tabEtud qui renseigne les noms prénoms etc..

  13. #12
    vgondr98

    Re : Une aide pour la correction de test if()

    Pourquoi tu utilises des tableaux à deux dimensions pour manipuler des concepts comme Binome et Etudiant ?
    Si tu code en java, utilise des objets, ton code sera beaucoup plus simple à lire.

  14. #13
    vgondr98

    Re : Une aide pour la correction de test if()

    Code:
    int n = tabEtud.length; 
    		      int i = 0;		      
    		      do { // C'est un do while qui mime exactement un for
    		         System.out.println("Veuillez saisir l’Id de l’étudiants :");
    		         tabEtud[i][0] = keby.nextLine();		         
    		        /* System.out.println("Veuillez saisir le nom de l’étudiants :");
    		         tabEtud[i][1] = keby.nextLine();		         
    		         System.out.println("Veuillez saisir le prénom de l’étudiants :");
    		         tabEtud[i][2] = keby.nextLine();		         
    		         System.out.println("Veuillez saisir l’adresse de l’étudiants :");
    		         tabEtud[i][3] = keby.nextLine(); */		        
    		         i = i + 1;
    		      } while (i < n);
    Par exemple, cette partie n'est pas terrible.
    Il est beaucoup plus lisible de créer un Objet Etudiant avec un attribut id, un attribut nom, un attribut prenom, un attribut adresse.
    https://openclassrooms.com/fr/course...ec-des-classes

  15. #14
    umfred

    Re : Une aide pour la correction de test if()

    Citation Envoyé par saniadaff Voir le message
    Bonjour Monsieur umfred

    Les étudiants sélectionnés seront chacun en binôme sur une ligne tabEtudSelect[i][j]="id_etudiant1" et "id_etudiant2" ;
    la suite serrait de trouver ou rechercher ses id dans le tableau tabEtud qui renseigne les noms prénoms etc..
    dans ton code, tu mets les tabTirage[0][0] et tabTirage[0][1] dans une arraylist tabEtudSelectCopy (donc 1D), donc tabTirage peut être sans souci un tableau 1D.

    Sinon effectivement +10 pour des objets Etudiant et éventuellement ClasseRoom, que tu n'auras plus qu'à gérer par des listes

  16. #15
    saniadaff

    Re : Une aide pour la correction de test if()

    Bonsoir Monsieur vgondr98
    Il y a deux objectifs qui m'ont poussés à traduire en java comme si j'étais en C;
    1-Je suis sur un problème de décision de type NP-difficile et pour trouve la solution il faut une solution banale(une approche banale) d'où le tirage au sort sur quoi j'ai fondé mes arguments;
    2- Classe Etudiant{
    id:..,
    nom:..,
    prenom:..,
    ..
    }
    est ce qu'il fallait faire mais pour manipuler id1 et id2 dans la methode saisieIncompatibilité() je savais pas pas comment créer une deuxième liste qui contient uniquement id1 et id2;
    au lieu de fatiguer les expert sur des truc de débutants mais un peu au dessus de mon niveau, j'ai préféré faire ce qui était plus facile pour moi pourvue que ça donne et après on verra la suite si quelqu'un pourra m'aider à le faire ou si quels qu'un pourra réécrire tout le programme pour réduire la complexité de plus; dans ce cas je ne manquerais pas de noté ses références dans la documentation;

    Bonjour Monsieur umfred;
    OUI tabTirage[0][1] est un tableau aui contient uniquement les id de Etud1 et Etud2 donc le binôme qui doit être logé dans la même chambre;
    je comprends pas:

    +10 pour des objets Etudiant et éventuellement ClasseRoom

    vous voulez dire d'apprendre sur ça?

    C'est quand j'ai la réponse de la complexité pour fixer mon esprit à savoir si j'ai trouvé ou pas que je pourrais me lancer dessus pour améliorer le programme; comme l'idée principale est le tirage au sort;

    Merci tous les deux!

  17. #16
    vgondr98

    Re : Une aide pour la correction de test if()

    Citation Envoyé par saniadaff Voir le message
    1-Je suis sur un problème de décision de type NP-difficile
    Je ne vois pas en quoi ton problème est NP-difficile. Tu cherches juste à mettre deux étudiants compatibles dans une même chambre, c'est ça ?

  18. #17
    saniadaff

    Re : Une aide pour la correction de test if()

    OUI c'est ça même;

    si j'ai la réponse de la complexité je vais vous afficher l’énoncé du problème et on verra ensemble si c'est le cas ou pas

Discussions similaires

  1. Aide pour correction de mes réponses
    Par invite127abfec dans le forum Physique
    Réponses: 8
    Dernier message: 22/02/2018, 08h59
  2. Besoin d'aide pour correction
    Par invite06ca88e4 dans le forum Physique
    Réponses: 9
    Dernier message: 02/02/2018, 23h50
  3. Besoin d'iune correction pour proba-test-estimateur
    Par invite40f82214 dans le forum Mathématiques du supérieur
    Réponses: 1
    Dernier message: 19/04/2009, 11h47
  4. DM de math 2nd (aide et correction pour mon DM)
    Par invitef07c4cf3 dans le forum Mathématiques du collège et du lycée
    Réponses: 4
    Dernier message: 03/01/2008, 15h52
  5. aide pour correction exo SN/E
    Par invite43050e88 dans le forum Chimie
    Réponses: 3
    Dernier message: 14/11/2005, 23h34