Exercices sur les tableaux

Consignes

• Ne pas de faire aider par des IA ou genAI

Série 1

1. Créer un programme Java qui génère un tableau aléatoire de 10 entiers compris entre -10 et 10 et affiche (Il faut calculer vous-même les valeurs avec une boulce for) :
   • La plus grande valeur
   • La plus petite valeur
   • La moyenne
   • L'écart type dont la formule est : racine carrée (somme((x - moyenne)²) / n)
   • Le nombre de valeurs positives et le nombre de valeurs négatives
   • Le nombre de valeurs paires et le nombre de valeurs impaires
2. Créer une programme Java qui met dans un tableau les 10 premiers nombres premiers posifitfs.
   • Rappel : un nombre premier est un nombre qui qui est divisible par exactement deux entiers disctints (qui sont 1 et le nombre-même). 0 et 1 ne sont pas des nombres premiers par définition (1 n'est pas divisible par deux nombres distincts).
3. Créer un fonction Java qui calcule le schtroumph de deux tableaux qui ne sont pas forcément de la même taille (source). Pour calculer le schtroumpf, il faut multiplier chaque élément du premier tableau par chaque élément du deuxième, et additionner le tout.
   • Par exemple si l'on a : Tableau 1 -> {4, 8, 7, 12}, Tableau 2 : {3, 6}. Le Schtroumpf sera : 3 ∗ 4 + 3 ∗ 8 + 3 ∗ 7 + 3 ∗ 12 + 6 ∗ 4 + 6 ∗ 8 + 6 ∗ 7 + 6 ∗ 12 = 279
   • Créer un programme Java qui génère deux tableaux de tailles aléatoire (entre 3 et 8) et de valeurs aléatoires (entre -10 et 10 inclus) et qui calcule leur schtroumpf.
4. Créer une fonction qui prend un tableau d’entiers (int[] numbers) et affiche la plus grande valeur et la plus petite valeur (Il faut calculer vous-même le max et le min)
   • Générer un tableau de 10 entier aléatoires et afficher le max et le min
   • Générer un tableau de 10 entiers saisis au clavier et afficher le max et le min
5. Créer une fonction int countVowels(String[] words) qui compte le nombre total de voyelles du tableau de mots passé en argument. Utiliser une boucle for (ou for each) imbriquée pour résoudre cet exercice.
   • Par exemple, pour {"Bonjour", "le", "monde"}, le résultat sera 6 (3 + 1 + 2).
   • Créer un programme Java qui génère une liste de 5 mots pris aléatoirement depuis la liste données ci-après et qui affiche le nombre total de voyelles de cette liste. Les mots disponibles sont : {"Bonjour", "le", "monde", "Java", "est", "un", "langage", "de", "programmation", "orienté", "objet"}.

Solutions

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

import java.util.random.RandomGenerator;

public class Serie2Ex1 {

  public static void main(String... args) {
    int numbers[] = new int[10];
    RandomGenerator rng = RandomGenerator.getDefault();
    int sum = 0;
    int oddCount = 0; // odd : impair
    int evenCount = 0; // even : pair
    // Si on n'a pas encore généré d'éléments, on initialise min et max avec les
    // extrêmes
    int minFirstLoop = Integer.MAX_VALUE;
    int maxFirstLoop = Integer.MIN_VALUE;
    // génération et calcul de la somme, min et max
    for (int i = 0; i < numbers.length; i++) {
      numbers[i] = rng.nextInt(-10, 10);
      System.out.print(numbers[i] + ", ");
      sum += numbers[i];
      if (numbers[i] % 2 == 0) {
        evenCount += 1;
      } else {
        oddCount += 1;
      }
      if (minFirstLoop > numbers[i]) {
        minFirstLoop = numbers[i];
      } else if (maxFirstLoop < numbers[i]) {
        maxFirstLoop = numbers[i];
      }
    }
    double average = (double) sum / (double) numbers.length;

    System.out.format("First loop data. sum %d, mean %f, evenCount %d, oddCount %d, min %d, max %d\n", sum, average,
        evenCount, oddCount,
        minFirstLoop, maxFirstLoop);

    // On connait déjà les éléments, plus besoin d'initialiser avec les extrêmes
    int min = numbers[0];
    int max = numbers[0];
    // min, max, écrat type
    double standardDeviation = 0; // ecart type
    for (int i = 0; i < numbers.length; i++) {
      standardDeviation += Math.pow(numbers[i] - average, 2);
      if (min > numbers[i]) {
        min = numbers[i];
      } else if (max < numbers[i]) {
        max = numbers[i];
      }
    }
    // SQRT: SQuare RooT -> racine carrée
    standardDeviation = Math.sqrt(standardDeviation / (double) numbers.length);
    System.out.format("Results 2nd loop -> min: %d, max: %d, Standard deviation: %f\n", min, max, standardDeviation);
  }
}

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

public class First10Prime {

  public static void main(String... args) {
    System.out.println("Hello World");

    int[] firstTenPrimes = new int[10];
    firstTenPrimes[2] = 2;
    int i = 1;
    for (int currentInt = 3; i < firstTenPrimes.length; currentInt++) {

      // check if currentInt is prime
      int j = 2;
      for (; j < currentInt; j++) {
        if (currentInt % j == 0) {
          break;
        }
      }
      if (j == currentInt) {
        firstTenPrimes[i] = currentInt;
        i++;
      }
    }

    System.out.println("Résutat ->");
    for (int j = 0; j < firstTenPrimes.length; j++) {
      System.out.print(firstTenPrimes[j] + ", ");
    }
  }
}

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

import java.util.random.RandomGenerator;

public class Schtroumph2Arrays {

  public static int computeSchtroumph(int[] leftItems, int[] rightItems) {
    int restult = 0;
    for (int i = 0; i < rightItems.length; i++) {
      for (int j = 0; j < leftItems.length; j++) {
        int mulitplication = rightItems[i] * leftItems[j];
        restult += mulitplication;
        System.out.format("%d x %d = %d", rightItems[i], leftItems[j], mulitplication);
        if (j < leftItems.length - 1) {
          // Ajouter un ", " à l'affichage pour tous les éléments sauf le dernier
          System.out.print(", ");
        }
      }
      System.out.println();
    }
    return restult;
  }

  public static int[] generateRandomArray() {
    RandomGenerator randomGenerator = RandomGenerator.getDefault();
    // Nombre d'éléments aléatoires
    int length = randomGenerator.nextInt(2, 5);
    int[] numbers = new int[length];
    System.out.print("[");
    for (int i = 0; i < numbers.length; i++) {
      numbers[i] = randomGenerator.nextInt(-10, 10);
      System.out.print(numbers[i]);
      if (i != length - 1) {
        // Ajouter un ", " à l'affichage pour tous les éléments sauf le dernier
        System.out.print(", ");
      }
    }
    System.out.println("]");
    return numbers;
  }

  public static void main(String... args) {
    System.out.println("Tableaux donnés en exemple");
    int[] exampleLeftItems = new int[] { 4, 8, 7, 12 };
    int[] exampleRightItems = new int[] { 3, 6 };
    int exampleResult = computeSchtroumph(exampleLeftItems, exampleRightItems);
    System.out.println(exampleResult);

    System.out.println("Tableaux aléatoires");
    int[] rightItems = generateRandomArray();
    int[] leftItems = generateRandomArray();
    int result = computeSchtroumph(leftItems, rightItems);
    System.out.println(result);
  }
}

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

import java.util.random.RandomGenerator;

public class RandomMinMax {

  public static void printMinMax(int[] numbers) {
    if (numbers.length == 0) {
      return;
    }

    int min = numbers[0];
    int max = numbers[0];

    for (int number : numbers) {
      min = number < min ? number : min;
      max = number > max ? number : max;
    }
    System.out.format("min: %d, max: %d\n", min, max);
  }

  public static void main(String... args) {
    RandomGenerator generator = RandomGenerator.getDefault();
    int[] numbers = new int[10];
    for (int i = 0; i < numbers.length; i++) {
      numbers[i] = generator.nextInt();
      System.out.format("%d, ", numbers[i]);
    }
    System.out.println();
    printMinMax(numbers);
  }
}

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

public class CountVowels {

  static int countVowels(String[] words) {
    int vowelCount = 0;
    for (String word : words) {
      for (int i = 0; i < word.length(); i++) {
        char c = word.toLowerCase().charAt(i);
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y') {
          vowelCount += 1;
        }
      }
    }
    return vowelCount;
  }

  public static void main(String... args) {
    String[] firstWords = new String[] { "Bonjour", "le", "monde" };
    System.out.format("%d\n", countVowels(firstWords));

    String[] secondWords = new String[] { "Bonjour", "le", "monde", "Java", "est", "un", "langage", "de",
        "programmation", "orienté", "objet" };
    System.out.format("%d\n", countVowels(secondWords));
  }
}

Série 2

1. Un spaceshooter est un type de jeu dans lequel un vaisseau, vu du dessus, parcourt le niveau du bas vers le haut. Un niveau du spaceshoorter est représenté par un tableau 2D de 10 lignes et 10 colonnes. Chaque case du tableau peut être vide ou contenir un ennemi. Un ennemi est représenté par un caractère E et une case vide par un caractère .. Le vaisseau est représenté par le caractère V. On va considérer que la ligne 0 représente la fin du niveau et la ligne 9 son début.
   • Créer un niveau de jeu en remplissant aléatoirement le tableau 2D d'ennemis, de vides et d'un joueur avec les contraintes suivantes:
     • Le joueur doit être sur la ligne 9 (la dernière ligne) au milieu du tableau (colonne 4 ou 5 aléatoire)
     • Il doit y avoir au maximum 7 ennemis dans le niveau.
     • Il n'y a pas d'ennemis sur les 2 premières lignes du niveau (lignes 9 et 8).
   • Afficher le niveau de jeu dans la console.
   • Astuces : utiliser char[][] comme type de tableau.
2. On souhaite développer un mode démo dans lequel le jeu joue automatiquement en suivant cet algorithme:
   • Le vaisseau se déplace d'une case vers le haut s'il n'y a pas d'ennemis.
   • S'il y a un obstacle, le vaisseau se déplace d'une case vers la droite tant qu'il y a un ennemi dans la case du dessus. S'il n'y a plus d'ennemis, il se déplace d'un case vers le haut.
   • Si le vaisseau ne peut plus se déplacer à droite, il se déplace vers la gauche d'un case tant qu'il y a un ennemi au dessus. S'il atteint le mur gauche et ne peut plus se déplacer, c'est la fin du jeu (game over).
   • Si le joueur atteint la ligne 0, il a gagné (win).
   • Générer une carte de jeu aléatoire et afficher le déroulement du jeu dans la console. A la fin de la partie, afficher le nombre de déplacements total et si le vaisseau a atteint la fin ou s'il a perdu.

Solution

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

import java.util.random.RandomGenerator;

public class Spaceshooter {

  public static void printLevelMap(char[][] levelMap) {
    System.out.println("Current Level map");
    for (int i = 0; i < levelMap.length; i++) {
      for (int j = 0; j < levelMap[i].length; j++) {
        System.out.format("%c ", levelMap[i][j]);
      }
      System.out.println();
    }
    System.out.println("End of current Level map\n");
  }

  public static void main(String... args) {
    char[][] levelMap = new char[10][10];
    // Boucle for imbriquée qui remplit le niveau de vide
    for (int i = 0; i < levelMap.length; i++) {
      for (int j = 0; j < levelMap[i].length; j++) {
        levelMap[i][j] = '.';
        // printLevelMap(levelMap);
      }
    }
    RandomGenerator randomGenerator = RandomGenerator.getDefault();
    // Permet de placer le vaisseau à peu près au milieu
    int shipColumn = randomGenerator.nextInt(levelMap[0].length / 2, levelMap[0].length / 2 + 2);
    int shipRow = levelMap.length - 1;
    levelMap[shipRow][shipColumn] = 'V';
    printLevelMap(levelMap);

    System.out.println("Adding enemies");
    putEnemiesWithExerciseConstraint(levelMap);
    // Commenter au dessus et décommenter en dessous pour avoir une variante
    // putEnemiesNoTwoAdjacentOnRow(levelMap);

    boolean hasShipFailed = false;
    while (!hasShipFailed) {
      levelMap[shipRow][shipColumn] = '.';
      if (shipRow == 0) {
        break;
      }
      int columnMovement = +1;
      // Vérifier que le vaisseau peut se déplacer
      while (levelMap[shipRow - 1][shipColumn] == 'E') {
        if (columnMovement > 0) {
          if (shipColumn + columnMovement < levelMap[shipRow].length
              && levelMap[shipRow][shipColumn + columnMovement] != 'E') {
            shipColumn += columnMovement;
            System.out.println("➡️ Movement");
          } else {
            System.out.println("Start to move left ⬅️");
            columnMovement = -1;
          }
        } else {
          if (shipColumn + columnMovement > 0
              && levelMap[shipRow][shipColumn + columnMovement] != 'E') {
            shipColumn += columnMovement;
            System.out.println("⬅️ Movement");
          } else {
            System.out.println("Oops, impossible to move ⬅️");
            levelMap[shipRow][shipColumn] = '*';
            hasShipFailed = true;
            break;
          }
        }
      }
      if (hasShipFailed) {
        System.out.println("BOOM 💥");
        break;
      }
      shipRow -= 1;
      levelMap[shipRow][shipColumn] = 'V';
      printLevelMap(levelMap);
    }
    System.out.println("Final level map");
    printLevelMap(levelMap);
    System.out.format("Ship has failed ? %s\n", hasShipFailed ? "yes" : "no");
  }

  public static void putEnemiesWithExerciseConstraint(char[][] levelMap) {
    RandomGenerator randomGenerator = RandomGenerator.getDefault();
    int enemyShipCount = 0;
    while (enemyShipCount < 40) {
      // Les ennemis ne sont pas dans les deux dernières lignes
      int randomLine = randomGenerator.nextInt(0, levelMap.length - 2);
      int randomColumn = randomGenerator.nextInt(0, levelMap[0].length);
      if (levelMap[randomLine][randomColumn] != 'E') {
        levelMap[randomLine][randomColumn] = 'E';
        enemyShipCount += 1;
      } else {
        System.out.format("Skip enemy because constraints not satisified at position (%d, %d)\n", randomLine,
            randomColumn);
      }
      printLevelMap(levelMap);
    }
  }

  /**
   * Exemple de placement d'ennemeis avec la containte supplémentaire qu'il ne
   * faut en avoir deux d'adjacents sur la même ligne
   */
  public static void putEnemiesNoTwoAdjacentOnRow(char[][] levelMap) {
    RandomGenerator randomGenerator = RandomGenerator.getDefault();
    int enemyShipCount = 0;
    while (enemyShipCount < 7) {
      // Les ennemus sont entre les lignes 0 et 7
      int randomLine = randomGenerator.nextInt(0, levelMap.length - 2);
      int randomColumn = randomGenerator.nextInt(0, levelMap[0].length);

      boolean isAlreadyEnemy = levelMap[randomLine][randomColumn] == 'E';
      // Opérateur ternaire correspond à une "if ? then : else" en une seule ligne
      // valeur = condition ? résultat si vrai : résultat si faux
      boolean hasEnemyOnLeft = randomColumn == 0 ? false : levelMap[randomLine][randomColumn - 1] == 'E';
      boolean hasEnemyOnRight = randomColumn == levelMap[randomLine].length - 1 ? false
          : levelMap[randomLine][randomColumn + 1] == 'E';
      if (!isAlreadyEnemy && !hasEnemyOnLeft && !hasEnemyOnRight) {
        levelMap[randomLine][randomColumn] = 'E';
        enemyShipCount += 1;
      } else {
        System.out.format("Skip enemy because constraints not satisified at position (%d, %d)\n", randomLine,
            randomColumn);
      }
      printLevelMap(levelMap);
    }
  }
}