Le sujet SIP-TD01.pdf

Éléments de corrigé

#############
# Exercice 1
#############
print("Hello World!")

# Sous Linux ou MacOS
# La variable d'environnement USER contient le nom de login de l'utilisateur
import os
print("Hello " + os.getenv("USER") + "!")

# os.getuid() rend le numéro (ID) de l'utilisateur
# pwd.getpwuid() rend les informations concernant un utilisateur à partir de son ID. 
# La cinquième entrée (indice 4) contient le nom (real name) de l'utilisateur.
import pwd
print("Hello " + pwd.getpwuid(os.getuid())[4] + "!")

#############
# Exercice 2
#############
prenom = "John"
nom = "Doe"
age = 45
male = True

x = nom + prenom
y = age + male
z = nom + prenom + str(y)

#############
# Exercice 3
#############
# Echanger nom et prenom avec une variable temporaire
# tmp = nom
# nom = prenom
# prenom = tmp

# Echanger nom et prenom avec l'affectation sur les paires
(prenom, nom) = (nom, prenom)

print(prenom, nom)

#############
# Exercice 4
#############
# Madlib
def madlib():
   print("Let's play madlibs!")
   place=input("A place?: ")
   adj=input("An adjective?: ")
   verb=input("A verb?: ")
   animal=input("An animal?: ")
   print("The {} {} {} in {}.".format(adj, animal, verb, place))

#############
# Exercice 5
#############
# Les chaînes de caractères délimitées par trois guillemets simples
# peuvent contenir des passages à la ligne.
def tic_tac_toe():
    print(
        '''***
***
***'''
    )

#############
# Exercice 6
#############
# Jeu sur les conversions entre entiers et chaînes de caractères
# Notez bien la différence entre + appliquée à des entiers et à des chaînes
a = 90
b = "10"
c = "11"
d = 0
print(str(a) + str(int(b) + int(c)) + str(d))

#############
# Exercice 7
#############
def str_form():
    a = int (input("Donner un entier : "))
    n1 = int("{0}".format(a))
    n2 = int("{0}{0}".format(a))
    n3 = int("{0}{0}{0}".format(a))
    print(n1+n2+n3)

#############
# Exercice 8
#############
# Elever 2 à la puissance 38 s'écrit 2**38 en python.

#############
# Exercice 9
#############
def fahrenheit_to_celcius(f):
    return (f - 32) * 5 / 9

#############
# Exercice 10
#############
# L'opérateur ** est associatif à droite, donc 2**2**3 = 2**(2**3) = 2**8 = 256
# L'élévation à une puissance et la division sont prioritaires par rapport à l'addition et la soustraction
# donc la dernière expression est ((x ** 2) ** 3) + 6 - ((z / 4) * 2)
z = 2
z = z ** 2 ** 3
print(z)
x = 4
x = (x ** 2) ** 3 + 6 - z / 4 * 2
print(x)

#############
# Exercice 11
#############
# Voir https://en.wikipedia.org/wiki/Double-precision_floating-point_format
# Cette valeur est trop grande pour être représentable, elle est remplacée par l'infini
print(1.8e308)
# Cette valeur est trop petite pour être représentable, elle est remplacée par 0.0
print(1e-325)

#############
# Exercice 12
#############
import math
p = math.pi
if 22/7 < p :
    print("22/7 is less than π")
else:
    print("22/7 is greater or equal to π")
print("Relative error = " + str(100*math.fabs(22/7 - p)/p) + "%")

#############
# Exercice 13
#############
# Représentation décimale de 25
xxv_dec = str(25)
# Représentation binaire de 25
xxv_bin = bin(25)
# Représentation octale de 25
xxv_oct = oct(25)
# Représentation hexadécimale de 25
xxv_hex = hex(25)
# Affichage des différentes représentations
print("dec: {}, bin: {}, oct: {}, hex: {}".format(xxv_dec, xxv_bin, xxv_oct, xxv_hex))
# Comparaison des différentes valeurs (le 2e argument de int() donne la base dans laquelle est écrit le nombre
print(xxv_dec == int(xxv_bin,2) and xxv_dec == int(xxv_oct, 8) and xxv_dec == int(xxv_hex, 16))

#############
# Exercice 14
#############
# Attention : input() rend une chaîne de caractères. La comparaison de chaînes de caractères
# n'est pas la même chose que la comparaison d'entiers ("123" < "23", alors que 123 > 2), 
# il faut donc convertir les chaînes en entiers avant de faire la comparaison des valeurs saisies.
a = input("Donnez un nombre : ")
b = input("Donnez un nombre : ")
if type(a) is not int :
    print("la valeur saisie est de type {}.".format(type(a)))
    a = int(a)
if type(b) is not int :
    print("la valeur saisie est de type {}.".format(type(b)))
    b = int(b)
if a < b :
    print("Le maximum est {}.".format(b))
else:
    print("Le maximum est {}.".format(a))

#############
# Exercice 15
#############
# Pierre feuille ciseaux = Hi Fu Mi
import random
def Hifumi():
    options = ["Rock", "Paper", "Scissors"]
    while True :
        comp_choice = options[random.randint(0,2)]
        usr_choice = input("Your choice (R/P/S): ")
        usr_choice = usr_choice.upper()[0]
        if not usr_choice in ("R", "P", "S"):
            print("Goodbye!")
            break
        if usr_choice == comp_choice[0] :
            print("Tie")
        elif (comp_choice == "Rock" and usr_choice == "P")\
                or (comp_choice == "Paper" and usr_choice == "S")\
                or (comp_choice == "Scissors" and usr_choice == "R"):
            print("You win! (against " + comp_choice + ")")
        else:
            print("You loose! (against " + comp_choice + ")")

#############
# Exercice 16
#############
sum = 0
for n in range(1, 101) :
    sum += 1/(n*n)
print(sum)

# Nombre d'itérations nécessaires pour approcher π2/6 à 1e-6 près
sum = 0
k = 1
limit = math.pi**2/6
while math.fabs(sum - limit) > 1e-6 :
    sum += 1/(k*k)
    k += 1
print("Nb itérations pour la précision 1e-6 : {}".format(k))

#############
# Exercice 17
#############
# Ce programme affiche tous les entiers i inférieurs à n qui n'ont pas de diviseur compris entre 2 et i-1.
# Il affiche donc les nombres premiers inférieurs à n.
# Attention, le "else" se rapporte au "for", pas au "if". "print(i)" est donc exécuté 
# quand on sort naturellement du "for", pas quand on sort par le "break".
n = int ( input (" Donnez un nombre : "))
for i in range (2, n):
    for j in range (2, i):
        if i % j == 0:
            break
    else:
        print(i)

# Ce programme affiche tous les entiers compris entre 2 et n-1.
# Le "continue" ne sert à rien, la boucle for interne termine toujours normalement,
# donc la clause "else" est toujours exécutée.
n = int ( input (" Donnez un nombre : "))
for i in range (2, n):
    for j in range (2, i):
        if i % j == 0:
            continue
    else:
        print(i)

#############
# Exercice 18
#############
def fizz_buzz(n):
    for i in range(1,n):
        res = ""
        if i % 3 == 0 : # write "Fizz" for multiples of 3
            res = "Fizz"
        if i % 5 == 0 : # add "Buzz" for multiples of 5, so we have FizzBuzz for multiples of 3 and 5
            res += "Buzz"
        if len(res) == 0 : # if res is empty, just write the number
            res = str(i)
        print(res)

#############
# Exercice 19
#############
euler = 0
for i in range(1000) :
    if i % 3 == 0 or i % 5 == 0 :
        euler += i
print("Euler sum : " + str(euler))

#############
# Exercice 20
#############
def armstrong(n, p):
    sum = 0
    num = n
    while num != 0 :
        digit = num % 10
        sum += digit ** p
        num //= 10
    if n == sum :
        print("{} is an Armstrong number of order {}.".format(n, p))

#############
# Exercice 21
#############
# Python challenge 2 : http://www.pythonchallenge.com/pc/def/map.html
# Each alphabetic character is offset by two places: k becomes M, O becomes Q, E becomes G etc.
# We write a generic function that offsets the alphabetic characters of a string by a given offset
def decypher(str, offset):
    res = ''
    for l in str:
        # Look for alphabetic characters
        if (l >= 'a' and l <= 'z') or (l >= 'A' and l <= 'Z'):
            nc = ord(l) + offset     # ord() gives the code of a character
            # Check if we went beyond 'Z' and wrap down to 'A'
            if nc > ord('Z') and nc < ord('a'):
                nc = nc - ord('Z') - 1 + ord('A')
            # Check if we went beyond 'z' and wrap down to 'a'
            if nc > ord('z'):
                nc = nc - ord('z') - 1 + ord('a')
            res+=chr(nc)    # chr() builds a character from a code
        else:
            res += l        # Non alphabetic characters are just appended to the result
    print(res)

# Another version, using the functions of the str class: isalpha(), isupper() etc.
def decypher2(string, offset):
    """
    Decode a string of text by offsetting each alphabetic caracter by offset positions
    Example:
        >>> decypher2("Abc def xyZ!", 2)
        'Cde fgh zaB!'
    """
    res = ''            # Initialize the decoded string
    for l in string:    # Handle each character in turn
        if l.isalpha():   # We decode only letters
            upper = l.isupper()  # Remember if it is an upper case letter
            l = l.lower()        # and take the lowercase version
            nc = ord(l) + offset # Add the offset to the code of the character
            if nc > ord('z'):    # If it went beyond 'z', loop back from 'a'
                nc = nc - ord('z') - 1 + ord('a')
            l = chr(nc)          # Get the character corresponding to the new code
            if upper:       # If we had an uppercase letter, switch back to upper case
                l = l.upper()
        res += l        # Add the decoded (or original) character to the result
    return res