Discussion :

[firepolo]

J'aurais un problème à résoudre :S
Mon but est de créer une mémoire courte qui retiendrait des mots (comme la mémoire courte de l'humain).

Chaque mot aurait une longueur(taille) et un temps de mémorisation(temps avant l'oubli).
la mémoire courte réagit en fonction du nombre de mot à retenir et au nombre de lettre dans chaque mot.
Maintenant j'ai vu sur internet que la mémoire courte pouvait retenir 7 mots maximum et que ces 7 mots était oublié en 20 secondes environs.

j'ai fais une classe Word dans laquel j'ai le string ou je peux récupérer ça longueur et un integer time qui correspond au temps de mémorisation du mot

Mon but est de faire un tableau de Word avec au maximum 7 entrées avec lequel je calculerais le temps de memorisation de chaque mot
Plus le mot serait court plus le temps de mémorisation serait élevé et plus le mot serait long moins le temps de mémorisation serait élevé
Il faudrait aussi tenir compte du faite que l'addition de tous les temps pour chaque mot devrais atteindre 20 secondes qui serait le temps maximum avant l'oubli de tous les mots.
j'ai réussi à faire l'inverse c'est à dire plus le mot et court plus le temps est court et inversement.

Maintenant je dois trouver le bon calcul pour calculer le temps de mémorisation pour chaque mot dans la méthode assignTimeWord().

Voilà j'espère que vous m'avez compris c'était dure à expliquer.

Merci d'avance pour votre aide !

Voilà le code que j'ai déjà fait :

CLASS WORD ---------------------------------------------------------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Word
{
    private int length;
    private int time;
 
    public Word(int length, int time)
    {
        this.length = length;
        this.time = time;
    }
 
    // GETTERS
    public int getLength()
    {
        return length;
    }
 
    public int getTime()
    {
        return time;
    }
 
    // SETTERS
    public void setLength(int length)
    {
        this.length = length;
    }
 
    public void setTime(int time)
    {
        this.time = time;
    }
}

CLASS MAIN ---------------------------------------------------------

si jamais le temps stocké dans la classe Word serait en milliseconde (d'où le *1000) et je me base sur une mémorisation de 3 mots maximum parce que c'était pour tester avec 3 déjà.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public class Main
{
    private static final int maxTime = 20;
    private static final int maxWords = 3;
 
    private static Word[] words;
    private static int nbLetters;
    private static int timePerLetter;
 
    public static void main(String[] args)
    {
        initTable();
        assignTimeWord();
        displayTable();
    }
 
    private static void initTable()
    {
        words = new Word[maxWords];
        words[0] = new Word(3, 0);
        words[1] = new Word(8, 0);
        words[2] = new Word(4, 0);
        /*words[3] = new Word(9, 0);
        words[4] = new Word(5, 0);
        words[5] = new Word(2, 0);
        words[6] = new Word(3, 0);*/
 
        nbLetters = countLetters();
        timePerLetter = (int)(((float)maxTime / nbLetters) * 1000);
 
        System.out.println("nbLetter = " + nbLetters);
        System.out.println("timePerLetter = " + timePerLetter + "\n");
    }
 
    private static int countLetters()
    {
        int n = 0;
 
        for (Word word : words)
        {
            n += word.getLength();
        }
 
        return n;
    }
 
    private static void assignTimeWord()
    {
        for (Word word : words)
        {
            word.setTime(timePerLetter * word.getLength());
            //word.setTime((timePerLetter / word.getLength()) * maxTime);
        }
    }
 
    private static void displayTable()
    {
        int totalTime = 0;
 
        for (int i = 0; i < words.length; i++)
        {
            System.out.println("word" + i);
            System.out.println("\tlength = " + words[i].getLength());
            System.out.println("\ttime = " + words[i].getTime() + "\n");
            totalTime += words[i].getTime();
        }
 
        System.out.println("-------------------------------");
        System.out.println("Total time : " + totalTime + "\n");
    }
}

[RhyuGnome]

Si j'ai bien compris ton problème, tu voudrais inverser la situation actuelle, donc un mot long=temps de mémorisation court.

J'ai une solution à ton problème, mais pour te l'expliquer, je vais plutôt prendre un exemple :

Imagine tu as 3 mots, nbLetters = 100. Tes 3 mots font respectivement 97, 2 et 1 lettre(s). Tu prends l'inverse de chaques nb de lettre soit 0,0103 0,5 et 1. Tu additionnes les 3 nombres (1,5103) et il ne te reste plus qu'à faire une règle de 3 pour récupéré un nouveau nombre de lettres inversement proportionnel au nombre initiale que tu as juste à multiplier par timePerLetter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
  private static void assignTimeWord()
    {
        float somme=0;
        for (Word word : words)
        {
            somme+=(1/(float)word.getLength());
        }
        for (Word word : words)
        {
            float time=timePerLetter *((nbLetters*(1/(float)word.getLength()))/somme);
            word.setTime((int)time);
        }
 
        //word.setTime((timePerLetter / word.getLength()) * maxTime);
    }

[firepolo]

Merci beaucoup pour ta réponse c'est exactement ce que je voulais Merci encore ça m'aidera beaucoup pour les prochains problèmes de ce genre aussi

Si j'ai bien compris ton problème, tu voudrais inverser la situation actuelle, donc un mot long=temps de mémorisation court.

J'ai une solution à ton problème, mais pour te l'expliquer, je vais plutôt prendre un exemple :

Imagine tu as 3 mots, nbLetters = 100. Tes 3 mots font respectivement 97, 2 et 1 lettre(s). Tu prends l'inverse de chaques nb de lettre soit 0,0103 0,5 et 1. Tu additionnes les 3 nombres (1,5103) et il ne te reste plus qu'à faire une règle de 3 pour récupéré un nouveau nombre de lettres inversement proportionnel au nombre initiale que tu as juste à multiplier par timePerLetter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
  private static void assignTimeWord()
    {
        float somme=0;
        for (Word word : words)
        {
            somme+=(1/(float)word.getLength());
        }
        for (Word word : words)
        {
            float time=timePerLetter *((nbLetters*(1/(float)word.getLength()))/somme);
            word.setTime((int)time);
        }
 
        //word.setTime((timePerLetter / word.getLength()) * maxTime);
    }