Python

Les tuples
Exercices pour débuter

Rappels utiles

Ces exercices doivent être utilisés pour vous entraîner à programmer. Ils sont généralement accompagnés d'aide et de leur solution pour vous permettre de progresser.

Avant de vous précipiter sur ces solutions dès la première difficulté, n'oubliez pas les conseils suivants :

Fonction parité

Question 1

Complétez la définition de la fonction parite() qui prend pour paramètre un tuple t et renvoie un tuple de même longueur contenant un 0 lorsque l'élément correspondant de t est pair, un 1 sinon. 


def parite(t):
    """
    t – tuple, n-uplet d’entiers naturels
    Sortie: tuple – n-uplet de même longueur que t contenant :
            0 si l’élément de même rang dans t est pair
            1 si l’élément de même rang dans t est impair
    >>> parite( (3, 2, 6) )
    (1, 0, 0)
    """

Question 2

On souhaite tester la fonction parité avec un tuple contenant des valeurs aléatoires. Rédiger une fonction alea() qui prend pour paramètre un entier n positif et renvoie un tuple t qui contient des valeurs aléatoires entre 0 et 99. Vous pourrez utiliser une boucle for qui crée un tuple par concaténation. Ne pas oublier d'importer le module random qui donne accès à randint()


def alea(n):
    """
    n - entier
    Sortie: tuple – n-uplet contenant n valeurs aléatoires entre 0 et 99
    >>> alea( 4 )
    (31, 71, 98, 63)
    """

Question 3

Regroupez les 2 codes précédents dans un unique programme afin de tester la fonction parite() dans le « main » du programme à l'aide de 5 tuples générés aléatoirement.

  • Une piste ?
  • Vous avez dit parité ?
  • Manipuler un tuple de longueur 1...
  • Une solution Question 1
  • Une piste Question 2 ?
  • Une solution Question 2
  • Une solution Question 3
Il va falloir renvoyer et donc construire un nouveau tuple...
Avec %2, on peut savoir si un nombre est pair...
Un tuple de longueur 1 s'écrit de la sorte : (valeur, ) 

def parite(t):
    """
    t – tuple, n-uplet d’entiers naturels
    Sortie: tuple – n-uplet de même longueur que t contenant :
            0 si l’élément de même rang dans t est pair
            1 si l’élément de même rang dans t est impair
    >>> parite( (3, 2, 6) )
    (1, 0, 0)
    """
    reponse = ()                # Création d’un tuple « vide »
    for valeur in t:
        reponse = reponse + (valeur%2, )
    return reponse
C'est comme la question 1, sauf qu'on n'ajoute pas la même chose dans le tuple. 
							
from random import randint

def alea(n):
    """
    n - entier
    Sortie: tuple – n-uplet contenant n valeurs aléatoires entre 0 et 99
    >>> alea( 4 )
    (31, 71, 98, 63)
    """
    generation = ()                # Création d’un tuple « vide »
    for i in range(n):
        generation = generation + (randint(0,100), )
    return generation
						
							
for i in range(5):
    t = alea(10)  # 10 est choisi arbitrairement
    print(t)
    u = parite(t)
    print(u)
    print()

Fonctions sur le temps

Question 1

Copiez/collez et complétez le corps de la fonction temps_secondes() qui renvoie le temps en secondes correspondant au cumul de h heures, m minutes et s secondes.


def temps_seconde(h, m, s):
    """
    h, m, s – int, triplet d’entiers positifs
    Sortie: int – temps en secondes égal à h heures,
            m minutes et s secondes
    >>> temps_seconde(1, 2, 3)
    3723
    >>> temps_seconde(2, 0, 1)
    7201
    """

Question 2

Copiez/collez et complétez le corps de la fonction a fonction sec_to_heure() qui prend pour paramètre un nombre entier de secondes et qui renvoie la valeur correspondante sous forme d'un triplet (heures, minutes, secondes). 

def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """
  • Une piste Question 1 ?
  • Une solution Question 1
  • Une piste Question 2 ?
  • Une solution Question 2
  • Une autre solution Question 2
Un simple return doit suffire. N'oubliez pas de tester ! 

def temps_seconde(h, m, s):
    """
    h, m, s – int, triplet d’entiers positifs
    Sortie: int – temps en secondes égal à h heures,
            m minutes et s secondes
    >>> temps_seconde(1, 2, 3)
    3723
    >>> temps_seconde(2, 0, 1)
    7201
    """
    return h*3600 + m*60 + s
Pour cela, on utilisera astucieusement la division euclidienne et le modulo. 
							
def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """
    h = s//3600
    reste = s%3600
    m = reste//60
    s = reste%60
    return h, m, s
						
							
def sec_to_heure(s):
    """
    s – int
    Sortie: triplet – conversion de s secondes en un
            triplet (heure, minute, seconde)
    >>> sec_to_heure(3723)
    (1, 2, 3)
    >>> sec_to_heure(7201)
    (2, 0, 1)
    """
    h = s//3600
    m = (s%3600)//60
    s = (s%3600) % 60
    return h, m, s

Fonction coïncidence()

Copiez/collez et complétez le corps de la fonction coincidence() en respectant ses spécifications. 


def coincidence(t):
    """
    t – tuple, n-uplet d'entiers positifs ou nuls
    Sortie: int – nombre de valeurs égales à leur indice
    >>> coincidence( (3, 2, 6) )
    0  # Aucun indice
    >>> coincidence( (3, 1, 6) )
    1  # Indice 1
    >>> coincidence( (0, 1, 6, 3) )
    2  # Indices 0 et 1
    """
  • Une piste Question 1 ?
  • Une solution
Parcourir le tuple et comparer l'élément parcouru avec son indice. 

def coincidence(t):
    """
    t – tuple, n-uplet d'entiers positifs ou nuls
    Sortie: int – nombre de valeurs égales à leur indice
    >>> coincidence( (3, 2, 6) )
    0
    >>> coincidence( (3, 1, 6) )
    1
    >>> coincidence( (0, 1, 6, 3) )
    3
    """
    nb_coincidences = 0
    for i in range(len(t)):
        if t[i] == i:
            nb_coincidences = nb_coincidences+1
    return nb_coincidences