Diviseurs n = int(input("entrer un nombre: ")) déclarer n comme un entier

for i in range(1,n):
if n%i == 0: début
print(i)
n <- saisir un nombre entier
pour i allant de 1 à n exclu faire
si n modulo i est égal à 0 alors
afficher i
fin pour
fin
Factoriel m = int(input("entre un nombre: ")) déclarer m comme un entier
fact=1
for i in range(2,m): déclarer fact comme un entier
fact = fact * i début
print(m, "! : est", fact)
m <- saisir un nombre entier
fact <- 1
pour i allant de 2 à m exclu faire
fact <- fact * i
afficher m, "! : est", fact
fin
Nombre Premier a = int(input("entre un nombre: ")) déclarer a comme un entier
for x in range(2,a):
if a % x == 0: début
print(a, "pas premier") a <- saisir un nombre entier
break
else: pour x allant de 2 à a exclu faire
print(a, "est premier")
si a modulo x est égal à 0 alors
afficher a, "pas premier"
arrêter la boucle
sinon
afficher a, "est premier"
fin pour
fin

1
Nombre Parfait b= int(input("entre le nombre: ")) déclarer b comme un entier
l = []
for i in range(1,b): déclarer l comme une liste vide
if b % i == 0:
début
l.append(i)
while True: b <- saisir un nombre entier
if sum(l) == b:
print(b, "est parfait") l <- liste vide
break pour i allant de 1 à b exclu faire
else:
print(b, "pas parfait") si b modulo i est égal à 0 alors
ajouter i à la liste l
tant que vrai faire
si la somme des éléments de l est égale à b alors
afficher b, "est parfait"
arrêter la boucle
sinon
afficher b, "pas parfait"
fin tant que
fin
Cube Parfait s = int(input("entrer un nombre: ")) déclarer s comme un entier
for i in range (2,s):
if i ** 3 == s: début
print(s, 'est cube parfait')
s <- saisir un nombre entier
break
print(s, 'pas cube parfait') pour i allant de 2 à s exclu faire
si i au cube est égal à s alors
afficher s, "est cube parfait"
arrêter la boucle
fin pour
afficher s, "pas cube parfait"
fin

2
Somme des for a in range(100,1000): début
Cubiques b = str(a)
som = int(b[0])**3 + int(b[1])**3 + pour a allant de 100 à 999 faire
int(b[2])**3
b <- convertir a en une chaîne de caractères
if som == a :
print(a) som <- (convertir le premier caractère de b en entier) ^3 +
(convertir le deuxième caractère de b en entier) ^3 + (convertir le
troisième caractère de b en entier) ^3
si som est égal à a alors
afficher a
fin pour
fin
début
pour a allant de 100 à 999 faire
Dans cette solution, nous utilisons une nombre <- a
approche différente pour calculer la
somme des cubes des chiffres de a. Nous som <- 0
itérons sur les nombres a allant de 100 à tant que nombre > 0 faire
999. À chaque itération, nous stockons la
valeur initiale de a dans une variable chiffre <- nombre modulo 10
nombre. Ensuite, à l'aide d'une boucle
tant que, nous extrayons le chiffre le som <- som + chiffre ^ 3
moins significatif de nombre à l'aide de nombre <- nombre div 10
l'opération modulo (nombre modulo 10) et
nous l'ajoutons à som après l'avoir élevé fin tant que
au cube. Ensuite, nous divisons nombre
par 10 pour passer au chiffre suivant.
si som est égal à a alors
Nous répétons ce processus jusqu'à ce que afficher a
nombre devienne 0. Si la somme som est
égale à a, nous affichons a. fin pour
fin

3
def ajout():
id = input("entrer identifiant: ")
nom= input("entrer nom: ")
prenom = input("entrer prenom: ")
filiere = input("entrer filiere: ")
f = open("student.txt", "a+")
f.write(id + "," + nom + "," + prenom + "," + filiere + "\n")
f.close()
def suppr():
id = input("entrer identifiant: ")
f = open("student.txt", "r+")
l = []
for ligne in f:
l.append(ligne)
for ele in l:
if id in ele.split(",")[0]:
l.remove(ele)
print("suppr avec succès!")
f = open("student.txt", "w+")
for i in l:
f.write(i)
def affich():
f= open("student.txt", "r+")
print(f.read())
def recherch():
id = input("entrer identifiant: ")
f= open("student.txt", "r+")
for ligne in f:
if id in ligne.split(",")[0]:
print(ligne)
else:
print("etud ne se trouve pas!")
def nombre_etud():
filiere = input("entrer filiere: ")
f= open("student.txt", "r+")
l= []
d = {}
for ligne in f:
l.append(ligne.split(",")[2])
for i in l:
if filiere in i:
d[filiere] = d[filiere] + 1
else:
d[filiere] = 1
for key, value in d.items():
print(key, ":", value)
def copie():
f = open("student.txt", "r+")
f1= f= open("student1.txt", "w+")
for ligne in f:
if float(ligne.split(",")[-1]) >=10:
f1.write(ligne)
f1.close()
while True:
print("1: Ajouter un étudiant ")
print("2: Supprimer un étudiant ")
print("3: Afficher les étudiants ")
print("4: Rechercher un étudiant ")
print("5: Afficher le nombre des étudiants ")
print("6: Copier un étudiant réussi ")
print("0: Quitter ")
choix = input("entre votre choix: ")
if choix == "1":
ajout()
elif choix == "2":
suppr()

4
elif choix == "3":
affich()
elif choix == "4":
recherch()
elif choix == "5":
nombre_etud()
elif choix == "6":
copie()
elif choix == "0":
print("Au revoir! ")
else:
print("choix invalid! ")

5
Diviseurs n = int(input("entrer un nombre: ")) Algorithme TrouverDiviseurs
for i in range(1,n):
if n%i == 0: // Déclarations des variables
print(i)
Variable nombre : entier
Variable diviseur : entier
// Saisie du nombre
Afficher "Entrez un nombre : "
Lire nombre
// Affichage des diviseurs
Afficher "Les diviseurs de ", nombre, " sont :"
// Parcours des diviseurs potentiels
Pour diviseur de 1 à nombre faire
Si nombre modulo diviseur est égal à 0 alors
Afficher diviseur
Fin Si
Fin Pour
Fin Algorithme
Factoriel m = int(input("entre un nombre: ")) Algorithme CalculerFactoriel
fact=1
for i in range(2,m): // Déclarations des variables
fact = fact * i
Variable nombre : entier
print(m, "! : est", fact)
Variable factoriel : entier
// Saisie du nombre
Afficher "Entrez un nombre : "
Lire nombre
// Initialisation du factoriel à 1
factoriel <- 1
// Calcul du factoriel
Pour i de 1 à nombre faire
factoriel <- factoriel * i

6

Nombre Premier a = int(input("entre un nombre: "))
for x in range(2,a):
if a % x == 0:
print(a, "pas premier")
break
else:
print(a, "est premier")
Fin Pour
// Affichage du résultat
Afficher "Le factoriel de ", nombre, " est ", factoriel
Fin Algorithme
Algorithme VerifierNombrePremier
// Déclarations des variables
Variable nombre : entier
Variable estPremier : booléen
// Saisie du nombre
Afficher "Entrez un nombre : "
Lire nombre
// Initialisation de la variable estPremier à true
estPremier <- vrai
// Vérification si le nombre est premier
Si nombre est inférieur ou égal à 1 alors
estPremier <- faux
Sinon
Pour diviseur de 2 à la racine carrée de nombre faire
Si nombre modulo diviseur est égal à 0 alors
estPremier <- faux
Quitter la boucle
Fin Si
Fin Pour
Fin Si
// Affichage du résultat
Si estPremier est vrai alors
Afficher nombre, " est un nombre premier"
Sinon
7
 Afficher nombre, " n'est pas un nombre premier"
Fin Si
Fin Algorithme
Nombre Parfait b= int(input("entre le nombre: ")) Algorithme VerifierNombreParfait
l = []
for i in range(1,b): // Déclarations des variables
if b % i == 0:
Variable nombre : entier
l.append(i)
while True: Variable sommeDiviseurs : entier
if sum(l) == b:
print(b, "est parfait") // Saisie du nombre
break Afficher "Entrez un nombre : "
else:
print(b, "pas parfait") Lire nombre
// Initialisation de la somme des diviseurs à 0
sommeDiviseurs <- 0
// Calcul de la somme des diviseurs
Pour diviseur de 1 à (nombre - 1) faire
Si nombre modulo diviseur est égal à 0 alors
sommeDiviseurs <- sommeDiviseurs + diviseur
Fin Si
Fin Pour
// Vérification si le nombre est parfait
Si sommeDiviseurs est égal à nombre alors
Afficher nombre, " est un nombre parfait"
Sinon
Afficher nombre, " n'est pas un nombre parfait"
Fin Si
Fin Algorithme
Cube Parfait s = int(input("entrer un nombre: ")) Algorithme VerifierCubeParfait
for i in range (2,s):
if i ** 3 == s: // Déclarations des variables
print(s, 'est cube parfait') Variable nombre : entier

8
 break Variable racineCubique : entier
print(s, 'pas cube parfait')
// Saisie du nombre
Afficher "Entrez un nombre : "
Lire nombre
// Calcul de la racine cubique arrondie du nombre
racineCubique <- Arrondir à l'entier inférieur (racine cubique de
nombre)
// Vérification si le nombre est un cube parfait
Si racineCubique * racineCubique * racineCubique est égal à nombre
alors
Afficher nombre, " est un cube parfait"
Sinon
Afficher nombre, " n'est pas un cube parfait"
Fin Si
Fin Algorithme
Somme des for a in range(100,1000): Algorithme TrouverNombresSommeCubes
Cubiques b = str(a)
som = int(b[0])**3 + int(b[1])**3 + // Déclarations des variables
int(b[2])**3
Variable nombre : entier
if som == a :
print(a) // Parcours des nombres de 100 à 1000
Pour nombre de 100 à 1000 faire
Variable sommeCubesChiffres : entier
Variable nombreTemporaire : entier
// Initialisation de la somme des cubes des chiffres à 0
sommeCubesChiffres <- 0
nombreTemporaire <- nombre
Tant que nombreTemporaire est supérieur à 0 faire
Variable chiffre : entier
Dans cette solution, nous utilisons une
approche différente pour calculer la chiffre <- nombreTemporaire modulo 10
somme des cubes des chiffres de a. Nous
itérons sur les nombres a allant de 100 à

9
999. À chaque itération, nous stockons la sommeCubesChiffres <- sommeCubesChiffres + (chiffre *
valeur initiale de a dans une variable chiffre * chiffre)
nombre. Ensuite, à l'aide d'une boucle
tant que, nous extrayons le chiffre le nombreTemporaire <- nombreTemporaire divisé par 10
moins significatif de nombre à l'aide de
l'opération modulo (nombre modulo 10) et Fin Tant que
nous l'ajoutons à som après l'avoir élevé // Vérification si le nombre est égal à la somme des cubes de ses
au cube. Ensuite, nous divisons nombre chiffres
par 10 pour passer au chiffre suivant.
Nous répétons ce processus jusqu'à ce que Si nombre est égal à sommeCubesChiffres alors
nombre devienne 0. Si la somme som est
égale à a, nous affichons a. Afficher nombre
Fin Si
Fin Pour
Fin Algorithme

10