C#
#Corrections
EXERCICE 1
using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
using System;
Permet de spécifier que dans le fichier courant il peut y avoir des éléments appartenant à l’espace de nom system.
Cela permet notamment d’écrire Console.WriteLine au lieu de System.Console.WriteLine
class Program
{
Le C# est un langage orienté objet dans lequel tout le code doit se trouver forcément dans une classe.
Cela permet une meilleure organisation du code.
static void Main(string[] args)
{
En C# le code qui est exécuté doit forcément être écrit dans une fonction.
La fonction nommée Main est celle qui sera exécutée au tout début du programme : il ne pourra y avoir qu’une seule fonction Main au sein du programme.
Le mot clef static signifie que la fonction appartient à la classe et non pas aux instances de celles-ci, la fonction n’a donc pas accès aux membres de la classe qui ne
sont pas static.
Console.WriteLine("Hello World!");
La classe Console contient une fonction static nommée WriteLine.
Pour appeler une fonction il suffit d’écrire le nom de la fonction ainsi que les parenthèses.
Cette fonction prend en argument une string et l’affiche à l’écran.
Les arguments d’une fonction se situent entre les parenthèses de l’appel de fonction
Dans Visual Studio en écrivant simplement Console et point ( . ) il est possible de voir la liste des fonctions et membres utilisables :
Il est aussi possible d’écrire uniquement cw puis tab tab afin d’écrire Console.WriteLine plus rapidement
Il ne reste qu’à appuyer sur F5 ou sur le bouton de build
pour constater le bon fonctionnement du programme.
EXERCICE 2
using System;
class Program
{
static void Main(string[] args)
{
string S = Console.ReadLine();
Console.WriteLine("Bonjour " + S);
}
}
string S = Console.ReadLine();
La classe Console contient une fonction static nommée ReadLine.
Cette fonction ne prend pas d’argument et retourne une string correspondant à la ligne entrée par l’utilisateur.
Il s'agit d’une rare fonction qui met en pause l'exécution du programme : tant que l’utilisateur n’a pas appuyé sur la touché entrée le programme attend.
Comme l’on a besoin de cette entrée utilisateur, il faut absolument stocker ce que retourne la fonction :
c’est le rôle de l’opérateur d’affectation = qui place la valeur retournée par ReadLine() dans la variable S de type string
Console.WriteLine("Bonjour " + S);
Enfin l’on affiche le texte désiré “Bonjour ” suivi du contenu de la variable S
Afin de ne passer qu’un seul paramètre à Console.WriteLine il faut regrouper le littéral “Bonjour “ et la variable S dans une même string,
cela se fait à l’aide de l’opérateur de concaténation + qui les transforme en une seule string
Il est tout à fait possible de réaliser la même chose en 2 instructions :
string result = "Bonjour " + S;
Console.WriteLine(result);
EXERCICE 3
using System;
class Program
{
static void Main(string[] args)
{
string S = Console.ReadLine();
int N = int.Parse(S);
int result = N * N + 2;
Console.WriteLine(result);
}
}
int N = int.Parse(S);
Afin d’effectuer des calculs il faut disposer de variables de type numérique,
ici il s’agit d’un calcul sur des nombres entiers le type int fera l’affaire.
Il faut donc convertir l’entrée de l’utilisateur contenu dans la variable S en int
Pour cela on utilise la fonction Parse de la classe int qui prend en argument une string et retourne un int
Le nombre entré par l’utilisateur est désormais stocké dans la variable N
int result = N * N + 2;
Il ne reste qu’à effectuer le calcul demandé NxN+2 et le stocker dans une variable.
L’opérateur d’affectation a la priorité la plus basse
c’est donc dans un premier temps la multiplication qui sera effectuée
puis l’addition
puis l’affectation
Console.WriteLine(result);
Enfin on affiche le contenu de cette variable
EXERCICE 4
using System;
class Program
{
static void Main(string[] args)
{
string S = Console.ReadLine();
float F = float.Parse(S);
float tva = F * 0.2f;
Console.WriteLine(tva);
}
}
float F = float.Parse(S);
Il faut effectuer des calculs sur des nombres à virgule le type float fera l’affaire.
Il faut donc convertir l’entrée de l’utilisateur contenu dans la variable S en float
Pour cela on utilise la fonction Parse de la classe float qui prend en argument une string et retourne un float
Le nombre entré par l’utilisateur est désormais stocké dans la variable F
float tva = F * 0.2f;
Il ne reste qu’à effectuer le calcul demandé : on peut obtenir les 20% en multipliant par 0,2
On écrit le littéral 0,2
0.2f
afin de spécifier qu’il s’agit d’un float, si l’on écrit uniquement 0.2 alors le littéral est considéré comme un double
Console.WriteLine(tva);
Enfin on affiche le contenu de cette variable
EXERCICE 5
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
for (int i = 0; i < N; i++)
{
Console.WriteLine("Hello World");
}
}
}
int N = int.Parse(Console.ReadLine());
Il est tout à fait possible de récupérer le nombre entré par l’utilisateur en une seule ligne
Il s’agit d’un choix personnel, mais il est préférable de garder des instructions simples et claires.
for (int i = 0; i < N; i++)
{
L’énoncé demande de répéter plusieurs fois une directive, il faudra donc utiliser une boucle
Comme l’on connait à l’avance le nombre de fois à répéter il est plus simple d’utiliser une boucle for
Console.WriteLine("Hello World");
Enfin entre l’accolade ouvrante { et l’accolade fermante } de la boucle for
on peut ajouter le code à répéter : ici l’affichage de “Hello World”
EXERCICE 6
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
if (N >= 18)
{
Console.WriteLine("Majeur");
}
else
{
Console.WriteLine("Mineur");
}
}
}
if (N >= 18)
La consigne indique un fonctionnement différent en fonction de l’entrée de l’utilisateur.
Lorsque l’on a besoin d’effectuer un code différent en fonction d’une variable il faut utiliser une structure conditionnelle
il suffit de mettre la condition entre parenthèse : N >= 18
En l'occurrence il s’agit d’une expression booléenne : celle-ci sera évaluée puis remplacé par un booléen : soit true soit false
{
Console.WriteLine("Majeur");
}
Si l’expression est vraie (true) alors le code contenu dans le bloc de code sera exécuté
else
{
Console.WriteLine("Mineur");
}
Si l’expression est fausse (false) c’est le code contenu dans le bloc else qui sera exécuté
EXERCICE 7
using System;
class Program
{
static void Main(string[] args)
{
int N1 = int.Parse(Console.ReadLine());
int N2 = int.Parse(Console.ReadLine());
int result;
if (N1 >= 0)
{
result = N1 + N2;
}
else
{
result = N1 - N2;
}
Console.WriteLine(result);
}
}
Dans un premier temps on récupère les 2 valeurs entrées par l’utilisateurs dans les variable N1 puis N2
int result;
L’énoncé demande d’afficher le résultat d’un calcul mais celui-ci peut être différent,
il faut donc dans un premier temps déclarer une variable qui stockera le résultat du calcul.
if (N1 > 0)
{
result = N1 + N2;
}
else
{
result = N1 - N2;
}
Ensuite il ne reste qu’à affecter le bon calcul à la variable result en fonction de la condition de l’énoncé
Console.WriteLine(result);
Et enfin l’affichage de ce résultat
EXERCICE 8
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
for (int i = 0; i < N; i++)
{
Console.WriteLine(i);
}
}
}
Ici l’énoncé demande de répéter un affichage mais en faisant varier celui-ci
for (int i = 0; i < N; i++)
On connaît d’avance le nombre d’affichages il est donc préférable d’utiliser une boucle for
On remarque que dans cette boucle for on dispose d’une variable i qui varie à chaque boucle
Cette variable i vaut exactement la valeur que l’on souhaite afficher
Console.WriteLine(i);
Il suffit donc de l’afficher directement
EXERCICE 9
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
int sum = 0;
for (int i = 1; i < N; i++)
{
sum += i;
}
Console.WriteLine(sum);
}
}
int sum = 0;
L’énoncé demande de calculer une somme, il faut dans un premier temps déclarer une variable pour stocker cette somme.
On l’initialise directement à 0 puisque lorsque l’on compte on commence à partir de 0
for (int i = 1; i < N; i++)
Il faut ajouter tous les nombres de 1 à N : il s’agit donc de répéter cet ajout
on utilise une boucle for puisque l’on sait combien de nombre l’on va ajouter
ATTENTION à la condition :
il est indiqué dans l’énoncé “N1 non compris” ; la condition doit donc être i < N et non i <= N
{
sum += i;
}
Puis pour chaque itération de la boucle on ajoute le nombre actuel à la somme
Console.WriteLine(sum);
Enfin, une fois que l’on sort de la boucle on peut afficher la somme
EXERCICE 10
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
for (int i = 0; i < N; i++)
{
if ( i % 5 == 0)
Console.WriteLine("Cool");
else
Console.WriteLine(i);
}
}
}
for (int i = 0; i < N; i++)
Il s’agit de répéter un affichage et l’on connaît le nombre d’itération, il est donc plus facile d’utiliser une boucle for
if ( i % 5 == 0)
Pour vérifier si un nombre A est divisible par un nombre B on utilise l’opérateur modulo % :
si le résultat du modulo par B est égal à 0 alors A est divisible par B
Console.WriteLine("Cool");
Dans ce cas on peut afficher “Cool”, pas besoin d’accolade puisque le code de la condition if ne fait qu’une seule ligne
else
Console.WriteLine(i);
Dans le cas contraire on affiche le nombre comme demandé
EXERCICE 11
using System;
class Program
{
static void Main(string[] args)
{
string S = Console.ReadLine();
}
int count = 0;
for (int i = 0; i < S.Length; i++)
{
char lower = char.ToLower(S[i]);
if (lower == 'a')
{
count++;
}
}
Console.WriteLine(count);
}
int count = 0;
Il va falloir compter, et pour compter il faut forcément se souvenir de la valeur actuelle :
pour cela on déclare une variable qui servira de compteur que l’on initialise à 0
for (int i = 0; i < S.Length; i++)
Il va falloir parcourir tous les caractères de la chaîne de caractères,
on utilise S.Length pour connaître le nombre de caractères de la chaîne S.
char lower = char.ToLower(S[i]);
Il faut vérifier à la fois les a minuscule et majuscule, nous allons tout simplement
transformer le caractère actuel S[i] en minuscule grâce à la fonction char.ToLower
if (lower == 'a')
{
count++;
}
Enfin, à chaque fois que l’on rencontre le caractère ‘a’ l’on incrémente le compteur
Console.WriteLine(count);
Il ne reste plus qu’à afficher la valeur du compteur une fois la boucle for terminée
EXERCICE 12
using System;
class Program
{
static void Main(string[] args)
{
string S = Console.ReadLine();
for (int i = 0; i < S.Length; i++)
{
Console.Write(S[S.Length - 1 - i]);
}
}
}
Console.Write(S[S.Length - 1 - i]);
Ici l’on affiche la chaîne caractère par caractère mais cette fois-ci l’on souhaite écrire dans la sens inverse : il faut donc commencer par la fin.
Le dernier index dans la chaîne de caractère est S.Length-1 (puisque l’on commence à 0)
Si l’on soustrait i, cela nous permet d’obtenir un décompte jusqu’à l’index 0 et donc d’écrire dans le sens inverse.
Il est aussi possible de résoudre le problème à l’aide d’une boucle for parcourue en sens inverse :
string S = Console.ReadLine();
for (int i = S.Length - 1; i >= 0; i--)
{
Console.Write(S[i]);
}
EXERCICE 13
using System;
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
int N2 = int.Parse(Console.ReadLine());
for (int y = 0; y < N; y++)
{
for (int x = 0; x < N2; x++)
{
Console.Write('*');
}
Console.WriteLine();
}
}
}
for (int y = 0; y < N; y++)
Le rectangle à réaliser à une taille de N, il faut donc commencer par une première boucle pour chaque ligne
for (int x = 0; x < N2; x++)
Ensuite pour chaque ligne il faut N2 caractère ‘*’, on utilise une nouvelle boucle pour effectuer chaque affichage
Console.Write('*');
On ne veut pas revenir à la ligne entre chaque caractère on utilise donc Console.Write
Console.WriteLine();
Par contre une fois la ligne affichée, on veut passer à la ligne, on appelle donc Console.WriteLine
entre chaque ligne pour obtenir un retour à la ligne
EXERCICE 19
class Program
{
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
string[] notes = new string[] { "Do", "Ré", "Mi", "Fa", "Sol", "La", "Si" };
for (int i = 0; i < N; i++)
{
int noteIndex = i % notes.Length;
Console.WriteLine(notes[noteIndex]);
}
}
}
string[] notes = new string[] { "Do", "Ré", "Mi", "Fa", "Sol", "La", "Si" };
Dans un premier temps il faut spécifier les données avec lesquelles on va travailler, ici nous avons 7 notes de musiques sous forme de string
alors il faut créer un tableau de string et lui affecter les notes directement.
for (int i = 0; i < N; i++)
Ensuite l’exercice demande d’afficher N notes, il faut donc répéter cela N fois grâce à une boucle for
int noteIndex = i % notes.Length;
Il faut récupérer l’index de la note actuelle, le problème c’est que i peut être supérieur au nombre de notes du tableau.
Afin de ne pas dépasser la taille du tableau, on utilise l’opérateur modulo qui fera revenir à chaque fois la valeur entre 0 et N-1.
Console.WriteLine(notes[noteIndex]);
On affiche donc la valeur du tableau de string à l’index donné