Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant un carré, une croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne
Saisissez la taille des figures
10
* * * * * * * * * *
* *
* *
* *
* *
* *
* *
* *
* *
* * * * * * * * * *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
Vous définirez des sous-programmes de quelques lignes et au plus deux niveaux d’imbrication. Vous ferez attention à ne jamais écrire deux fois les mêmes instructions. Pour ce faire, complétez le code source suivant :
| using System; namespace tests { class MainClass { /* Affiche le caractere c */ public static void afficheCaractere(char c) { } /*****************************************/ /* affiche n fois le caractere c, ne revient pas a la ligne apres le dernier caractere. */ public static void ligneSansReturn(int n, char c) { } /*****************************************/ /* affiche n fois le caractere c, revient a la ligne apres le dernier caractere. */ public static void ligneAvecReturn(int n, char c) { } /*****************************************/ /* Affiche n espaces. */ public static void espaces(int n) { } /*****************************************/ /* Affiche le caractere c a la colonne i, ne revient pas a la ligne apres. */ public static void unCaractereSansReturn(int i, char c) { } /*****************************************/ /* Affiche le caractere c a la colonne i, revient a la ligne apres. */ public static void unCaractereAvecReturn(int i, char c) { } /*****************************************/ /* Affiche le caractere c aux colonnes i et j, revient a la ligne apres. */ public static void deuxCaracteres(int i, int j, char c) { } /*****************************************/ /* Affiche un carre de cote n. */ public static void carre(int n) { } /*****************************************/ /* Affiche un chapeau dont la pointe - non affichee - est sur la colonne centre, avec les caracteres c. */ public static void chapeau(int centre, char c) { } /*****************************************/ /* Affiche un chapeau a l'envers avec des caracteres c, la pointe - non affichee - est a la colonne centre */ public static void chapeauInverse(int centre, char c) { } /*****************************************/ /* Affiche un losange de cote n. */ public static void losange(int n) { } /*****************************************/ /* Affiche une croix de cote n */ public static void croix(int n) { } /*****************************************/ public static void Main(string[] args) { int taille; Console.WriteLine("Saisissez la taille des figures : "); taille = int.Parse(Console.ReadLine()); carre(taille); losange(taille); croix(taille); } } } |
public static int unites(int n) retournant le chiffre
des unités du nombre n.
public static int dizaines(int n) retournant le
chiffre des dizaines du nombre n.
public static int extrait(int n, int p) retourant le
p-ème chiffre de représentation décimale de n en partant des unités.
public static int nbChiffres(int n) retournant le
nombre de chiffres que comporte la représentation décimale de n.
public static int sommeChiffres(int n) retournant la
somme des chiffres de n.
Soient a et b deux entiers strictement positifs. a est un diviseur strict de b si a divise b et a ≠ b. Par exemple, 3 est un diviseur strict de 6. Mais 6 n’est pas un diviseur strict 6. a et b sont des nombres amis si la somme des diviseurs stricts de a est b et si la somme des diviseurs de b est a. Le plus petit couple de nombres amis connu est 220 et 284.
public static int sommeDiviseursStricts(int n), elle doit
renvoyer la somme des diviseurs stricts de n.
public static bool sontAmis(int a, int b), elle doit
renvoyer 1 si a et b sont amis, 0 sinon.
Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.
public static bool estParfait(int n), elle doit
retourner true ssi n est un nombre parfait.
Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n2 peut être séparée en une partie gauche u et une partie droite v tel que u + v = n. 452 = 2025, comme 20 + 25 = 45, 45 est aussi un nombre de Kaprekar. 48792 = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter toute confusion), alors 4879 est encore un nombre de Kaprekar.
public static int sommeParties(int n, int p) qui
découpe n est deux nombres dont le deuxième comporte p chiffres,
et qui retourne leur somme. Par exemple,
| sommeParties(12540, 2) = 125 + 40 = 165 |
public static bool estKaprekar(int n)
Ecrire une fonction
public static int somme(int[] T) retournant la
somme des éléments de T.
Ecrire une fonction
public static int min(int[] T) retournant la
valeur du plus petit élément de T.
Ecrire une fonction
public static bool existe(int[] T, int k)
retournant
true si et seulement si k est un des éléments de T.
Ecrivez le corps de la fonction
public static int sommePairs(int[] T),
sommePairs(T) retourne la somme
des éléments pairs de T. N’oubliez pas que
a%b est le reste de la division entière de a par b.
Ecrivez le corps de la fonction
public static bool estTrie(int[] T), estTrie(T) retourne
vrai si et seulement si les éléments de T sont triés dans
l’ordre croissant.
Ecrire une fonction
public static void permutation(int[] T)
effectuant une permutation circulaire vers la droite des éléments de
T.
Ecrire une fonction
public static void miroir(int[] T inversant
l’ordre des éléments de T.
On rappelle qu’un nombre est premier s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.
Écrivez une fonction
public static bool estPremier(int x, int[] premiers, int k)
retournant vrai si et seulement si x est premier. Vous vérifierez la
primarité de x en examinant les restes des divisions de x par les
k premiers éléments de premiers. On suppose que k est toujours
supérieur ou égal à 1.
Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de x inférieur à √x n’a été trouvé, alors x est premier
Écrivez une fonction
public static int [] trouvePremiers(int n)
retournant un tableau contenant les n premiers nombres premiers.
Écrivez une fonction
public static int[] decompose(int x, int[] premiers)
retournant un tableau contenant la décomposition en facteurs premiers
du nombre x, sachant que T contient les n premiers nombres
premiers. Par exemple, si x = 108108, alors on décompose n en
produit de facteurs premiers de la sorte
| 108108 = 2*2*3*3*3*7*11*13 = 22*33*50*71*111*131*170*190* … *Z0 |
(où Z est le n-ième nombre premier). On représente donc x de façon unique par le tableau à n éléments suivant :
| {2, 3, 0, 1, 1, 1, 0, 0, 0, …, 0} |
Écrivez une fonction
public static int recompose(int[] decomposition, int [] premiers)
effectuant l’opération réciproque de celle décrite ci-dessus.
Écrivez une fonction
public static int[] pgcd(int[] T, int[] K)
prenant en paramètre les décompositions en facteurs premiers T et
K de deux nombres, retournant la décomposition en facteurs
premiers du plus grand commun diviseur de ces deux nombres.
Écrivez une fonction
public static int pgcd(int i, int j) prenant en
paramètres deux nombres i et j, et combinant les fonctions
précédentes pour retourner le pgcd de i et j. Vous poserez n
suffisamment grand pour le calcul puisse fonctionner correctement.