Daftar

Las listas representan colecciones ordenadas de valores. Pueden declararse con tipo especifico (lista<entero>) o sin tipo (lista).

Declaracion

// Lista tipada
lista<texto> nombres = ["Ana", "Carlos", "Maria"]
lista<entero> numeros = [1, 2, 3, 4, 5]
lista<numero> precios = [10.5, 20.3, 15.0]

// Lista no tipada (puede contener cualquier tipo)
lista mixta = [1, "dos", verdadero, 3.14]

// Lista vacia
lista<entero> vacia = []

Las listas son inmutables a menos que se indiquen como variables con var.

lista<entero> var numeros = [3, 1, 4]
numeros.agregar(2)  // Ahora: [3, 1, 4, 2]

Acceso a elementos

Indices positivos comienzan en 0.
Indices negativos acceden desde el final (-1 es el ultimo elemento).

lista<texto> frutas = ["manzana", "banana", "cereza"]

texto primera = frutas[0]    // "manzana"
texto segunda = frutas[1]    // "banana"
texto ultima = frutas[-1]    // "cereza"
texto penultima = frutas[-2] // "banana"

Metodos de listas

Informacion basica

Metodo	Descripcion	Retorna
`longitud()`	Numero de elementos	`entero`
`esta_vacia()`	Verifica si la lista no tiene elementos	`log`
`contiene(valor)`	Verifica la presencia de un valor	`log`

lista<texto> frutas = ["manzana", "banana"]

entero tamaño = frutas.longitud()     // 2
log vacia = frutas.esta_vacia()       // falso
log tiene = frutas.contiene("banana") // verdadero

Agregar y remover elementos

Metodo	Descripcion
`agregar(valor)`	Inserta al final
`insertar(indice, valor)`	Inserta en una posicion especifica
`remover(valor)`	Elimina la primera coincidencia
`quitar_en(indice)`	Elimina y devuelve el elemento de la posicion
`limpiar()`	Vacia la lista

lista<texto> var frutas = ["manzana", "banana"]

// Agregar al final
frutas.agregar("cereza")
// ["manzana", "banana", "cereza"]

// Insertar en posicion especifica
frutas.insertar(1, "naranja")
// ["manzana", "naranja", "banana", "cereza"]

// Remover por valor
frutas.remover("banana")
// ["manzana", "naranja", "cereza"]

// Remover por indice
texto removido = frutas.quitar_en(0)
// removido = "manzana", frutas = ["naranja", "cereza"]

// Vaciar la lista
frutas.limpiar()
// []

Busqueda

Metodo	Descripcion	Retorna
`buscar(valor)`	Posicion de la primera coincidencia	`entero` (-1 si no existe)
`buscar_ultimo(valor)`	Posicion de la ultima coincidencia	`entero` (-1 si no existe)
`contar(valor)`	Numero de veces que aparece	`entero`

lista<texto> letras = ["a", "b", "a", "c", "a"]

entero primera = letras.buscar("a")        // 0
entero ultima = letras.buscar_ultimo("a")  // 4
entero cuenta = letras.contar("a")         // 3
entero no_existe = letras.buscar("z")      // -1

Ordenacion

Metodo	Descripcion	Modifica original
`ordenar()`	Ordena ascendente	Si
`ordenar_descendente()`	Ordena descendente	Si
`ordenado()`	Devuelve copia ordenada	No
`invertir()`	Invierte el orden	Si

lista<entero> var numeros = [3, 1, 4, 2]

// Ordenar ascendente (modifica la lista)
numeros.ordenar()
// [1, 2, 3, 4]

// Ordenar descendente
numeros.ordenar_descendente()
// [4, 3, 2, 1]

// Obtener copia ordenada sin modificar original
lista<entero> copia = numeros.ordenado()

// Invertir orden
numeros.invertir()
// [1, 2, 3, 4]

Extraccion de elementos

Metodo	Descripcion
`primero()`	Obtiene el primer elemento
`ultimo()`	Obtiene el ultimo elemento
`tomar(n)`	Crea sublista con los primeros `n` elementos
`saltar(n)`	Omite los primeros `n` elementos
`sublista(inicio, fin)`	Extrae un rango (sin incluir `fin`)

lista<texto> frutas = ["manzana", "banana", "cereza", "durazno"]

texto primera = frutas.primero()  // "manzana"
texto ultima = frutas.ultimo()    // "durazno"

lista<texto> primeras_dos = frutas.tomar(2)
// ["manzana", "banana"]

lista<texto> sin_primeras = frutas.saltar(2)
// ["cereza", "durazno"]

lista<texto> medio = frutas.sublista(1, 3)
// ["banana", "cereza"]

Operaciones numericas

Estos metodos funcionan con listas de entero o numero.

Metodo	Descripcion
`sumar()`	Suma todos los elementos
`promedio()`	Calcula el promedio
`maximo()`	Obtiene el valor maximo
`minimo()`	Obtiene el valor minimo

lista<entero> numeros = [1, 2, 3, 4, 5]

entero suma = numeros.sumar()        // 15
numero promedio = numeros.promedio() // 3.0
entero max = numeros.maximo()        // 5
entero min = numeros.minimo()        // 1

// Con numeros decimales
lista<numero> precios = [10.5, 20.3, 15.0]
numero total = precios.sumar()  // 45.8

Combinacion de listas

Metodo	Descripcion	Modifica original
`concatenar(otra)`	Devuelve nueva lista combinada	No
`extender(otra)`	Añade elementos de otra lista	Si
`unir(delimitador)`	Concatena elementos como texto	No

lista<texto> lista1 = ["A", "B"]
lista<texto> lista2 = ["C", "D"]

// Concatenar (crea nueva lista)
lista<texto> combinada = lista1.concatenar(lista2)
// ["A", "B", "C", "D"]

// Extender (modifica la original)
lista<texto> var base = ["A", "B"]
base.extender(lista2)
// base = ["A", "B", "C", "D"]

// Unir como texto
lista<texto> palabras = ["Hola", "Mundo", "Quetzal"]
texto frase = palabras.unir(" ")  // "Hola Mundo Quetzal"

lista<entero> nums = [1, 2, 3]
texto numeros_texto = nums.unir(", ")  // "1, 2, 3"

Conversion

Metodo	Descripcion
`texto()`	Representacion textual
`json()`	Convierte a JSON
`logico()`	`verdadero` si no esta vacia

lista<texto> frutas = ["manzana", "banana"]

texto como_texto = frutas.texto()  // "[manzana, banana]"
texto como_json = frutas.json()    // '["manzana","banana"]'
log tiene_elementos = frutas.logico()  // verdadero

Matrices multidimensionales

Las matrices son listas de listas, permitiendo crear estructuras de datos multidimensionales.

Matriz 2D

lista<lista<entero>> matriz_2d = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

// Acceder a elementos
entero valor = matriz_2d[1][2]  // 6 (fila 1, columna 2)
entero primera_fila_primer_elem = matriz_2d[0][0]  // 1

// Obtener una fila completa
lista<entero> fila = matriz_2d[1]  // [4, 5, 6]

Matriz 3D

lista<lista<lista<numero>>> matriz_3d = [
    [
        [1.1, 1.2],
        [1.3, 1.4]
    ],
    [
        [2.1, 2.2],
        [2.3, 2.4]
    ]
]

// Acceder a elementos
numero valor = matriz_3d[1][0][1]  // 2.2

Modificar matrices

lista<lista<entero>> var matriz = [
    [1, 2],
    [3, 4]
]

// Modificar un elemento
matriz[0][1] = 10
// [[1, 10], [3, 4]]

// Agregar una fila
matriz.agregar([5, 6])
// [[1, 10], [3, 4], [5, 6]]

Iterar sobre matrices

lista<lista<entero>> matriz = [
    [1, 2, 3],
    [4, 5, 6]
]

// Iterar por filas
para (lista<entero> var fila en matriz) {
    consola.mostrar(t"Fila: {fila.texto()}")
}

// Iterar por elementos individuales
para (lista<entero> var fila en matriz) {
    para (entero var elemento en fila) {
        consola.mostrar(t"Elemento: {elemento}")
    }
}

Funcion `rango`

Genera listas de enteros consecutivos.

// Desde 0 hasta n-1
lista<entero> del_cero = rango(5)
// [0, 1, 2, 3, 4]

// Desde inicio hasta fin-1
lista<entero> del_dos = rango(2, 7)
// [2, 3, 4, 5, 6]

Manejo de errores

Cuando un indice no existe, el interprete lanza una excepcion.

lista<texto> frutas = ["manzana", "banana"]

intentar {
    texto elemento = frutas[10]  // Error: indice fuera de rango
} capturar (excepcion error) {
    consola.mostrar_advertencia(error.mensaje)
}

Buenas practicas

Usa listas tipadas cuando conozcas el tipo de elementos para mayor seguridad.
Declara como var solo las listas que necesites modificar.
Verifica indices antes de acceder o usa intentar/capturar.
Usa metodos como esta_vacia() antes de llamar a primero() o ultimo().

lista<entero> var numeros = []

// Verificar antes de acceder
si (!numeros.esta_vacia()) {
    entero primero = numeros.primero()
    consola.mostrar(t"Primer elemento: {primero}")
} sino {
    consola.mostrar_advertencia("La lista esta vacia")
}