Introducción
Arrays
La biblioteca central de Cairo implementa un tipo Array.
Es similar a los tipos array habituales de otros lenguajes de programación, pero con algunas diferencias clave:
- Los elementos solo se pueden añadir de forma eficiente al final del tipo
Array, y solo se pueden eliminar de forma eficiente del principio.
- Es imposible asignar manualmente un elemento 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 añadir 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 no es más que una estructura de datos que permite a Cairo «ver» una sección del array, sin modificarla de ninguna forma.
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 principio 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]
Ten en cuenta que tuvimos que hacer mutable one_to_four_span con la palabra clave mut para invocar pop_back, que modifica el span acortando 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 de la pila 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 añadida a la parte superior de la pila.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Elimina la carta superior de la pila
Implementa la función remove_top_card que devuelve una copia de la pila tras haber eliminado su 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 añadida a la parte inferior de la pila.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Elimina una carta de la parte inferior de la pila
Implementa la función remove_bottom_card que devuelve una copia de la pila tras haber eliminado su 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 al stack_size proporcionado 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 sencillo como en otros lenguajes de programación, conviene tener en cuenta que Cairo usa un modelo de memoria inmutable, lo que significa que, una vez que se escribe en una celda de memoria, esta no se puede sobrescribir jamás, solo leer.
El lenguaje abstrae un poco esta característica, lo que permite a los desarrolladores declarar y usar sus variables como si fueran mutables.
Aunque esto hace que escribir código sea un poco más complicado, sobre todo el código que usa el tipo Array (incluido ByteArray, que en realidad es un «array de bytes»), permite escribir programas demostrables que pueden ejecutarse con confianza incluso en máquinas que no son de fiar, lo que hace que la contrapartida merezca de sobra la pena.
Ejercicio de aprendizaje
