https://github.com/gabin221/exercism
This repository contains my solutions to the exercises offered on Exercism. There you will find implementations in several programming languages, including Bash, C++, JavaScript and Python.
https://github.com/gabin221/exercism
bash cpp exercism exercism-solutions javscript python
Last synced: about 1 month ago
JSON representation
This repository contains my solutions to the exercises offered on Exercism. There you will find implementations in several programming languages, including Bash, C++, JavaScript and Python.
- Host: GitHub
- URL: https://github.com/gabin221/exercism
- Owner: Gabin221
- License: mit
- Created: 2024-03-19T14:29:09.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2025-03-09T20:24:09.000Z (over 1 year ago)
- Last Synced: 2025-03-09T21:24:07.560Z (over 1 year ago)
- Topics: bash, cpp, exercism, exercism-solutions, javscript, python
- Language: C++
- Homepage: https://exercism.org/profiles/Gabin221
- Size: 8.73 MB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Exercism
## Table des Matières
* [Bash](#bash)
* [Structure d'un fichier Bash](#structure-fichier-bash)
* [Récupérer le nombre de paramètres en Bash](#recuperer-nombre-parametres-bash)
* [Récupérer les paramètres en Bash](#recuperer-parametres-bash)
* [Connaître la taille d'une chaine de caractères en Bash](#connaitre-taille-chaine-caracteres-bash)
* [Boucles en Bash](#boucles-bash)
* [if else en Bash](#if-else-bash)
* [for en Bash](#for-bash)
* [Incrémenter une variable en Bash](#incrementer-variable-bash)
* [Opérations mathématiques en Bash](#operations-mathematiques-bash)
* [Vérifier si une chaîne est contenue dans une autre en Bash](#verifier-si-chaine-contenue-dans-une-autre-bash)
* [Lowercase/Uppercase en Bash](#lowercase-uppercase-bash)
* [Enlever un caractère d'une chaîne en Bash](#enlever-caractere-chaine-bash)
* [Concaténer deux chaînes de caractères en Bash](#concatener-deux-chaines-bash)
* [Comparer deux chaînes de caractères en Bash](#comparer-deux-chaines-bash)
* [Comparer deux entiers en Bash](#comparer-deux-entiers-bash)
* [Récupérer la position d'une sous-chaîne dans une chaîne en Bash](#recuperer-position-sous-chaine-dans-chaine-bash)
* [C++](#c++)
* [Structure d'un fichier C++](#structure-fichier-c++)
* [Récupérer le nombre de paramètres en C++](#recuperer-nombre-parametres-c++)
* [Récupérer les paramètres en C++](#recuperer-parametres-c++)
* [Connaître la taille d'une chaine de caractères en C++](#connaitre-taille-chaine-caracteres-c++)
* [Boucles en C++](#boucles-c++)
* [if else en C++](#if-else-c++)
* [for en C++](#for-c++)
* [Incrémenter une variable en C++](#incrementer-variable-c++)
* [Opérations mathématiques en C++](#operations-mathematiques-c++)
* [Vérifier si une chaîne est contenue dans une autre en C++](#verifier-si-chaine-contenue-dans-une-autre-c++)
* [Lowercase/Uppercase en C++](#lowercase-uppercase-c++)
* [Enlever un caractère d'une chaîne en C++](#enlever-caractere-chaine-c++)
* [Concaténer deux chaînes de caractères en C++](#concatener-deux-chaines-c++)
* [Comparer deux chaînes de caractères en C++](#comparer-deux-chaines-c++)
* [Comparer deux entiers en C++](#comparer-deux-entiers-c++)
* [Récupérer la position d'une sous-chaîne dans une chaîne en C++](#recuperer-position-sous-chaine-dans-chaine-c++)
* [JavaScript](#javascript)
* [Récupérer le nombre de paramètres en JavaScript](#recuperer-nombre-parametres-javascript)
* [Récupérer les paramètres en JavaScript](#recuperer-parametres-javascript)
* [Connaître la taille d'une chaine de caractères en JavaScript](#connaitre-taille-chaine-caracteres-javascript)
* [Boucles en JavaScript](#boucles-javascript)
* [if else en JavaScript](#if-else-javascript)
* [for en JavaScript](#for-javascript)
* [Incrémenter une variable en JavaScript](#incrementer-variable-javascript)
* [Opérations mathématiques en JavaScript](#operations-mathematiques-javascript)
* [Vérifier si une chaîne est contenue dans une autre en JavaScript](#verifier-si-chaine-contenue-dans-une-autre-javascript)
* [Lowercase/Uppercase en JavaScript](#lowercase-uppercase-javascript)
* [Enlever un caractère d'une chaîne en JavaScript](#enlever-caractere-chaine-javascript)
* [Concaténer deux chaînes de caractères en JavaScript](#concatener-deux-chaines-javascript)
* [Comparer deux chaînes de caractères en JavaScript](#comparer-deux-chaines-javascript)
* [Comparer deux entiers en JavaScript](#comparer-deux-entiers-javascript)
* [Récupérer la position d'une sous-chaîne dans une chaîne en JavaScript](#recuperer-position-sous-chaine-dans-chaine-javascript)
* [Python](#python)
* [Structure d'un fichier Python](#structure-fichier-python)
* [Récupérer le nombre de paramètres en Python](#recuperer-nombre-parametres-python)
* [Récupérer les paramètres en Python](#recuperer-parametres-python)
* [Connaître la taille d'une chaine de caractères en Python](#connaitre-taille-chaine-caracteres-python)
* [Boucles en Python](#boucles-python)
* [if else en Python](#if-else-python)
* [for en Python](#for-python)
* [Incrémenter une variable en Python](#incrementer-variable-python)
* [Opérations mathématiques en Python](#operations-mathematiques-python)
* [Vérifier si une chaîne est contenue dans une autre en Python](#verifier-si-chaine-contenue-dans-une-autre-python)
* [Lowercase/Uppercase en Python](#lowercase-uppercase-python)
* [Enlever un caractère d'une chaîne en Python](#enlever-caractere-chaine-python)
* [Concaténer deux chaînes de caractères en Python](#concatener-deux-chaines-python)
* [Comparer deux chaînes de caractères en Python](#comparer-deux-chaines-python)
* [Comparer deux entiers en Python](#comparer-deux-entiers-python)
* [Récupérer la position d'une sous-chaîne dans une chaîne en Python](#recuperer-position-sous-chaine-dans-chaine-python)
* [PowerShell](#powershell)
* [Structure d'un fichier PowerShell](#structure-fichier-powershell)
* [Récupérer le nombre de paramètres en PowerShell](#recuperer-nombre-parametres-powershell)
* [Récupérer les paramètres en PowerShell](#recuperer-parametres-powershell)
* [Connaître la taille d'une chaine de caractères en PowerShell](#connaitre-taille-chaine-caracteres-powershell)
* [Boucles en PowerShell](#boucles-powershell)
* [if else en PowerShell](#if-else-powershell)
* [for en PowerShell](#for-powershell)
* [Incrémenter une variable en PowerShell](#incrementer-variable-powershell)
* [Opérations mathématiques en PowerShell](#operations-mathematiques-powershell)
* [Vérifier si une chaîne est contenue dans une autre en PowerShell](#verifier-si-chaine-contenue-dans-une-autre-powershell)
* [Lowercase/Uppercase en PowerShell](#lowercase-uppercase-powershell)
* [Enlever un caractère d'une chaîne en PowerShell](#enlever-caractere-chaine-powershell)
* [Concaténer deux chaînes de caractères en PowerShell](#concatener-deux-chaines-powershell)
* [Comparer deux chaînes de caractères en PowerShell](#comparer-deux-chaines-powershell)
* [Comparer deux entiers en PowerShell](#comparer-deux-entiers-powershell)
* [Récupérer la position d'une sous-chaîne dans une chaîne en PowerShell](#recuperer-position-sous-chaine-dans-chaine-powershell)
### Structure d'un fichier Bash
```bash
#!/usr/bin/env bash
# le reste du programme
```
### Récupérer le nombre de paramètres en Bash
```bash
#!/usr/bin/env bash
nbr=$#
echo "Nombre de paramètres: ${nbr}"
```
### Récupérer les paramètres en Bash
```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
```bash
#!/usr/bin/env bash
input=$1
echo "La taille de la chaîne '${input}' est: ${#input}"
```
```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
```
```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
```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
```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
```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
```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
```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
```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
```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
```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
```bash
chaine="16 16 r1616 r1616 16 r1616 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}
```
### Structure d'un fichier C++ en C++
```cpp
#include
int main() {
// le reste du programme
return 0;
}
```
### Récupérer le nombre de paramètres en C++
```cpp
#include
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++
```cpp
#include
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++
```cpp
#include
#include
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;
}
```
```cpp
#include
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;
}
```
```cpp
#include
#include
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++
```cpp
#include
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++
```cpp
#include
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++
```cpp
#include
#include
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++
```cpp
#include
#include
#include
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++
```cpp
#include
#include
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++
```cpp
#include
#include
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++
```cpp
#include
#include
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++
```cpp
#include
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++
```cpp
#include
#include
int main() {
std::string chaine = "16 16 r1616 r1616 16 r1616 r8.g8.3 r16";
std::string recherche = "16";
size_t position = chaine.find(recherche);
std::cout << position << std::endl;
return 0;
}
```
### Récupérer le nombre de paramètres en JavaScript
```javascript
const nbr = process.argv.length - 2;
console.log("Nombre de paramètres:", nbr);
```
### Récupérer les paramètres en JavaScript
```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
```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();
});
```
```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");
}
```
```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
```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
```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
```javascript
const chaine = "coucou";
const sousChaine = "ou";
if (chaine.includes(sousChaine)) {
console.log(`'${chaine}' contient '${sousChaine}'`);
}
```
### Lowercase/Uppercase en JavaScript
```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
```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
```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
```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
```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
```javascript
const chaine = "16 16 r1616 r1616 16 r1616 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);
```
### Structure d'un fichier Python
```python
#!/usr/bin/env python3
# le reste du programme
```
### Récupérer le nombre de paramètres en Python
```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
```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
```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)))
```
```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")
```
```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
```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
```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
```python
#!/usr/bin/env python3
chaine = "coucou"
sousChaine = "ou"
if sousChaine in chaine:
print("'{}' contient '{}'".format(chaine, sousChaine))
```
### Lowercase/Uppercase en Python
```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
```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
```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
```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
```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
```python
chaine = "16 16 r1616 r1616 16 r1616 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
```powershell
function Get-Greeting {
param([string]$name)
"Hello, $name"
}
Get-Greeting -name "World"
```
### Récupérer le nombre de paramètres en PowerShell
```powershell
$paramCount = $args.Count
Write-Output "Nombre de paramètres: $paramCount"
```
### Récupérer les paramètres en PowerShell
```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
```powershell
$string = "PowerShell"
$length = $string.Length
Write-Output "La longueur de la chaîne est : $length"
```
```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"
}
```
```powershell
for ($i = 0; $i -lt 5; $i++) {
Write-Output "Itération: $i"
}
```
### Incrémenter une variable en PowerShell
```powershell
$counter = 0
$counter++
Write-Output "Compteur après incrémentation: $counter"
```
### Opérations mathématiques en PowerShell
```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
```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
```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
```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
```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
```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
```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
```powershell
$string = "PowerShell est puissant"
$position = $string.IndexOf("puissant")
Write-Output "Position de 'puissant' dans la chaîne : $position"
```