Exercises

Palindrome

Une chaîne de caractères est un palindrome si le mot est le même en lisant de gauche à droite et de droite à gauche.

In [5]:
def palindrome(s):
    return list(s) == list(reversed(s))

def palindrome2(s):
    res = True
    
    i = 0
    j = len(s) - 1
    
    while i < len(s):
        if s[i] != s[j]:
            res = False
            
        i += 1
        j -= 1
    
    return res

true_palindrome1 = 'redder'
true_palindrome2 = 'madam'
false_palindrome = 'palindrome'

print('Should print True: ' + str(palindrome(true_palindrome1)))
print('Should print True: ' + str(palindrome(true_palindrome2)))
print('Should print False: ' + str(palindrome(false_palindrome)))

print()

print('Should print True: ' + str(palindrome2(true_palindrome1)))
print('Should print True: ' + str(palindrome2(true_palindrome2)))
print('Should print False: ' + str(palindrome2(false_palindrome)))
Should print True: True
Should print True: True
Should print False: False

Should print True: True
Should print True: True
Should print False: False

Fibonacci

L'objectif de cet exercice est d'obtenir le nème élément de la suite de Fibonacci, n étant une valeur qui sera donnée à la fonction en paramètre. La définition mathématique de la suite de Fibonacci est la suivante :

Fibonacci

In [9]:
def fibonacci(n):
    if n < 2:
        return n
    
    l = [0, 1]
    
    for i in range(2, n + 1):
        l.append(l[i - 1] + l[i - 2])
        
    return l[len(l)-1] # last

def fibonacci2(n):
    if n < 2:
        return n
    
    return fibonacci2(n-1) + fibonacci2(n - 2)

print('Should print True: ' + str(fibonacci(0) == 0))
print('Should print True: ' + str(fibonacci(8) == 21))

print()

print('Should print True: ' + str(fibonacci2(0) == 0))
print('Should print True: ' + str(fibonacci2(8) == 21))
Should print True: True
Should print True: True

Should print True: True
Should print True: True

Le jeu du pendu

Le but de cet exercice est de coder le jeu du pendu.

Le programme affichera le mot sous forme de lettres séparées par des espaces, et remplacera les lettres qui n'ont pas encore été trouvées par des "_". Il est possible d'afficher une chaîne de caractères sur la même ligne en utilisant la méthode suivante :

In [13]:
s = "azerty"

for c in s:
    print(c, end=" ") # Replaces the line return (default end character) by a space
a z e r t y 

Le programme devra demander de nouveaux caractères jusqu'à ce que l'utilisateur ait trouvé toutes les lettres.

In [4]:
def pretty_print(l):
    """ Prints the word in a prettier manner. """
    for e in l:
        print(e, end=' ')
    print()

def hangman(s):
    """ Jeu du pendu. Exemple avec index """
    
    found = ['_'] * len(s)
    
    while found != list(s):
        pretty_print(found)
        entree = input('Entrez une lettre: ')
        
        for i in range(len(s)):
            if s[i] == entree:
                found[i] = entree
                
    print("You won! You found the word " + s)
    
def hangman2(s):
    """ Jeu du pendu. Exemple avec enumerate """
    
    found = ['_'] * len(s)
    
    while found != list(s):
        pretty_print(found)
        entree = input('Entrez une lettre: ')
        
        for index, value in enumerate(s):
            if value == entree:
                found[index] = entree
                
    print("You won! You found the word " + s)
    
hangman2('geography')
_ _ _ _ _ _ _ _ _ 
Entrez une lettre: e
_ e _ _ _ _ _ _ _ 
Entrez une lettre: o
_ e o _ _ _ _ _ _ 
Entrez une lettre: p
_ e o _ _ _ p _ _ 
Entrez une lettre: h
_ e o _ _ _ p h _ 
Entrez une lettre: y
_ e o _ _ _ p h y 
Entrez une lettre: g
g e o g _ _ p h y 
Entrez une lettre: r
g e o g r _ p h y 
Entrez une lettre: a
You won! You found the word geography

Faire la somme successive d'une liste

L'objectif de cet exercice est de programmer une fonction qui prendra une liste de taille quelconque en paramètre et qui retournera une liste d'un élément.

La manière de passer d'une liste de taille n à une liste de taille n - 1 est la suivante: le ième élément d'une liste sera égal à la somme du ièmé élément de la liste et du dernier élément de la liste. Le dernier élément de la liste sera ensuite enlevé.

Exemple :

In [4]:
[0, 1, 2, 3, 4, 5]
[5, 6, 7, 8, 9] # [0 + 5, 1 + 5, 2 + 5, 3 + 5, 4 + 5]
[14, 15, 16, 17] # [5 + 9, 6 + 9, 7 + 9, 8 9 +]
[31, 32, 33] # ...
[64, 65]
print("Le resultat final est " + str(129))
Le resultat final est [129]
In [10]:
def reduce_one_list(l):
    """ Function that applies the correct transformation to one list. """
    last = l[-1]
    
    # Delete last element from list
    del l[-1]
    
    for i in range(len(l)):
        l[i] = l[i] + last
        
    return l

def reduce_entire_list(l):
    """ Repeats reduce_one_list until end condition is met. """
    print(l)
    
    while len(l) > 1:
        l = reduce_one_list(l)
        print(l)
        
    return l[0]

l = [0, 1, 2, 3, 4, 5]
print("Example with one step: " + str(reduce_one_list(l)))

l = [0, 1, 2, 3, 4, 5]
print("Example with all steps: " + str(reduce_entire_list(l)))
Example with one step: [5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5]
[5, 6, 7, 8, 9]
[14, 15, 16, 17]
[31, 32, 33]
[64, 65]
[129]
Example with all steps: 129

Parcourir une grille

Créez une grille de largeur et de hauteur variable que vous pourrez afficher. Placez un joueur sur la grille, et utilisez ensuite une fonction random pour placer un objectif sur la grille créée.

L'objectif sera de déplacer le joueur de case en case jusqu'à ce qu'il arrive sur la case objectif. Vous pourrez utiliser la fonction input() pour décider quel déplacement devra être fait par le joueur.

In [33]:
import random

def create_maze(rows, columns):
    """ Returns a maze of the correct size. """
    maze = []
    
    # Create each column with the correct column size
    for i in range(columns):
        # Append a list of size row to the maze
        maze.append(['_'] * rows)
        
    return maze

def print_maze(maze):
    """ Print the maze in a prettier way. """
    
    for line in maze:
        print(line)

def get_move():
    """ Returns action depending on user input. """
    
    # Coordonnées pour se déplacer. 1: se déplacer à droite ou vers le bas
    # -1: se déplacer à gauche ou vers le haut
    # 0: ne pas se déplacer
    x = 0
    y = 0
    action = input("Entrez une action (wasd): ")
    
    if action == 'w':
        print("Going up")
        x = -1
    elif action == 'a':
        print("Going left")
        y = -1
    elif action == 's':
        print("Going down")
        x = 1
    elif action == 'd':
        print("Going right")
        y = 1
    else:
        print("Invalid action!")
        
    return x, y        
    
def move(player, maze, x, y):
    """ Moves player in maze according to x and y. """
    # Set spot where player is now to _
    maze[player[0]][player[1]] = '_'
    
    # Update player coordinates (% in case you go outside of bound)
    player[0] = (player[0] + x) % len(maze)
    player[1] = (player[1] + y) % len(maze[0])
    
    # Set spot where player is now to P
    maze[player[0]][player[1]] = 'P'
    
    return player, maze

def path_finder(width, height):
    maze = create_maze(width, height)
    
    goal = [
        random.randint(0, height - 1),
        random.randint(0, width - 1)
    ]
    print('The goals coordinates: ' + str(goal))
    
    # Add Special character for goal
    maze[goal[0]][goal[1]] = 'X'
    
    player = [
        random.randint(0, height - 1),
        random.randint(0, width - 1)
    ]
    print('The players coordinates: ' + str(player))
    
    # Add Special character for player
    maze[player[0]][player[1]] = 'P'
    
    print_maze(maze)
    
    # Tant que le joueur et le goal ne sont pas sur la meme case
    while goal != player:
        x, y = get_move()
        
        # Move player
        player, maze = move(player, maze, x, y)
        
        print_maze(maze)
        
    print("You won! Congratulations.")

w = 6
h = 3

path_finder(w, h)
The goals coordinates: [0, 0]
The players coordinates: [0, 2]
['X', '_', 'P', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
Entrez une action (wasd): w
Going up
['X', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
['_', '_', 'P', '_', '_', '_']
Entrez une action (wasd): a
Going left
['X', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
['_', 'P', '_', '_', '_', '_']
Entrez une action (wasd): a
Going left
['X', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
['P', '_', '_', '_', '_', '_']
Entrez une action (wasd): s
Going down
['P', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
['_', '_', '_', '_', '_', '_']
You won! Congratulations.

Le jeu du morpion

Le but de cet exercice est de coder le jeu de morpion. Vous jouerez les deux joueurs à la fois, et utiliserez une ou plusieurs listes pour stocker la grille de jeu.

Dans un deuxième temps, vous spécifierez la taille de la grille de jeu en paramètre (par exemple 5 de largeur et 2 de hauteur).

In [64]:
def create_grid():
    """ Returns a 3x3 tic tac toe grid."""
    res = []
    
    for i in range(3):
        res.append(['_', '_', '_'])
        
    return res

def print_grid(grid):
    """ Prettier version of the grid. """
    for line in grid:
        print(line)
        
def won(grid):
    """ Returns True if a player won. """
    
    res = False
    
    # In the following tests, I need to check if the element is X or O because
    # if I don't an empty row like [' ', ' ', ' '] will end the game.
    
    # Test if rows are equal
    for i in range(len(grid)):
        if grid[i][0] in 'XO' and grid[i][0] == grid[i][1] == grid[i][2]:
            res = True
            
    # Test if columns are equal
    for i in range(len(grid)):
        if grid[0][i] in 'XO' and grid[0][i] == grid[1][i] == grid[2][i]:
            res = True
            
    # Test if diagonals are equal
    if grid[0][0] in 'XO' and grid[0][0] == grid[1][1] == grid[2][2]:
        res = True
    elif grid[0][2] in 'XO' and grid[0][2] == grid[1][1] == grid[2][0]:
        res = True
    
    return res

def tic_tac_toe():
    grid = create_grid()
    print_grid(grid)
    
    symbol = 'O'
    
    while not won(grid):
        # Switch symbol after each iteration
        if symbol == 'O':
            symbol = 'X'
        else:
            symbol = 'O'
            
        x = int(input("Enter x coordinate: "))
        y = int(input("Enter y coordinate: "))        
        
        if grid[y][x] != '_':
            print("Invalid move! You lost a turn.")
        else:
            grid[y][x] = symbol
            
        print_grid(grid)
        
    print('Game Over!')

tic_tac_toe()
['_', '_', '_']
['_', '_', '_']
['_', '_', '_']
Enter x coordinate: 0
Enter y coordinate: 0
['X', '_', '_']
['_', '_', '_']
['_', '_', '_']
Enter x coordinate: 1
Enter y coordinate: 0
['X', 'O', '_']
['_', '_', '_']
['_', '_', '_']
Enter x coordinate: 1
Enter y coordinate: 1
['X', 'O', '_']
['_', 'X', '_']
['_', '_', '_']
Enter x coordinate: 2
Enter y coordinate: 1
['X', 'O', '_']
['_', 'X', 'O']
['_', '_', '_']
Enter x coordinate: 2
Enter y coordinate: 2
['X', 'O', '_']
['_', 'X', 'O']
['_', '_', 'X']
Game Over!