EXERCICE:

QUESTION 1:

def puiss(k):
return 1 if k % 2 == 0 else -1
k = int(input("Entrez un nombre strictement positif : "))
resultat = puiss(k)
print(f"Le résultat de (-1)^{k} est : {resultat}")

Question 2:

def terme(k):
return (4 * (-1) ** (k + 1)) / (2 * k * (2 * k + 1) * (2 * k + 2))
k = int(input("Entrez un nombre entier strictement positif : "))8
resultat = terme(k)
print(f"Le terme suivant pour k={k} est : {resultat}")

QUESTION 3 :

def terme(k):
return (4 * (-1) ** (k + 1)) / (2 * k * (2 * k + 1) * (2 * k + 2))
def liste_terme(n):
L = []
for k in range(1, n+1):
L.append(terme(k))
return L
n = int(input("Entrez un nombre entier strictement positif : "))
resultat = liste_terme(n)
print(f"La liste des termes pour n={n} est : {resultat}")

QUESTION 4:

def somme(L):
total = 0
for element in L:
total += element
return total
liste = input("Entrez une liste de nombres réels (séparés par des espaces) :
").split()
liste = [float(element) for element in liste]
resultat = somme(liste)
print(f"La somme des éléments de la liste est : {resultat}")

QUESTION 5 :

def terme(k):
return (4 * (-1) ** (k + 1)) / (2 * k * (2 * k + 1) * (2 * k + 2))
def liste_terme(n):
L = []
for k in range(1, n+1):
L.append(terme(k))
return L
def somme(L):
total = 0
for element in L:
total += element
return total
def pi_nilakantha(n):
L = liste_terme(n)
 somme_L = somme(L)
return 3 + somme_L
n = int(input("Entrez un nombre entier strictement positif : "))
resultat = pi_nilakantha(n)
print(f"La valeur approchée de π pour n={n} est : {resultat}")

PROBLEME :

1/ def transforme(fichier):
matrice = []
with open(fichier, 'r') as f:
for ligne in f:
valeurs = ligne.strip().split()
ligne_matrice = [int(v) for v in valeurs]
matrice.append(ligne_matrice)
return matrice
2/ p = []

def empiler(x, y):

p.append((x, y))

def parcours_profondeur(labyrinthe, id, jd, ia, ja):

n = len(labyrinthe)
m = len(labyrinthe[0])
visite = [[False] * m for _ in range(n)]
chemin = []

def parcours(id, jd):

if id == ia and jd == ja:
chemin.append((id, jd))
return True

if id < 0 or id >= n or jd < 0 or jd >= m or labyrinthe[id][jd] == 0 or

visite[id][jd]:
return False

visite[id][jd] = True
empiler(id, jd)

if parcours(id - 1, jd) or parcours(id, jd + 1) or parcours(id + 1, jd) or

parcours(id, jd - 1):
return True

p.pop()
return False

parcours(id, jd)
return chemin

3/ def depiler():
if len(p) > 0:
return p.pop()
else:
return None
4/ def blocked(labyrinthe, i, j):
n = len(labyrinthe)
m = len(labyrinthe[0])
if labyrinthe[i - 1][j] == 0 or labyrinthe[i + 1][j] == 0 or labyrinthe[i][j +
1] == 0 or labyrinthe[i][j - 1] == 0:
return False
else:
return True
5/ def next(labyrinthe, i, j):
n = len(labyrinthe)
m = len(labyrinthe[0])
if labyrinthe[i - 1][j] == 1:
return (i - 1, j)
elif labyrinthe[i + 1][j] == 1:
return (i + 1, j)
elif labyrinthe[i][j + 1] == 1:
return (i, j + 1)
elif labyrinthe[i][j - 1] == 1:
return (i, j - 1)
6/ def parcourt(id, jd, ia, ja):
m[id][jd] = 0
empiler((id, jd))
while True:
i, j = depiler()
if i == ia and j == ja:
break
if m[i - 1][j] == 1 and not blocked(m, i - 1, j):
m[i - 1][j] = 0
empiler((i - 1, j))
elif m[i][j + 1] == 1 and not blocked(m, i, j + 1):
m[i][j + 1] = 0
empiler((i, j + 1))
elif m[i + 1][j] == 1 and not blocked(m, i + 1, j):
m[i + 1][j] = 0
empiler((i + 1, j))
elif m[i][j - 1] == 1 and not blocked(m, i, j - 1):
m[i][j - 1] = 0
empiler((i, j - 1))
7/ def sauve(id, jd, ia, ja):
with open('Labyrinthe.txt', 'r') as file:
lines = file.readlines()
for i in range(id, ia + 1):
line = lines[i].strip().split()
for j in range(jd, ja + 1):
line[j] = 'x'
lines[i] = ' '.join(line) + '\n'
with open('Labyrinthe.txt', 'w') as file:
file.writelines(lines)