tableau int[]

Question

Bonjour a tous.


j'ai un tres tres gros pb:


je suis entrain de concevoir un prog qui a besoin de stocker dans un tableau de type int[] beaucoup de valeur, mais alors vraiment beacoup (environ 8715 nombre entiers); lors de sa compilation, Jbuilder (mon editeur java), ne veux pas me le compiler car il trouve que le tableau est trop volumineux.


savez vous comment remedier a ce pb?


merci.

Twinuts · Answer

Salut,

essaye avec un vecteur de int ou un arraylist de int

Vector vec = new Vector
//vec.add(1);

//int n = vec.get(n);

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

didoux95 · Answer

D'accord, mais quand vous dites "vec.add(1)" cela veut-il dire qu'il faut que je fasse


"vec.add(1)


vec.add(2)


..." jusqu'a 8715 ?


merci.

Twinuts · Answer

Salut,

oui tu le fais dans une boucle

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

didoux95 · Answer

a vrai dire ce son des nombre premiers (que j'ai deja) que je doi y stocker.
donc un boucle ce serais mal approprier je pense.
precedemment, l'aventage de int[] c'etait: int[] A = {3.,5,7,11,13,...};

merci.

Twinuts · Answer

salut,

ba pres calcul les nombres premiers dans ta boucle...

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

sheorogath · Answer

si tu veux une grosse methde de bourrin :

public class premiers { 

   public static void main(String[] args) 

   { 
      int somme = 0; 
      for (int i = 1; i < 100; i++) { 
         if (isPrimary(i)){ 
            somme += i; 
         System.out.println(i); 
         } 
      } 
      System.out.println("la somme des 100 premiers est = " + somme); 
   } 

   public static boolean isPrimary(int nb) {       if (nb 2 || nb 3 || nb == 5 || nb == 7) 
         return true;       else if ((!((nb & 1) 0 || nb % 3 0 || nb % 5 == 0|| nb % 7 == 0)) 
            && nb != 1) 
         return true; 
      else 
         return false; 
   } 
} 

sinon il existe d'autre algo qui permette d'aller plus vite mais bon je n'en avais pas besoin donc je ne m'y suis pas penché

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"

Ar0z · Answer

Tiens, une autre méthode, peut etre un peu moins bourrine qui te renvoie un vecteur contenant tous les nombres premiers jusqu'à n (j'ai testé, le vecteur peut largement contenir assez de valeurs).
C'est surement pas la meilleure solution mais bon (j'utilise le crible d'ératostène ici): 

public Vector nbPremiers(int n){
    // On crée une hashtable que l'on rempli de tous les nombres de 0 à n
    // à ces nombres on associe "oui" si c'est un nb premier, non sinon
    // par defaut ils le sont tous sauf 0 et 1
    Hashtable h = new Hashtable();
    h.put(0,"non");
    h.put(1,"non");
    for(int N=2;N<=n;N++){
        h.put(N,"oui");
    }
    
    // Grace au crible d'Eratostène, on attribue la valeur non à tous les nombres non premiers
    int i=2, j=0;
    while(i<=n){
        j=i*2;
        while(j<=n){
            h.put(j,"non");
            j+=i;
        }
        i++;
        while (i<=n && ((String)h.get(i)).equals("non")){
            i++;
        }
    }
    
    //En se basant sur la hashtable précédemment créée,on crée et retourne 
    //un vecteur ne contenant que les nombres premiers
    Vector v = new Vector();
    for(int k=0;k<=n;k++){
        if (((String)h.get(k)).equals("oui")){
            v.addElement(k);
        }
    }
    return v;
}

Ar0z · Answer

Ou plutot, vu que tu n'as peut etre pas besoin de la table complete, petite optimisation :

public Vector nbPremiers(int n){
    Vector v = new Vector();
    for(int N=2;N<=n;N++){
        v.addElement(new Integer(N));
    }
    int i=2, j=0;
    while(i<=n){
        j=i*2;
        while(j<=n){
            v.remove(new Integer(j));
            j+=i;
        }
        i++;
        while (i<=n && !v.contains(new Integer(i))) i++;
    }
    return v;
}

Voilà, c'est plus simple et çà evite des calculs inutiles ^^.

Twinuts · Answer

Salut,

c'est super bourrin de remplire le vecteur pour supprimer les val apres, pourquoi ne pas le remplire que si c'est un nombre entier, cela t'eviteras de 
passer jun temps non negligeable avec les traitements sur ton vecteur.....

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

Ar0z · Answer

En effet. 
Mais pour faire ansi tu es obligé (je pense, pas sur, dites moi si je me trompe) de faire un test par divisions successives (comme dans le post de [auteurdetail.aspx?ID=234347 ]sheorogath) sur chaque nombre, ce qui, pour une valeur de n très élevée, peut s'averrer long.
La méthode du crible d'ératostène que j'ai postée permet d'éviter de traiter énormément de nombres. En effet, on ne traite pas les multiples de X si X n'est lui même pas un nombre premier et ainsi de suite.
D'une certaine façon cette méthode permet donc d'isoler les nombres qui ne sont pas premier et non les nombres premiers.

En revanche, si ta valeur de n ne varie pas trop (ce qui a l'air d'être le cas ici), je pense qu'on peut obtenir de meilleurs résultats en adaptant un algorithme probabiliste. Peut être en faisant un test en deux temps pour écarter les nombres délicats. A tester.

Twinuts · Answer

Salut,

enfaite ce qui me dérrange le plus dans ton code c'est l'oubli d'un petit detail qui n'est pas négligeable soit tu fais

public class Tmp {
    public static void main(String[] args) {
        new Tmp();

    }
    
    public Tmp(){
        Vector v =  nbPremiers(10000);
        System.out.println(v.size()); //affiche 1229 
        System.out.println(v.capacity());//affiche 10240 (place mémoire pour rien)
    }
    
    public Vector nbPremiers(int n){
        Vector v  = new Vector();
        for(int N=2;N<=n;N++)
            v.add(new Integer(N));
        int i=2, j=0;
        while(i<=n){
            j=i*2;
            while(j<=n){
                v.remove(new Integer(j));
                j+=i;
            }
            i++;
            while (i<=n && !v.contains(new Integer(i))) i++;
        }
        return v;
    }
}

Donc pour remedier à ce problème mémoire je conseil un petit trim du vecteur avant de le renvoyer, ce qui remettra la capacité au meme niveau que la taille donc plus de perte de mémoire :
public Vector nbPremiers(int n){
        Vector v = new Vector();
        for(int N=2;N<=n;N++)
            v.add(new Integer(N));
        int i=2, j=0;
        while(i<=n){
            j=i*2;
            while(j<=n){
                v.remove(new Integer(j));
                j+=i;
            }
            i++;
            while (i<=n && !v.contains(new Integer(i))) i++;
        }
        v.trimToSize();
        return v;
    }

maintenant concernant l'algo choisi je trouve le Crible d'Eratostène super lourd sur un point de vu application dans un code (ca reste un avis perso).

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

Ar0z · Answer

ok, je croyais que les vecteurs grandissaient dynamiquement au fur et à mesure qu'on leur ajoutait des éléments. Visiblement c'est pas le cas :).
Sinon pour le crible. L'algo en lui même me parait tres efficace mais c'est vrai qu'appliqué dans un code il peut paraitre un peu lourd.

kaloway · Answer

les vecteurs grandissent dynamiquement au fur et à mesure. mais quand tu crées ton vecteur avec new vector(n), tu lui réserve au démarrage une place de n élèments en mémoire. quand cette taile est dépassée,  java incrémente la taille du vecteur de n élèments. il faut choisir intelligement n de maniere que trop de ressource soit attribué et que java incrémente le vecteur trop fréquement.

didoux95 · Answer

Super, merci a tous.
En revanche (a titre informatif),la generation des nombres premiers avec la methode de "ArOz", met, pour des nombres alan jusaqu'a 90000, un peut plus de 50sec 1min.
MAIS sinon merci.

Ar0z · Answer

Je me suis amusé à faire quelques tests sur les vecteurs et
effectivement, le fait de remplir un vecteur comme je fais comme un
bourrin prends non seulement beaucoup de ram mais en plus çà prend
beaucoup de temps !



Sinon question d'algo pur, j'ai testé par le crible d'ératostène et par
divisions successives et effectivement le crible est plus rapide pour
des nombres élevés. 


(PS : la méthode postée par sheorogath ne permet évidemment que de calculer les nombres premiers < 121).


Bon, je vais faire un peu plus attention à mes gros vecteurs moi à l'avenir ^^

sheorogath · Answer

(PS : la méthode postée par sheorogath ne permet évidemment que de calculer les nombres premiers < 121) 

pourquoi cela ? elle permet de tester si un nombre est premier cela dit c'est vrai que c bourrin ... c'est plus adapte pour un test unique pas un crible

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"

Ar0z · Answer

En fait, à partir de 121, certains résultats seront faux, par exemple 121=11*11, ce n'est pas un nombre premier.

sheorogath · Answer

a oui en effet :s il faudrais que je rajoute comme diviseur les nombre premier eux meme ...

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"

Tableau int[]

18 réponses

Votre réponse

Discussions similaires