Parcours
/
Cairo
Cairo
/
Exercices
/
Jeu embarqué à faible consommation
Jeu embarqué à faible consommation

Jeu embarqué à faible consommation

Exercice d'apprentissage

Introduction

Les tuples sont un moyen léger de regrouper un ensemble fixe de types de données arbitraires. Un tuple n'a pas de nom particulier ; le fait de nommer une structure de données la transforme en struct. Les champs d'un tuple n'ont pas de nom ; on y accède par déstructuration ou par position.

Création

Les tuples sont toujours créés à l'aide d'une expression de tuple :

// pointless but legal
let unit = ();
// single element
let single_element = ("note the comma",);
// two element
let two_element = (123, "elements can be of differing types");

Les tuples peuvent contenir un nombre arbitraire d'éléments.

Accès par déstructuration

Il est possible d'accéder aux éléments d'un tuple par déstructuration. Cela revient simplement à attribuer des noms de variables aux éléments individuels du tuple, ce qui le consomme.

let (elem1, _elem2) = two_element;
assert_eq!(elem1, 123);

Instructions

Tu travailles sur un jeu qui cible un système embarqué à faible consommation, et tu dois écrire plusieurs traits de commodité qui seront utilisés par d'autres parties du jeu.

1. Calcule le quotient et le reste d'une division

Le quotient est le résultat d'une division.

fn divmod(self: @u16, divisor: u16) -> (u16, u16)

Exemple :

let dividend: u16 = 10;
assert_eq!(dividend.divmod(3), (3, 1));

2. Choisis les éléments aux positions paires d'un tableau

Cela t'aidera à activer une optimisation du tampon d'écran, promet ton patron.

trait EvensTrait<T> {
    fn evens(self: @Array<T>) -> Array<T>;
}

Exemples :

let arr: Array<u16> = array![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
assert_eq!(arr.evens(), array![0, 2, 4, 6, 8]);
let arr: Array<u16> = array![1, 2, 3, 4, 5, 6, 7, 8, 9];
assert_eq!(arr.evens(), array![1, 3, 5, 7, 9]);

3. Calcule la distance de Manhattan d'une position par rapport à l'origine

Pour faciliter la cartographie, tu disposes d'un type tuple Position :

type Position = (i16, i16);

Tu dois implémenter une méthode manhattan sur Position qui renvoie la distance de Manhattan de cette position par rapport à l'origine (let p: Position = (0, 0)).

trait PositionTrait {
    fn manhattan(self: @Position) -> i16
}

Exemple :

let p: Position = (3, 4);
assert_eq!(p.manhattan(), 7);
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
Cairo Exercism

Prêt à commencer Jeu embarqué à faible consommation ?

Inscris-toi sur Exercism pour apprendre et maîtriser Cairo avec 25 concepts68 exercices, et un vrai mentorat humain, le tout gratuitement.