Ir al contenido
Descargar
Curso de Grost

Listas

Módulo 2 · Datos y coleccionesLección 6 de 209 min de lectura4 retos
main.groPaso 1 de 4
monedas : []int = [5, 10, 20]1 · Una listaUna lista guarda varios valores en orden. []int dice que todos son int, y los valores van entre corchetes, separados por comas.print(monedas)
Output
[5, 10, 20]
main.groPaso 2 de 4
monedas : []int = [5, 10, 20]
print(monedas[0])
print(monedas[2])2 · Leer por posiciónCada valor tiene una posición, su índice. Se empieza a contar en 0: monedas[0] es el primero y monedas[2], el tercero.
Output
5
20
main.groPaso 3 de 4
mut monedas : []int = [5, 10, 20]
monedas.append(50)
print(monedas.size())3 · Añadir al finalCon mut la lista puede cambiar. append añade un valor al final y size() dice cuántos hay.
Output
4
main.groPaso 4 de 4
monedas : []int = [5, 10, 20]
mut total : int = 0
for m : int in monedas {
  total += m
}4 · Recorrerla con forfor recorre la lista: en cada vuelta, m toma el siguiente valor. Aquí se suman todos.print(total)
Output
35
También con las flechas ← →

Un juego casi nunca tiene una sola cosa de cada tipo: hay varias monedas en el nivel, varios objetos en la mochila, una tabla de puntuaciones. Guardar cada una en su propia variable (puntos1, puntos2, puntos3…) no funciona, porque no sabes cuántas habrá.

Para eso están las listas: un solo nombre que guarda muchos valores, uno detrás de otro.

Crear una lista

main.gro
module Listas
fn _ready() void {
puntos : []int = [30, 10, 20]
nombres : []String = ["Ana", "Leo"]
vacia : []int = []
print(puntos)
print(nombres)
print(vacia.size())
}
Output[30, 10, 20] ["Ana", "Leo"] 0
ParteQué hace
puntosEl nombre de la lista
: []intSu tipo: los corchetes delante de int quieren decir “lista de int”
[30, 10, 20]Los valores, entre corchetes y separados por comas
[]Una lista vacía, sin ningún valor

Todos los valores de una lista son del mismo tipo: en un []int solo caben enteros, y en un []String, solo textos. Si intentas meter un texto en un []int, Grost te avisa.

¿Por qué en otros sitios las llaman arrays?

Es su nombre en inglés, y el que usan Grost y casi todos los lenguajes. En este curso decimos “lista”, pero si lees array en el libro de Grost, es lo mismo.

Leer por posición: el índice

Cada valor de la lista tiene una posición, que se llama índice. Para leer uno, pon su índice entre corchetes detrás del nombre:

main.gro
module Indices
fn _ready() void {
puntos : []int = [30, 10, 20]
print(puntos[0])
print(puntos[1])
print(puntos[-1])
}
Output30 10 20
  • El primero es el 0, no el 1. En una lista de tres, los índices son 0, 1 y 2.
  • Un índice negativo cuenta desde el final: puntos[-1] es el último.
¿Por qué se empieza a contar en 0?

Piensa en el índice como “cuántos valores hay antes que él”. Delante del primero no hay ninguno, así que su índice es 0.

Cambiar una lista

Una lista que cambia (una mochila en la que metes y sacas cosas) se declara con mut, como cualquier variable que cambia:

main.gro
module Mochila
fn _ready() void {
mut mochila : []String = ["espada", "escudo"]
mochila.append("llave")
mochila[0] = "hacha"
print(mochila)
print(mochila.size())
mochila.remove_at(1)
print(mochila)
}
Output["hacha", "escudo", "llave"] 3 ["hacha", "llave"]
  • append("llave") añade al final.
  • mochila[0] = "hacha" cambia el valor de esa posición.
  • remove_at(1) quita el de la posición 1, y los que venían detrás avanzan un puesto.

Sin mut, Grost no te deja añadir ni quitar valores: te pide que la declares con mut.

Estas son las funciones que más vas a usar. Se escriben con un punto detrás del nombre de la lista, como mochila.size():

EscribesQué hace
append(v)Añade v al final
size()Cuántos valores hay
is_empty()Si está vacía (true o false)
has(v)Si contiene v
find(v)La posición de v, o -1 si no está
remove_at(i)Quita el valor de la posición i
sort()La ordena de menor a mayor
clear()La vacía
main.gro
module Buscar
fn _ready() void {
mut puntos : []int = [30, 10, 20]
print(puntos.has(20))
print(puntos.find(20))
print(puntos.find(99))
puntos.sort()
print(puntos)
}
Outputtrue 2 -1 [10, 20, 30]

Recorrer una lista con for

En el módulo anterior usaste for con range. Con una lista funciona igual: el bucle da una vuelta por cada valor.

main.gro
module Recorrer
fn _ready() void {
mochila : []String = ["espada", "llave", "poción"]
for objeto : String in mochila {
print($"Llevas: {objeto}")
}
}
OutputLlevas: espada Llevas: llave Llevas: poción

objeto es una variable nueva que en cada vuelta vale el siguiente elemento. Ponle el tipo de los valores de la lista (: String).

Si además necesitas la posición, recorre los índices con range y size():

main.gro
module Podio
fn _ready() void {
puntos : []int = [340, 120, 90]
for i : int in range(puntos.size()) {
print($"Puesto {i + 1}: {puntos[i]}")
}
}
OutputPuesto 1: 340 Puesto 2: 120 Puesto 3: 90

Una lista en el juego: las puntuaciones

Una lista declarada fuera de las funciones es parte de la memoria del script: va creciendo partida a partida.

main.gro
module Puntuaciones
mut puntuaciones : []int = []
fn guardar(puntos: int) void {
puntuaciones.append(puntos)
}
fn mejor() int {
mut maximo : int = 0
for p : int in puntuaciones {
if p > maximo {
maximo = p
}
}
return maximo
}
fn _ready() void {
guardar(120)
guardar(340)
guardar(90)
print($"Partidas: {puntuaciones.size()}, mejor: {mejor()}")
}
OutputPartidas: 3, mejor: 340

mejor() recorre la lista y se queda con el valor más alto que encuentra. Es un patrón que vas a repetir mucho: el enemigo más cercano, el objeto más caro, la vuelta más rápida.

Dos nombres, una sola lista

Hay algo de las listas que sorprende al principio. Si asignas una lista a otra variable, no se copia: las dos variables son nombres de la misma lista.

main.gro
module Compartir
fn _ready() void {
mut a : []int = [1, 2]
mut b : []int = a
b.append(3)
print(a)
mut copia : []int = a.duplicate()
copia.append(4)
print(a)
print(copia)
}
Output[1, 2, 3] [1, 2, 3] [1, 2, 3, 4]
  • Lo que añades por b aparece en a, porque son la misma lista.
  • duplicate() crea una copia aparte: cambiarla no toca la original.

Hora de practicar

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué imprime este código?

main.gro
nombres : []String = ["Ana", "Leo", "Zoe"]
print(nombres[1])
El índice empieza en 0: nombres[0] es Ana y nombres[1], Leo.
Recuerda en qué número empieza a contar el índice.
Reto 2 de 4sin resolver

Completa el código: añade la llave a la mochila e imprime cuántos objetos hay.

Salida esperada
2
main.gro
mut mochila : []String = ["espada"]
mochila.("llave")
print(mochila.())
El primer hueco añade al final; el segundo cuenta los valores.
Solución:
main.gro
mut mochila : []String = ["espada"]
mochila.append("llave")
print(mochila.size())
Reto 3 de 4sin resolver

¿Qué imprime este código?

main.gro
puntos : []int = [4, 9, 2]
mut mejor : int = 0
for p : int in puntos {
  if p > mejor {
    mejor = p
  }
}
print(mejor)
El bucle se queda con el mayor: 4, luego 9, y el 2 no lo supera.
Sigue el valor de mejor en cada vuelta: solo cambia cuando aparece uno más grande.
Reto 4 de 4sin resolver

¿Qué imprime este código?

main.gro
mut a : []int = [1, 2]
mut b : []int = a
b.append(3)
print(a)
a y b son dos nombres de la misma lista, así que lo que añades por b también se ve por a. Para una copia aparte, usa a.duplicate().
Al escribir b = a no se crea una lista nueva.