JAVA TP Royale

~ édition spéciale IE ~

Résultats IE Algo

moyen: 12.3

Sources des Erreurs

• lire bien les questions (expliquer ou appeler?)
• rouge, c'est le couleur de la correction !
• repondre au plus bref possible pour gagner du temps
  (faire ce qui est demandé, pas plus)
• rajouter vos notes (illustration du chemin vers la solution)
• pas d'explications banales, comme paraphrase pour "beta > 0"
• moins de piège que vous pensez dans ce IE
• lesquelles sont vraies? :
  pas des points pour lesquelles qui sont fausses
• modifications != réproduction entier
  (difference exprès ou pas?)

Best of Erreurs

• short est un type primaire pour déclarer un entier
• int a = 12.; ne marche pas, car "12." est un double
• La question "Qu'est-ce qui est affiché sur le terminal" était apparemment pas clair (très coûteux).
• La variable i dans un for doit être déclaré auparavant.

Erreur pas conter :

• int sum; sum += 2; est une abréviation légale
• difference entre System.out.print() et System.out.println()

Retour sur le TP 6

méthodes et tableaux

public class StatsTableaux {
    public static void main(String[] args) {
        int[] tab1={1 , 2 , 3 , 4 , 5 , 6 , 1 , 1 , 3 , 2, 1};

        afficheTableau(tab1);
        afficheTableau2(tab1);
        System.out.println("la valeur max du tableau vaut " + valMaxTableau(tab1));
        System.out.println("la valeur max du tableau est en position " + (posMaxTableau(tab1)));
        System.out.println("la somme des elements du tableau vaut " + sommeTableau(tab1));
        System.out.println("la moyenne des elements du tableau vaut " + moyenneTableau(tab1));
        System.out.println("l'ecart-type des elements du tableau vaut " + ecartTypeTableau(tab1)); 
        int valeur = 3;
        System.out.println("la valeur "+ valeur + " du tableau est en position " + rechercheTableau(tab1,valeur));  
        if (estTrie(tab1) == 1)
            System.out.println("Le tableau est croissant");  
        else if (estTrie(tab1) == -1) 
            System.out.println("Le tableau est decroissant");   
        else 
            System.out.println("Le tableau n'est pas trie");
        
        afficheDistribution(tab1);    
        diagrammeBaton(tab1);
 }
    
    /** Methode afficheTableau
    * @param t Le tableau
    */
    public static void afficheTableau(int [] t) {
        for (int i = 0; i < t.length; i++) { 
            System.out.print(t[i] + "  "); 
        }
        System.out.println();
    }
    
    /** Methode afficheTableau2
    * @param t Le tableau
    */
    public static void afficheTableau2(int [] t) {
        for (int i = 0; i < t.length; i++) { 
            if (t[i] != 0)
                System.out.print(t[i] + "  "); 
            }
        System.out.println();
    }     
    
    /** Methode valMaxTableau
    * @param t Le tableau
    * @return La valeur du plus grand element 
    */ 
    public static int valMaxTableau(int [] t) {
        int max = t[0];
        for (int i = 1; i < t.length; i++) { 
          if (t[i] > max)
             max = t[i]; 
        }
        return max;
    }
     
    /** Methode posMaxTableau	
    * @param t Le tableau
    * @return La position du plus grand element. position 0 pour la 1ère valeur
    */
    public static int posMaxTableau(int[] t){
        int max = t[0];
        int posMax = 0;
        for (int i = 1; i < t.length; i++) { 
            if (t[i] > max){
                max = t[i]; 
                posMax = i;
            }
        }  
        return posMax;
    }       
        
    /** methode sommeTableau qui renvoie la somme de tous les elements du tableau
    * 
    * @param t Le tableau
    * @return La somme des elements du tableau
    */
    public static int sommeTableau(int[ ] t) {
        int somme = 0;
        for (int i = 0; i < t.length; i++) { 
                somme = somme + t[i];
        }
        return somme;
    }
    
    /** methode moyenneTableau calculant la moyenne des elements du tableau
    * 
    * @param t Le tableau
    * @return La moyenne des elements du tableau
    */
    public static double moyenneTableau(int[ ] t) {
        return (double)sommeTableau(t) / t.length;
    }
    
    /** methode ecartTypeTableau calculant l'ecart type des elements du tableau
    * 
    * @param t Le tableau
    * @return L'ecart type 
    */
    public static double ecartTypeTableau(int[ ] t) {
        double sommeEcartCarre = 0;
        double moy = moyenneTableau(t);
        for (int i = 0; i < t.length; i++) { 
                sommeEcartCarre = sommeEcartCarre + Math.pow((t[i]-moy),2);
        }
        return Math.sqrt(sommeEcartCarre / t.length);
    }
    
    /** Methode rechercheTableau
    * @param t Le tableau
    * @param v La valeur a chercher
    * @return La position de l'element 
    */
    public static int rechercheTableau(int[] t, int v) {
        int pos = -1;
        int j = 0;
        boolean trouve = false;
        while ((j < t.length) && (!trouve )) { 
            if (t[j] == v){
                pos = j;
                trouve = true;
            }
            j++;
        }  
        return pos;        
    }
    
    /** Methode estCroissant
    * @param t Le tableau
    * @return true si le tableau est croissant, false sinon
    */
    public static boolean estCroissant(int[] t) {
        boolean croissant = true;
        int j = 0;
        while ((j < t.length-1) && (croissant )) { 
            if (t[j] > t[j+1]){
                croissant = false;
            }
            j++;
        }  
        return croissant;        
    }    
        
    /** Methode estDecroissant
    * @param t Le tableau
    * @return true si le tableau est decroissant, false sinon
    */
    public static boolean estDecroissant(int[] t) {
        boolean decroissant = true;
        int j = 0;
        while ((j < t.length-1) && (decroissant )) { 
            if (t[j] < t[j+1]){
                decroissant = false;
            }
            j++;
        }  
        return decroissant;        
    }            
    
    /** Methode estrie
    * @param t Le tableau
    * @return true si le tableau est trie, false sinon
    */
     public static int estTrie(int[] t) {
        int trie = 0;
        if (estCroissant(t)) trie = 1;
        if (estDecroissant(t)) trie = -1;
        return trie;
    }           
}

Sujet cette semaine

opérations binaires

À Faire

1. Lisez le sujet entier (comme toujours !)
2. Recherchez la difference entre
   'Big Endian' et 'Little Endian'
3. Travaillez sur le concept pour l'addition sur papier
   1. Comment un peu afficher les résultats ?
      1. en binaire
      2. en décimal
4. Et n'utilisez pas Scanner pour la saisie !
5. Proposition: dans la classe : final static int taille = 8;