Code pour calculer une suite de Fibonacci avec python

Dans ce tutoriel, nous allons explorer la célèbre suite de Fibonacci et comment la calculer en utilisant le langage de programmation Python.

Suite de Fibonacci

La suite de Fibonacci est une séquence de nombres avec des propriétés uniques. Chaque nombre dans la séquence, à partir du troisième terme, est la somme des deux nombres précédents. La séquence commence généralement par les chiffres 1, 1.

Exemple de la suite de Fibonacci :
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, \ldots]

On obtient chaque nombre en additionnant les deux chiffres qui le précèdent, à l’exclusion des deux premiers.

Fibonacci : Histoire et Exemple Concret

L’empereur Frédéric II de Hohenstaufen a posé un problème mathématique lors d’un tournoi en 1223, ce qui a conduit à la première formulation de la suite de Fibonacci. Le défi consistait à déterminer le nombre de couples de lapins que l’on obtiendrait en un an, à partir d’un couple initial, en supposant que chaque couple donne naissance à un autre couple chaque mois, à partir du deuxième mois de leur vie.

On construit la séquence en ajoutant les deux termes précédents, ce qui produit une séquence croissante de nombres.

Utilisation Pratique dans la Nature

La suite de Fibonacci se manifeste de manière étonnante dans la nature, notamment dans le nombre de pétales de fleurs. Les mathématiciens ont observé une récurrence de certains chiffres dans le nombre de pétales des fleurs, tels que 3, 5, 8, 13, 21, 34, ou 55. Par exemple, les lys ont 3 pétales, les pâquerettes 34 ou 55, et ainsi de suite.

Les botanistes mettent souvent en évidence la corrélation entre la suite de Fibonacci et la nature grâce à la phyllotaxie, qui décrit l’agencement des éléments d’une plante. On observe fréquemment le chiffre 5 dans la disposition des éléments floraux.

Calcul de la Suite de Fibonacci avec Python

Pour calculer la suite de Fibonacci en utilisant Python, nous pouvons suivre sa définition. Nous commençons par attribuer les valeurs 1 aux variables ‘a’ et ‘b’ pour les deux premiers termes de la suite. Ensuite, nous utilisons une boucle ‘for’ pour afficher les ‘N’ premiers termes en calculant chaque terme comme la somme des deux précédents.

Voici un exemple de code Python pour calculer la suite de Fibonacci :

def calculer_fibonacci(n):
    a, b = 1, 1
    for i in range(n):
        print(a, end=" ")
        a, b = b, a + b

n = int(input("Combien de termes de la suite de Fibonacci voulez-vous générer ? : "))
calculer_fibonacci(n)

Ce code demande à l’utilisateur combien de termes de la suite de Fibonacci il souhaite générer, puis il affiche les termes correspondants.

Vous pouvez également implémenter une version récursive de l’algorithme pour calculer la suite de Fibonacci en Python :

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

if __name__ == '__main__':
    n = 8
    result = fibonacci(n)
    print(f"Le terme {n} de la suite de Fibonacci est : {result}")

Ce code utilise une fonction récursive pour calculer le terme souhaité de la suite de Fibonacci.

En résumé, la suite de Fibonacci est une séquence mathématique fascinante qui se manifeste non seulement dans le monde des mathématiques, mais aussi dans la nature. De plus, sa mise en œuvre avec Python est relativement simple, que ce soit avec une approche itérative ou récursive. En outre, elle est utile dans divers domaines, de l’informatique à la biologie en passant par les mathématiques.

Application de la suite de Fibonacci

Testez vos compétences avec ces deux problématiques :

Problématique 1 : Optimisation des Itinéraires de Livraison

Imaginez une entreprise de logistique qui doit livrer des colis à travers une ville. La première problématique consiste à optimiser les itinéraires de livraison pour minimiser le temps de trajet et les coûts opérationnels. Les livreurs doivent efficacement planifier leurs tournées pour éviter les embouteillages, réduire au minimum le nombre de kilomètres parcourus et garantir que chaque livraison est effectuée en temps opportun.

Solution :

Utilisation d’algorithmes d’optimisation, tels que l’algorithme du voyageur de commerce (TSP), pour déterminer les itinéraires les plus courts. Il est possible d’intégrer les données de trafic en temps réel pour ajuster les itinéraires en cours de route. De plus, des logiciels de gestion de la chaîne d’approvisionnement peuvent automatiser la planification.

Code

from itertools import permutations

# Exemple de distances entre les points de livraison
distances = {
    ('A', 'B'): 10,
    ('A', 'C'): 15,
    ('A', 'D'): 20,
    ('B', 'C'): 35,
    ('B', 'D'): 25,
    ('C', 'D'): 30
}

def tsp(distances):
    all_cities = set(city for cities in distances for city in cities)
    shortest_path = None
    min_distance = float('inf')

    for path in permutations(all_cities):
        distance = sum(distances.get((path[i], path[i + 1]), float('inf')) for i in range(len(path) - 1))
        if distance < min_distance:
            shortest_path = path
            min_distance = distance

    return shortest_path, min_distance

shortest_path, min_distance = tsp(distances)
print("Le chemin le plus court est :", shortest_path)
print("La distance minimale est :", min_distance)

Problématique 2 : Détection de la Fraude dans les Transactions Financières

Les entreprises financières sont constamment confrontées à la menace de la fraude. La deuxième problématique consiste à détecter de manière proactive les transactions frauduleuses parmi des milliers de transactions légitimes. La détection précoce de la fraude est essentielle pour éviter les pertes financières et protéger la réputation de l’entreprise.

Solution :

Utilisation de l’apprentissage automatique et de l’analyse de données pour développer des modèles prédictifs de détection de la fraude. Les algorithmes peuvent analyser des schémas suspects, des anomalies, et des comportements inhabituels dans les données transactionnelles. De plus, des systèmes de gestion des risques peuvent être mis en place pour alerter les responsables de la sécurité en cas de transactions suspectes.

Code

from sklearn.ensemble import IsolationForest

# Exemple de données de transactions
data = [
    [100.0],
    [120.0],
    [2000.0],
    [150.0],
    [180.0],
    [2200.0],
    [110.0],
    [2500.0]
]

clf = IsolationForest(contamination=0.2)
clf.fit(data)

fraud_status = clf.predict(data)
print("Statut de fraude pour chaque transaction :", fraud_status)

Défi de Programmation : Sudoku Solver

Le défi de programmation consiste à développer un programme qui peut résoudre un jeu de Sudoku. Le Sudoku est un casse-tête numérique populaire qui consiste en une grille de 9×9 cases, divisée en neuf régions de 3×3 cases. L’objectif est de remplir la grille de manière à ce que chaque rangée, chaque colonne et chaque région contienne toutes les chiffres de 1 à 9, sans répétition.

Solution :

Vous pouvez résoudre ce défi en implémentant un algorithme de récursivité et de rétrogradation (backtracking) qui remplit la grille du Sudoku en testant différentes combinaisons de chiffres jusqu’à ce que la solution correcte soit trouvée. De plus, ce défi demande des compétences en programmation et en algorithmes, ainsi que la capacité à gérer de grandes quantités de données.
Ce défi est un excellent moyen d’améliorer vos compétences en résolution de problèmes et en programmation. Il existe de nombreuses ressources et tutoriels en ligne pour vous aider à démarrer si vous décidez de relever ce défi.

Code

def solve_sudoku(board):
    for i in range(9):
        for j in range(9):
            if board[i][j] == 0:
                for num in range(1, 10):
                    if is_valid(board, i, j, num):
                        board[i][j] = num
                        if solve_sudoku(board):
                            return True
                        board[i][j] = 0
                return False
    return True

def is_valid(board, row, col, num):
    for i in range(9):
        if board[row][i] == num or board[i][col] == num:
            return False
    box_row, box_col = 3 * (row // 3), 3 * (col // 3)
    for i in range(box_row, box_row + 3):
        for j in range(box_col, box_col + 3):
            if board[i][j] == num:
                return False
    return True

# Exemple de grille Sudoku à résoudre (0 représente une case vide)
sudoku_board = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

if solve_sudoku(sudoku_board):
    for row in sudoku_board:
        print(row)
else:
    print("Pas de solution possible.")