AE | CLASE 2

Recursión

Universidad ORT Uruguay

Docente: Ing. Florencia
AGENDA
 Introducción

 Motivación

 Recursión vs. Iteración

 Ejemplos

 Pila de llamados
OBJETIVOS
 Entender el concepto de recursividad.

 Conocer los fundamentos del diseño de algoritmos

recursivos.

 Ser capaces de ejecutar (a mano) un algoritmo recursivo.

 Identificar cuando es necesario utilizar un algoritmo

recursivo.
INTRODUCCIÓN
 ¿Qué es la recursión?

 Según la RAE
 Volver una cosa al sitio dónde salió, retornar, repetirse, reaparecer.

 En términos de programación
 Un método es recursivo si directa o indirectamente realiza una llamada a si
mismo.

 Se dice que el método se define en “términos de sí mismo”.

 Diferente a la circularidad.
MOTIVACIÓN
 Forma natural, lógica

 Más fácil de demostrar si la función es correcta

[factorial]
EJEMPLO: FUNCIÓN FACTORIAL
 Para todo número natural n, se llama n factorial o
factorial de n al producto de todos los naturales desde 1
hasta n:

n! = 1 * 2 * 3 * 4 …* (n-1)*n
1, si n = 0
n! =
n*(n-1)!, si n>=1
RECURSIVO VS. ITERATIVO
[FACTORIAL]
Factorial Iterativo Factorial Recursivo
Definición de función factorial
int factorial (int n){ int factorial (int n){
int f = 1; if n = 0
Fact (0) = 1
for (int i=2; i<=n; i ++) return 1;
Fact (n) = n * Fact (n-1)
{ else
f = f * i; return n*factorial(n-1);
} }
return f;
}
MOTIVACIÓN
 Forma natural, lógica

 Más fácil de demostrar si la función es correcta

[factorial]

 Ineficiencia vs. Simplicidad

 Nos permite resolver un problema grande,

concentrándonos en la resolución de unos pocos pasos.
EJEMPLOS – ELIMINAR FACTORES DE 2
 Eliminar los factores de 2 de un número natural positivo.
Tenemos que calcular num = 2^n * val
public class Entero{
public int valor;
}
//Post: Devuelve el Entero num factorizado (num = 2^n * val)
public void elimFact2(Entero num, Entero n, Entero val){
if par(num.valor)
n.valor += 1;
Entero nuevo = num.valor/2;
elimFact2(nuevo, n, val);
else
val.valor = num.valor;
}
EJEMPLOS – SUCESIÓN DE FIBONACCI
 La sucesión de Fibonacci se define de la siguiente manera:
 Fib (0) = 0
 Fib (1) = 1
 Fib (n) = Fib (n-1) + Fib (n-2)

//Pre: n>=0
int Fib (int n){
if (n <= 1)
return n;

return (Fib(n-1) + Fib(n-2));

}
 EJEMPLO – SUCESIÓN DE FIBONACCI
 Si llamamos, por ejemplo, a fib(5), produciremos un árbol de
llamadas
con muchos llamados repetidos.

fib(5)
fib(4) + fib(3)
(fib(3) + fib(2)) + (fib(2) + fib(1))
((fib(2) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))
(((fib(1) + fib(0)) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))

 En particular, fib(2) se ha calculado tres veces.

 A medida que n crece el número de llamados repetidos necesarios
para resolver fib(n) crece exponencialmente.
EJEMPLO – SUCESIÓN DE FIBONACCI
 ¿Cómo podemos evitar recalcular resultados repetidos?

 Para evitar este inconveniente, podemos almacenar los

resultados ya calculados para utilizarlos posteriormente.

 Así, llenaríamos una tabla con los resultados de los distintos

sub-problemas, para reutilizarlos cuando haga falta en lugar de
volver a calcularlos.

 La tabla resultante sería una tabla unidimensional con los

resultados desde 0 hasta n.
EJEMPLO – SUCESIÓN DE FIBONACCI
// Inicializada en 0
int tabla[N+1]; Mejora importante, debido a
que no se vuelven a calcular
//PRE: n>=0 los sub-problemas. Requiere
int Fib2R (int [] T; int n){ de un costo de
if (n != 0){ almacenamiento
if (n == 1){
if(T[n]==0)
T[n] = 1;
} Evalúa si se ha calculado
else{
if(T[n]==0)
T[n] = Fib2R (T, n-1)+ Fib2R (T, n-2);
}
}
return T[n];
}
EJEMPLO – SUCESIÓN DE FIBONACCI
int tabla[N];

//PRE: n>=0
int Fib2I (int [] T; int n){
if (n == 0)
return 0;
if (n == 1)
return 1;

T[0] = 0;
T[1] = 1;
for (int i = 2; i <= n; i++){
T[i] = T[i-1] + T[i-2];
}
return T[n];
0 10 10 20 30 50 08 13
0 21
0 34
0
}
FIBONACCI – POSIBLES MEJORAS
 Almacenar en una tabla los resultados obtenidos. De esta
forma, si queremos calcular fib(n) preguntaremos previamente
si dicho valor ya fue calculado.

 Considerar la solución iterativa.

 Otro nivel de refinamiento que optimizaría la solución sería

quedarnos tan sólo con los dos últimos valores calculados en
lugar de toda la tabla, que son realmente los que nos resultan
útiles para calcular la solución a los sub-problemas.
CONSIDERACIONES - DEFINICIÓN
CORRECTA
 Caso base: Siempre se debe tener uno o más casos base.

 Caso recursivo: Para los pasos que deben resolverse

recursivamente, la llamada recursiva siempre debe
tender a un caso base.

 Corroborar que la definición no es circular.

“Función definida en términos de sí misma.”
PILA DE LLAMADOS
 Cada vez que un programa Q llama a otro R, debe
guardarse una indicación del punto en Q al cual debe
devolverse el control al finalizar la ejecución de R.

 Se utiliza una estructura de datos llamada Pila para

almacenar los puntos de retorno.

 Pila:Estructura lineal dinámica donde se agregan y quitan

elementos sólo en uno de sus extremos.
 Cola: Estructura lineal dinámica donde se agregan elementos
en unos de sus extremos y se quitan en el otro extremo.
PILA DE LLAMADOS
 El tope de la pila es el punto donde debe retornarse el
control tras la terminación del subprograma corriente.

 Así mismo, si el subprograma corriente llama a otro, el

correspondiente punto de retorno debe colocarse como
nuevo tope de la pila.

 Al finalizar un subprograma, se usa el tope de la pila

como dirección de retorno y se lo remueve de la pila.
EJEMPLO: POTENCIA
y
 Potencia (x, y) =x

 Potencia (x, 0) = 1
 Potencia (0, y) = 0

 Potencia (x ,y) con y > 0 = x * x * x…….*x

y veces

1
 Potencia (x, y) con y < 0 =
Potencia( x, y )
EJEMPLO: POTENCIA
int potencia (int x, int y){
if (y = 0)
return 1;
else if (x = 0)
return 0;
else if (y > 0)
return x * potencia(x, y-1);
else // (y < 0)
return 1/potencia(x, -y);
}
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 3

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 2

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 1

int potencia (int x, int y){

if y = 0
return 1
else
P(2,1),*x
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 0

int potencia (int x, int y){

if y = 0
return 1
else
P(2,1),*x
if x = 0
return 0 P(2,2),*x
else P(2,3),*x
return x * potencia (x, y-1)
end
}
stack
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 1

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 P(2,2),*x
1
else P(2,3),*x
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
2
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 2

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 2
else P(2,3),*x
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
4
PILA DE LLAMADOS – POTENCIA
(NÚMEROS POSITIVOS)

VARIABLES X = 2, Y = 3

int potencia (int x, int y){

if y = 0
return 1
else
if x = 0
return 0 4
else
potencia
return x * potencia (x, (x,
y-1)y-1)
end
}
stack
8
PILA DE LLAMADOS – OTRO MÉTODO
RECURSIÓN VS. ITERACIÓN
 Usando recursión no es necesario definir la secuencia de
pasos exacta para resolver el problema.

 La recursión podría ser menos eficiente (mayor uso de

memoria, y overhead por llamados sucesivos).

 Tanto la recursión como la iteración pueden incurrir en

ejecuciones infinitas
 Recursión: Mal definido el caso base.
 Iteración: Mal definido el criterio de parada del loop.
OBJETIVOS - ¿CUMPLIDOS?
 Entender el concepto de recursividad.

 Conocer los fundamentos del diseño de algoritmos

recursivos.

 Ser capaces de ejecutar un algoritmo recursivo.

 Identificar cuando es necesario utilizar un algoritmo

recursivo.
EJERCICIO
int Recursivo (int []v, int i1, int i2) {
int aux1, aux2;
if (i1 = i2) //Caso base
return V[i1];
else { //Caso recursivo
aux1 = Recursivo(V, i1, (i1+i2)/2);
aux2 = Recursivo(V, ((i1+i2)/2)+1, i2);
if (aux1>aux2)
return aux1;
else
return aux2;
}
EJERCICIO
 Ejecutar manualmente el código con:
 V [3,7,0,1]
 i1 =0
 I2 = 3

 Proponga un nombre nemotécnico para la función.

 Ejecútelo nuevamente para:

 V [9,2,3,7,8]
 i1 =1
 I2 = 3
¿EN QUE ORDEN SE EJECUTA?
Diseñar una rutina que liste los números del n al 1.
public void listarDesc(int n) {
if(n>0){
System.out.print (n+ " ");
listarDesc(n-1); 10 9 8 7 6 5 4 3 2 1
}
}

¿Podría lograr que los liste en orden inverso?

public void listarAsc(int n) { 1 2 3 4 5 6 7 8 9 10
if(n>0){
listarAsc(n-1);
System.out.print (n+ " ");
}
}
 MÁXIMO COMÚN DIVISOR
Pre condición
Algoritmo de Euclides :
1. Dados dos números n>m, comenzamos realizando la división entera de n entre m.

2. Cada paso consiste en una nueva división, en la que el dividendo es el número que actuó de divisor en
la división anterior y el divisor es el número que se obtuvo como resto en la división anterior.

3. Cuando en una división se obtiene resto nulo, el máximo común divisor de los números de los que
partimos será el número que ha actuado como divisor en esa última división efectuada y que resultó ser
una división exacta.

public int MCDI(int a, int b){ public int MCDR(int a, int b){
int resto = a%b; int resto = a%b;
while (resto!=0){ if(resto==0){
a=b;
return b;
b=resto;
resto = a % b; }else{
} return MCDR(b, resto);
return b; }
}
}
EJERCICIO: ADOQUINES
Al principio del juego los niños se ubican en el adoquín numerado 0.

Ir de un adoquín numerado i al adoquín numerado i+1.

Ir de un adoquín numerado i al adoquín i+2 (salteándose el adoquín i+1).

Se pide calcular el número de caminos posibles para alcanzar un adoquín objetivo numerado
con n (mayor que cero).

0 1 2 … N N+1
ADOQUINES
1 1 58
= 54 3 =
2 5+ 4
0 3+ 3
2 3
2 2 2
1
1 0 1
0 0

1 =33 6
2 + 1 3
+ 5=
2 8 5
1 4
0 3
2
1
0
EJERCICIO: ADOQUINES

adoquines (1) = 1;

adoquines (2) = 2;

adoquines (n) = adoquines (n-1) + adoquines (n-2);

//Pre: n>0
int adoquines (int n){

if(n = 1)
return 1;

if(n = 2)
return 2;

return (adoquines(n-1) + adoquines(n-2));

}
 CONTADOR DE ISLAS (2.11)
int ContarIslas (int m[][], int d1, int d2)
// d1 y d2 son las dimensiones de la matriz
{
cant_islas = 0;
for(int i = 0; i<d1; i++){
for (int j=0; j<d2; j++){
if esTierra (m[i][j])
{
cant_islas++;
borrarIsla(m, d1, d2, i, j)
}
}
}
return cant_islas;
}

 
 CONTADOR DE ISLAS (2.11)

void borrarIsla(int m[][], int d1, int d2, i, j)

{
if PerteneceAlMapa(d1, d2, i, j){
if esTierra(i,j){
Borrar(m, i, j);
for (int p=-1, p<=1, p++){
for(int q=-1, q<=1, q++){
borrarIsla(m, d1, d1, i+p, j+q);
}
}
}
}
}

 
CONTADOR DE ISLAS (2.11)
boolean PerteneceAlMapa(int d1, int d2, int i, int j)
{
return ((i>=0) and (i<d1) and (j>=0) and (i<d2))
}
 
void Borrar(int m[],int i,int j){
m[i][j]=0;
}
 
void esTierra (int m[][], int i, int j){
return (m[i][j] == 1)
{

 
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas = 0
1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas = 1
1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 1 1 0 0 0 1 0 cantIslas = 1
1 0 0 1 0 1 0 0 0 1 1
2 0 1 0 0 1 1 1 0 0 0
3 0 1 0 0 0 0 0 1 0 0
4 0 0 1 0 1 0 1 0 0 1
5 0 0 1 0 1 0 1 0 0 1
6 0 0 1 0 1 0 1 0 0 1
7 0 0 0 1 1 1 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas = 1
1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas = 2
1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0 cantIslas = 2
1 0 0 0 0 0 0 0 0 1 1
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 2
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 3
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 3
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 1
5 0 0 0 0 0 0 0 0 0 1
6 0 0 0 0 0 0 0 0 0 1
7 0 0 0 0 0 0 0 0 1 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 1 0 0 0
10 0 0 1 1 0 0 1 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 3
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 4
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 4
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 1 1 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 4
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 5
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 5
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 1 0
11 0 0 0 0 0 0 0 0 0 1
CONTADOR DE ISLAS (2.11)
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 0 0 cantIslas = 5
1 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0
3 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0
5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0 0
8 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0
10 0 0 0 0 0 0 0 0 0 0
11 0 0 0 0 0 0 0 0 0 0