README.md

Exercism

Table des Matières

• Bash
  • Structure d'un fichier Bash
  • Récupérer le nombre de paramètres en Bash
  • Récupérer les paramètres en Bash
  • Connaître la taille d'une chaine de caractères en Bash
  • Boucles en Bash
    • if else en Bash
    • for en Bash
  • Incrémenter une variable en Bash
  • Opérations mathématiques en Bash
  • Vérifier si une chaîne est contenue dans une autre en Bash
  • Lowercase/Uppercase en Bash
  • Enlever un caractère d'une chaîne en Bash
  • Concaténer deux chaînes de caractères en Bash
  • Comparer deux chaînes de caractères en Bash
  • Comparer deux entiers en Bash
  • Récupérer la position d'une sous-chaîne dans une chaîne en Bash
• C++
  • Structure d'un fichier C++
  • Récupérer le nombre de paramètres en C++
  • Récupérer les paramètres en C++
  • Connaître la taille d'une chaine de caractères en C++
  • Boucles en C++
    • if else en C++
    • for en C++
  • Incrémenter une variable en C++
  • Opérations mathématiques en C++
  • Vérifier si une chaîne est contenue dans une autre en C++
  • Lowercase/Uppercase en C++
  • Enlever un caractère d'une chaîne en C++
  • Concaténer deux chaînes de caractères en C++
  • Comparer deux chaînes de caractères en C++
  • Comparer deux entiers en C++
  • Récupérer la position d'une sous-chaîne dans une chaîne en C++
• JavaScript
  • Récupérer le nombre de paramètres en JavaScript
  • Récupérer les paramètres en JavaScript
  • Connaître la taille d'une chaine de caractères en JavaScript
  • Boucles en JavaScript
    • if else en JavaScript
    • for en JavaScript
  • Incrémenter une variable en JavaScript
  • Opérations mathématiques en JavaScript
  • Vérifier si une chaîne est contenue dans une autre en JavaScript
  • Lowercase/Uppercase en JavaScript
  • Enlever un caractère d'une chaîne en JavaScript
  • Concaténer deux chaînes de caractères en JavaScript
  • Comparer deux chaînes de caractères en JavaScript
  • Comparer deux entiers en JavaScript
  • Récupérer la position d'une sous-chaîne dans une chaîne en JavaScript
• Python
  • Structure d'un fichier Python
  • Récupérer le nombre de paramètres en Python
  • Récupérer les paramètres en Python
  • Connaître la taille d'une chaine de caractères en Python
  • Boucles en Python
    • if else en Python
    • for en Python
  • Incrémenter une variable en Python
  • Opérations mathématiques en Python
  • Vérifier si une chaîne est contenue dans une autre en Python
  • Lowercase/Uppercase en Python
  • Enlever un caractère d'une chaîne en Python
  • Concaténer deux chaînes de caractères en Python
  • Comparer deux chaînes de caractères en Python
  • Comparer deux entiers en Python
  • Récupérer la position d'une sous-chaîne dans une chaîne en Python
• PowerShell
  • Structure d'un fichier PowerShell
  • Récupérer le nombre de paramètres en PowerShell
  • Récupérer les paramètres en PowerShell
  • Connaître la taille d'une chaine de caractères en PowerShell
  • Boucles en PowerShell
    • if else en PowerShell
    • for en PowerShell
  • Incrémenter une variable en PowerShell
  • Opérations mathématiques en PowerShell
  • Vérifier si une chaîne est contenue dans une autre en PowerShell
  • Lowercase/Uppercase en PowerShell
  • Enlever un caractère d'une chaîne en PowerShell
  • Concaténer deux chaînes de caractères en PowerShell
  • Comparer deux chaînes de caractères en PowerShell
  • Comparer deux entiers en PowerShell
  • Récupérer la position d'une sous-chaîne dans une chaîne en PowerShell

Bash

Structure d'un fichier Bash

#!/usr/bin/env bash

# le reste du programme

Récupérer le nombre de paramètres en Bash

#!/usr/bin/env bash

nbr=$#
echo "Nombre de paramètres: ${nbr}"

Récupérer les paramètres en Bash

#!/usr/bin/env bash

parametre1=$1
parametre2=$2
echo "Le premier paramètre: ${parametre1}"
echo "Le second paramètre: ${parametre2}"

Connaître la taille d'une chaine de caractères en Bash

#!/usr/bin/env bash

input=$1

echo "La taille de la chaîne '${input}' est: ${#input}"

Boucles en Bash

if else en Bash

#!/usr/bin/env bash

nbr=$#
if [ $nbr -eq 1 ]; 
then 
    echo "Il y a un seul paramètre"
elif [ $nbr -eq 2 ]; 
then
    echo "Il y a deux paramètres"
else
    echo "Il y a plus de deux paramètres"
fi

for en Bash

#!/usr/bin/env bash

input=$1

for i in $(seq 1 ${#input}); 
do
    echo $(echo $input | cut -c$i)
done

echo "Autre possibilité:"

for (( i=1; i<=${#input}; i++ ))
do
    echo $(echo $input[i] | cut -c$i)
done

Incrémenter une variable en Bash

#!/usr/bin/env bash

nbr=0
echo "Avant incrémentation: ${nbr}"
for (( i=1; i<=5; i++ ))
do
    nbr=$((nbr+1))
done

echo "Après incrémentation: ${nbr}"

Opérations mathématiques en Bash

#!/usr/bin/env bash

echo "5 plus 3 = $((5+3))"
echo "5 fois 3 = $((5*3))"
echo "5 puissance 3: $((5**3))"
echo "5 modulo 3: $((5%3))"
echo "2 puissance 100 avec bc: $(echo "2 ^ 100" | bc)"
echo "2 puissance 100 sans bc: $((2**100))"

Vérifier si une chaîne est contenue dans une autre en Bash

#!/usr/bin/env bash

chaine="coucou"
sousChaine="ou"

if [[ ${chaine} =~ ${sousChaine} ]];
then
    echo "'${chaine}' contient '${sousChaine}'"
fi

echo "Autre possibilité:"

if [[ $chaine == *"$sousChaine"* ]];
then
    echo "'${chaine}' contient '${sousChaine}'"
fi

Lowercase/Uppercase en Bash

#!/usr/bin/env bash

chaine="CouCou"

lowercase=$(tr '[:upper:]' '[:lower:]' <<< "$chaine")
uppercase=$(tr '[:lower:]' '[:upper:]' <<< "$chaine")

echo "${chaine} en lowercase: ${lowercase}"
echo "${chaine} en uppercase: ${uppercase}"

Enlever un caractère d'une chaîne en Bash

#!/usr/bin/env bash

chaine="coucou"
chaineModifiee=$( echo $chaine | tr -d 'c' )

echo "chaîne de départ: ${chaine}"
echo "chaine modifiée: ${chaineModifiee}"

Concaténer deux chaînes de caractères en Bash

#!/usr/bin/env bash

chaine1="Hello, "
chaine2="World!"

concatenation="${chaine1}${chaine2}"

echo "chaine 1: '${chaine1}'"
echo "chaine 2: '${chaine2}'"
echo "concaténation: '${concatenation}'"

Comparer deux chaînes de caractères en Bash

#!/usr/bin/env bash

chaine1="coucou"
chaine2="CouCou"

if [ "$chaine1" = "coucou" ];
then 
    echo "${chaine1} = coucou"
fi
if [ "$chaine1" = "$chaine2" ];
then 
    echo "${chaine1} = ${chaine2}"
else
    echo "${chaine2} != ${chaine2}"
fi

Comparer deux entiers en Bash

#!/usr/bin/env bash

nbr=3
if [ $nbr -eq 3 ]; 
then 
    echo "${nbr} = 3"
fi
if [ $nbr -ne 5 ]; 
then 
    echo "${nbr} != 3"
fi
if [ $nbr -ge 2 ] || [ $nbr -gt 2 ]; 
then 
    echo "${nbr} >= 2, ${nbr} > 2"
fi
if [ $nbr -le 4 ] || [ $nbr -lt 4 ]; 
then 
    echo "${nbr} <= 4, ${nbr} < 4"
fi

Récupérer la position d'une sous-chaîne dans une chaîne en Bash

chaine="<fis4 e'1 >16 <fis4 e'1 >16 r16<fis4 e'1 >16 r16<fis4 c'2 >16 <fis4 e'1 >16 r16<b2 g'1 >16 r8.g8.3 r16"
# recherche de la première position de la chaine "16"
recherche="16"
debut_chaine="${chaine%%${recherche}*}"
position=$((${#debut_chaine}+1))
echo ${position}

C++

Structure d'un fichier C++ en C++

#include <iostream>

int main() {
    // le reste du programme
    return 0;
}

Récupérer le nombre de paramètres en C++

#include <iostream>

int main(int argc, char *argv[]) {
    int nbr = argc - 1;
    std::cout << "Nombre de paramètres: " << nbr << std::endl;
    return 0;
}

Récupérer les paramètres en C++

#include <iostream>

int main(int argc, char *argv[]) {
    if (argc >= 3) {
        std::cout << "Le premier paramètre: " << argv[1] << std::endl;
        std::cout << "Le second paramètre: " << argv[2] << std::endl;
    }
    return 0;
}

Connaître la taille d'une chaine de caractères en C++

#include <iostream>
#include <string>

int main(int argc, char *argv[]) {
    std::string input = argv[1];
    std::cout << "La taille de la chaîne '" << input << "' est: " << input.size() << std::endl;
    return 0;
}

Boucles en C++

if else en C++

#include <iostream>

int main(int argc, char *argv[]) {
    int nbr = argc - 1;
    if (nbr == 1) {
        std::cout << "Il y a un seul paramètre" << std::endl;
    } else if (nbr == 2) {
        std::cout << "Il y a deux paramètres" << std::endl;
    } else {
        std::cout << "Il y a plus de deux paramètres" << std::endl;
    }
    return 0;
}

for en C++

#include <iostream>
#include <string>

int main(int argc, char *argv[]) {
    std::string input = argv[1];

    for (int i = 0; i < input.size(); i++) {
        std::cout << input[i] << std::endl;
    }

    std::cout << "Autre possibilité:" << std::endl;

    for (char c : input) {
        std::cout << c << std::endl;
    }

    return 0;
}

Incrémenter une variable en C++

#include <iostream>

int main() {
    int nbr = 0;
    std::cout << "Avant incrémentation: " << nbr << std::endl;
    for (int i = 1; i <= 5; i++) {
        nbr++;
    }
    std::cout << "Après incrémentation: " << nbr << std::endl;
    return 0;
}

Opérations mathématiques en C++

#include <iostream>

int main() {
    std::cout << "5 plus 3 = " << (5 + 3) << std::endl;
    std::cout << "5 fois 3 = " << (5 * 3) << std::endl;
    std::cout << "5 puissance 3: " << (5 * 5 * 5) << std::endl;
    std::cout << "5 modulo 3: " << (5 % 3) << std::endl;
    return 0;
}

Vérifier si une chaîne est contenue dans une autre en C++

#include <iostream>
#include <string>

int main() {
    std::string chaine = "coucou";
    std::string sousChaine = "ou";

    if (chaine.find(sousChaine) != std::string::npos) {
        std::cout << "'" << chaine << "' contient '" << sousChaine << "'" << std::endl;
    }

    std::cout << "Autre possibilité:" << std::endl;

    if (chaine.find(sousChaine) != std::string::npos) {
        std::cout << "'" << chaine << "' contient '" << sousChaine << "'" << std::endl;
    }

    return 0;
}

Lowercase/Uppercase en C++

#include <iostream>
#include <algorithm>
#include <string>

int main() {
    std::string chaine = "CouCou";

    std::transform(chaine.begin(), chaine.end(), chaine.begin(), ::tolower);
    std::cout << chaine << " en lowercase: " << chaine << std::endl;

    std::transform(chaine.begin(), chaine.end(), chaine.begin(), ::toupper);
    std::cout << chaine << " en uppercase: " << chaine << std::endl;

    return 0;
}

Enlever un caractère d'une chaîne en C++

#include <iostream>
#include <string>

int main() {
    std::string chaine = "coucou";
    chaine.erase(std::remove(chaine.begin(), chaine.end(), 'c'), chaine.end());

    std::cout << "chaîne de départ: " << chaine << std::endl;

    return 0;
}

Concaténer deux chaînes de caractères en C++

#include <iostream>
#include <string>

int main() {
    std::string chaine1 = "Hello, ";
    std::string chaine2 = "World!";
    std::string concatenation = chaine1 + chaine2;

    std::cout << "chaine 1: '" << chaine1 << "'" << std::endl;
    std::cout << "chaine 2: '" << chaine2 << "'" << std::endl;
    std::cout << "concaténation: '" << concatenation << "'" << std::endl;

    return 0;
}

Comparer deux chaînes de caractères en C++

#include <iostream>
#include <string>

int main() {
    std::string chaine1 = "coucou";
    std::string chaine2 = "CouCou";

    if (chaine1 == "coucou") {
        std::cout << chaine1 << " = coucou" << std::endl;
    }
    if (chaine1 == chaine2) {
        std::cout << chaine1 << " = " << chaine2 << std::endl;
    } else {
        std::cout << chaine2 << " != " << chaine2 << std::endl;
    }

    return 0;
}

Comparer deux entiers en C++

#include <iostream>

int main() {
    int nbr = 3;

    if (nbr == 3) {
        std::cout << nbr << " = 3" << std::endl;
    }
    if (nbr != 5) {
        std::cout << nbr << " != 3" << std::endl;
    }
    if (nbr >= 2 || nbr > 2) {
        std::cout << nbr << " >= 2, " << nbr << " > 2" << std::endl;
    }
    if (nbr <= 4 || nbr < 4) {
        std::cout << nbr << " <= 4, " << nbr << " < 4" << std::endl;
    }

    return 0;
}

Récupérer la position d'une sous-chaîne dans une chaîne en C++

#include <iostream>
#include <string>

int main() {
    std::string chaine = "<fis4 e'1 >16 <fis4 e'1 >16 r16<fis4 e'1 >16 r16<fis4 c'2 >16 <fis4 e'1 >16 r16<b2 g'1 >16 r8.g8.3 r16";
    std::string recherche = "16";

    size_t position = chaine.find(recherche);
    std::cout << position << std::endl;

    return 0;
}

JavaScript

Récupérer le nombre de paramètres en JavaScript

const nbr = process.argv.length - 2;
console.log("Nombre de paramètres:", nbr);

Récupérer les paramètres en JavaScript

const parametre1 = process.argv[2];
const parametre2 = process.argv[3];
console.log("Le premier paramètre:", parametre1);
console.log("Le second paramètre:", parametre2);

Connaître la taille d'une chaine de caractères en JavaScript

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

readline.question("Entrez une chaîne de caractères: ", (input_string) => {
    console.log(`La taille de la chaîne '${input_string}': ${input_string.length}`);
    readline.close();
});

Boucles en JavaScript

if else en JavaScript

const nbr = process.argv.length - 2;

if (nbr === 1) {
    console.log("Il y a un seul paramètre");
} else if (nbr === 2) {
    console.log("Il y a deux paramètres");
} else {
    console.log("Il y a plus de deux paramètres");
}

for en JavaScript

const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

readline.question("Entrez une chaîne de caractères: ", (input_string) => {
  console.log("Méthode 1:");
  for (const char of input_string) {
      console.log(char);
  }

  console.log("Méthode 2:");
  for (let i = 0; i < input_string.length; i++) {
      console.log(input_string[i]);
  }

  readline.close();
});

Incrémenter une variable en JavaScript

let nbr = 0;
console.log("Avant incrémentation:", nbr);
for (let i = 1; i <= 5; i++) {
    nbr++;
}
console.log("Après incrémentation:", nbr);

Opérations mathématiques en JavaScript

console.log("5 plus 3 =", 5 + 3);
console.log("5 fois 3 =", 5 * 3);
console.log("5 puissance 3:", 5 ** 3);
console.log("5 modulo 3:", 5 % 3);
console.log("2 puissance 100:", 2 ** 100);

Vérifier si une chaîne est contenue dans une autre en JavaScript

const chaine = "coucou";
const sousChaine = "ou";

if (chaine.includes(sousChaine)) {
    console.log(`'${chaine}' contient '${sousChaine}'`);
}

Lowercase/Uppercase en JavaScript

const chaine = "CouCou";

const lowercase = chaine.toLowerCase();
const uppercase = chaine.toUpperCase();

console.log(`${chaine} en lowercase: ${lowercase}`);
console.log(`${chaine} en uppercase: ${uppercase}`);

Enlever un caractère d'une chaîne en JavaScript

const chaine = "coucou";
const chaineModifiee = chaine.replace('c', '');

console.log("Chaîne de départ:", chaine);
console.log("Chaîne modifiée:", chaineModifiee);

Concaténer deux chaînes de caractères en JavaScript

const chaine1 = "Hello, ";
const chaine2 = "World!";

const concatenation = chaine1 + chaine2;

console.log("Chaine 1: '", chaine1, "'");
console.log("Chaine 2: '", chaine2, "'");
console.log("Concaténation: '", concatenation, "'");

Comparer deux chaînes de caractères en JavaScript

const chaine1 = "coucou";
const chaine2 = "CouCou";

if (chaine1 === "coucou") {
    console.log(`${chaine1} = coucou`);
}

if (chaine1 === chaine2) {
    console.log(`${chaine1} = ${chaine2}`);
} else {
    console.log(`${chaine1} != ${chaine2}`);
}

Comparer deux entiers en JavaScript

const nbr = 3;

if (nbr === 3) {
    console.log(`${nbr} = 3`);
}

if (nbr !== 5) {
    console.log(`${nbr} != 5`);
}

if (nbr >= 2 || nbr > 2) {
    console.log(`${nbr} >= 2, ${nbr} > 2`);
}

if (nbr <= 4 || nbr < 4) {
    console.log(`${nbr} <= 4, ${nbr} < 4`);
}

Récupérer la position d'une sous-chaîne dans une chaîne en JavaScript

const chaine = "<fis4 e'1 >16 <fis4 e'1 >16 r16<fis4 e'1 >16 r16<fis4 c'2 >16 <fis4 e'1 >16 r16<b2 g'1 >16 r8.g8.3 r16";
// recherche de la première position de la chaine "16"
const recherche = "16";
const position = chaine.indexOf(recherche) + 1;
console.log(position);

Python

Structure d'un fichier Python

#!/usr/bin/env python3

# le reste du programme

Récupérer le nombre de paramètres en Python

#!/usr/bin/env python3

import sys

nbr = len(sys.argv) - 1
print("Nombre de paramètres:", nbr)

Récupérer les paramètres en Python

#!/usr/bin/env python3

import sys

parametre1 = sys.argv[1]
parametre2 = sys.argv[2]
print("Le premier paramètre:", parametre1)
print("Le second paramètre:", parametre2)

Connaître la taille d'une chaine de caractères en Python

#!/usr/bin/env python3

input_string = input("Entrez une chaîne de caractères: ")

print("La taille de la chaîne '{}': {}".format(input_string, len(input_string)))

Boucles en Python

if else en Python

#!/usr/bin/env python3

import sys

nbr = len(sys.argv) - 1

if nbr == 1:
    print("Il y a un seul paramètre")
elif nbr == 2:
    print("Il y a deux paramètres")
else:
    print("Il y a plus de deux paramètres")

for en Python

#!/usr/bin/env python3

input_string = input("Entrez une chaîne de caractères: ")

print("Méthode 1:")
for char in input_string:
    print(char)

print("Méthode 2:")
for i in range(len(input_string)):
    print(input_string[i])

Incrémenter une variable en Python

#!/usr/bin/env python3

nbr = 0
print("Avant incrémentation:", nbr)
for i in range(1, 6):
    nbr += 1

print("Après incrémentation:", nbr)

Opérations mathématiques en Python

#!/usr/bin/env python3

print("5 plus 3 =", 5 + 3)
print("5 fois 3 =", 5 * 3)
print("5 puissance 3:", 5 ** 3)
print("5 modulo 3:", 5 % 3)
print("2 puissance 100:", 2 ** 100)

Vérifier si une chaîne est contenue dans une autre en Python

#!/usr/bin/env python3

chaine = "coucou"
sousChaine = "ou"

if sousChaine in chaine:
    print("'{}' contient '{}'".format(chaine, sousChaine))

Lowercase/Uppercase en Python

#!/usr/bin/env python3

chaine = "CouCou"

lowercase = chaine.lower()
uppercase = chaine.upper()

print("{} en lowercase: {}".format(chaine, lowercase))
print("{} en uppercase: {}".format(chaine, uppercase))

Enlever un caractère d'une chaîne en Python

#!/usr/bin/env python3

chaine = "coucou"
chaineModifiee = chaine.replace('c', '')

print("Chaîne de départ:", chaine)
print("Chaîne modifiée:", chaineModifiee)

Concaténer deux chaînes de caractères en Python

#!/usr/bin/env python3

chaine1 = "Hello, "
chaine2 = "World!"

concatenation = chaine1 + chaine2

print("Chaine 1: '{}'".format(chaine1))
print("Chaine 2: '{}'".format(chaine2))
print("Concaténation: '{}'".format(concatenation))

Comparer deux chaînes de caractères en Python

#!/usr/bin/env python3

chaine1 = "coucou"
chaine2 = "CouCou"

if chaine1 == "coucou":
    print("{} = coucou".format(chaine1))

if chaine1 == chaine2:
    print("{} = {}".format(chaine1, chaine2))
else:
    print("{} != {}".format(chaine1, chaine2))

Comparer deux entiers en Python

#!/usr/bin/env python3

nbr = 3

if nbr == 3:
    print("{} = 3".format(nbr))

if nbr != 5:
    print("{} != 5".format(nbr))

if nbr >= 2 or nbr > 2:
    print("{} >= 2, {} > 2".format(nbr, nbr))

if nbr <= 4 or nbr < 4:
    print("{} <= 4, {} < 4".format(nbr, nbr))

Récupérer la position d'une sous-chaîne dans une chaîne en Python

chaine = "<fis4 e'1 >16 <fis4 e'1 >16 r16<fis4 e'1 >16 r16<fis4 c'2 >16 <fis4 e'1 >16 r16<b2 g'1 >16 r8.g8.3 r16"
# recherche de la première position de la chaine "16"
recherche = "16"
position = chaine.find(recherche) + 1
print(position)

PowerShell

Structure d'un fichier PowerShell

function Get-Greeting {
    param([string]$name)
    "Hello, $name"
}

Get-Greeting -name "World"

Récupérer le nombre de paramètres en PowerShell

$paramCount = $args.Count
Write-Output "Nombre de paramètres: $paramCount"

Récupérer les paramètres en PowerShell

$firstParam = $args[0]
$secondParam = $args[1]
Write-Output "Premier paramètre: $firstParam"
Write-Output "Second paramètre: $secondParam"

Connaître la taille d'une chaîne de caractères en PowerShell

$string = "PowerShell"
$length = $string.Length
Write-Output "La longueur de la chaîne est : $length"

Boucles en PowerShell

if else en PowerShell

$number = 10
if ($number -gt 5) {
    Write-Output "Le nombre est supérieur à 5"
} else {
    Write-Output "Le nombre est inférieur ou égal à 5"
}

for en PowerShell

for ($i = 0; $i -lt 5; $i++) {
    Write-Output "Itération: $i"
}

Incrémenter une variable en PowerShell

$counter = 0
$counter++
Write-Output "Compteur après incrémentation: $counter"

Opérations mathématiques en PowerShell

$a = 10
$b = 5

$sum = $a + $b
$product = $a * $b
$quotient = $a / $b

Write-Output "Somme: $sum"
Write-Output "Produit: $product"
Write-Output "Quotient: $quotient"

Vérifier si une chaîne est contenue dans une autre en PowerShell

$string = "PowerShell est génial"
if ($string -like "*génial*") {
    Write-Output "La chaîne contient le mot 'génial'"
}

Lowercase/Uppercase en PowerShell

$string = "PowerShell"
$lowercase = $string.ToLower()
$uppercase = $string.ToUpper()

Write-Output "En minuscules: $lowercase"
Write-Output "En majuscules: $uppercase"

Enlever un caractère d'une chaîne en PowerShell

$string = "PowerShell"
$newString = $string.Remove(0, 1)  # Retire la première lettre
Write-Output "Nouvelle chaîne: $newString"

Concaténer deux chaînes de caractères en PowerShell

$string1 = "Power"
$string2 = "Shell"
$concatenated = $string1 + $string2
Write-Output "Chaîne concaténée: $concatenated"

Comparer deux chaînes de caractères en PowerShell

$string1 = "PowerShell"
$string2 = "powershell"

if ($string1 -ieq $string2) {
    Write-Output "Les chaînes sont égales (comparaison insensible à la casse)"
} else {
    Write-Output "Les chaînes sont différentes"
}

Comparer deux entiers en PowerShell

$number1 = 10
$number2 = 20

if ($number1 -lt $number2) {
    Write-Output "$number1 est plus petit que $number2"
} else {
    Write-Output "$number1 est plus grand ou égal à $number2"
}

Récupérer la position d'une sous-chaîne dans une chaîne en PowerShell

$string = "PowerShell est puissant"
$position = $string.IndexOf("puissant")
Write-Output "Position de 'puissant' dans la chaîne : $position"