From 6813e583bb589312b071e7c90845cd2adce4c5e9 Mon Sep 17 00:00:00 2001 From: Geoffrey Frogeye Date: Fri, 10 Oct 2014 00:02:58 +0200 Subject: [PATCH] Ajout de TP 4 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Et un supplément. --- S1/TP 4/choisis.py | 101 ++++++++++++++++++++++++++++++ S1/TP 4/dichotomie.py | 122 +++++++++++++++++++++++++++++++++++++ S1/TP 4/harmonique.py | 34 +++++++++++ S1/TP 4/plusOuMoinsYOLO.py | 58 ++++++++++++++++++ S1/TP 4/rebours.py | 31 ++++++++++ S1/TP 4/suite.py | 67 ++++++++++++++++++++ S1/TP 4/tables.py | 36 +++++++++++ 7 files changed, 449 insertions(+) create mode 100644 S1/TP 4/choisis.py create mode 100644 S1/TP 4/dichotomie.py create mode 100644 S1/TP 4/harmonique.py create mode 100644 S1/TP 4/plusOuMoinsYOLO.py create mode 100644 S1/TP 4/rebours.py create mode 100644 S1/TP 4/suite.py create mode 100644 S1/TP 4/tables.py diff --git a/S1/TP 4/choisis.py b/S1/TP 4/choisis.py new file mode 100644 index 0000000..1bc8fe6 --- /dev/null +++ b/S1/TP 4/choisis.py @@ -0,0 +1,101 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Choisis un nombre +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + + +from random import randint + +# [Q1] Que fait la fonction randint ? + +# Utilisée sous la forme randint(a, b), a et b étant des entiers, elle retourne +# un entier pseudo-aléatoire entre a et b (différent à chaque éxecution) + +# [Tests] +# >>> randint(0, 100) +# 39 +# >>> randint(-500, 500) +# -161 +# >>> randint(0, 1) +# 1 + +# [Q2] Créez une variable nommée mystere contenant un nombre entier +# tiré (pseudo-)aléatoirement entre 1 et 100. +mystere = randint(0, 100) + +# [Q3] Que fait la fonction input ? + +# Utilisée sous la forme input(a), elle affiche le texte a et autorise la +# saisie dans le terminal tout en bloquant l'execution du script. Après l'appui +# de la touche Entrée, la fonction se débloque et renvoie le texte de la saisie + +# Quel est le type des valeurs renvoyées par cette fonction ? + +# Le type renvoyé par input est une chaîne de caractrèes () + +# [Q4] Écrivez une ou plusieurs instructions qui demandent à +# l’utilisateur d’entrer un nombre. + +# print("[Q4]") +# reponse1 = input("En quelle année a été assassiné Louis XVI ? ") +# reponse2 = input("Quelles sont les 10 premières décimales de π ? ") +# reponse3 = input("J'ai dix billes que je partage équitablement entre trois \ +# de mes camarades, combien me reste-t-il de bille(s) ? ") + +# [Q5-7] (le code est majoritairement issu de la Q5, ce qui a été +# ajouté après est identifié comme telen commentaire) +def jeu(): + """ + Lance un jeu de + ou -. + + CU : nombre minimum inférieur au nombre maximum, + nombre d'essais supérieur à 0 + """ + print("Jeu du + ou -") + continuer_jeu = True # Cette variable permet de savoir si il faut continuer + # à demander un nombre ou non. + + # On demande au joueur les valeurs avec lesquels il veut jouer + minimum = int(input("Entrez le nombre minimum : ")) # Q7 + maximum = int(input("Entrez le nombre maximum : ")) # Q7 + assert(minimum < maximum), "Le nombre minimum doit être inférieur au \ + nombre maximum" # Q7 + maxEssais = int(input("Entrez le nombre d'essais : ")) # Q7 + assert(maxEssais > 0), "Le nombre d'essais doit être supérieur à 0" # Q7 + # minimum = 1 # Pré-Q7 + # maximum = 100 # Pré-Q7 + # maxEssais = 1 # Pré-Q7 + essais = 0 # Comptabilise les essais réalisés + # J'utilise un autre nom de variable pour être conforme à la règle PEP 3104 + mystere2 = randint(minimum, maximum) # On pioche le nombre mystère + # print("Nombre à trouver :", mystere2) # Décommenter pour tricher + while continuer_jeu: + proposition = int(input("Entrez un nombre entre "+str(minimum)+" et "+\ + str(maximum)+" ("+str(maxEssais - essais)+" essais restants): ")) + if proposition >= minimum and proposition <= maximum: # Si le nombre est + # en dehors de l'intervalle, on ne fait rien (pas même compter un essai) + # et on revient à l'affichage du essage + if proposition == mystere2: + print("C'est GAGNÉ") + continuer_jeu = False # On coupe la boucle + else: # Ce décalage permet, en cas de victoire, de ne pas afficher + # comme quoi le nombre d'essai est dépassé ni de compter un essai + # supplémentaire + essais += 1 # On comptabilise l'essai + if proposition < mystere2: # Si le nombre est inférieur + print("C'est PLUS") + elif proposition > mystere2: # Si le nombre est supérieur + print("C'est MOINS") + if essais >= maxEssais: # Q6 + print("Vous avez dépassé le nombre d'essais autorisés") # Q6 + continuer_jeu = False # Q6 + score = int((7**2 * (maximum - minimum))/(maxEssais*99)-essais) # Q7 + # J'utilise cette méthode de calcul de score car : + # - Elle donne les mêmes résultat que le jeu décrit dans le sujet pour un + # intervalle de [1,100] et un nombre d'essai de 7 + # - Elle est est proportionelle à l'intervalle entre les bornes du choix + # - Elle est est inversement proportionelle au nombre d'essais donné + # - Elle me parait relativement équitable + # - Elle est tronquée pour la lisibilité + + # score = 7 - essais # Pré-Q7 + print("Vous avez marqué", score, "points.") diff --git a/S1/TP 4/dichotomie.py b/S1/TP 4/dichotomie.py new file mode 100644 index 0000000..f4d17a0 --- /dev/null +++ b/S1/TP 4/dichotomie.py @@ -0,0 +1,122 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Recherche de zéro par dichotomie +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + +import doctest + +# [Q1] Définissez en Python la fonction f. +def f(x): + """ + Renvoie la valeur x**2-3 + + CU : x réel positif + + Exemple : + >>> f(0) + -3 + >>> f(42) + 1761 + """ + assert((type(x) is int or type(x) is float) and x >= 0), \ + "x doit être un réel positif" + + return x**2-3 + +# [Q2] Créez deux variables a et b, puis calculez f(a) et f(b) +a = 0 +b = 2 + +f_a = f(a) # -3 +f_b = f(b) # 1 + +# [Q2] Calculez aussi la longueur de l’intervalle [a,b]. +intervalle = b-a + +# [Q3] Créez une variable c puis calculez f(c). +c = intervalle/2+a # 1 +f_c = f(c) # -2 + +# [Q3] Doit-on chercher le zéro de f dans l’intervalle ]a,c[ ou dans +# l’intervalle ]c,b[ ? + +# f(c) vaut -2, donc 0 ∈ [f(c);f(b)], donc on doit chercher le zéro de f dans +# ]c,b[ + +# [Q4] Écrivez une fonction zero qui prend un paramètre epsilon +# strictement positif et qui renvoie une approximation du zéro de f à epsilon +# / 2 près. +def zero(epsilon): + """ + Renvoie une approximation du zéro de f à epsilon/2 près. + + CU : epsilon doit être un réel supérieur à 0 + + Exemple : + >>> zero(0.1) + 1.6875 + >>> zero(0.00001) + 1.7320480346679688 + """ + assert((type(epsilon) is int or type(epsilon) is float) and epsilon >= 0), \ + "epsilon supérieur à 0" + + # Pour être conforme à la règle PEP 3104 + mini = a + maxi = b + + while maxi - mini >= epsilon: + milieu = (maxi - mini)/2+mini + if f(milieu) > 0: + maxi = milieu + else: + mini = milieu + return milieu + +# [Q5] Modifiez votre fonction zero pour qu’elle accepte en paramètres +# n’importe quelle fonction continue strictement monotone et n’importe quel +# intervalle initial contenant le zéro de cette fonction. +def fTest(x): # Fonction fournie pour tester zeroGenrique + """ + Renvoie la valeur x**3-4 + + CU : x réel + + Exemple : + >>> f(0) + -3 + >>> f(42) + 1761 + """ + assert((type(x) is int or type(x) is float)), \ + "x doit être un réel" + + return x**3-4 + +def zeroGenerique(fonction, mini, maxi, epsilon): + """ + Renvoie une approximation du zéro de la fonction f entre mini et maxi + à epsilon/2 près. + + CU : fonction E → F continue et monotone avec E,F ⊂ ℝ, mini,maxi ∈ E, + mini>> zeroGenerique(fTest, -10, 10, 0.001) + 1.5875244140625 + """ + assert(type(mini) is int or type(mini) is float), "mini doit être un réel" + assert(type(maxi) is int or type(maxi) is float), "maxi doit être un réel" + assert(mini < maxi), "mini doit être inférieur à maxi" + assert((type(epsilon) is int or type(epsilon) is float) and epsilon >= 0), \ + "epsilon doit être un réel supérieur à 0" + + while maxi - mini >= epsilon: + milieu = (maxi - mini)/2+mini + if fonction(milieu) > 0: + maxi = milieu + else: + mini = milieu + return milieu + +def tester(): + doctest.testmod(verbose=True) diff --git a/S1/TP 4/harmonique.py b/S1/TP 4/harmonique.py new file mode 100644 index 0000000..edabe11 --- /dev/null +++ b/S1/TP 4/harmonique.py @@ -0,0 +1,34 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Série harmonique alternée +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + +import doctest + +# [Q1] Écrivez une fonction somme_partielle +def somme_partielle(n): + """ + Renvoie la valeur de la somme de i=1 à n de (-1)^i/i. + + CU : n entier + + Exemple : + >>> somme_partielle(5) + -0.7833333333333332 + >>> somme_partielle(3145) + -0.6933061377964356 + """ + assert(type(n) is int), "n doit être un entier" + + somme = 0 + for i in range(1, n+1): + # On simplifie (-1)**i pour éviter de faire + # trop de calculs + if i % 2 == 0: # Si i est pair + i_puissance = 1 # (-1)**i = 1 + else: # Si i est impair + i_puissance = -1 # (-1)**i = 1 + somme += i_puissance/i + return somme + +def tester(): + doctest.testmod(verbose=True) diff --git a/S1/TP 4/plusOuMoinsYOLO.py b/S1/TP 4/plusOuMoinsYOLO.py new file mode 100644 index 0000000..4a0caaf --- /dev/null +++ b/S1/TP 4/plusOuMoinsYOLO.py @@ -0,0 +1,58 @@ +# Du gros n'importe quoi pour la déconnade + +from random import * +from time import sleep + +def dire(propositions="", fin="\n"): + if propositions == "": + sleep(1) + else: + phrase = choice(propositions) + for i in range(0, len(phrase)): + print(phrase[i], end='') + if phrase[i] in ['.', ',', '!', '?', '\n']: + sleep(0.5) + else: + sleep(0.02) + print(end=fin) + +def jeu(): + continuer_jeu = True + + minimum = 1 + maximum = 100 + maxEssais = 7 + essais = 0 + mystere = randint(minimum, maximum) + dire() + if random() < 1: + dire(["Donc je prend un nombre, tu vois, genre "+str(mystere)+", et tu dois le trouver, OK ?", str(mystere-2)+" ? "+str(mystere-1)+" ? "+str(mystere)+", c'est bien ça, "+str(mystere)+"...", str(mystere)+". EUH ! C'est pas "+str(mystere)+", pas du tout !"]) + else: + dire(["Ayé, trouvé !", "Attends je cherche un nombre sympa...\nC'est bon !", "...\nAh oui ! Un nombre.\n...\nVoilà !","Je viens de penser à un nombre, tu vas devoir le trouver."]) + while continuer_jeu: + dire() + dire(["Vas-y, je t'écoute.","Alors ?","Un nombre entre 1 et 100, oublie pas.","Euh, je crois que j'ai oublié le nombre...\n\nAh non, c'est bon ! Je l'ai retrouvé !", "Rzzz...\nRzzz...\nRzzz...\nHmm ? Ah oui, pardon.", "ATTENTION, DERRIÈRE TOI, UNE GUÈPE !\n\nNon je déconne, je voulais te faire perdre où tu en étais.","Nous t'écoutons.","Mais, qui es-tu ?\nAh oui, c'est vrai, tu viens jouer.","Comment tu t'appelle ?\nAh non, c'est pas ça la question.","Poooo, Polytech !\nOui pardon je t'écoute","CECI EST UN HOLD-UP, DONNE MOI TON NOMBRE !"], " ") + proposition = int(input()) + if proposition >= minimum and proposition <= maximum: + essais += 1 + if proposition == mystere: + dire(["C'est GAGNÉ", "C'est ça. Je crois","Eh, mais comment t'as fait ?","C'est PLUS.\n\n\nEuh, attends, non, c'est ça ! T'as gagné là !","C'est pas ça ? Ah si, c'est ça.","Non, tu n'as pas gagné, c'est pas ça.","Putain !\nT'as triché non ?","Alors là, non, t'as triché c'est pas possible","Tricheur."]) + continuer_jeu = False + elif proposition < mystere: + dire(["C'est PLUS","C'est un peu plus","C'est plus, c'est moins, en tout cas c'est pas ça.","T'es juste en dessous !","Trop bas","Ah ah, je te dirai rien !","Sérieusement, tu crois ? Bah non, c'est PLUS.","Non, c'est beaucoup plus","Même mon chat il joue mieux !"]) + elif proposition > mystere: + dire(["C'est MOINS","C'est un peu moins","C'est moins, c'est plus, en tout cas c'est pas ça.","T'es juste au dessus !","Trop haut","Mouhahah, tu crois que je vais parler ?","Vraiment, tu pense ? Eh non, c'est MOINS.","Non, c'est beaucoup moins","Même mon chien il joue mieux !"]) + if essais >= maxEssais and continuer_jeu: + dire(["DING ! T'as épuisé tout ton crédit !","Fini ! Concentre-toi un peu","Perdu ! Et ça se dit pro...","Eh, réflechi un peu de temps en temps !"]) + continuer_jeu = False + score = int((7**2 * (maximum - minimum))/(maxEssais*99)-essais+1) + if score >= 4: + dire([str(score)+" points, c'est pas mal.","T'as marqué "+str(score)+" points. Bien !","T'ain, t'as tout déchiré ! "+str(score)+" points !","Tu vas me ruiner avec tes "+str(score)+" points !\nAh, non, c'est pas un jeu d'argent","Tu m'énerve...\nTellement que je te dirais pas que t'as "+str(score)+" points.","Ah le salaud !"]) + else: + dire(["Noob. "+str(score)+" points c'est digne d'un noob.","OH MON DIEU ! C'EST EXTRAORDINAIRE ! "+str(score)+" POINTS !\nAh non c'est naze en fait.","Et ça se dit pro avec ses "+str(score)+" points !",str(score)+"/7, insuffisant.",str(score)+" points. T'as ton bac au moins ?","HAHA LE NUL ! QUE "+str(score)+" POINTS !"+"Nul, nul, nul."]) + +dire(["Yo ! Bienvenue au jeu du plus ou moins !", "Salut ! Ça roule ? Tu veux jouer avec moi au plus ou moins ?", "...\nAh, salut ! Tu veux jouer au plus ou moins ?"]) +while True: + jeu() + dire("", "\n\n\n") + dire(["On refait une partie ?", "Toujours là ? Bon, eh bah c'est reparti !", "Tu t'arrête quand ?", "Bon, on en refait une, je peux pas rester sur une défaite.", "Allez on rejoue !"]) diff --git a/S1/TP 4/rebours.py b/S1/TP 4/rebours.py new file mode 100644 index 0000000..6374c76 --- /dev/null +++ b/S1/TP 4/rebours.py @@ -0,0 +1,31 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Compte à rebours +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + + +# [Q1] Programmez une procédure nommée compte_a_rebours +def compte_a_rebours(depart): + """ + Affiche le décompte jusque 0 à partir de depart. + + CU : depart entier > 0 + """ + assert(type(depart) is int and depart > 0), \ + "depart doit être un entier supérieur à 0" + + for i in range(depart, -1, -1): + print(i) + +# [Test] +# >>> compte_a_rebours(10) +# 10 +# 9 +# 8 +# 7 +# 6 +# 5 +# 4 +# 3 +# 2 +# 1 +# 0 diff --git a/S1/TP 4/suite.py b/S1/TP 4/suite.py new file mode 100644 index 0000000..31c2a74 --- /dev/null +++ b/S1/TP 4/suite.py @@ -0,0 +1,67 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Suite arithmético-géométrique +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + +import doctest + +# [Q1] Créez une variable u_0, u_1 et u_2 +u_0 = 0 +u_1 = 3*u_0+1 +u_2 = 3*u_1+1 + +# [Q2] Définissez une fonction u_terme qui renvoie la valeur de u_n. +def u_terme(n): + """ + Renvoie la valeur de u_n. + + CU : n ≥ 0 + + Exemple: + >>> u_terme(0) + 0 + >>> u_terme(59) + 7065193045869367252382405533 + """ + assert(type(n) is int and n >= 0), "n doit être un entier positif" + + u = 0 + for i in range(1, n+1): + u = 3*u+1 + return u + +# [Tests] +# >>> print(u_terme(0), u_0) +# 0 0 +# >>> print(u_terme(1), u_1) +# 1 1 +# >>> print(u_terme(2), u_2) +# 4 4 + + +# [Q3] Ecrivez une fonction atteint +def atteint(M): + """Renvoie le rang à partir duquel les termes de la suite u sont supérieurs + à M. + + CU : M numérique + + Exemple: + >>> atteint(50623334) + 17 + >>> atteint(299792458) + 19 + """ + assert(type(M) is int or type(M) is float), "M doit être un numérique" + + # On pourrait utiliser la fonction u_terme(), mais celle-ci calcule tous + # les termes de u_0 à u_n à chaque appel. Si l'on parcourt la suite + # directement depuis cette fonction, on évite les calculs superflus + u = 0 + n = 0 + while u <= M: + n += 1 + u = 3*u+1 + return n + +def tester(): + doctest.testmod(verbose=True) diff --git a/S1/TP 4/tables.py b/S1/TP 4/tables.py new file mode 100644 index 0000000..f1f2bbf --- /dev/null +++ b/S1/TP 4/tables.py @@ -0,0 +1,36 @@ +# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015 +# TP n°4 donné le 3/10/2014 - Tables de multiplication +# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/tp_iteration_conditionnelle.html + +# [Q1] Écrivez une procédure qui affiche la table de multiplication par +# un nombre k sous la forme donnée ci-après. +def imprimer_table(k): + """ + Affiche la table de multiplication par un nombre k. + + CU : k entier + """ + assert(type(k) is int), "k doit être un entier" + + for i in range(1, 11): + print(k, "×", i, "=", k*i) + +# [Test] +# >>> imprimer_table(7) +# 7 x 1 = 7 +# 7 x 2 = 14 +# 7 x 3 = 21 +# 7 x 4 = 28 +# 7 x 5 = 35 +# 7 x 6 = 42 +# 7 x 7 = 49 +# 7 x 8 = 56 +# 7 x 9 = 63 +# 7 x 10 = 70 + +# [Q2] Donnez une séquence d’instructions permettant d’avoir l’affichage +# de toutes les tables de multiplication de 1 jusqu’à 10. +# (En commentaire pour éviter de polluer la console) + +for table in range(1, 11): + imprimer_table(table)