From b4067cebc30c2432d9cdfe924d0746d808af02b6 Mon Sep 17 00:00:00 2001 From: Koffi Gantchou <koffi.gantchou.etu@univ-lille.fr> Date: Thu, 23 Jan 2025 14:43:36 +0100 Subject: [PATCH] Upload New File tp 2 en cours --- recursivite.py | 345 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 345 insertions(+) create mode 100644 recursivite.py diff --git a/recursivite.py b/recursivite.py new file mode 100644 index 0000000..d214f30 --- /dev/null +++ b/recursivite.py @@ -0,0 +1,345 @@ +#!/usr/bin/python3 +# -*- coding: utf-8 -*- + +# Noms :gantchou +# Prenoms :koffi +# Groupe :13 +# Date :23/01/2025 + + + +""" + +:mod: module `recursivite` +:author: FIL - Faculté des Sciences et Technologies - Univ. Lille +:link: <http://portail.fil.univ-lille1.fr>_ +:date: Mars 2020 +:dernière révision: janvier 2024 + +""" + +from ap_decorators import count, trace +# l'instruction suivante permet d'annoter des paramètres qui sont des functions. +from collections.abc import Callable + + +def taille_binaire(naturel: int) -> int: + """ + Renvoie le nombre de chiffres dans l'écriture binaire de l'entier naturel `naturel` + + Précondition : + naturel >= 0 + + Exemples : + $$$ taille_binaire(0) + 1 + $$$ taille_binaire(1) + 1 + $$$ taille_binaire(2) + 2 + $$$ taille_binaire(1023) + 10 + $$$ taille_binaire(1024) + 11 + $$$ from random import randrange + $$$ l = [randrange(1,2**100) for _ in range(100)] + $$$ all(taille_binaire(elt) == len(bin(elt))-2 for elt in l) + True + + """ + res = 1 + while naturel >= 2: + res += 1 + naturel //= 2 + return res + +def taille_binaire_recursive(naturel: int) -> int: + """ + Renvoie le nombre de chiffres dans l'écriture binaire de l'entier naturel `naturel` + + Précondition : + naturel >= 0 + + Exemples : + $$$ taille_binaire_recursive(0) + 1 + $$$ taille_binaire_recursive(1) + 1 + $$$ taille_binaire_recursive(2) + 2 + $$$ taille_binaire_recursive(1023) + 10 + $$$ taille_binaire_recursive(1024) + 11 + $$$ from random import randrange + $$$ l = [randrange(1,2**100) for _ in range(100)] + $$$ all(taille_binaire_recursive(elt) == len(bin(elt))-2 for elt in l) + True + """ + if naturel==1 or naturel ==0: + res=1 + else: + naturel //=2 + res=taille_binaire_recursive(naturel) + res+=1 + return res + + +def poids_binaire(naturel: int) -> int: + """ + Renvoie le nombre de chiffre 1 dans l'écriture binaire de l'entier naturel `naturel` + + Précondition : + naturel >= 0 + + Exxemples : + + $$$ poids_binaire(0) + 0 + $$$ poids_binaire(1) + 1 + $$$ poids_binaire(2) + 1 + $$$ poids_binaire(255) + 8 + $$$ from random import randrange + $$$ l = [randrange(1,2**100) for _ in range(100)] + $$$ all([poids_binaire(x)==bin(x).count('1') for x in l]) + True + """ + res = naturel % 2 + while naturel > 0: + naturel //= 2 + res += naturel % 2 + return res + + +def poids_binaire_recursif(naturel: int) -> int: + """ + Renvoie le nombre de chiffre 1 dans l'écriture binaire de l'entier naturel `naturel` + + Précondition : + naturel >= 0 + + Exxemples : + + $$$ poids_binaire_recursif(0) + 0 + $$$ poids_binaire_recursif(1) + 1 + $$$ poids_binaire_recursif(2) + 1 + $$$ poids_binaire_recursif(255) + 8 + $$$ from random import randrange + $$$ l = [randrange(1, 2**100) for _ in range(100)] + $$$ all([poids_binaire_recursif(x)==bin(x).count('1') for x in l]) + True + """ + if naturel==0: + return 0 + else: + return (naturel%2)+ poids_binaire_recursif(naturel//2) + +def puissance(x: int|float, n: int) -> int|float: + """ + Calcule x élevé à la puissance n + + Précondition : + n>=0 + + Exemples : + + $$$ puissance(10, 0) + 1 + $$$ puissance(10, 1) + 10 + $$$ puissance(2, 10) + 1024 + """ + if n==0: + return 1 + elif n%2==0: + half= puissance(x,n//2) + return half*half + else: + return x*puissance(x,n-1) + + +def puissance_v2(x: int|float, n: int) -> int|float: + """ + calcule x élevé à la puissance n + + Précondition : n>=0 + + Exemples : + $$$ puissance_v2(10,0) + 1 + $$$ puissance_v2(10,1) + 10 + $$$ puissance_v2(2,10) + 1024 + """ + if n==0: + return 1 + elif n == 1: + return x + else: + return fois(x, puissance_v2(x,n-1)) + +@count +def fois(x: int|float, y: int|float) -> int|float: + """ + renvoie le produit de x par y + + Précondition : les mêmes que l'opérateur * + + Exemples : + $$$ fois(8, 7) + 56 + """ + return x * y + +# le parametre de comptage est la fonction puissance +# le resultat est une liste d'entier comptant le nombre de solutions fournis par la puissance + +def comptage(puissance: Callable[[int|float, int], int|float]) -> list[int]: + """ + Renvoie une liste de longueur 100 contenant le nombre de multiplications + effectuées par la fonction ``puissance`` passée en paramètre + + Précondition : + la fonction doit être implantée en utilisant la fonction ``fois`` + """ + res = [] + for i in range(100): + fois.counter = 0 + _ = puissance(2, i) + res.append(fois.counter) + return res +#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +#on obtient ce resultat car on a pas fait appel a la fonction fois decoré par "count" +# [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98] +# une expression en fonction de n est n-1 +# + + + +#@trace +def puissance_calbuth(x: int|float, n: int) -> int|float: + """ + calcule x élevé à la puissance n + + Précondition : + n>=0 + + Exemples : + + $$$ puissance_calbuth(10,0) + 1 + $$$ puissance_calbuth(10,1) + 10 + $$$ puissance_calbuth(2,10) + 1024 + + """ + if n == 0: + return 1 + if n == 1: + return x + else: + k = n // 2 + return puissance_calbuth(x, k) * puissance_calbuth(x, n - k) + +def puissance_calbuth_v2(x: int|float, n: int) -> int|float: + """ + calcule x élevé à la puissance n + + Précondition : + n>=0 + + Exemples : + + $$$ puissance_calbuth_v2(10,0) + 1 + $$$ puissance_calbuth_v2(10,1) + 10 + $$$ puissance_calbuth_v2(2,10) + 1024 + + """ + if n == 0: + return 1 + if n == 1: + return x + else: + k = n // 2 + return fois(puissance_calbuth_v2(x, k) , puissance_calbuth_v2(x, n - k)) + +# oui ça permet de diminuer la complexite de multiplications +# ça permet de ne pas gerer les cas ou la puissance est paire ou impaire + +def puissance_calbuth_v2_amelioree(x: int|float, n: int) -> int|float: + """ + calcule x élevé à la puissance n + + Précondition : + n>=0 + + Exemples : + + $$$ puissance_calbuth_v2_amelioree(10,0) + 1 + $$$ puissance_calbuth_v2_amelioree(10,1) + 10 + $$$ puissance_calbuth_v2_amelioree(2,10) + 1024 + + """ + + +def puissance_erronee(x: int|float, n: int) -> int|float: + """ + aurait dû calculer x élevé à la puissance n + + Précondition : + n >= 0 + + Exemples : + + $$$ puissance_erronee(10, 0) + 1 + $$$ puissance_erronee(10, 1) + 10 + $$$ #$$$ puissance_erronee(2, 10) + $$$ #1024 + """ + if n == 0: + return 1 + elif n == 1: + return x + else: + r = n % 2 + q = n // 2 + return puissance_erronee(x, r) * puissance_erronee(puissance_erronee(x, q), 2) + +def puissance_reparee(x: int|float, n: int) -> int|float: + """ + calcule x élevé à la puissance n + + Précondition : + n>=0 + + Exemples : + + $$$ puissance_reparee(10,0) + 1 + $$$ puissance_reparee(10,1) + 10 + $$$ puissance_reparee(2,10) + 1024 + """ + ... + + + -- GitLab