Exercices listes et dictionnaires

Consignes

• Ne pas se faire aider par des IA ou genAI

Série 1

1. Créer une fonction qui génère une liste d'entiers aléatoires, entre -2 et 2 inclus. La génération s'arrête lorsque le même nombre est généré 3 fois d'affilée. Créer une autre fonction qui prend une liste d'entiers en argument et qui génère un dictionnaire dont les clés sont les entiers distincts de ce tableau et les valeurs sont le nombre de répétition dans la liste. Afficher le résultat de cette fonction sur une liste générée avec la première fonction.
   • Exemple : {1, 1, -1, 2, 0, 0, 1, 1, 1} => {1: 5, -1: 1, 2: 1, 0: 2}
2. Implémenter la fonction Map<String, Integer> countWords(String text) qui prend un long texte et renvoie un dictionnaire dont les clés sont les mots distincts et les valeurs sont le nombre d'occurrences de chaque mot dans la liste. Astuce, utiliser String.split(" ") pour séparer les mots. Par exemple, pour le texte suivant : Il y a un chat et un chien. Le chat est noir et le chien est blanc. le résultat sera : {Il: 1, y: 1, a: 1, un: 2, chat: 2, et: 2, chien.: 1, Le: 1, est: 2, noir: 1, blanc.: 1}.
   • Afficher le résultat de cette fonction sur le texte suivant : Le feu ça brûle et ça fait mal et l'eau ça mouille mais ça moins mal que le feu.
3. Les dictionnaires sont souvent utilisés pour la mise en cache et la mémorisation de résultats précédents (ou la mémoisation).
   • Créer une fonction int countA(List<String> words) qui compte le nombre total de a ou A dans la liste de mots.
     • Afficher le résultat de cette fonction avec cette liste de mots : List.of("I", "love", "Java", "and", "the", "JVM", "which", "is", "the", "Java", "Virtual", "Machine"). Le résultat doit être 7.
     • Dans cette liste, le calcul doit être fait une seule fois pour Java et le résultat est réutilisé pour l'occurrence suivante. Pareil pour the.
   • Créer une fonction int compteFibonacci(int n) qui calcule le Fibonacci et qui utilise la mémoisation afin d'optimiser le calcul.
     • En d'autres termes, si compteFibonacci(10) => 55 et compteFibonacci(9) => 34 sont déjà exécutés. Alors compteFibonacci(11) calcule depuis le dictionnaire et renvoie 89 sans recalculer compteFibonacci(10) et compteFibonacci(9).
     • Aussi, si compteFibonacci(10) est déjà exécuté, alors cache contient tous les Fibonacci de 0 à 10.

Solutions

///usr/bin/env jbang "$0" "$@" ; exit $?

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.random.RandomGenerator;

public class randnumcount {

  public static List<Integer> generateRandomeIntegers() {
    List<Integer> integers = new ArrayList<>();
    RandomGenerator randomGenerator = RandomGenerator.getDefault();
    int lastGeneratedInt = 10;
    int repeatCount = 0;
    while (repeatCount < 3) {
      int randomInt = randomGenerator.nextInt(-2, 3);
      integers.add(randomInt);
      if (lastGeneratedInt == randomInt) {
        repeatCount += 1;
      } else {
        repeatCount = 1;
        lastGeneratedInt = randomInt;
      }
    }
    return integers;
  }

  public static Map<Integer, Integer> countOccurences(List<Integer> integers) {
    Map<Integer, Integer> counts = new HashMap<>();
    for (Integer i : integers) {
      if (counts.containsKey(i)) {
        // Add 1 to number of occurences (appearances)
        counts.put(i, counts.get(i) + 1);
      } else {
        // First time an int is found
        counts.put(i, 1);
      }
    }
    return counts;
  }

  public static void main(String... args) {
    List<Integer> randomIntegers = generateRandomeIntegers();
    Map<Integer, Integer> counts = countOccurences(randomIntegers);
    for (Integer integer : randomIntegers) {
      System.out.format("%d, ", integer);
    }
    System.out.println();
    for (var entry : counts.entrySet()) {
      System.out.format("Key: %d, value %d \n", entry.getKey(), entry.getValue());
    }
  }
}

///usr/bin/env jbang "$0" "$@" ; exit $?

import java.util.HashMap;
import java.util.Map;

public class countrepeatingwords {
  public static Map<String, Integer> countWords(String sentence) {
    Map<String, Integer> counts = new HashMap<>();
    // On supprime les points et les virgules
    String[] words = sentence
        .replaceAll("[\\.\\,]", "")
        .toLowerCase()
        .split(" ");
    for (String word : words) {
      if (counts.containsKey(word)) {
        // Add 1 to number of occurences (appearances)
        counts.put(word, counts.get(word) + 1);
      } else {
        // First time an int is found
        counts.put(word, 1);
      }
    }
    return counts;
  }

  public static void main(String... args) {
    String sentence = "Il y a un chat et un chien. Le chat est noir et le chien est blanc";
    Map<String, Integer> counts = countWords(sentence);
    System.out.format("Count repeating words of sentence: %s \n", sentence);
    for (var entry : counts.entrySet()) {
      System.out.format("Key: %s, value %d \n", entry.getKey(), entry.getValue());
    }
  }
}

///usr/bin/env jbang "$0" "$@" ; exit $?

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class countacache {

  public static Map<String, Integer> cache = new HashMap<>();

  public static int countAs(String word) {
    int count = 0;
    word = word.toLowerCase();
    if (cache.containsKey(word)) {
      count = cache.get(word);
      System.out.format("('%s', %d) already in cache \n", word, count);
      return count;
    }
    for (int i = 0; i < word.length(); i++) {
      if (word.charAt(i) == 'a') {
        count += 1;
      }
    }
    System.out.format("Adding ('%s', %d) to cache\n", word, count);
    cache.put(word, count);
    return count;
  }

  public static int countAs(List<String> words) {
    int result = 0;
    for (String word : words) {
      result += countAs(word);
    }
    return result;
  }

  public static void main(String... args) {
    List<String> words = List.of("I", "love", "Java", "and", "the", "JVM", "which", "is", "the", "Java", "Virtual",
        "Machine");
    int count = countAs(words);
    System.out.format("The numbers of a in the list is %d\n", count);
  }
}

Série 2

1. Développer une fonction qui génère une liste de personnages RPG. La fonction demande à l'utilisateur de saisir le nom du premier personnage et sa classe (parmi les classe Fighter et Mage qui héritent de la classe Hero). Ensuite, la fonction demande si l'utilisateur souhaite ajouter un personne ou non, si ou un nouveau personnage est créé comme précédemment, sinon, la fonction renvoie la liste des personnages créés.
   • Créer un programme qui appelle cette fonction et qui affiche la liste des personnages créés.
   • Exemple : Fighter: Bob, Mage: Alice.

2. Nous souhaitons enrichir la fonction précédents en ajoutant la génération des attributs des personnages. Voici la listes des attributs initiaux pour les classes Fighter et Mage listés dans ce tableau:

   Attribut	Fighter	Mage
   Points de vie	entre 20 et 25	entre 5 et 10
   Force	entre 10 et 15	entre 1 et 5
   Intelligence	entre 1 et 5	entre 5 et 10
   Agilité	entre 5 et 10	entre 5 et 10

   • Modifier la fonction de génération de personnages pour générer aléatoirement les attributs des personnages en respectant les contraintes ci-dessus et les affiche à l'utilisateur. La fonction demande à l'utilisateur s'il accepte les valeurs générées ou s'il souhaite tenter une nouvelle génération d'attributs.
   • Modifier le programme pour afficher les attributs des personnages créés en respectant le format suivant : Fighter: Bob [P: 22, F: 12, I: 2, A: 8]. Mage: Alice [P: 7, F: 11, I: 6, A: 9].