Fonctions - Introduction

Contenu

Fonctions - Introduction#

Déplacement des pièces#

Aux échecs, chaque pièce se déplace différemment:

La tour se déplace d'un nombre quelconque de cases horizontalement ou verticalement.
Le roi se déplace d'une seule case dans toutes les directions.
La dame se déplace d'un nombre quelconque de cases verticalement, horizontalement ou en diagonale sans pouvoir sauter une pièce.
Le fou se déplace d'un nombre quelconque de cases en diagonale sans pouvoir sauter une pièce.
Le cavalier se déplace en L, c'est-à-dire de deux cases dans une direction (horizontalement ou verticalement), puis d'une case perpendiculairement. Il est le seul à pouvoir sauter par-dessus une pièce lors de son mouvement.
Le pion avance d'une case à la fois. Il se déplace d'une case en diagonale en prenant une pièce adverse. S'il n'a pas encore bougé, il peut avancer de deux cases d'un coup, sans pouvoir sauter une pièce.

Exercice 1#

Essayez de comprendre le programme en comparant le programme et le résultat.
Modifiez le programme pour que le roi suive les numéros.

nord()
est()
nord()
nord()
ouest()

Solution

for _ in range(2):
  nord()
  ouest()
sud()
sud()
est()

Exercice 2#

Écrivez le programme qui permet à la tour de prendre tous les pions noirs en un minimum de coups.

# Écrivez le programme ici

Solution

est()
nord()
est()
est()
nord()
est()
nord()

Exercice 3#

Le programme de l'exercice précédent contient des répétitions de suites d'instructions (nord() suivi de est()), mais il n'est pas possible d'utiliser une boucle for, car il y a d'autres instructions entre. La solution est de définir une nouvelle fonction diagonale().

Résolvez l'exercice précédent en appelant la fonction diagonale à la place de répéter du programme.

De cette manière le programme est plus lisible!

# définition de la fonction diagonale
def diagonale():
  est()
  nord()

# appel de la fonction
diagonale()

Solution

# définition de la fonction diagonals
def diagonale():
  est()
  nord()

# programme principal
diagonale()
est()
diagonale()
diagonale()

Exercice 4#

Pour avoir des pièces qui se déplacent vraiment en diagonale comme le roi, de nouvelles fonctions ont été définies.

Essayez de comprendre le programme en comparant le programme et le résultat.
Modifiez le programme pour que le roi suive les numéros.

nord_ouest()
nord()
nord_est()
sud_ouest()

Solution

nord()
nord_est()
nord_est()
for _ in range(3):
  sud()
ouest()
ouest()
nord_ouest()
nord_ouest()

Exercice 5#

Modifiez le programme pour que la tour suive les numéros.

for _ in range(3):
  nord()

Solution

for _ in range(4):
  est()
for _ in range(2):
  nord()
for _ in range(3):
  ouest()
nord()
for _ in range(2):
  est()

Exercice 6#

On constate qu'il y a beaucoup de répétitions malgré l'utilisation de boucles for et cela ne représente pas réellement le déplacement de la tour qui se déplace en général de plusieurs cases en un coup.

Il serait mieux de pouvoir indiquer entre parenthèse le nombre de cases desquelles on veut déplacer la tour. Pour cela, il faut définir une nouvelle fonction.

Définissez de la même manière les autres fonctions aller_est, aller_ouest et aller_sud.
Résolvez l'exercice précédent en appeler les fonctions.

# définition de la fonction aller_nord qui prend le nombre de cases en paramètre
def aller_nord(nb_cases):
  for _ in range(nb_cases):
    nord()

# appel de la fonction pour que le programme effectue l'action demandée
aller_nord(3)

Solution

# définitions des fonctions
def aller_nord(nb_cases):
  for _ in range(nb_cases):
    nord()

def aller_sud(nb_cases):
  for _ in range(nb_cases):
    sud()

def aller_est(nb_cases):
  for _ in range(nb_cases):
    est()

def aller_ouest(nb_cases):
  for _ in range(nb_cases):
    ouest()

# appel de la fonction pour que le programme effectue l'action demandée
aller_est(4)
aller_nord(2)
aller_ouest(3)
aller_nord(1)
aller_est(2)

Exercice 7#

En utilisant les fonctions nord(nb_cases), sud(nb_cases), est(nb_cases) et ouest(nb_cases), écrivez le programme pour que la tour prenne tous les pions noirs en un minimum de coups.

# Écrivez le programme ici

Solution

nord(4)
est(3)
sud(3)
ouest(2)
nord(2)
est(1)

Exercice 8#

La fonction deplace(x, y) a été définie.

Essayez de comprendre le programme en comparant le programme et le résultat.
Modifiez le programme pour que le roi suive les numéros.

deplace(2, 0)
deplace(-4, 4)
deplace(0, -3)

Solution

deplace(0, 4)
deplace(-5, 0)
deplace(0, -3)
deplace(6, 6)

Exercice 9#

En utilisant la fonction deplace(x, y), définissez une fonction deplace_fou(direction, nb_cases) où le premier paramètre est la direction du mouvement ("ne", "se", "so" ou "no") et le deuxième est le nombre de cases.

def deplace_fou(direction, nb_cases):
  # Complétez la définition de la fonction
  pass

# programme principale qui déplace le fou en suivant les numéros
deplace_fou("no", 2)

Solution

def deplace_fou(direction, nb_cases):
  if direction == "ne":
    deplace(nb_cases, nb_cases)
  elif direction == "se":
    deplace(nb_cases, -nb_cases)
  elif direction == "no":
    deplace(-nb_cases, nb_cases)
  elif direction == "so":
    deplace(-nb_cases, -nb_cases)
  else:
    print("direction non valide")

deplace_fou("ne", 5)
deplace_fou("no", 2)
deplace_fou("so", 5)
deplace_fou("se", 1)

Exercice 10#

En utilisant la fonction deplace_fou(direction, nb_cases) définie à l'exercice précédent, déplace le fou prendre le pion noir.

# Écrivez le programme ici

Solution

deplace_fou("ne", 1)
deplace_fou("no", 2)
deplace_fou("so", 2)
deplace_fou("no", 2)
deplace_fou("ne", 3)
deplace_fou("se", 1)

Exercice 11#

En utilisant la fonction deplace(x, y), définissez une fonction deplace_roi. Quels paramètres sont nécessaires?

# Écrivez le programme ici

Solution

Le roi se déplaçant toujours d'une seule case, un seul paramètre, la direction est nécessaire.

def deplace_roi(direction):
  if direction == "n":
    deplace(0, 1)
  elif direction == "s":
    deplace(0, -1)
  elif direction == "e":
    deplace(1, 0)
  elif direction == "o":
    deplace(-1, 0)
  elif direction == "ne":
    deplace(1, 1)
  elif direction == "se":
    deplace(1, -1)
  elif direction == "no":
    deplace(-1, 1)
  elif direction == "so":
    deplace(-1, -1)
  else:
    print("direction non valide")

deplace_roi("ne")
deplace_roi("n")
deplace_roi("n")
deplace_roi("ne")
deplace_roi("no")
deplace_roi("n")
deplace_roi("so")

Exercice 12#

En utilisant la fonction deplace(x, y), définissez une fonction deplace_cavalier qui permet depuis le centre d'atteindre chacun des pions noirs. Quels paramètres sont nécessaires?

# Écrivez le programme ici

Solution

Le cavalier se déplaçant toujours du même nombre de cases (2 et 1), un seul paramètre, la direction est nécessaire.

def deplace_cavalier(direction):
  if direction == "ne":
    deplace(1, 2)
  elif direction == "en":
    deplace(2, 1)
  elif direction == "no":
    deplace(-1, 2)
  elif direction == "on":
    deplace(-2, 1)
  elif direction == "se":
    deplace(1, -2)
  elif direction == "es":
    deplace(2, -1)
  elif direction == "so":
    deplace(-1, -2)
  elif direction == "os":
    deplace(-2, -1)
  else:
    print("direction non valide")

deplace_cavalier("on")
deplace_cavalier("es")
deplace_cavalier("no")
deplace_cavalier("se")
deplace_cavalier("ne")
deplace_cavalier("so")
deplace_cavalier("en")
deplace_cavalier("os")
deplace_cavalier("es")
deplace_cavalier("on")
deplace_cavalier("se")
deplace_cavalier("no")
deplace_cavalier("so")
deplace_cavalier("ne")
deplace_cavalier("os")
deplace_cavalier("en")

Exercice 13#

En utilisant la fonction deplace_cavalier(direction) définie à l'exercice précédent, déplacez le cavalier pour prendre tous les pions noirs en un minimum de coups.

# Écrivez le programme ici

Solution

deplace_cavalier("ne")
deplace_cavalier("en")
deplace_cavalier("no")
deplace_cavalier("on")
deplace_cavalier("se")
deplace_cavalier("en")
deplace_cavalier("se")

Exercice 14#

En utilisant la fonction deplace(x, y), définissez une fonction deplace_dame. Quels paramètres sont nécessaires?

# Écrivez le programme ici

Solution

La dame se déplace dans toutes les directions et de plusieurs cases, deux paramètres sont nécessaires.

def deplace_dame(direction, nb_cases):
  if direction == "n":
    deplace(0, nb_cases)
  elif direction == "s":
    deplace(0, -nb_cases)
  elif direction == "e":
    deplace(nb_cases, 0)
  elif direction == "o":
    deplace(-nb_cases, 0)
  elif direction == "ne":
    deplace(nb_cases, nb_cases)
  elif direction == "se":
    deplace(nb_cases, -nb_cases)
  elif direction == "no":
    deplace(-nb_cases, nb_cases)
  elif direction == "so":
    deplace(-nb_cases, -nb_cases)
  else:
    print("direction non valide")

deplace_dame("n", 7)
deplace_dame("se", 4)
deplace_dame("so", 2)
deplace_dame("no", 5)
deplace_dame("s", 1)

Exercice 15#

En utilisant la fonction deplace_dame(direction, nb_cases) définie à l'exercice précédent, déplacez la dame pour prendre tous les pions noirs en un minimum de coups.

# Écrivez le programme ici

Solution

deplace_dame("ne", 1)
deplace_dame("no", 3)
deplace_dame("e", 4)
deplace_dame("ne", 2)
deplace_dame("o", 4)
deplace_dame("so", 3)
deplace_dame("n", 3)

Exercice 16#

En utilisant la fonction deplace_cavalier(direction) définie à l'exercice précédent, déplacez le cavalier pour prendre tous les pions noirs en un minimum de coups.

# Écrivez le programme ici

Solution

deplace_cavalier("ne")
deplace_cavalier("os")
deplace_cavalier("es")
deplace_cavalier("no")
deplace_cavalier("es")
deplace_cavalier("no")
deplace_cavalier("so")
deplace_cavalier("en")
deplace_cavalier("on")
deplace_cavalier("se")
deplace_cavalier("on")

Exercice 17#

En utilisant la fonction deplace_cavalier(direction) définie à l'exercice précédent, déplacez le cavalier pour prendre tous les pions noirs en un minimum de coups.

# Écrivez le programme ici