Machine Translated by Google

Machine Translated by Google

PYTHON
Programme 100

Par Devbrat Rudra

[Link]

ENSEMBLE­1

1. Programme Bonjour tout le monde :

print("Bonjour le monde !")

2. Calculatrice simple :

a = int(input("Entrez le premier nombre : ")) b =

int(input("Entrez le deuxième nombre : "))

print("Somme :", a + b)

print("Différence :", a ­ b)

print("Produit :", a * b)

print("Quotient :", a / b)

3. Factorielle d'un nombre :

def factoriel(n):
si n == 0 :

retour 1

autre:
Machine Translated by Google

retour m * factorielle(n ­ 1)

num = int(input("Entrez un nombre : "))

print("Factorial :", factorial(num))

4. Séquence de Fibonacci :

déf fibonacci(n):
si n <= 1 :

retour m

autre:

retourner fibonacci(n ­ 1) + fibonacci(n ­ 2)

termes = int(input("Entrez le nombre de termes : "))

print("Séquence de Fibonacci :")

pour i dans la plage(terms) :

imprimer(fibonacci(i))

5. Vérifiez le nombre premier :

def is_prime(n):
si n <= 1 :

retourner Faux

pour je dans range(2, int(n ** 0.5) + 1):

si n % i == 0 :

retourner Faux

retourner vrai

num = int(input("Entrez un nombre : "))

Machine Translated by Google

si is_prime(num):

print("Prime")
autre:

print("Pas premier")

6. Calculateur d’intérêts simple :

p = float(input("Entrez le montant principal : ")) r =

float(input("Entrez le taux d'intérêt : "))

t = float(input("Entrez la période : ")) Interest = (p *

print("Simple r * t) / 100

Interest:", Interest)

7. Vérifiez Pair ou Impair :

num = int(input("Entrez un nombre : "))

si num % 2 == 0 :

print("Pair")
autre:

print("Imparable")

8. Aire d'un cercle :

importer des mathématiques

radius = float(input("Entrez le rayon du cercle : "))

zone = [Link] * rayon * rayon

print("Zone :", zone)

Machine Translated by Google

9. Compréhension de la liste :

carrés = [i ** 2 pour i dans la plage (10)]

print("Carrés :", carrés)

10. Gestion simple des fichiers :

# Ecrire dans un fichier

avec open("[Link]", "w") comme fichier :

[Link]("Bonjour, ceci est un exemple de texte.")

# Lecture à partir d'un

fichier avec open("[Link]", "r") comme fichier :

data = [Link]()

print("Données du fichier :", données)

ENSEMBLE­2

1. Recherchez le palindrome :

def est_palindrome(s) :

retourner s == s[::­1]

string = input("Entrez une chaîne : ") if

is_palindrome(string):

print("Palindrome")
autre:

print("Pas un palindrome")

2. Trouvez le plus grand parmi trois nombres :

Machine Translated by Google

a = float(input("Entrez le premier chiffre : ")) b =

float(input("Entrez le deuxième chiffre : ")) c =

float(input("Entrez le troisième chiffre : ")) max_num

= max(a , b, c) print("Plus

grand nombre :", max_num)

3. Imprimer la table de multiplication :

num = int(input("Entrez un nombre : "))

pour je dans la plage (1, 11):

print(f"{num} x {i} = {num * i}")

4. Convertissez les degrés Celsius en Fahrenheit :

celsius = float(input("Entrez la température en Celsius : "))

Fahrenheit = (celsius * 9/5) + 32

print("Température en Fahrenheit :", Fahrenheit)

5. Opérations de chaîne simples :

string = "Bonjour le monde !"

print("Longueur de la chaîne :", len(string))

print("Majuscule :", [Link]())

print("Lowercase :", [Link]())

print("Chaîne inversée :", string [::­1])

6. Algorithme de tri à bulles :

Machine Translated by Google

def bubble_sort(arr) : n =

len(arr) pour i

dans la plage(n ­ 1) : pour j

dans la plage(0, n ­ i ­ 1) : si arr[j] >

arr[j + 1] : arr [j], arr[j + 1] =

arr[j + 1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]

bubble_sort(arr)

print("Tableau trié :", arr)

7. Vérifiez l'année bissextile :

def is_leap_year(année):

si (année % 4 == 0 et année % 100 != 0) ou (année % 400 == 0) :

retourner vrai

retourner Faux

year = int(input("Entrez une année : ")) if

is_leap_year(year):

print("Année bissextile")

autre:

print("Pas une année bissextile")

8. Comptez les voyelles dans une chaîne :

def count_voyelles(s) :

voyelles = 'aeiouAEIOU'

compte = 0
Machine Translated by Google

pour char en s :

si char dans les voyelles :

compter += 1

nombre de retours

string = input("Entrez une chaîne : ")

print("Nombre de voyelles :", count_voyelles(string))

9. Trouvez le LCM de deux nombres :

def calculate_lcm(x, y) : si x > y :

plus grand = x

autre:

plus grand = y

tandis que Vrai :

si supérieur à % x == 0 et supérieur à % y == 0 : lcm =

supérieur

casser

supérieur += 1

retourner lcm

num1 = int(input("Entrez le premier numéro : ")) num2 =

int(input("Entrez le deuxième numéro : ")) print("LCM:",

calculate_lcm(num1, num2))

10. Classe de base et objet :

Machine Translated by Google

classe Rectangle :

def __init__(self, length, width) : [Link]

= length
[Link] = largeur

def zone (self):

renvoie [Link] * [Link]

length = float(input("Entrez la longueur du rectangle : ")) width =

float(input("Entrez la largeur du rectangle : ")) rect = Rectangle(longueur,

largeur) print("Zone du rectangle :",

[Link]())

ENSEMBLE­3

1. Vérifiez l'anagramme :

def is_anagram(s1, s2) : return

trié(s1) == trié(s2)

string1 = input("Entrez la première chaîne : ") string2

= input("Entrez la deuxième chaîne : ") if

is_anagram(string1, string2) :

print("Anagrammes")
autre:

print("Pas des anagrammes")

2. Générez un nombre aléatoire :

importer au hasard
Machine Translated by Google

print("Nombre aléatoire :", [Link](1, 100))

3. Algorithme de recherche binaire :

def binaire_search(arr, x):

faible = 0

high = len(arr) ­ 1

tandis que low <= high :

mid = (low + high) // 2

si arr[milieu] < x :

bas = milieu + 1

elif arr[milieu] > x :

élevé = moyen ­ 1
autre:

retour au milieu

retour ­1

arr = [2, 3, 4, 10, 40]

x = 10

résultat = recherche_binaire (arr, x)

si résultat != ­1 :

print(f"Élément trouvé à l'index {result}")

autre:

print("Élément introuvable")

4. Vérifiez le numéro Armstrong :

def is_armstrong(n):
Machine Translated by Google

commande = len(str(n))

température = n

somme = 0

while temp > 0 :

chiffre = temp % 10

somme += chiffre ** ordre

temp //= 10

retour n == somme

number = int(input("Entrez un nombre : "))

si is_armstrong(nombre) :

print("Numéro Armstrong")

autre:

print("Pas un numéro Armstrong")

5. Générez un modèle simple :

n=5

pour i dans la plage(n):

print('* ' * (i + 1))

6. Algorithme de recherche linéaire :

def Linear_search (arr, x):

pour i in range(len(arr)) : si arr[i]

== x :

je reviens

retour ­1
Machine Translated by Google

arr = [4, 2, 1, 7, 5]
x=7

résultat = recherche_linéaire (arr, x)

si résultat != ­1 :

print(f"Élément trouvé à l'index {result}")

autre:

print("Élément introuvable")

7. Calculez la puissance d'un nombre :

base = int(input("Entrez la base : ")) exponent

= int(input("Entrez l'exposant : "))

résultat = base ** exposant

print("Résultat :", résultat)

8. Imprimez la série de Fibonacci :

def fibonacci_series(n): a, b =

0, 1

pour _ dans la plage (n) :

print(a, end=" ") a, b

= b, a + b

termes = int(input("Entrez le nombre de termes : ")) print("Série

Fibonacci :") fibonacci_series(terms)

9. Fusionner deux listes triées :

Machine Translated by Google

liste1 = [1, 3, 5, 7]

liste2 = [2, 4, 6, 8]

merged_list = sorted(list1 + list2) print("Liste

fusionnée et triée :", merged_list)

10. Générez un modèle de pyramide simple :

n=5

pour je dans la plage (n):

print(" " * (n ­ i ­ 1) + "*" * (2 * i + 1))

ENSEMBLE­4

1. Vérifiez si un nombre est positif, négatif ou zéro :

num = float(input("Entrez un nombre : "))

si nombre > 0 :

print("Nombre positif")

numéro elif < 0 :

print("Nombre négatif")

autre:

imprimer("Zéro")

2. Générez une liste de nombres premiers dans une plage :

def generate_primes (début, fin) :

nombres

premiers = [] pour num dans la plage (début, fin + 1) :

si num > 1 :
Machine Translated by Google

pour je dans la plage (2, num):

si num % i == 0 :

casser

autre:

[Link](num) renvoie

des nombres premiers

start_range = int(input("Entrez la plage de départ : ")) end_range =

int(input("Entrez la plage de fin : ")) print("Nombres premiers :",

generate_primes(start_range, end_range))

3. Calculez l'aire et le périmètre d'un rectangle :

length = float(input("Entrez la longueur du rectangle : ")) width = float(input("Entrez

la largeur du rectangle : ")) surface = longueur * largeur périmètre = 2 *

(longueur + largeur)

print( f"Zone : {zone}, Périmètre : {périmètre}")

4. Trouvez le PGCD de deux nombres :

def calculate_gcd(x, y) : tandis

que y : x,

y = y, x % y

retourner x

num1 = int(input("Entrez le premier nombre : ")) num2 =

int(input("Entrez le deuxième nombre : ")) print("GCD:",

calculate_gcd(num1, num2))
Machine Translated by Google

5. Vérifiez si une année est une année bissextile ou n'utilise pas de fonctions :

def is_leap_year(année):

si année % 4 == 0 :

si année % 100 == 0 :

si année % 400 == 0 :

retourner vrai

autre:

retourner Faux

autre:

retourner vrai

autre:

retourner Faux

year = int(input("Entrez une année : ")) if

is_leap_year(year) :

print("Année bissextile")

autre:

print("Pas une année bissextile")

6. Imprimez la somme des nombres naturels jusqu'à un nombre donné :

n = int(input("Entrez un nombre : "))

somme = 0

pour je dans la plage (1, n + 1):

somme += je

print("Somme des nombres naturels :", somme)

Machine Translated by Google

7. Inverser une chaîne :

string = input("Entrez une chaîne : ")

reverse_string = string[::­1]

print("Chaîne inversée :", chaîne_inversée)

8. Vérifiez si un nombre est un nombre parfait :

def is_perfect_number(n):

somme = 0

pour je dans la plage (1, n):

si n % i == 0 :

somme += je

retourner la somme == n

number = int(input("Entrez un nombre : "))

if is_perfect_number(number): print("Nombre

parfait")

autre:

print("Ce n'est pas un nombre parfait")

9. Comptez le nombre de mots dans une chaîne :

string = input("Entrez une chaîne : ")

word_count = len([Link]()) print("Nombre

de mots :", word_count)

10. Concaténer deux chaînes :

Machine Translated by Google

string1 = input("Entrez la première chaîne : ")

string2 = input("Entrez la deuxième chaîne : ")

concatenated_string = string1 + string2

print("Chaîne concaténée :", concatenated_string)

ENSEMBLE­5

1. Vérifiez si un nombre est un carré parfait :

importer des mathématiques

def is_perfect_square(n) : racine

= [Link](n)

retourner la racine
* racine == n

number = int(input("Entrez un nombre : ")) if

is_perfect_square(number): print("Carré

parfait")

autre:

print("Pas un carré parfait")

2. Implémentez une structure de données de pile :

Pile de classe :

def __init__(self):

[Link] = []

def push (soi, élément):

[Link](élément)
Machine Translated by Google

def pop(self) :
renvoie [Link]()

def is_empty(soi) :
retourner [Link] == []

stack = Stack()
[Link](1)
[Link](2)
[Link](3)
print("Objet sauté :", [Link]())
print("La pile est vide :", stack.is_empty( ))

3. Calculez l'aire d'un triangle :

base = float(input("Entrez la base du triangle : "))

height = float(input("Entrez la hauteur du triangle : ")) area =
0.5 * base * height print("Zone
du triangle :", zone)

4. Recherchez la valeur ASCII d'un caractère :

char = input("Entrez un caractère : ")

ascii_value = ord(char)
print("Valeur ASCII :", ascii_value)

5. Générez un motif de diamant simple :

n=5
Machine Translated by Google

pour i dans la

plage(n): print(" " * (n ­ i ­ 1) + "* " * (i + 1)) pour

je dans la plage (n ­ 1, 0, ­1) :

print(" " * (n ­ i) + "* " * i)

6. Vérifiez si un nombre est un cube parfait :

def is_perfect_cube(n):

racine = rond(n ** (1/3))

renvoie la racine
** 3 == n

number = int(input("Entrez un nombre : ")) if

is_perfect_cube(number): print("Cube

parfait")

autre:

print("Ce n'est pas un cube parfait")

7. Implémentez une structure de données de file d'attente :

File d'attente de classe :

def __init__(soi) :

[Link] = []

def mettre en file d'attente (soi, élément):

[Link](0, élément)

def dequeue(self) :

renvoie [Link]()

def is_empty(soi) :
Machine Translated by Google

retourner [Link] == []

file d'attente = Queue()

file d'[Link](1)

[Link](2)

[Link](3)

print("Élément retiré de la file d'attente :", [Link]())

print("La file d'attente est vide :", queue.is_empty())

8. Calculez l’ensemble de puissance d’un ensemble :

à partir de la chaîne d'importation itertools, combinaisons

def power_set(s): return

list(chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)))

input_set = [1, 2, 3]

print("Ensemble de puissance :", power_set(input_set))

9. Échangez deux variables :

a = input("Entrez la valeur de a : ") b =

input("Entrez la valeur de b : ") a, b = b, a

print("Valeur

de a après échange :", a) print("Valeur de b après

échange :", b)

10. Imprimez les facteurs d'un nombre :

Machine Translated by Google

def print_factors(n): facteurs

= []

pour je dans la plage (1, n + 1):

si n % i == 0 :

[Link](i)

facteurs de rendement

number = int(input("Entrez un nombre : "))

print("Factors :", print_factors(number))

ENSEMBLE­6

1. Vérifiez si une chaîne est un pangramme :

chaîne d'importation

def is_pangram(s) :

alphabet = set(string.ascii_lowercase) return

set([Link]()) >= alphabet

input_string = input("Entrez une chaîne : ") if

is_pangram(input_string):

print("Pangram")

autre:

print("Pas un pangramme")

2. Calculez le volume d'un cylindre :

importer des mathématiques

Machine Translated by Google

radius = float(input("Entrez le rayon du cylindre : ")) height =

float(input("Entrez la hauteur du cylindre : ")) volume = [Link] * rayon *

rayon * hauteur print("Volume de le cylindre :", volume)

3. Vérifiez si une chaîne est un palindrome :

def est_palindrome(s) :

retourner s == s[::­1]

input_string = input("Entrez une chaîne : ") if

is_palindrome(input_string):

print("Palindrome")
autre:

print("Pas un palindrome")

4. Triez une liste de chaînes :

strings = ['pomme', 'banane', 'cerise', 'date', 'sureau'] sorted_strings

= sorted(strings) print("Chaînes triées :",

sorted_strings)

5. Générez un triangle de Pascal simple :

def generate_pascals_triangle(n):

triangle = [[1]]

pour i dans la plage (1,

n): prev_row = triangle[­1]

Machine Translated by Google

curr_row = [1] + [prev_row[j] + prev_row[j + 1] pour j dans la plage (i ­ 1)]

+ [1]

[Link] (curr_row) renvoie

le triangle

lignes = 5

print("Triangle de Pascal :") pour

la ligne dans generate_pascals_triangle(rows): print(row)

6. Implémentez un arbre de recherche binaire :

Nœud de classe :

def __init__(soi, valeur) :

[Link] = valeur

[Link] = Aucun

[Link] = Aucun

classe BinaryTree :

def __init__(self) :
[Link] = Aucun

def insert (soi, valeur):

si [Link] vaut None :

[Link] = Nœud (valeur)

autre:

self._insert_recursive([Link], valeur)

def _insert_recursive(self, nœud, valeur) :

si valeur < [Link] :
Machine Translated by Google

si [Link] vaut Aucun :

[Link] = Nœud (valeur)

autre:

self._insert_recursive([Link], valeur)
valeur elif > [Link] :

si [Link] est Aucun :

[Link] = Node(value)
autre:

self._insert_recursive([Link], valeur)

# Exemple d'utilisation :

tree = BinaryTree()

[Link](5)

[Link](3)

[Link](7)

7. Implémentez un modèle de régression linéaire :

à partir de sklearn.linear_model importer LinearRegression importer

numpy en tant que np

X = [Link]([[1, 1], [1, 2], [2, 2], [2, 3]])

y = [Link](X, [Link]([1, 2])) + 3 reg =

LinearRegression().fit(X, y) print("Coef:",

reg.coef_) print("Interception :" ,

reg.intercept_)

8. Comptez le nombre de chiffres dans un nombre entier :

Machine Translated by Google

number = int(input("Entrez un entier : "))

num_digits = len(str(abs(number)))

print("Nombre de chiffres :", num_digits)

9. Générez un mot de passe aléatoire :

importer une chaîne

d'importation aléatoire

def generate_password (longueur):

caractères = string.ascii_letters + [Link] + [Link] password =

''.join([Link](characters) pour le mot de passe de _ dans la plage (longueur))

retour

password_length = 12

print("Mot de passe généré :", generate_password(password_length))

10. Calculez la valeur exponentielle :

base = float(input("Entrez la base : "))

exponent = float(input("Entrez l'exposant : "))

résultat = base ** exposant

print("Résultat :", résultat)

ENSEMBLE­7

1. Trouvez la somme des nombres naturels en utilisant la récursion :

def sum_of_natural_numbers(n):
si n <= 1 :
Machine Translated by Google

retour m

autre:

retourner n + sum_of_natural_numbers (n ­ 1)

num = int(input("Entrez un nombre : ")) print("Somme

des nombres naturels :", sum_of_natural_numbers(num))

2. Validez une adresse IP :

prise d'importation

def is_valid_ip(ip):

essayer:

socket.inet_aton(ip)

retourner vrai

sauf [Link] :

retourner Faux

ip_address = input("Entrez une adresse IP : ") if

is_valid_ip(ip_address) :

print("Adresse IP valide")

autre:

print("Adresse IP invalide")

3. Calculez le plus grand diviseur commun (PGCD) à l'aide de la récursivité :

def pgcd(x, y) : si

y == 0 :

retourner x
Machine Translated by Google

autre:

retourner pgcd (y, x % y)

num1 = int(input("Entrez le premier chiffre : "))

num2 = int(input("Entrez le deuxième nombre : ")) print("GCD:",

gcd(num1, num2))

4. Implémentez une file d'attente à l'aide d'une liste :

File d'attente de

classe : def __init__(self) :

[Link] = []

def mettre en file d'attente (soi, élément):

[Link](0, élément)

def retirer la file d'attente (soi) :

si [Link] :

retourner [Link]()

retourner Aucun

def is_empty(soi) :

retourner [Link] == []

queue = Queue()

[Link](1)

[Link](2)

[Link](3)

print("Élément retiré de la file d'attente :", [Link]())

print("La file d'attente est vide :", queue.is_empty( ))

Machine Translated by Google

5. Calculez l'ensemble de puissance d'un ensemble en utilisant une approche itérative :

def power_set_iterative(s) : power_set

= [[]]

pour les éléments en s :

pour sub_set dans power_set[:] :

power_set.append(sub_set + [elem])

retourner power_set

input_set = [1, 2, 3]

print("Ensemble de puissance (itératif) :", power_set_iterative(input_set))

6. Imprimez le calendrier d'un mois et d'une année donnés :

importer un calendrier

year = int(input("Entrez l'année : ")) mois =

int(input("Entrez le mois : ")) print([Link](année,

mois))

7. Trouvez la médiane de trois valeurs :

def find_median(a, b, c):

retourner trié([a, b, c])[1]

num1 = float(input("Entrez le premier chiffre : ")) num2 =

float(input("Entrez le deuxième chiffre : ")) num3 = float(input("Entrez

le troisième chiffre : "))

print("Médiane :", find_median(num1, num2, num3))

Machine Translated by Google

8. Implémentez un algorithme de recherche binaire utilisant la récursion :

def binaire_search_recursive (arr, faible, élevé, x) :

si haut >= bas :

milieu = (haut + bas) // 2

si arr[mid] == x :

retour au milieu

elif arr[milieu] > x :

retourner binaire_search_recursive (arr, bas, milieu ­ 1, x)

autre:

retourner binaire_search_recursive (arr, mid + 1, high, x)

autre:

retour ­1

arr = [2, 3, 4, 10, 40]

x = 10

résultat = binaire_search_recursive(arr, 0, len(arr) ­ 1, x)

si résultat != ­1 :

print(f"Élément trouvé à l'index {result}")

autre:

print("Élément introuvable")

9. Trouvez la somme des chiffres dans un nombre :

def sum_of_digits(n):

return sum(int(digit) pour le chiffre dans str(n))

number = int(input("Entrez un nombre : "))

print("Somme des chiffres :", sum_of_digits(number))

Machine Translated by Google

10. Convertir le décimal en binaire, octal et hexadécimal :

dec = int(input("Entrez un nombre décimal : "))

print("Binaire :", bin(dec))

print("Octal :", oct(déc))

print("Hexadécimal :", hex(déc))

ENSEMBLE­8

1. Implémenter le tri par sélection :

def selection_sort(arr) : n =

len(arr) pour i

dans la plage(n) :

min_idx = i

pour j dans la plage (i + 1, n):

si arr[j] < arr[min_idx] : min_idx

=j

arr[i], arr[min_idx] = arr[min_idx], arr[i]

arr = [64, 25, 12, 22, 11]

selection_sort(arr)

print("Tableau trié :", arr)

2. Trouvez le plus grand parmi trois nombres :

a = float(input("Entrez le premier chiffre : ")) b =

float(input("Entrez le deuxième chiffre : "))

c = float(input("Entrez le troisième nombre : "))

Machine Translated by Google

max_num = max(a, b, c)
print("Plus grand nombre :", max_num)

3. Implémenter le tri par insertion :

def insertion_sort(arr) :
pour i dans range(1,
len(arr)) :
key = arr[i] j = i ­ 1
tandis que j >= 0 et clé < arr[j] :
arr[j + 1] = arr[j] j
­= 1
arr[j + 1] = clé

arr = [12, 11, 13, 5, 6]

insertion_sort(arr)
print("Tableau trié :", arr)

4. Convertir décimal en binaire :

dec = int(input("Entrez un nombre décimal : "))

binaire = bin(déc)
print("Binaire :", binaire[2:])

5. Convertir décimal en octal :

dec = int(input("Entrez un nombre décimal : "))

octal = oct(dec)
print("Octal:", octal[2:])
Machine Translated by Google

6. Convertir le décimal en hexadécimal :

dec = int(input("Entrez un nombre décimal : "))

hexadécimal = hex(dec)

print("Hexadécimal :", hexadécimal[2:])

7. Implémentez un algorithme de tri à bulles :

def bubble_sort(arr):

n = len(arr)

pour i dans la plage(n ­

1) : pour j dans la plage(0, n ­ i

­ 1) : si arr[j] > arr[j + 1] :

arr[j], arr[ j + 1] = arr[j + 1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]

bubble_sort(arr)

print("Tableau trié :", arr)

8. Trouvez le LCM et le PGCD de deux nombres :

def calculate_lcm(x, y):

lcm = (x * y) // calcul_gcd(x, y)
retourner lcm

def calculate_gcd(x, y) :

tandis

que y : x, y = y, x % y
retourner x
Machine Translated by Google

num1 = int(input("Entrez le premier nombre : "))

num2 = int(input("Entrez le deuxième nombre : "))

print("LCM:", calculate_lcm(num1, num2)) print("GCD:",

calculate_gcd (numéro1, numéro2))

9. Trouvez la factorielle d'un nombre :

def factoriel(n):
si n == 0 :

retour 1

autre:

retour m * factorielle(n ­ 1)

num = int(input("Entrez un nombre : "))

print("Factorial :", factorial(num))

10. Implémentez le tri rapide :

def quick_sort(arr) : si

len(arr) <= 1 :
retour arr

pivot = arr[len(arr) // 2] gauche

= [x pour x dans arr si x < pivot] milieu =

[x pour x dans arr si x == pivot] droite = [x pour

x dans arr si x > pivot] return

quick_sort(gauche) + milieu + quick_sort(droite)

arr = [12, 11, 13, 5, 6, 7]

sorted_arr = quick_sort(arr)
Machine Translated by Google

print("Tableau trié :", sorted_arr)

ENSEMBLE­9

1. Recherchez la somme des éléments dans une liste :

ma_liste = [1, 2, 3, 4, 5]

sum_of_elements = sum(my_list) print("Somme

des éléments :", sum_of_elements)

2. Générez une séquence de Fibonacci à l'aide d'une boucle :

def generate_fibonacci(n):

fibonacci_sequence = [0, 1] pour i

dans range(2, n) :

next_num = fibonacci_sequence[­1] + fibonacci_sequence[­2]

fibonacci_sequence.append(next_num) return

fibonacci_sequence

termes = 10

print("Séquence de Fibonacci :", generate_fibonacci(terms))

3. Calculez la valeur exponentielle à l'aide d'une boucle :

base = int(input("Entrez la base : ")) exponent =

int(input("Entrez l'exposant : "))

résultat = 1

pour _ dans la plage (exposant):

résultat *= base
Machine Translated by Google

print("Résultat :", résultat)

4. Implémentez un algorithme de recherche linéaire à l'aide d'une boucle :

def Linear_search (arr, x):

pour i in range(len(arr)) : si

arr[i] == x :

je reviens

retour ­1

arr = [4, 2, 1, 7, 5]

x=7

résultat = recherche_linéaire (arr, x)

si résultat != ­1 :

print(f"Élément trouvé à l'index {result}")

autre:

print("Élément introuvable")

5. Calculez l'aire d'un triangle à l'aide de la formule de Heron :

importer des mathématiques

a = float(input("Entrez la longueur du côté a : ")) b =

float(input("Entrez la longueur du côté b : ")) c =

float(input("Entrez la longueur du côté c : ") ) s = (a + b +

c) / 2 aire = [Link](s

* (s ­ a) * (s ­ b) * (s ­ c)) print("Aire du triangle :", aire)

Machine Translated by Google

6. Implémentez un algorithme de tri par fusion :

def merge_sort(arr):

si len(arr) > 1 :

milieu = len(arr) // 2

moitié gauche = arr[:milieu]

moitié_droite = arr[milieu :]

merge_sort (moitié_gauche)

merge_sort (moitié_droite)

je = j = k = 0

tandis que je < len (moitié_gauche) et j < len (moitié_droite) :

si moitié_gauche[i] < moitié_droite[j] :

arr[k] = moitié_gauche[i]

je += 1

autre:

arr[k] = moitié_droite[j] j +=

1
k+=1

tandis que je < len(left_half) :

arr[k] = moitié_gauche[i]

je += 1

k+=1

tandis que j < len (moitié_droite):

arr[k] = moitié_droite[j]

j += 1
Machine Translated by Google

k+=1

arr = [12, 11, 13, 5, 6, 7]

merge_sort(arr)

print("Tableau trié :", arr)

7. Trouvez l'aire d'un cercle :

importer des mathématiques

radius = float(input("Entrez le rayon du cercle : ")) area = [Link] *

radius * radius print("Zone du cercle :",

zone)

8. Implémentez un algorithme de recherche binaire à l'aide d'une boucle :

def binaire_search(arr, x):

faible = 0

high = len(arr) ­ 1

tandis que low <= high :

mid = (low + high) // 2

si arr[milieu] < x :

bas = milieu + 1

elif arr[milieu] > x :

élevé = moyen ­ 1
autre:

retour au milieu

retour ­1
Machine Translated by Google

arr = [2, 3, 4, 10, 40]

x = 10

résultat = recherche_binaire (arr, x)

si résultat != ­1 :

print(f"Élément trouvé à l'index {result}")

autre:

print("Élément introuvable")

9. Vérifiez si une chaîne est une adresse e­mail valide :

importer re

def is_valid_email(e­mail) :

return bool([Link](r"[^@]+@[^@]+\.[^@]+", email))

input_email = input("Entrez une adresse e­mail : ")

si is_valid_email(input_email) :

print("Adresse email valide")

autre:

print("Adresse email invalide")

10. Générez une liste aléatoire de nombres :

importer au hasard

random_list = [Link](range(1, 100), 5) print("Liste

aléatoire :", random_list)

ENSEMBLE­10
Machine Translated by Google

1. Trouvez le plus grand diviseur commun (PGCD) de plusieurs nombres :

importer des mathématiques

nombres = [24, 36, 48, 60, 72] pgcd

= [Link](*nombres)

print("PGCD des nombres :", pgcd)

2. Calculez l'écart type d'une liste de nombres :

statistiques d'importation

données = [1, 2, 3, 4, 5]

std_dev = [Link](data)

print("Écart type :", std_dev)

3. Générez un mot de passe aléatoire avec des exigences spécifiques :

importer une chaîne

d'importation aléatoire

def generate_password (longueur, include_digits=True,

include_special_chars=True) :

caractères = string.ascii_letters si

include_digits :

caractères += [Link]

si

include_special_chars : caractères += chaî[Link]

mot de passe = ''.join([Link](caractères) pour _ dans la plage (longueur))

retourner le mot de passe

Machine Translated by Google

password_length = 12

print("Mot de passe généré :", generate_password(password_length))

4. Implémentez une calculatrice simple :

def ajouter (x, y):

retourner x + y

def soustraire (x, y):

retourner x ­ y

def multiplier (x, y):

retourner x * et

def diviser(x, y) : si

y == 0 :

return "Impossible de diviser par zéro"

return x / y

num1 = float(input("Entrez le premier nombre : "))

num2 = float(input("Entrez le deuxième nombre : "))

print("Somme :", add(num1, num2))

print("Différence :", soustraire (numéro1, numéro2))

print("Produit :", multiplier(num1, num2))

print("Quotient :", diviser(num1, num2))

5. Vérifiez si un nombre est un nombre premier :

def is_prime(n):
si n <= 1 :
Machine Translated by Google

retourner Faux

pour i dans range(2, int(n**0.5) + 1) :

si n % i == 0 :

retourner Faux

retourner vrai

number = int(input("Entrez un nombre : ")) if

is_prime(number):

print("Nombre premier")
autre:

print("Pas un nombre premier")

6. Trier une liste de dictionnaires par une clé spécifique :

list_of_dicts = [{'name' : 'John', 'age' : 30}, {'name' : 'Jane', 'age' : 25}, {'name' : 'Bob',
'age' : 35} ] sorted_list =

sorted(list_of_dicts, key=lambda x: x['age']) print("Liste triée des

dictionnaires :", sorted_list)

7. Générez une matrice aléatoire :

importer numpy en tant que np

lignes = 3

colonnes = 3

random_matrix = [Link](lignes, colonnes)

print("Matrice aléatoire :")

print(random_matrix)
Machine Translated by Google

8. Implémentez une classe compteur :

compteur de classe :

def __init__(soi) :
[Link] = 0

incrément def (auto):

[Link] += 1

def décrémenter(soi) :
[Link] ­= 1

def réinitialiser (auto):

[Link] = 0

compteur = Compteur()

[Link]()

[Link]()

print("Count:", [Link])

[Link]()

print("Count:", [Link])

[Link]()

print("Count:", [Link])

9. Trouvez l'aire d'un rectangle :

length = float(input("Entrez la longueur du rectangle : ")) width =

float(input("Entrez la largeur du rectangle : ")) area = length *

width print("Zone du

rectangle :", zone )

Machine Translated by Google

10. Vérifiez si une chaîne est une URL valide :

importer re

def is_valid_url(url):

regex = [Link](

r'^(?:http|ftp)s?://' r'(?:

(?:[A­Z0­9](?:[A­Z0­9­]{0,61}[A­ Z0­9])?\.)+(?:[AZ]{2,6}\.?|
[A­Z0­9­]{2,}\.?)|'

r'localhost|'

r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' r'\[?[A­

F0­9]*:[A­F0­9:]+\]?)' r'(?::\d+)?'

r'(?:/?|[/?]

\S+)$', [Link]) return

[Link](regex, url) n'est pas Aucun

input_url = input("Entrez une URL : ") if

is_valid_url(input_url) :

print("URL valide")
autre:

print("URL invalide")

Merci

Veuillez consulter mon LIVRE DE PROGRAMME JAVA 100, PROGRAMME C# 100

LIVRE, LIVRE DE PROGRAMME C++ 50 sur Amazon