- Exécuteurs
-
Apprendre
Apprendre Python Exemples exécutables, NumPy, pandas et plus Apprendre l'IARéseaux de neurones, ML et LLM de zéro Apprendre le C et le C++ Pointeurs, mémoire, STL et C++ moderne Apprendre le C#Bases, POO, LINQ, async et exercices .NET Apprendre MatplotlibCourbes, barres, nuages de points et camemberts avec visualiseurs Algorithmes Python Recherche, tri, récursivité et visualisations O(n) Algorithmes C et C++ Comparer les implémentations en C et C++ Programmation pour enfants Apprends à coder en jouant !
- DéfisNouveau
- EnseignantsNouveau
- Mises à Jour
- Offrez-moi un café
Return the number of days in month of year in the Gregorian calendar. February has 29 days in a leap year: years divisible by 4, except those divisible by 100 unless also divisible by 400. A helper function is_leap(year) keeps the code tidy.
Implement days_in_month(year, month).
Input
year: The year. month: The month, 1 (January) to 12 (December).
Output
Return the number of days.
Contraintes
1 ≤ year ≤ 9,999; 1 ≤ month ≤ 12
Exemples
Exemple 1
Entrée :
year = 2024
month = 2
Sortie attendue :
29Explication
2024 is divisible by 4 and not by 100, so it is a leap year: 29 days.
Exemple 2
Entrée :
year = 1900
month = 2
Sortie attendue :
28Explication
1900 is divisible by 100 but not 400, so it is not a leap year: 28 days.
Références
-
Exemple 1 Non exécutéEntrée :
year = 2024 month = 2Sortie attendue :29Votre sortie -
Exemple 2 Non exécutéEntrée :
year = 1900 month = 2Sortie attendue :28Votre sortie
4 tests cachés seront aussi exécutés lors de la soumission. Si votre code en échoue un, vous verrez ce test. Résolvez le défi pour tous les voir.
Online Rust Compiler
Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.
🚀 252,702 exécutions totales (135 ce mois-ci)
Pratiquez Rust avec des défis de code
Résolvez des problèmes concrets dans cet éditeur : lancez les tests, soumettez et recevez une relecture IA.
🦀 À propos de cet exécuteur de code Rust en ligne
L’exécuteur Rust CodeUtility vous permet d’écrire et d’exécuter du code Rust directement dans votre navigateur - aucune installation, configuration de la chaîne d’outils ou environnement local requis. Il s’appuie sur un bac à sable sécurisé qui prend en charge de vraies versions du compilateur Rust 1.70, 1.72, 1.73 et 1.74.
Cet outil compile et exécute vos programmes Rust dans le cloud à l’aide d’un véritable compilateur rustc,
garantissant des résultats précis et cohérents. Vous pouvez expérimenter facilement les variables, la propriété,
l’emprunt, la correspondance de motifs, les traits, les génériques et d’autres fonctionnalités modernes de Rust.
C’est idéal pour apprendre les concepts essentiels de Rust - en particulier la sécurité mémoire, la gestion des erreurs et la concurrence - sans devoir installer Cargo ni effectuer de configuration locale. Tout s’exécute directement dans votre navigateur en quelques secondes.
Bien plus qu’un exécuteur de code
Utilisez depuis le même exécuteur un éditeur multifichier, un terminal d’exécution isolé, des bibliothèques propres à chaque environnement, des espaces de travail persistants, le partage et la collaboration en temps réel.
Comment utiliser cet exécuteur ?
Choisissez un environnement d’exécution, ouvrez ou créez un fichier, écrivez votre code, puis sélectionnez Exécuter. La sortie s’affiche dans le terminal ; les utilisateurs connectés peuvent conserver leurs fichiers dans un espace de travail, installer des bibliothèques et collaborer grâce aux partages.
- Sélectionnez une version et modifiez le fichier actuel, ou ouvrez un autre fichier de l’espace de travail.
- Exécutez le code, saisissez les données demandées dans le terminal et consultez l’historique des exécutions enregistrées.
- Utilisez les bibliothèques, les outils de l’espace de travail, le partage et le chat lorsque votre tâche nécessite plusieurs extraits de code.
💡 Notions de base de Rust et exemples à essayer ci‑dessus
1. Déclarer des variables et des constantes
Utilisez let pour déclarer des variables. Utilisez const pour les constantes et mut pour les variables mutables.
let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;
const MAX_USERS: u32 = 100;2. Conditions (if / match)
Rust utilise if pour les conditions et match pour la correspondance de motifs.
let x = 2;
if x == 1 {
println!("Un");
} else if x == 2 {
println!("Deux");
} else {
println!("Autre");
}
match x {
1 => println!("Un"),
2 => println!("Deux"),
_ => println!("Autre"),
}3. Boucles
Rust prend en charge for, while et loop pour les boucles infinies.
for i in 0..3 {
println!("{}", i);
}
let mut n = 3;
while n > 0 {
println!("{}", n);
n -= 1;
}4. Tableaux
Les tableaux de taille fixe en Rust utilisent des crochets. Utilisez des slices pour obtenir des vues.
let nums = [10, 20, 30];
println!("{}", nums[1]);5. Vecteurs (tableaux dynamiques)
Vec est utilisé pour les tableaux dynamiques.
let mut fruits = vec!["pomme", "banane"];
fruits.push("cerise");
fruits.pop();
for fruit in &fruits {
println!("{}", fruit);
}6. Entrée/Sortie console
Utilisez println! pour la sortie et std::io pour l’entrée.
use std::io;
let mut name = String::new();
println!("Entrez votre nom :");
io::stdin().read_line(&mut name).unwrap();
println!("Bonjour, {}", name.trim());7. Fonctions
Les fonctions utilisent fn et peuvent retourner des valeurs avec ->.
fn greet(name: &str) -> String {
format!("Bonjour, {}", name)
}
println!("{}", greet("Alice"));8. HashMaps
Utilisez std::collections::HashMap pour les données clé‑valeur.
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("nom", "Bob");
println!("{}", person["nom"])9. Gestion des erreurs
Rust gère les erreurs avec Result et match ou unwrap().
fn fail() -> Result<(), String> {
Err("Quelque chose s’est mal passé".to_string())
}
match fail() {
Ok(_) => println!("Succès"),
Err(e) => println!("{}", e),
}10. Entrée/Sortie de fichiers
Utilisez std::fs pour lire et écrire des fichiers.
use std::fs;
fs::write("fichier.txt", "Bonjour fichier").unwrap();
let content = fs::read_to_string("fichier.txt").unwrap();
println!("{}", content);11. Manipulation de chaînes
Les chaînes en Rust sont allouées sur le tas et prennent en charge de nombreuses méthodes.
let mut text = String::from(" Bonjour Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Bonjour", "Salut");
println!("{}", text);12. Structs et méthodes
Rust utilise struct pour les types de données et impl pour les méthodes.
struct Person {
name: String,
}
impl Person {
fn greet(&self) -> String {
format!("Salut, je m'appelle {}", self.name)
}
}
let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());13. Références et emprunt
Rust utilise & pour emprunter des valeurs et &mut pour des références mutables.
fn update(x: &mut i32) {
*x += 1;
}
let mut value = 10;
update(&mut value);
println!("{}", value);