Algoritmes-Vincenzo-Serie-1

*** Notice that all along these exercises, we invite the user to interact with the functions, by using ``` let variable = window.prompt("", ""); ``` . ***

// EXERCICE 1.1

/*Ecrire un algorithme qui demande un nombre à l’utilisateur, 
et l’informe ensuite si ce nombre est positif ou négatif 
(on laisse de côté le cas où le nombre vaut zéro). */

function signe(number) {
  if(number > 0) {
    console.log("Ce nombre est positif");
  } else {
    console.log("Ce nombre est négatif");
  }
}
signe(1); // returns "Ce nombre est positif"
signe(-22); // returns "Ce nombre est négatif"

--------------------------------------------------------------------------------

// EXERCICE 1.2

/*
Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si 
leur produit est négatif ou positif (on laisse de côté le cas où le produit est nul).
Attention toutefois : on ne doit pas calculer le produit des deux nombres. */

function productSigne(number1, number2) {
  if(number1 > 0 && number2 < 0 || number1 < 0 && number2 > 0){
    console.log("Le produit est négatif");
  } else {
    console.log("Le produit est positif");
  }
}
productSigne(1, 3); // returns "Le produit est positif"
productSigne(-1, 3); // returns "Le produit est négatif"
productSigne(1, -3); // returns "Le produit est négatif"
productSigne(-1, -3); // returns "Le produit est positif"

--------------------------------------------------------------------------------

// Exercice 1.3
/* Ecrire un algorithme qui demande trois noms à l’utilisateur et l’informe ensuite s’ils sont
rangés ou non dans l’ordre alphabétique.
Remarque : une chaine de caractère peut être comparée à une autre. Par exemple la chaine ‘aa’ est inférieur à la chaine ‘ab’ */

function sortName(name1, name2, name3) {
  let arr = [];
  arr.push(name1, name2, name3);
  return arr.sort();
}
sortName("Yvan", "Khaled", "Albert");
console.log(sortName("Yvan", "Khaled", "Albert")); // returns [ 'Albert', 'Khaled', 'Yvan' ]

--------------------------------------------------------------------------------

// Exercice 1.4

/*  Ecrire un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce nombre est positif ou négatif
(on inclut cette fois le traitement du cas où le nombre vaut zéro).   */

function signe(number) {
if(number > 0) {
    console.log("Ce nombre est positif");
  } else if(number == 0) {
    console.log("Ce nombre est nul");
  } else {
    console.log("Ce nombre est négatif");
  }
}
signe(0); // returns "Ce nombre est nul"

--------------------------------------------------------------------------------

/* Exercice 1.5

 Ecrire un algorithme qui demande deux nombres à l’utilisateur et l’informe ensuite si le produit est négatif ou positif 
(on inclut cette fois le traitement du cas où le produit peut être nul). Attention toutefois, on ne doit pas calculer le produit ! */


function productSigne(number1, number2) {
  if(number1 > 0 && number2 < 0 || number1 < 0 && number2 > 0){
    console.log("Le produit est négatif");
  } else if(number2 == 0 || number1 == 0) {
    console.log("Le produit est nul");
  } else {
    console.log("Le produit est positif");
  }
}

productSigne(0, -3); // returns "Le produit est nul"
productSigne(-1, 0); // returns "Le produit est nul"


--------------------------------------------------------------------------------

/* Exercice 1.6

 Ecrire un algorithme qui demande l’âge d’un enfant à l’utilisateur. Ensuite, il l’informe de sa catégorie :
 "Poussin" de 6 à 7 ans
 "Pupille" de 8 à 9 ans
 "Minime" de 10 à 11 ans
 "Cadet" après 12 ans     */


function category(age) {
  if(age == 6 || age == 7){
    console.log("Poussin");  
  } else if(age == 8 || age == 9) {
    console.log("Pupille");
  } else if(age == 10 || age == 11) {
    console.log("Minime");
  } else if(age >= 12) {
    console.log("Cadet");
  }
}

category(9); // returns "Pupille"
category(90); // returns "Cadet"

--------------------------------------------------------------------------------

/* PARTIE 2 – ENCORE DE LA LOGIQUE
ENONCE DES EXERCICES

Exercice 2.1

Cet algorithme est destiné à prédire l'avenir, et il doit être infaillible !
Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une minute plus tard.
Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la vérifier. */

function clock(hour, minutes) {  
let arr = [];
  if(0 <= minutes && minutes < 59) {
      arr.push(hour, minutes + 1);
  } else if(minutes == 59){
    arr.push(hour + 1, 0);
      if(hour == 23){
        arr.push(0, 0);
      }
  }
     return "Dans 1 minute, il sera " + arr[0].toString() + " heure(s) " + arr[1].toString();
}
    clock(21, 32);
    console.log(clock(21, 32)); // returns "Dans 1 minute, il sera 21 heure(s) 33"

--------------------------------------------------------------------------------

/* Exercice 2.2

De même que le précédent, cet algorithme doit demander une heure et en afficher une autre. 
Mais cette fois, il doit gérer également les secondes, et afficher l'heure qu'il sera une seconde plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit répondre :
"Dans une seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : là encore, on suppose que l'utilisateur entre une heure valide. */

function clock(hour, minutes, seconds) {  
let arr = [];
  if(0 <= seconds && seconds < 59) {
      arr.push(hour, minutes, seconds + 1);
  } else if(seconds == 59){
    arr.push(hour, minutes + 1, 0);
    if(minutes == 59){
      arr = [];
      arr.push((hour + 1), 0, 0);
      if(hour == 23){
        arr = [];
        arr.push(0, 0, 0);
      } 
    }
  }
     return "Dans une seconde, il sera " + arr[0].toString() + " heure(s) " + arr[1].toString() + " minute(s) " + arr[2].toString() + " seconde(s).";
}
  clock(23, 59, 59);
  console.log(clock(23, 59, 59)); // returns Dans une seconde, il sera 0 heure(s) 0 minute(s) 0 seconde(s).
  clock(23, 59, 58);
  console.log(clock(23, 59, 58)); // returns Dans une seconde, il sera 23 heure(s) 59 minute(s) 59 seconde(s).
  
  --------------------------------------------------------------------------------

/* Exercice 2.3
Un magasin de reprographie facture 0,10 € les dix premières photocopies, 0,09 € les vingt suivantes et 0,08 € au-delà.
Ecrivez un algorithme qui demande à l’utilisateur le nombre de photocopies effectuées et qui affiche la facture correspondante.
Attention, les 10 premières photocopies restent tout le temps à 10 cts et les 11 à 20 photocopies à 9 cts. */

function bill (copy) {
  let arr = [];
  if(copy <= 10) {
    arr.push(copy * 0.1);
  } else if(copy <= 30) {
    arr.push(copy * 0.09);
  } else if(copy > 30) {
    arr.push(copy * 0.08);
  }
  return arr.toString() + " €";
}
bill();
console.log(bill(50)); // returns 4 €
console.log(bill(10)); // returns 1 €

--------------------------------------------------------------------------------

/* PARTIE 2 – LES BOUCLES
ENONCE DES EXERCICES

Exercice 2.1

Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la réponse convienne. */

let num = window.prompt("Enter a number from 1 to 3", "");

while(num != 4 - 2) {
  console.log("Enter a number from 1 to 3");
} 
console.log("Good job!");

let num = 1 // returns "Enter a number from 1 to 3" 
let num = 2 // returns "Good job!"

--------------------------------------------------------------------------------

/* Exercice 2.2
Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse convienne. 
En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit ! », et inversement, 
« Plus grand ! » si le nombre est inférieur à 10. */

function match(num){
  if (num < 10) {
    console.log("Plus grand !");
  } else if(num > 20){
    console.log("Plus petit !");
  } else if(num > 10 && num < 20 && num == 20 - 5) {
    console.log("Good job !");
  } else {
    console.log("Try again !");
  }

}
match(34); // returns "Plus petit !"
match(15); // returns "Good job !"
match(7); // returns "Plus grand !"

--------------------------------------------------------------------------------

// Exercice 2.3

/* Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix nombres suivants. 
Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de 18 à 27. */


function plus10(num) {
  let arr = [];
  for(let i = num + 1; i <= num + 10; i++) {
    arr.push(i);
  } 
  return arr;
}
plus10();
console.log(plus10(17)); // returns [ 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 ]
console.log(plus10(20)); // returns [ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 ]

--------------------------------------------------------------------------------

// Exercice 2.4

/* Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de multiplication de ce nombre,
présentée comme suit (cas où l'utilisateur entre le nombre 7) : 
Table de 7 :
7x1=7
7 x 2 = 14 7 x 3 = 21 ...
7 x 10 = 70 */

function multiply(num) {
  let arr = [];
  for(let i = 0; i <= 10; i++) {
     arr.push(num + " x " + i + " = " + i * num);
  } 
  return arr;
}
multiply();
console.log(multiply(3)); // returns [ '3 x 0 = 0', '3 x 1 = 3', '3 x 2 = 6', '3 x 3 = 9', '3 x 4 = 12', '3 x 5 = 15', '3 x 6 = 18', '3 x 7 = 21', '3 x 8 = 24', '3 x 9 = 27', '3 x 10 = 30' ]

--------------------------------------------------------------------------------

// Exercice 2.5
/* Réécrire l’algorithme précédent, mais cette fois-ci on ne connaît pas d’avance combien l’utilisateur souhaite saisir de nombres. 
La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro. */

function multiply(num) {
  if(num != 0) {
    let arr = [];
    for(let i = 0; i <= 10; i++) {
      arr.push(num + " x " + i + " = " + i * num);
    } 
    return arr;
  } else {
  console.log("STOP");
  }
}
multiply();
console.log(multiply(9)); // returns ['9 x 0 = 0', '9 x 1 = 9', '9 x 2 = 18', '9 x 3 = 27', '9 x 4 = 36', '9 x 5 = 45', '9 x 6 = 54', '9 x 7 = 63',' 9 x 8 = 72', '9 x 9 = 81', '9 x 10 = 90'] ]
console.log(multiply(0)); // returns "STOP"


-------------------------------------------------------------------------------- 

/* PARTIE 3 – LES TABLEAUX
ENONCE DES EXERCICES

Exercice 3.1

Ecrire un algorithme qui déclare et remplisse un tableau de 7 valeurs numériques en les mettant toutes à zéro. */

function array() {
  let arr = [];
  let i = 0
  while(arr.length < 7) {
    arr.push(i);
  }
  return arr;
}
array();
console.log(array()); // returns [ 0, 0, 0, 0, 0, 0, 0 ]

-------------------------------------------------------------------------------- 
/* Exercice 3.2
Ecrire un algorithme qui déclare un tableau qui permettra de saisir les notes obtenues dans une évaluation. 
On fait ensuite saisir 9 valeurs par l’utilisateur.*/

function array(num1, num2, num3, num4, num5, num6, num7, num8, num9){
  let arr = [];
  arr.push(num1, num2, num3, num4, num5, num6, num7, num8, num9);
  return arr;
}
array();
console.log(array(6, 18, 16, 7, 11, 0, 13, 5, 12)); // returns [ 6, 18, 16, 7, 11, 0, 13, 5, 12 ]