L2 SoQ 2016-2017 - Déroulement réel des cours

La « pensée » du Dilun, d'an 20 a viz Du 2017 , 23h41m35s :
Pourquoi "abréviation" est-il un mot si long?

Semaine du mordi 11 octob' 2016 : CMTD n°1 (Cumul=3h)

Qu'est-ce qu'un langage informatique ?

Voir http://www.grappa.univ-lille3.fr/polys/php/ch02.html.

Présentation de l'algorithmique

Lecture utile : Initiation à l'algorithmique, de Fabien Torre.

Python

  • Page de ressources, y compris le poly pour Python 3.
    Il vous est conseillé de préférer la version du poly ci-dessus (forcément plus à jour), mais si elle est inaccessible vous pouvez en télécharger ici une version locale datant de janvier 2012.
  • Télécharger Python
  • Présentation de Python, page VIII de la préface.
  • Chapitre 1, À l'école des sorciers :
    • L'activité essentielle d'un programmeur est de résoudre des problèmes.
    • Langage machine-langage de programmation.
    • Code source, interprétation
    • Mise au point d'un programme, les différents types d'erreur.
  • Chapitre 2, Premiers pas :
    • Calculer avec Python.
    • Données et variables.
    • Noms de variables et mots réservés.
    • Affectation (ou assignation).
    • Afficher la valeur d’une variable.
    • Typage des variables.
    • Affectations multiples.
    • Exercices page 18.
    • Opérateurs et expressions.
    • Exercice page 19.
    • Priorité des opérateurs.
    • Composition.
  • Chapitre 3, contrôle du flux d'instructions :
    • Séquence.
    • Alternative.
    • Opérateurs de comparaison.
    • Instructions composées – blocs d’instructions.
    • Instructions imbriquées.
    • Quelques règles de syntaxe Python.
Dernière modification : 17/10/2016

Semaine du mordi 18 octob' 2016 : CMTD n°2 (Cumul=6h)

Python

On continue avec le poly.
  • Chapitre 4, Instructions répétitives :
    • Ré-affectation.
    • Répétitions en boucle – l’instruction while.
    • Premiers scripts, ou comment conserver nos programmes.
    • Exercices page 31.
Dernière modification : 24/10/2016

Semaine du mordi 25 octob' 2016 : CMTD n°3 (Cumul=9h)

Python

On continue avec le poly.
  • Chapitre 4, Instructions répétitives :
    • Exercice 4.4 page 31.
    • Exercices page 35.
Dernière modification : 4/11/2016

Semaine du mordi 8 novemb' 2016 : CMTD n°4 (Cumul=12h)

Python

Le contrôle n°1 aura lieu le mardi 15 novembre 2016, pendant le cours de 9h à 12h, en salle habituelle, dans les conditions suivantes :
  • sur feuille,
  • tous documents PAPIER autorisés,
  • aucun document électronique (liseuse, tablette, ordinateur, téléphone, etc.).
Programme : tout ce qui aura été fait en cours.

Le contrôle n°2 aura lieu le mardi 6 décembre dans les mêmes conditions.
On continue avec le poly.
  • Chapitre 4, Instructions répétitives :
    • Retour sur les exercices de la page 35 ?
  • Chapitre 5, principaux types de données :
    • Les données numériques.
Dernière modification : 25/11/2016

Semaine du mordi 15 novemb' 2016 : CMTD n°5 (Cumul=15h)

Python

On continue avec le poly.
  • Chapitre 5, principaux types de données :
    • Les données numériques, exercices.
Puis Contrôle n°1.
Dernière modification : 25/11/2016

Semaine du mordi 22 novemb' 2016 : CMTD n°6 (Cumul=18h)

Python

Le contrôle n°2 aura lieu le mardi 6 décembre 2016, pendant le cours de 9h à 12h, en salle habituelle, dans les conditions suivantes :
  • sur feuille,
  • tous documents PAPIER autorisés,
  • aucun document électronique (liseuse, tablette, ordinateur, téléphone, etc.).
Programme : tout ce qui aura été fait en cours.

On continue avec le poly.
  • Chapitre 5, principaux types de données :
    • Les données alphanumériques.
Dernière modification : 25/11/2016

Semaine du mordi 29 novemb' 2016 : CMTD n°7 (Cumul=21h)

Le contrôle n°2 aura lieu le mardi 6 décembre 2016, pendant le cours de 9h à 12h, en salle habituelle, dans les conditions suivantes :
  • sur feuille,
  • tous documents PAPIER autorisés,
  • aucun document électronique (liseuse, tablette, ordinateur, téléphone, etc.).
Programme : tout ce qui aura été fait en cours.

On continue avec le poly.
  • Chapitre 5, principaux types de données :
    • Les données alphanumériques.
    • Les listes (première approche).
Dernière modification : 29/11/2016

Semaine du mordi 6 décemb' 2016 : CMTD n°8 (Cumul=24h)

Exercices récapitulatifs
  1. Un programme commence par :
    mot = "Jean"
    liste = [ "Jean", "Henri", ... ]
    Afficher le nombre de fois où mot apparaît dans liste.

    Les réponses devront être, selon le cas, sous la forme « mot n'apparaît pas dans liste » ou « mot apparaît une seule fois dans liste » ou « mot apparaît N fois dans liste ».
    1. mot = "Jean"
    2. liste = [ "Jean", "Henri", "Jean", "jhfjyf", "opupoup", "Jean", "fghjk"]
    3.  
    4. nombre = 0
    5. i = 0
    6. while i < len(liste) :
    7.     if liste[i] == mot :
    8.         nombre = nombre +1
    9.     i = i+1
    10.  
    11. if nombre == 0 :
    12.     print (mot, "n'apparait pas dans",  liste)
    13. else :
    14.     if nombre == 1 :
    15.         print (mot, "apparait une seule fois dans", liste)
    16.     else:
    17.         print (mot, "apparait", nombre, "fois dans",  liste)
    18.  
    1. mot = "Jean"
    2. liste = [ "Jean", "Henri", "Jean", "jhfjyf", "opupoup", "Jean", "fghjk"]
    3.  
    4. nombre = 0
    5. i = 0
    6. while i < len(liste) :
    7.     if liste[i] == mot :
    8.         nombre = nombre +1
    9.     i = i+1
    10.  
    11. if nombre == 0 :
    12.     print (mot, "n'apparait pas dans",  liste)
    13. elif nombre == 1 :
    14.     print (mot, "apparait une seule fois dans", liste)
    15. else:
    16.     print (mot, "apparait", nombre, "fois dans",  liste)
    17.  
  2. Un programme commence par :
    mot = "Jean"
    liste = [ "Jean", "Henri", ... ]
    Supprimer toutes les occurences de mot dans liste.

    Attention :
    • il ne faut pas créer de deuxième liste ;
    • vérifiez que votre programme marche aussi quand le mot recherché figure deux fois de suite dans la liste.
    1. mot = "Jean"
    2. liste = [ "Jean", "Henri", "Jean", "Jean", "jhfjyf", "opupoup", "Jean", "fghjk"]
    3.  
    4. nombre = 0
    5. i = 0
    6. while i < len(liste) :
    7.     if liste[i] == mot :
    8.         del(liste[i])
    9.     else:
    10.         i = i+1
    11.  
    12. print ("Après suppression de", mot, "on obtient",  liste)
    13.  
  3. Quel est l'affichage exact produit par ce programme ?
    L = [ 3, "abcd", 7.5, 'marcel', 15, "jean" ]
    x = 1
    while x <= len(L)-3 :
       print (x)
       x = x+1
  4. Quel est l'affichage exact produit par ce programme ?
    L = [ 3, "abcd", 7.5, 'marcel', 15, "jean" ]
    x = 1
    while x <= len(L)-3 :
       x = x+1
       print (x)
  5. Quel est l'affichage exact produit par ce programme ?
    L = [ [3, "abcd", 7.5], ['marcel', 15], ["jean"] ]
    x = 0
    while x < len(L) :
       print (x)
       x = x+1
  6. [Difficile] Écrire un programme qui produise exactement cet affichage :
    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
    1. limite = 9    # nombre de lignes à afficher
    2. ligne = 1     # numéro de ligne en cours d'affichage, mais aussi longueur de cette ligne
    3. encours = 0   # nombre de nombres déjà affichés dans la ligne en cours
    4. nombre = 1    # le prochain nombre à afficher
    5.  
    6. while ligne <= limite :     # tant qu'on a pas fini les lignes à afficher
    7.     print (nombre, end=" ") # on affiche un nombre
    8.     nombre = nombre + 1     # nombre suivant
    9.     encours = encours + 1   # un de plus dans la ligne
    10.     if encours >= ligne :   # on a fini la ligne
    11.         print()             # passage à la ligne
    12.         encours = 0         # on recommence une nouvelle ligne
    13.         ligne = ligne + 1   # numéro et longueur de la nouvelle ligne
    14.  
  7. Un programme commence par la définition d'une liste d'entiers :
    L = [12, 19, 45, 52, 14, 9, 10, 49 ]
    Compléter le programme pour qu'il affiche, pour chaque entier, s'il est multipe de 3,5 ou 7, ou d'aucun des trois.
    Avec la liste ci-dessus on doit obtenir :
    12 est multiple de 2
    12 est multiple de 3
    19 n'est multiple de rien
    45 est multiple de 3
    45 est multiple de 5
    52 est multiple de 2
    14 est multiple de 2
    9 est multiple de 3
    10 est multiple de 2
    10 est multiple de 5
    49 n'est multiple de rien
    1. L = [12, 19, 45, 52, 14, 9, 10, 49 ]
    2.  
    3. i = 0
    4. while i <len(L) :
    5.   multiple = 0
    6.   if L[i] % 2 == 0 :
    7.       print (L[i], "est multiple de 2")
    8.       multiple = 1
    9.   if L[i] % 3 == 0 :
    10.       print (L[i], "est multiple de 3")
    11.       multiple = 1
    12.   if L[i] % 5 == 0 :
    13.       print (L[i], "est multiple de 5")
    14.       multiple = 1
    15.   if multiple==0 :
    16.       print (L[i], "n'est multiple de rien")
    17.   print()
    18.   i = i+1
    19.  
  8. Écrire un programme qui crée une liste contenant tous les entiers de 1 à 500.
    1. L =[]
    2. i = 1
    3. while i <= 500 :
    4.     L.append(i)
    5.     i = i+1
    6. print (L)
    7.  
  9. Un programme commence par la définition d'une liste d'entiers :
    L = [12, 19, 45, 52, 14, 9, 10, 49 ]
    Compléter le programme pour qu'il affiche la moyenne des éléments de la liste.
    1. L = [12, 19, 45, 52, 14, 9, 10, 49 ]
    2.  
    3. i = 0
    4. somme = 0
    5. while i <len(L) :
    6.   somme = somme + L[i]
    7.   i = i+1
    8. print("La moyenne est",somme/len(L))
    9.  
  10. Afficher la liste des 10 premiers multiples non nuls des 15 premiers entiers non nuls. L'affichage devra être :
    Les multiples de 1 sont : 1 2 3 4 5 6 7 8 9 10
    Les multiples de 2 sont : 2 4 6 8 10 12 14 16 18 20
    Les multiples de 3 sont : 3 6 9 12 15 18 21 24 27 30
    . . . .
    Les multiples de 13 sont : 13 26 39 52 65 78 91 104 117 130
    Les multiples de 14 sont : 14 28 42 56 70 84 98 112 126 140
    Les multiples de 15 sont : 15 30 45 60 75 90 105 120 135 150
    1. n = 1                             # pour compter les nombres
    2. while n <= 15 :                   # tant qu'on n'a pas fini d'énumérer les nombres
    3.     print ("Les multiples de", n, "sont : ", end="") # début de ligne
    4.     m = 1                         # pour compter les multiples de n
    5.     while m <= 10 :               # tant qu'on n'a pas affiché 10 multiples
    6.         print (m*n, end=" ")      # afficher un multiple
    7.         m = m + 1                 # passer au multiple suivant
    8.     print ()                      # finir la ligne d'un nombre
    9.     n = n + 1                     # passer au nombre suivant
    10. print ()                          # facultatif : soigner l'affichage final
    11.  
  11. [Difficile] Une façon de savoir si un nombre est premier est de tenter de le diviser par tous les nombres plus petits que lui. S'il n'est divisible par aucun d'entre eux, il est premier.
    Utiliser cette méthode pour afficher les nombres premiers inférieurs à 100.
    L'affichage devra être :
    Les premiers nombres premiers sont : 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
    1. print ("Les premiers nombres premiers sont : ", end="")
    2. p = 2                              # les nombres à tester
    3. while p <= 100 :                   # tant qu'on n'a pas testé jusque 100...
    4.     d = 2                          # les diviseurs éventuels à tester sur p
    5.     premier = 1                    # drapeau (flag) : 1 =p premier, 0=p pas premier
    6.     while (premier==1) and (d<p) : # tant qu'on n'a pas testé tous les diviseurs éventuels
    7.         if p % d == 0 :            # si p est divisible par d ...
    8.             premier = 0            #   ... p n'est aps premier
    9.         d = d + 1                  # diviseur éventuel suivant
    10.     if premier == 1 :              # si p est premier ...
    11.         print (p, end=" ")         #   ... afficher p
    12.     p = p + 1                      # passer au nombre suivant à tester
    13. print ()
    14.  
    Remarque : cette méthode pour rechercher des nombres premiers est extrémement inefficace. Elle n'est raisonnable que pour des petis nombres.
  12. [Difficile] Une méthode un peu plus efficace (mais seulement un peu...) pour trouver des nombres premiers est celle du Crible d'Ératosthène (voir https://fr.wikipedia.org/wiki/Crible_d'%C3%89ratosth%C3%A8ne pour plus de détails).
    Écrire un programme qui affiche les nombres premiers de 2 à 500 en utilisant cette méthode. (On utilisera une liste pour contenir les nombres de 0 à 500.)
    Les premiers nombres premiers sont : 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499
    1. #
    2. # INITIALISATION ET REMPLISSAGE DU CRIBLE
    3. #
    4. eratho =[]                # initialiser le crible
    5. i = 0                     # remplissage du crible :
    6. while i <= 500 :          # - dans chaque case eratho[i] il y a la valeur i
    7.     eratho.append(i)      # - les nombres non premiers seront remplacés par -1
    8.     i = i+1
    9.  
    10. #
    11. # SUPPRESSION DES MULTIPLES
    12. #
    13. eratho[0] = -1            # 0 n'est pas premier (définition)
    14. eratho[1] = -1            # 1 n'est pas premier (définition)
    15. n = 2                     # tester tous les nombres
    16. while n*n <= 500 :        # inutile d'aller plus loin que racine carrée de 500
    17.     m = 2                 # compter les multiples de n
    18.     while m*n <=500 :
    19.         eratho[m*n] = -1  # les multiples de n ne sont pas premiers
    20.         m = m + 1
    21.     n = n + 1
    22.  
    23. #
    24. # AFFICHAGE DU RÉSULTAT
    25. #
    26. print ("Les premiers nombres premiers sont : ", end="")
    27. i = 0
    28. while i <= 500 :
    29.     if eratho[i] != -1 :  # on n'affiche que ceux qui n'ont pas été remplacés par -1
    30.         print (i, end=" ")
    31.     i = i+1
    32.      
    33. print ()                  # facultatif : soigner l'affichage final
    34.  
    35.  
Contrôle n°2.
Dernière modification : 30/11/2016

Semaine du mordi 13 décemb' 2016 : CMTD n°9 (Cumul=27h)

Patience...
Dernière modification : 14/10/2016
Dernière modification : 14/10/2016