Syntaxe Book Algo Book Algo Terre Algo Eau Algo Air
Problème Solution
- 1 -
l'argument qui n'a pas
de jumeaux
- Javascript -		 //Parsing
let arg = process.argv;
arg.splice(0, 2);

//Parsing

//Function / résolution du problème
const twin = (arg) => {
if (arg.length < 3) {
console.log("Veuillez indiquer au minimum, trois arguments au script,
dont deux identiques. Example : node air01.js 1 5 1");
console.log(arg);
return;
}

let value = arg.shift();
let flag = true;
let solution = [];

while (arg.length !== 0) {
for (let x = 0; x < arg.length; x++) {
if (value === arg[x]) {
arg.splice(x, 1);
x--;
flag = false;
}
}
if (flag) {
solution.push(value);
}
value = arg.shift();
flag = true;
x = 0;
}
for (i in solution) {
if (value === solution || value === undefined) {
return solution;
}
}
solution.push(value);
console.log(solution);
return solution;
};

//Affichage
twin(arg);
- 2 -
supprime les caractères
identiques adjacents
- Javascript -		 //Gestion d'erreur
if (process.argv.length !== 3) {
console.log(
'Veuillez indiquer une seule phrase au script.
Exemple : node air02.js "J\'aime le chocolat, avec des crevettes !!!!"'
);
return;

}

//Parsing
let phrase = process.argv;
phrase.splice(0, 2);
phrase = phrase.toString();
//console.log(phrase);

//Function / Résolution du problème

const recurrence = (phrase) => {
let c = 0;
const character = [
" ",
",",
";",
":",
"!",
"?",
".",
"/",
"§",
"-",
"_",
"%",
"~",
"#",
"@",
"*",
"-",
"+",
">",
"<",
"'",
];
while (c !== phrase.length) {
let length = phrase.length;
for (let x = 0; x < character.length; x++) {
if (phrase[c] === character[x] && phrase[c] === phrase[c + 1]) {
phrase = phrase.slice(0, c) + phrase.slice(c + 1, length);
length = phrase.length;
c -= 1;
}
}
x = 0;
c += 1;
}
return phrase;
};

//Afichage

console.log(recurrence(phrase));
return recurrence(phrase);
- 3 -
insert un entier au bon endroit
dans une liste d'entier triées
- Javascript -		 // Gestion d'erreur
let arg = process.argv;
arg.splice(0, 2);
const liste = arg.map((num) => Number(num));

if (liste.length < 3) {
console.log(
"Veuillez indiquer au moins 3 entiers naturels au script.
Les premiers représentent une liste triée
et le dernier un entier à introduire dans la liste"
);
return;
}

for (let a = 0; a < liste.length; a++) {
if (liste[a] % 1 !== 0) {
console.log(
"Veuillez indiquer seulement des entiers naturel au script.
Exemple : node air03.js 1 2 3 5 4 "
);
return;
}
}

for (let b = 1; b < liste.length - 1; b++) {
if (liste[b] < liste[b - 1]) {
console.log("La liste d'entier n'est pas tiée par ordre croissant.");
return;
}
}

// Parsing
const intenger = liste.pop();
const intenger_list = liste;

// Function / Résolution du problème
const insertion = (intenger_list, intenger) => {
for (let i = 0; i < intenger_list.length; i++) {
if (intenger < intenger_list[i]) {
intenger_list.splice(i, 0, intenger);
return intenger_list;
}
}
intenger_list.push(intenger);
return intenger_list;
};

// Affichage
console.log(insertion(intenger_list, intenger));
- 4 -
fusionne deux listes de nombres
triées de manière croissantes
- Javascript -		 // Parsing
let arg = process.argv;
arg.splice(0, 2);

let listeA = arg.slice(0, arg.indexOf("fusion"));
let listeB = arg.slice(arg.indexOf("fusion") + 1, arg.length);

// Function
const sort = (liste) => {
liste = arg.map((num) => Number(num));
for (let x = 1; x < liste.length; x++) {
if (liste[x] < liste[x - 1]) {
console.log(
"La liste " + liste + " n'est pas triée de manière croissante"
);
return true;
}
}
};

// Gestion d'erreur
if (sort(listeA) || sort(listeB)) {
return;
}

if (!arg.includes("fusion")) {
console.log(
'Veuillez séparer les deux liste à fusionner par le mot "fusion"'
);
return;
}

// Résolution du problème

const fusion = (listeA, listeB) => {
a = listeA.map((num) => Number(num));
b = listeB.map((num) => Number(num));
let listeC = [];
while (a.length !== 0 && b.length !== 0) {
if (a[0] < b[0]) {
listeC.push(a.shift());
} else {
listeC.push(b.shift());
}
}
return listeC.concat(a, b);
};

// Affichage

console.log(fusion(listeA, listeB));
- 5 -
affiche une pyramide
- Javascript -		 // Gestion d'erreur
let arg = process.argv;
arg.splice(0, 2);

if (arg.length != 2) {
console.log(
"Veuillez indiquer deux arguments au script.
Le premier étant un élément au choix pour construire la pyramide
(symbole, chiffre, lettre) et le deuxième un nombre pour
indiquer le nombres d'étage de la pyramide."
);
return;
}

// Parsing
let symbole = arg[0];
let stage = arg[1];
let i = 1;

// Function / Résolution du problème
const pyramide = (symbole, stage, i) => {
if (stage === 0) {
return;
} else {
console.log(" ".repeat(stage - 1) + symbole.repeat(i));
let result = pyramide(symbole, stage - 1, i + 2);
return result;
}
};

// Affichage
pyramide(symbole, stage, i);
- 6 -
Quicksort
- Javascript -		 // Gestion d'erreur
let arg = process.argv;
arg.splice(0, 2);

if (arg.length < 3) {
console.log(
"Veuillez indiquer au script, une liste de nombre à trier.
Exemple : node air06.js 15 4 2 8 56 3"
);
return;
}

for (let x = 0; x < arg.length; x++) {
if (arg[x] % 1 != 0) {
console.log("Veuillez indiquer seulement des nombres au script");
return;
}
}

// Function
const quicksort = (arg) => {
const liste = arg.map((num) => Number(num));

if (liste.length <= 1) {
return liste;
}

const pivot = liste.pop();
const left = [];
const right = [];

for (let x = 0; x < liste.length; x++) {
if (liste[x] < pivot) {
left.push(liste[x]);
} else {
right.push(liste[x]);
}
}

return [...quicksort(left), pivot, ...quicksort(right)];
};

console.log(quicksort(arg));
- 7 -
vérifie tous les exercices
de l'épreuve de l'air
- Javascript -		 const { exec } = require("child_process");
const util = require("util");
const execProm = util.promisify(exec);

// Gestion d'erreur
if (process.argv.length > 2) {
console.log("Le script n'a pas besoin d'argument pour fonctionner.");
return;
}

// Function
async function testAir(air, arg, solution) {
let result;
try {
result = await execProm(`node ${air} ${arg}`);
} catch (error) {
result = error;
}
return result;
}

// Air06
const air06 = "../Air06/air06.js";
const listeJ = "1 7 2 8 2 3 5 4 9 5 6";
const listeK = "15 2 7 56 34 79 20 4 67 12 85 46 38";
const listeL = "125 754 142 246 963 582 762 436 953 412 384 689";

// Air01
async function Air01() {
const air01 = "../Air01/air01.js";

const listeA = `1 1 2 5 2 5 4 4 7 6 7 5 5`;
const listeA_Sol = `"[ '6' ]"`;

const listeB = "manger dormir boire danser vomir manger danser dormir";
const listeB_Sol = `"[ 'boire', 'vomir' ]"`;

const listeC = "+ 2 - 5 a 5 - 7 . 8 g g 9 , 3 - 1 . 5 a k 7 g 8 9 3 2 ";
const listeC_Sol = `"[ '+', ',', '1', 'k' ]"`;

let count = 0;

await testAir(air01, listeA, listeA_Sol).then((res) => {
let solution = JSON.stringify(
res.stdout.substring(0, res.stdout.length - 1)
const result = listeA_Sol;
if (solution === result) {
return count++;
}
});

await testAir(air01, listeB, listeB_Sol).then((res) => {
let solution = JSON.stringify(
res.stdout.substring(0, res.stdout.length - 1)
);
const result = listeB_Sol;
if (solution === result) {
return count++;
}
});

await testAir(air01, listeC, listeC_Sol).then((res) => {
let solution = JSON.stringify(
res.stdout.substring(0, res.stdout.length - 1)
);
const result = listeC_Sol;
if (solution === result) {
return count++;
}
});

return console.log(` air01 : ${count} / 3`);
}

// Air02
Reprendre ligne 84