TD3 : Introduction à la programmation en Python - Chap 1

Sauvegarder les réponses à chaque exercice dans le dossier : nsi/chap1/td3.

Exercice 1 : Fonctions et boucles.

À faire directement dans Pyzo.

Écrire une fonction naturels() qui prend en paramètre un entier naturel n et qui affiche tous les entiers compris entre 0 et n (inclus).
Écrire une fonction pairs() qui prend en paramètre un nombre entier naturel n et qui affiche tous les nombres entiers pairs compris entre 0 et n (inclus).
Écrire une fonction bart_simpson() qui prend en paramètre une chaîne de caractères ch et un nombre entier n et qui affiche n fois la chaîne ch (1 seule fois par ligne). Vous pourrez utiliser la chaîne de caractères : "Mes devoirs ne m'ont pas été volés par un manchot." pour faire un essai.
Écrire une fonction longueur() qui prend en paramètre une chaîne de caractères ch et qui renvoie le nombre de caractères de cette chaîne (utilisation de la fonction len interdite).
Écrire une fonction gauss() qui prend un entier naturel n en paramètre et qui renvoie la somme de tous les entiers de 0 à n (inclus).

À retenir : une variable qui sert à stocker un résultat en cours de calcul, en ajoutant (ou en combinant) de nouvelles valeurs à chaque étape d’une boucle est appelée accumulateur.

On dispose d'une feuille de papier d'épaisseur 0,1 mm. Écrire une fonction pliage() qui prend en parametre un entier naturel hauteur et qui renvoie le nombre de fois qu'on doit plier la feuille au minimum pour que l'épaisseur dépasse alors la hauteur passée en paramètre. On fera l'essai pour la tour Eiffel de 324 m (résultat surprenant).
Écrire une fonction occurences() qui prend en paramètre une chaîne de caractères ch et un caractère car et qui renvoie le nombre de fois où ce caractère apparaît dans la chaîne (nombre d'occurences du caractère).

À retenir : une variable qui sert à compter combien de fois quelque chose se produit dans un programme est appelé un compteur.

Exercice 2 : Fonctions et chaînes de caractères.

Coder les fonctions suivantes dans Pyzo.

Écrire une fonction table() qui prend en paramètre un entier naturel n et qui affiche la table de multiplication de ce nombre (de 0 à 10). Par exemple pour le nombre 3, on doit obtenir :
Écrire une fonction retire_doublons() qui prend une chaîne de caractères ch et qui renvoie la chaîne de caractères sans les doublons. Par exemple : retire_doublons('abcbad') renvoie 'abcd'. On rapelle qu'on ne peut pas modifier une chaîne de caractères déjà définie.
Écrire une fonction somme_chiffres() qui prend en paramètre une chaîne de caractères formée uniquement de chiffres et qui renvoie la somme de ces chiffres (sous la forme d'un entier). Par exemple somme_chiffres('1305') renvoie 9.
Écrire une fonction voyelles() qui prend en paramètre une chaîne de caractères ch et qui renvoie le nombre de voyelles présentes dans cette chaîne. On pourra commencer par définir une chaîne de caractères formée de toutes les voyelles.
Écrire une fonction inverse_car() qui prend en paramètre une chaîne de caractères ch et qui renvoie une chaîne de caractères "inversée" (par exemple inverse_car('abc') retourne 'cba').
Écrire une fonction palindrome() qui prend en paramètre une chaîne de caractères ch et qui renvoie True si c'est un palindrome et False si ce n'est pas un palindrome. Un palindrome est un mot (ou une phrase) qui peut s’écrire dans les deux sens, exemple : radar est un palindrome. On pourra utiliser une des fonctions précédentes...
Écrire une fonction triangle() qui prend en paramètre un nombre entier naturel n et qui affiche le triangle ci-dessous pour n = 10 :
Écrire une fonction sapin() qui prend en paramètre un nombre entier naturel n et qui affiche le "joli" sapin de Noël ci-dessous pour n = 12 :

Exercice 3 : Un petit jeu sous Pyzo.

Le but de l'exercice est de coder un petit jeu consistant à trouver le plus rapidement possible un nombre entier, compris entre 1 et 100, choisi aléatoirement par l'ordinateur. À chaque essai, l'ordinateur doit guider le joueur en indiquant si le nombre recherché est plus petit ou plus grand que celui proposé par le joueur. À la fin, l'ordinateur félicite le joueur et lui communique son score, c'est-à-dire le nombre de tentatives nécessaires pour trouver le nombre.

Pour choisir un nombre entier aléatoire entre 0 et 100, on importe le module random, puis on utilise : random.randint(0, 100) pour obtenir le nombre entier aléatoire (à affecter à une variable).

Vous aurez aussi besoin de la fonction native input() pour récupérer dans le shell les propositions du joueur. Elle prend en paramètre une chaîne de caractères (la question à poser) et met le programme en pause jusqu'à ce que le joueur rentre son nombre et valide avec la touche "Entrer".

Le programme doit être bien structuré : il faut utiliser des fonctions et la partie programme principal doit être la plus courte possible.

Compléments possibles :

Limiter le nombre d'essais. Si cette limite est atteinte, le joueur a perdu et l'ordinateur "ne le félicite pas" mais il lui indique quel était le nombre à trouver.
Créer 3 niveaux : facile : entre 1 et 50 ; moyen : entre 1 et 100 et difficile : entre 1 et 1000 ; puis demander au joueur de choisir son niveau de difficulté au lancement du jeu.

Exercice 4 : Jeu vidéo / Fonctions et boucles (pyxel).

Copier/coller le code suivant et remplacer les "." en répondant aux questions :

import pyxel

taille = 15 # Taille des ennemis
# Ennemi 1
x1 = 20
y1 = 10
dx1 = 1
dy1 = 1

# Ennemi 2
x2 = 70
y2 = 20
dx2 = 2
dy2 = 1

# Ennemi 3
x3 = 40
y3 = 30
dx3 = 1
dy3 = 2


def update_objects(cote):
    global x1, y1, dx1, dy1
    global x2, y2, dx2, dy2
    global x3, y3, dx3, dy3
    # On fait bouger les 3 ennemis en même temps.
    # Chaque ennemi a sa propre position (x, y) et sa propre direction (dx, dy).
    # On incrémente la position de chaque ennemi par sa direction respective.
    # On vérifie les conditions de rebond pour chaque ennemi.
    # On utilise des if pour vérifier si l'ennemi atteint le bord de la fenêtre.
    # Si l'ennemi atteint le bord droit, on inverse la direction (dx devient négatif).
    # Si l'ennemi atteint le bord gauche, on inverse la direction (dx devient positif).
    # Si l'ennemi atteint le bord inférieur, on inverse la direction (dy devient négatif).
    # Si l'ennemi atteint le bord supérieur, on inverse la direction (dy devient positif).
    # Attention : les conditions de rebond doivent être adaptées à la taille des ennemis donc à cote.
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
def draw_objects():
    pyxel.rect(x1, y1, taille, taille, 10)
    pyxel.rect(x2, y2, taille, taille, 11)
    pyxel.rect(x3, y3, taille, taille, 12)

def update():
    update_objects(taille)  
    

def draw():
    pyxel.cls(0)
    draw_objects()


pyxel.init(128, 128, title="Version 4, 3 ennemis")
pyxel.run(update, draw)

Penser à sauvegarder le code obtenu avec Pyzo dans votre dossier nsi/chap1/td3.

Exercice 5 : Jeu vidéo / Fonctions et boucles (pyxel).

En reprenant les versions précédentes du jeu vues dans les td précédents, créez un jeu avec un joueur (représenté par un disque ou un carré) qui se déplace avec les touches du clavier et 3 ennemis (représentés par des carrés) qui se déplacent automatiquement "en diagonale". On ne demande pas de gérer les collisions pour l'instant.