Introducción
Arrays
La biblioteca central de Cairo implementa un tipo Array.
Es similar a los tipos de array habituales de otros lenguajes de programación, pero tiene algunas diferencias clave:
- Los elementos solo se pueden agregar de forma eficiente al final del tipo
Array, y solo se pueden eliminar de forma eficiente desde el frente.
- Es imposible asignar un elemento manualmente usando el índice del array.
Los arrays se pueden crear con la función ArrayTrait::new y también con la macro array!:
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
Los elementos se pueden agregar al array con la función ArrayTrait::append:
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
Los elementos se pueden eliminar del array con la función ArrayTrait::pop_front:
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
Cairo también introduce un tipo Span que actúa como una «instantánea» del Array.
Cualquier Array se puede convertir en un Span con la función ToSpanTrait::span:
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
Convertir un array en un Span es muy eficiente, ya que Span es solo una estructura de datos que le permite a Cairo «ver» una sección del array; no lo modifica de ninguna manera.
Al convertir un array en un Span, Cairo permite realizar más operaciones de las que se permitirían directamente sobre Array, como eliminar un elemento del frente del span.
let one_to_four = array![1, 2, 3, 4];
let mut one_to_four_span = one_to_four.span();
one_to_four_span.pop_back();
// -> [2, 3, 4]
Fíjate que tuvimos que hacer mutable one_to_four_span con la palabra clave mut para poder invocar pop_back, que modifica el span al acortar la sección del array que el span está «viendo».
Instrucciones
Como futura maga, Elyse necesita practicar algunos conceptos básicos.
Tiene una pila de cartas que quiere manipular.
Para que todo sea un poco más fácil, solo usa las cartas del 1 al 10.
La pila de cartas se representa con un Array, con la parte inferior de la pila al principio del array y la parte superior al final.
1. Inserta una carta en la parte superior de la pila
Implementa la función insert_top, que devuelve una copia de la pila con la nueva carta proporcionada agregada en la parte superior de la pila.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Quita la carta superior de la pila
Implementa la función remove_top_card, que devuelve una copia de la pila después de quitarle la carta superior.
Si la pila dada está vacía, se debe devolver la pila original, sin cambios.
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. Inserta una carta en la parte inferior de la pila
Implementa la función insert_bottom, que devuelve una copia de la pila con la nueva carta proporcionada agregada en la parte inferior de la pila.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Quita una carta de la parte inferior de la pila
Implementa la función remove_bottom_card, que devuelve una copia de la pila después de quitarle la carta inferior.
Si la pila dada está vacía, se debe devolver la pila original, sin cambios.
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. Comprueba el tamaño de la pila
Implementa la función check_size_of_stack, que comprueba si el tamaño de la pila es igual a un stack_size dado o no.
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Para entender por qué trabajar con arrays en Cairo no es tan directo como en otros lenguajes de programación, conviene tener en cuenta que Cairo usa un modelo de memoria inmutable: una vez que se escribe en una celda de memoria, ya no se puede sobrescribir nunca, solo se puede leer de ella.
El lenguaje abstrae un poco esta característica, y permite declarar y usar las variables como si fueran mutables.
Aunque esto hace que escribir código sea un poco más difícil, sobre todo el código que usa el tipo Array (incluido ByteArray, que por debajo es un «array de bytes»), permite escribir programas demostrables que se pueden ejecutar con confianza incluso en máquinas que no son de confianza, por lo que bien vale la pena el sacrificio.
Ejercicio de aprendizaje
