Exercices sur les tableaux

Consignes

• Ne pas de faire aider par des IA ou genAI

Exercice 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

Série 2 exo 1

///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
    // génération et calcul de la somme
    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;
      }
    }
    // min, max, écrat type
    int min = numbers[0];
    int max = numbers[0];
    double standardDeviation = 0; // ecart type
    double average = (double) sum / (double) numbers.length;
    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];
      }
    }
    standardDeviation = Math.sqrt(standardDeviation / (double) numbers.length);
    System.out.println("\nResults ->");
    System.out.println("min: " + min + ", max:" + max);
    System.out.println("Even count: " + evenCount + ", Odd count:" + oddCount);
    System.out.println("sum: " + sum + ", Standard deviation:" + standardDeviation);
  }
}

Exercice 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).

10 premiers nombres premiers

///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] + ", ");
    }
  }
}

Exercice 3

Créer un fonctione 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 aléatoires (de valeurs de entre -10 et 10 inclus) de taille aléatoire ( 2 <= nombre d'éléments < 5) et qui calcule leur schtroumpf.

Schtroumphons 💻

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

import static java.lang.System.*;

import java.util.random.RandomGenerator;

public class Schtroumph2Arrays {

  public static int compute(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.print(String.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();
    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 = compute(exampleLeftItems, exampleRightItems);
    System.out.println(exampleResult);

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

Exercice 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

• Supposons qu'on ait deux cercles : un cercle de centre A et de rayon Ra, et un cercle de centre B et de rayon Rb. Les coordonnées de A sont notées (xa, ya) et les coordonnées de B sont notées (xb, yb). On souhaite écrire un algorithme (très simple) permettant de dire si les deux cercles se rentrent dedans. La distance entre les deux centres A et B est: sqrt((xb-xa)² + (yb-ya)²)

  • Donner la condition qui permet de savoir s’il y a collision (ou pas) entre les cercles
  • Exprimer cette condition sans racine carrée
  • Ecrire une fonction isCollision qui prend les informations de deux cercles en arguments et renvoie true s’il y a collision entre les deux cercles, sinon false.
  • Faire cet exercice en définissant une classe Circle et isCollision comme une méthode de cette classe

Random min and max

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

import java.util.random.RandomGenerator;
import static java.lang.System.*;

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.println(String.format("min: %d, max: %d", 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.print(String.format("%d, ", numbers[i]));
    }
    System.out.println();
    printMinMax(numbers);
  }
}

CircleCollisionDetector

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

public class CircleCollisionDetector {
  public static void main(String[] args) {
    CircleCollisionDetector circleCollisionDetector = new CircleCollisionDetector();
    circleCollisionDetector.isColliding(0, 0, 10, 10, 0, 10);
  }

  /**
   * La distance entre les deux cercles est plus petite que la somme des rayons
   * 
   * @param xa
   * @param ya
   * @param ra
   * @param xb
   * @param yb
   * @param rb
   * @return
   */
  boolean isColliding(int xa, int ya, int ra, int xb, int yb, int rb) {
    return Math.pow(xb - xa, 2) + Math.pow(yb - ya, 2) < Math.pow(rb + ra, 2);
  }
}