Arreglos
## Objetivos de Aprendizaje
- Dominar la manipulacion de arreglos
- Usar operaciones de listas
- Trabajar con map y grep
- Ordenar arreglos efectivamente
- Comprender el contexto de arreglos
## Basicos de Arreglos
### Creando Arreglos
```perl
use strict;
use warnings;
my @vacio;
my @nums = (1, 2, 3, 4, 5);
my @mixed = ("hola", 42, 3.14);
my @rango = (1 .. 10);
my @letras = ('a' .. 'z');
```
### Tamano de Arreglo
```perl
my @colores = ("rojo", "verde", "azul");
print scalar @colores; # 3 (numero de elementos)
print $#colores; # 2 (ultimo indice)
```
### Accediendo a Elementos
```perl
my @frutas = ("manzana", "banana", "cereza");
print $frutas[0]; # "manzana"
print $frutas[-1]; # "cereza" (ultimo elemento)
print $frutas[-2]; # "banana" (penultimo)
# Modificar
$frutas[0] = "albaricoque";
```
## Operaciones de Listas
### Push y Pop
```perl
my @pila = (1, 2, 3);
push @pila, 4; # (1, 2, 3, 4)
my $sacado = pop @pila; # Retorna 4, @pila = (1, 2, 3)
unshift @pila, 0; # (0, 1, 2, 3)
my $desplazado = shift @pila; # Retorna 0, @pila = (1, 2, 3)
```
### splice
```perl
my @nums = (1, 2, 3, 4, 5);
# Remover y reemplazar
splice @nums, 1, 2, (10, 20); # (1, 10, 20, 4, 5)
# Solo remover
splice @nums, 0, 2; # Retorna (1, 10), @nums = (20, 4, 5)
# Solo insertar
splice @nums, 1, 0, (30, 40); # Insertar en posicion 1
```
### join y split
```perl
my @palabras = ("Hola", "Mundo", "Perl");
my $oracion = join " ", @palabras;
print $oracion; # "Hola Mundo Perl"
my $linea = "manzana,banana,cereza";
my @frutas = split ",", $linea;
print "@frutas"; # manzana banana cereza
# Split con limite
my @partes = split ":", "a:b:c:d", 2; # ("a", "b:c:d")
```
### reverse
```perl
my @nums = (1, 2, 3, 4, 5);
my @invertido = reverse @nums; # (5, 4, 3, 2, 1)
my @chars = split "", "hola";
my @rev_chars = reverse @chars;
my $rev_string = join "", @rev_chars; # "aloh"
```
## map
### map Basico
```perl
use strict;
use warnings;
my @nums = (1, 2, 3, 4, 5);
# Cuadrado de cada numero
my @cuadrados = map { $_ * $_ } @nums;
print "@cuadrados\n"; # 1 4 9 16 25
# Transformar cadenas
my @nombres = ("alice", "bob", "charlie");
my @caps = map { ucfirst lc $_ } @nombres;
print "@caps\n"; # Alice Bob Charlie
```
### map con Multiples Expresiones
```perl
my %hash = (
a => 1,
b => 2,
c => 3,
);
# Duplicar valores
my %duplicado = map { $_, $hash{$_} * 2 } keys %hash;
print "$_ => $duplicado{$_}\n" for keys %duplicado;
```
### map vs foreach
```perl
# map retorna lista transformada
my @cuadrados = map { $_ * $_ } (1 .. 5);
# foreach solo itera
foreach my $num (1 .. 5) {
print "$num ";
}
```
## grep
### grep Basico
```perl
use strict;
use warnings;
my @nums = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
# Encontrar numeros pares
my @pares = grep { $_ % 2 == 0 } @nums;
print "@pares\n"; # 2 4 6 8 10
# Encontrar numeros mayores a 5
my @grandes = grep { $_ > 5 } @nums;
print "@grandes\n"; # 6 7 8 9 10
```
### grep con Regex
```perl
my @palabras = ("manzana", "banana", "albaricoque", "cereza", "aguacate");
# Palabras que empiezan con 'a'
my @a_palabras = grep { /^a/ } @palabras;
print "@a_palabras\n"; # manzana albaricoque aguacate
# Palabras que contienen 'an'
my @an_palabras = grep { /an/ } @palabras;
print "@an_palabras\n"; # banana albaricoque
```
### grep vs grep not
```perl
my @nums = (1, 2, 3, 4, 5);
my @chicos = grep { $_ < 4 } @nums; # 1, 2, 3
my @no_chicos = grep { $_ >= 4 } @nums; # 4, 5
```
## sort
### sort Basico
```perl
use strict;
use warnings;
my @nums = (3, 1, 4, 1, 5, 9, 2, 6);
my @ordenado = sort @nums;
print "@ordenado\n"; # 1 1 2 3 4 5 6 9 (ordena como cadenas!)
# Ordenamiento de cadenas
my @palabras = ("banana", "manzana", "cereza");
my @alpha = sort @palabras;
print "@alpha\n"; # manzana banana cereza
```
### Ordenamiento Numerico
```perl
my @nums = (3, 1, 4, 1, 5, 9, 2, 6);
my @ordenado = sort { $a <=> $b } @nums;
print "@ordenado\n"; # 1 1 2 3 4 5 6 9
# Numerico inverso
my @inv = sort { $b <=> $a } @nums;
print "@inv\n"; # 9 6 5 4 3 2 1 1
```
### Ordenamiento Personalizado
```perl
# Por longitud
my @palabras = ("manzana", "hola", "banana", "a", "cereza");
my @por_len = sort { length($a) <=> length($b) } @palabras;
print "@por_len\n"; # a hola manzana banana cereza
# Ordenamiento sin caso
my @mixed = ("Manzana", "banana", "Cereza");
my @ordenado = sort { lc($a) cmp lc($b) } @mixed;
print "@ordenado\n"; # Manzana banana Cereza
# Orden estable (preserve orden de iguales)
```
### Ordenar Claves/Valores de Hash
```perl
my %puntuaciones = (
Alice => 95,
Bob => 87,
Charlie => 92,
);
# Ordenar por valores
my @por_puntuacion = sort { $puntuaciones{$a} <=> $puntuaciones{$b} } keys %puntuaciones;
print "@por_puntuacion\n"; # Bob Charlie Alice
```
## Operaciones Avanzadas de Arreglos
### Asignacion de Lista
```perl
my ($primero, $segundo, @resto) = (1, 2, 3, 4, 5);
print "$primero, $segundo, @resto\n"; # 1, 2, 3 4 5
# Intercambiar valores
my ($x, $y) = (10, 20);
($x, $y) = ($y, $x); # Intercambio!
```
### Lista como Valor de Retorno
```perl
sub obtener_rango {
return (1 .. 10);
}
my @nums = obtener_rango(); # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
```
### Aplanamiento
```perl
my @a = (1, 2);
my @b = (3, 4);
my @combinado = (@a, @b); # (1, 2, 3, 4)
# Arreglos anidados se aplanan
my @anidado = (1, [2, 3], 4); # En realidad (1, 2, 3, 4) en contexto de lista
```
### Contexto de Lista
```perl
# Forzar contexto de lista
my @copia = (1, 2, 3);
# En contexto escalar, ultimo valor
my $ultimo = (1, 2, 3); # $ultimo = 3
# Forzar escalar con scalar()
my $count = scalar @arreglo;
```
## Reduciendo Arreglos
### Reduccion Manual
```perl
sub sumar {
my $total = 0;
foreach my $val (@_) {
$total += $val;
}
return $total;
}
print sumar(1, 2, 3, 4, 5); # 15
```
### Usando reduce (List::Util)
```perl
use List::Util qw(reduce);
my $suma = reduce { $a + $b } 1, 2, 3, 4, 5;
my $producto = reduce { $a * $b } 1 .. 5;
```
## Resumen
- Arreglos creados con el sigil `@` y parentesis
- `$#arreglo` da el ultimo indice, `scalar @arreglo` da la longitud
- Push/pop trabajan al final, shift/unshift al principio
- `splice` para insercion/eliminacion avanzada
- `map` transforma cada elemento
- `grep` filtra elementos por condicion
- `sort` ordena elementos (usar `<=>` para numerico)
- `reverse` invierte el orden de la lista
- `join` combina, `split` separa
- Las listas se aplanan en contexto de lista
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →