Track
/
Cairo
Cairo
/
Esercizi
/
Gioco embedded a basso consumo
Gioco embedded a basso consumo

Gioco embedded a basso consumo

Esercizio di apprendimento

Introduzione

Le tuple sono un modo leggero per raggruppare un insieme fisso di dati di tipo arbitrario. Una tupla non ha un nome particolare; dare un nome a una struttura dati la trasforma in una struct. I campi di una tupla non hanno nomi; vi si accede tramite destrutturazione o in base alla posizione.

Creazione

Le tuple si creano sempre con un'espressione di tupla:

// 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");

Le tuple possono avere un numero arbitrario di elementi.

Accesso tramite destrutturazione

È possibile accedere agli elementi di una tupla tramite destrutturazione. Questo significa semplicemente assegnare nomi di variabile ai singoli elementi della tupla, consumandola.

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

Istruzioni

Stai lavorando a un gioco destinato a un sistema embedded a basso consumo e devi scrivere diversi trait di utilità che verranno usati da altre parti del gioco.

1. Calcola il quoziente e il resto di una divisione

Il quoziente è l'output di una divisione.

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

Esempio:

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

2. Scegli gli elementi in posizione pari da un array

Sarà utile per abilitare un'ottimizzazione del buffer dello schermo, come promette il tuo capo.

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

Esempi:

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. Calcola la distanza di Manhattan di una posizione dall'origine

Per comodità di mappatura, hai un tipo tupla Position:

type Position = (i16, i16);

Devi implementare un metodo manhattan su Position che restituisce la distanza di Manhattan di quella posizione dall'origine (let p: Position = (0, 0)).

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

Esempio:

let p: Position = (3, 4);
assert_eq!(p.manhattan(), 7);
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
Cairo Exercism

Vuoi iniziare Gioco embedded a basso consumo?

Iscriviti a Exercism per imparare e padroneggiare Cairo con 25 concetti68 esercizi e il mentoring di persone reali, tutto gratis.