Skip to content

QCM☘

Rappel

L'épreuve de fin de première pour ceux qui ne continuent pas la spéciliaté NSI en terminale est une épreuve de QCM.

La règle est la suivante:

  • Vous devez choisir entre 4 réponses, dont une seule est correcte.
  • Une bonne réponse est comptée +3 points.
  • Une mauvaise réponse est comptée -1 point.
  • Une absence de réponse est comptée +0 point.
  • Plusieurs réponses revient à ne pas répondre (+0 point).

Il faut apprendre à répondre à ce type de QCM: une mauvaise réponse c'est -4 points par rapport à quelqu'un qui répond correctement. Dans l'incertitude, il faut donc savoir ne pas répondre.

QCM 1☘

On dispose de listes d'entiers positifs. On veut écrire une fonction renvoyant le produit de deux éléments (d'indices différents) tel que ce produit soit le plus grand possible.

Par exemple:

f([ 3, 2, 6, 9, 3, 9]) = 81

f([11, 3, 2, 6, 9, 3, 9]) = 99

Quelle fonction ne convient pas?

A.

1
2
3
def f(t):
    t.sort()
    return t[-1]*t[-2]

B. On rappelle que l'on a -float('Inf') < a pour toute valeur a de type int.

1
2
3
4
5
6
7
8
def f(t):
    pm =  -float('Inf')
    for i in range(len(t)-1):
        for j in range(i+1, len(t)):
            p = t[i]*t[j]
            if p > pm:
                pm = p
    return pm

C.

1
2
3
4
5
6
def f(t):
    m1 = max(t)
    i = t.index(m1)  
    t2 = [ t[k] for k in range(len(t)) if k != i ]
    m2 = max(t2)
    return m1 * m2

D.

1
2
3
4
5
def f(t):
    m1 = max(t)
    t2 = [ x for x in t if x != m1 ]
    m2 = max(t2)
    return m1 * m2
Réponse

La réponse est D.

  • En A, on trie la liste, puis on calcule le produit des deux derniers éléments (qui sont bien les deux plus grands).

  • En B, pour t = [ a_0, a_1, a_2, ..., a_k], on calcule a_0a_1, a_0a_2, ... a_0a_k, puis a_1a_2, a_1a_3, ..., a_1a_k, ... et ainsi de suite jusqu'à a_{k-1}a_k. Et on affecte à pm le résultat à chaque fois que la valeur trouvée est plus grande que celles trouvées auparavant. Le produit obtenu est donc le plus grand possible: c'est donc le produit des deux entiers naturels les plus grands.

  • En C, on détermine le maximum m_1 de la liste puis un indice i d'une occurrence de ce maximum m_1 dans la liste. On détermine ensuite le maximum m_2 de la liste privée du seul élément d'indice i. Le code donne le bon résultat.

  • En D, par contre, après avoir déterminé m_1, on définit m_2 comme étant le maximum de la liste privée de toutes les occurrences de m_1. Si par exemple, t = [9, 9, 2, 3], on aura m_1 =9, puis m_2 = max([2,3]) = 3. On obtiendra donc le produit 9\times 3 au lieu du produit 9\times 9.

QCM 2☘

On considère le programme suivant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def maxi(tab):
    """
    tab est une liste de couples (nom, note)
    où nom est de type str
    et où note est un entier entre 0 et 20.
    """
    m = tab[0]
    for x in tab:
        if x[1] >= m[1]:
            m = x
    return m


L = [('Adrien', 17), ('Barnabé', 17), ('Casimir', 17), ('Dorian', 17), ('Emilien', 16), ('Fabien', 16)]

print(maxi(L))

On obtient l'affichage:

A. ('Adrien', 17)
B. ('Dorian', 17)
C. ('Fabien', 16)
D. On ne peut pas savoir.

Résolution

La réponse est B: ('Dorian', 17). La fonction renvoie effectivement un élément du tableau ayant la note maximale. Le tableau est parcouru dans l'ordre des indices et le test pour remplacer m est "\geqslant": on modifie donc la valeur à chaque fois que l'on obtient de nouveau la note maximale.

Remarque: si on remplaçait if x[1] >= m[1]: par if x[1] > m[1]:, le couple obtenu serait le premier couple de note maximale rencontré lors du parcours (c'est à dire ici ('Adrien', 17)).

QCM 3☘

On considère le programme suivant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
from random import choice

def maxi(dico):
    """
    dico est un dictionnaire. Les clefs sont de type str
    et les valeurs associées sont des entiers compris entre 0 et 20.
    """
    m = choice(list(dico.items()))
    for x in dico.items():
        if x[1] > m[1]:
            m = x
    return m

dico = {'Adrien': 17, 'Dorian': 17, 'Barnabé': 17, 'Casimir': 17,  'Emilien': 16, 'Fabien': 16}
print(maxi(dico))

On obtient l'affichage:

A. ('Adrien', 17)
B. ('Dorian', 17)
C. ('Casimir', 17)
D. On ne peut pas savoir.

Résolution

La réponse est D: on ne peut pas savoir.

On sait que le couple affiché correspondra à l'un des 4 ayant une note de 17, mais on ne peut pas savoir lequel. En effet, même si l'on suppose que l'ordre de parcours des éléments d'un dictionnaire peut être connu, le couple renvoyé serait le premier rencontré parmi ceux ayant une note égale à 17 (car on a utilisé ">" dans le test), or le premier rencontré dépend de l'initialisation au hasard de la variable m.

QCM 4☘

On exécute le code python suivant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
def max_binaire(a,b):
        return a if a > b else b

def max_tableau(tab):
    """
    tab est une liste d'éléments de type int.
    La fonction renvoie la plus grande des valeurs de ces éléments.
    """
    assert len(tab) > 1, "argument de max_tableau de longueur non prise en compte"
    m = max_binaire(tab[0], tab[1])
    for x in tab:
        m = max_binaire(m,x)
    return m


m = max_tableau([3])
print(m)

On obtient:

A. IndexError: list index out of range
B. AssertionError: argument de max_tableau de longueur non prise en compte
C. TypeError: max_tableau() missing 1 required positional argument: 'tab'
D. TypeError: object of type 'int' has no len()

Réponse

La réponse correcte est la réponse B.
Si l'on supprime la ligne assert ..., on obtiendra la réponse A.