🎯 Algorithmes Fonctionnels - Collection Multi-Langages

Une collection pédagogique d'algorithmes implémentés de manière purement fonctionnelle dans 11 langages de programmation différents. Parfait pour apprendre la programmation fonctionnelle, comparer les paradigmes, et découvrir de nouveaux langages.

✨ Points Forts

• 🎯 11 Langages Fonctionnels : Haskell, Scala, JavaScript, Clojure, F#, OCaml, Elixir, Python, Rust, Kotlin, Swift
• 📚 Algorithmes Complets : Tri, recherche, graphes, arbres, mathématiques, chaînes
• 🧪 Tests Exhaustifs : Tests unitaires, d'intégration et property-based
• 📖 Documentation Complète : Guides, exemples et tutoriels pour chaque langage
• 🚀 Prêt à l'Emploi : Configurations build et environnements de développement

📊 Métriques du Projet

Aspect	Statut
Langages Implémentés	11/11 ✅
Algorithmes Moyens	269/312 (86%)
Tests	100% des implémentations ✅
Documentation	Complète ✅
CI/CD	GitHub Actions ✅

🎯 Langages Disponibles

Haskell Pure • Lazy • Mathématique	Scala OO + FP • JVM • Concis	JavaScript Pratique • Web • Universel	Clojure Lisp • Immuable • Macro
F# .NET • ML • Industriel	OCaml ML • Natif • Rapide	Elixir Concurrent • BEAM • Scalable	Python Pragmatique • Écosystème • Simple
Rust Ownership • Sécurisé • Performant	Kotlin Moderne • JVM • Android	Swift Apple • Sécurisé • Rapide	Plus à venir...

📁 Structure du Projet

functional-algorithms/
├── 📂 haskell/          # Haskell purement fonctionnel
├── 📂 scala/            # Scala (OO + Fonctionnel)
├── 📂 javascript/       # JavaScript moderne ES6+
├── 📂 clojure/          # Clojure (Lisp fonctionnel)
├── 📂 fsharp/           # F# (.NET fonctionnel)
├── 📂 ocaml/            # OCaml (ML fonctionnel)
├── 📂 elixir/           # Elixir (concurrence)
├── 📂 python/           # Python fonctionnel
├── 📂 rust/             # Rust (ownership)
├── 📂 kotlin/           # Kotlin (JVM moderne)
├── 📂 swift/            # Swift (Apple moderne)
├── 📋 ALGORITHMS.md     # Catalogue complet des algorithmes
├── 📜 CONTRIBUTING.md   # Guide de contribution
├── ⚖️ LICENSE           # Licence MIT
└── 📖 README.md         # Ce fichier

🧪 Algorithmes Implémentés

Algorithmes de Tri (100% dans tous les langages)

• ✅ Bubble Sort - Tri à bulles O(n²)
• ✅ Insertion Sort - Tri par insertion O(n²)
• ✅ Selection Sort - Tri par sélection O(n²)
• ✅ Quick Sort - Tri rapide O(n log n)
• ✅ Merge Sort - Tri fusion O(n log n)
• ✅ Heap Sort - Tri par tas O(n log n)

Algorithmes de Recherche

• ✅ Binary Search - Recherche binaire O(log n)
• ✅ Linear Search - Recherche linéaire O(n)
• ✅ Jump Search - Recherche par sauts O(√n)
• 🔄 Interpolation Search - Recherche par interpolation

Structures de Données

• ✅ Binary Search Tree - Arbre binaire de recherche
• ✅ Graph (Adjacency List) - Graphe avec liste d'adjacence
• ✅ Functional List - Liste fonctionnelle persistante

Algorithmes sur Graphes

• ✅ DFS/BFS - Parcours en profondeur/largeur
• ✅ Dijkstra - Plus courts chemins
• 🔄 Kruskal/Prim - Arbres couvrants minimums
• 🔄 Topological Sort - Tri topologique

Algorithmes Mathématiques (100%)

• ✅ GCD (Euclide) - PGCD avec algorithme d'Euclide
• ✅ Extended GCD - PGCD étendu avec coefficients
• ✅ Fibonacci - Suite de Fibonacci
• ✅ Factorial - Factorielle
• ✅ Prime Factors - Factorisation en nombres premiers
• ✅ Primality Test - Test de primalité
• ✅ Sieve of Eratosthenes - Crible d'Ératosthène

Algorithmes de Chaînes

• ✅ Levenshtein Distance - Distance d'édition
• ✅ Hamming Distance - Distance de Hamming
• 🔄 KMP Algorithm - Recherche de Knuth-Morris-Pratt
• 🔄 Boyer-Moore - Recherche de Boyer-Moore
• ✅ Run-Length Encoding - Codage RLE

Utilitaires Fonctionnels

• ✅ Function Composition - Composition de fonctions
• ✅ Currying/Uncurrying - Transformations curryfiées
• ✅ Memoization - Mémoïsation automatique
• ✅ Identity/Constant - Fonctions utilitaires

🚀 Démarrage Rapide

Prérequis

• Git
• Environnements de développement pour les langages souhaités

Clonage et Installation

# Clone the repository
git clone https://github.com/your-username/functional-algorithms.git
cd functional-algorithms

# Choose your language
cd haskell  # or scala, javascript, clojure, etc.

# Follow the README instructions for your language
cat README.md

Exemples par Langage

Haskell

cd haskell
cabal build
cabal run

Rust

cd rust
cargo build
cargo run --bin main

Python

cd python
pip install -e .
python src/main.py

Swift

cd swift
swift build
swift run

📈 Comparaison des Paradigmes

Aspect	Haskell	Scala	JavaScript	Clojure	F#	OCaml	Elixir	Python	Rust	Kotlin	Swift
Pureté	Totale	Partielle	Volontaire	Fonctionnelle	Fonctionnelle	Fonctionnelle	Fonctionnelle	Pratique	Hybride	Pratique	Pratique
Types	Forts/statiques	Forts/statiques	Faibles/dynamiques	Dynamiques	Forts/statiques	Forts/statiques	Dynamiques	Dynamiques	Forts/statiques	Forts/statiques	Forts/statiques
Performance	Excellente	Excellente	Bonne	Excellente	Excellente	Excellente	Excellente	Excellente	Excellente	Excellente	Excellente
Courbe d'apprentissage	Raide	Moyenne	Douce	Moyenne	Moyenne	Moyenne	Douce	Très douce	Raide	Moyenne	Moyenne

🎓 Cas d'Usage Pédagogiques

Apprendre la Programmation Fonctionnelle

• Comparez les mêmes algorithmes dans différents paradigmes
• Découvrez les patterns fonctionnels (map, filter, reduce)
• Comprenez l'immuabilité et la récursion

Découvrir de Nouveaux Langages

• Apprenez Haskell, OCaml ou F# pour la première fois
• Comparez Scala vs Kotlin pour le développement JVM
• Découvrez Elixir pour la programmation concurrente

Préparation aux Entretiens Techniques

• Implémentations d'algorithmes courants
• Optimisations et analyses de complexité
• Tests et edge cases

Recherche et Expérimentation

• Comparez les performances entre langages
• Testez de nouvelles approches algorithmiques
• Étudiez les différences d'implémentation

🤝 Contribution

Nous accueillons les contributions ! Voir CONTRIBUTING.md pour :

• 🆕 Ajouter un nouvel algorithme dans un langage existant
• 🌍 Implémenter un langage manquant (Go, R, Julia, Crystal...)
• ⚡ Optimiser les performances d'un algorithme
• 🧪 Ajouter des tests ou corriger des bugs
• 📚 Améliorer la documentation

Comment Contribuer

1. Fork le repository
2. Clone votre fork : git clone https://github.com/michaelgermini/Collection-Functional-Algorithms.git
3. Créez une branche : git checkout -b feature/your-feature-name
4. Commitez vos changements : git commit -m "Add: description claire"
5. Push et créez une Pull Request

📜 Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

🙏 Remerciements

• Contributeurs : Merci à tous ceux qui ont contribué !
• Communauté : Merci au soutien de la communauté open source
• Inspiration : S'inspire des travaux de recherche en programmation fonctionnelle

📞 Support

• 🐛 Bugs : GitHub Issues
• 💡 Features : GitHub Discussions
• 📧 Contact : michael@germini.info

---

⭐ Si ce projet vous aide, n'hésitez pas à lui donner une étoile !

Construit avec ❤️ pour la communauté de la programmation fonctionnelle