package model;
import java.util.ArrayList;
import java.util.LinkedList;
public class Ejercicios
{
// 1.Programa que salude 10 veces
public void ejercicio1 (int n, int contator)
{
if (contator == n)
{
return;
}
System.out.println("Hi");
ejercicio1(n, contator + 1);
}
// 2.Programa que realice la tabla de multiplicar de un numero dado
// y muestre el resultado en la misma función.
public void ejercicio2 (int n, int contator)
{
if (contator == 11)
{
return;
}
int temp = 0;
temp = contator * n;
System.out.println(n + " X " + contator + " = " + temp);
ejercicio2(n, contator + 1);
}
// 3.Realice una función recursiva que dado un vector lo invierta
//en uno nuevo.
public void ejercicio3 (int []array, int []temp, int contator)
{
if (contator == array.length)
{
return;
}
temp[contator] = array[array.length - contator - 1];
ejercicio3(array, temp, contator + 1);
}
// 4.Escriba una función recursiva que ordene de menor a mayor un
// arreglo de enteros, utilice cualquier método de ordenamiento
// (burbuja o quicksort)
public void ejercicio4 (int []array, int n)
{
if (n == 1)
{
for (int i : array)
{
System.out.println(array[i]);
}
return;
}
for (int i = 0; i < n-1; i++)
{
if (array[i] > array[i + 1])
{
int temp = array[i + 1];
array[i + 1] = array[i];
array[i] = temp;
}
}
ejercicio4(array, n-1);
}
// 5.Realice una funcion recursiva que imprima los datos de un vector
public void ejercicio5 (int []array, int n)
{
if (n == array.length)
{
return;
}
System.out.println(array[n]);
ejercicio5(array, n + 1);
}
// 6.Realice una funcion recursiva que imprima los datos de una
//lista
public void ejercicio6 (LinkedList<String> stack, int n)
{
if (n == stack.size())
{
return;
}
System.out.println(stack.get(n));
ejercicio6(stack, n + 1);
}
// 7.Realice una funcion recursiva que imprima los datos de un Arraylist
public void ejercicio7 (ArrayList<Integer> array, int n)
{
if (n == array.size())
{
return;
}
System.out.println(array.get(n));
ejercicio7(array, n + 1);
}
// 8.Escribir un programa que retorne la suma de los enteros positivos pares
desde
//N hasta 2. Chequear que si N es impar se guarde en una lista un mensaje de
error
//por cada número impar.
public int ejercicio8 (int n, LinkedList<String> stack)
{
if (n < 2) return 0;
if ((n % 2) != 0)
stack.add("Error");
int temp = ejercicio8(n - 1, stack);
if ((n % 2) == 0)
temp += n;
return temp;
}
// 9.Programe un método recursivo que retorne la suma de un arreglo de números
enteros.
public int ejercicio9 (int []array, int n)
{
if(n == array.length) return 0;
int temp = ejercicio9(array, n + 1);
temp += array[n];
return temp;
}
// 10. Programe un método recursivo que invierta los números de una lista de
//enteros en otra lista (retorne la lista nueva).
public LinkedList<Object> ejercicio10 (LinkedList<Integer> stack, int n)
{
if (n == stack.size()) return new LinkedList<>();
LinkedList<Object> temp = ejercicio10(stack, n + 1);
temp.add(stack.get(n));
return temp;
}
// 11.Programar un algoritmo recursivo que permita invertir un número.
Ejemplo: Entrada:123 Salida:321
public String ejercicio11 (int a, int n)
{
String temp = Integer.toString(a);
if (n == temp.length()) return "";
String number = ejercicio11(a, n + 1);
number = number + temp.charAt(n);
return number;
}
// 12.Programar un algoritmo recursivo que retorne la suma los elementos de
una matriz
// public int ejercicio12 (int [][] m, int i, int j)
// {
//// if (i == m.length & j == m[i].length) return 0;
////
//// if (j == m[i].length)
//// {
//// int temp = eje
//// }
////
// }
// 13.Programar un algoritmo recursivo que retorne el número menor de un
vector.
public int ejercicio13 (int []array, int n, int menor)
{
if(n == array.length) return 0;
menor = ejercicio13(array, n + 1, menor);
if (array[n] < menor)
{
menor = array[n];
}
return menor;
}
// 14.Una función recursiva que me retorne cuantas veces se repite un numero
en específico en un vector.
public int ejercicio14 (int []array, int n, int a)
{
if (n == array.length) return 0;
int temp = ejercicio14 (array, n + 1, a);
if (array[n] == a)
{
temp++;
}
return temp;
}
public int veces (int n)
{
int x = 0;
for (int i = 1; i <= n; i++)
{
if ((n % i) == 0)
{
x++;
}
}
return x;
// 15.Indicar si un número es primo.
public String ejercicio15 (int a, int n)
{
if (n == a) return "";
String message = ejercicio15(a, n + 1);
if (veces(a) == 2)
{
message = "Es primo";
return message;
}
return "No es primo";
}
// 16.Escriban una función recursiva llamada Merge que, a partir de dos listas
ordenadas L1 y L2,
//retorne una lista ordenada L3, a través de un proceso de intercalación de
elementos
public LinkedList<Object> ejercicio16 (LinkedList<Integer> l1,
LinkedList<Integer> l2, int n)
{
if (n == l1.size()) return new LinkedList<>();
LinkedList<Object> temp = ejercicio16(l1, l2, n + 1);
temp.add(l1.get(l1.size() - n - 1 ));
temp.add(l2.get(l2.size() - n - 1 ));
return temp;
}
// 17.Retornar la cantidad de dígitos pares de un número entero positivo N. El
dígito 0 debe
//considerarse como par. Por ejemplo, si N = 23025, el resultado es 3.
public int ejercicio17 (int a, int n)
{
String number = Integer.toString(a);
if(n == number.length()) return 0;
int temp = ejercicio17(a, n + 1);
if ((number.charAt(n)) % 2 == 0 )
{
temp++;
}
return temp;
}
/*
18. Un número natural N puede ser expresado utilizando ceros y unos
solamente mediante el denominado
sistema binario. Para obtener la representación binaria de N, deben calcularse
los restos de dividir
sucesivamente N por 2 hasta que el dividendo sea 0. Los restos obtenidos
(listados en orden inverso) son
la representación binaria de N. Por ejemplo, para calcular la representación
binaria de N=28, se deben
calcular los siguientes restos:
28 dividido 2 da 14 y resto 0
14 dividido 2 da 7 y resto 0
7 dividido 2 da 3 y resto 1
3 dividido 2 da 1 y resto 1
1 dividido 2 da 0 y resto 1
Por lo tanto, la representación binaria de 28 es 11100.
*/
public String ejercicio18(int n)
{
if (n < 1) return "";
String i= ejercicio18(n / 2);
i += "" + (n % 2);
return i;
}
/*
19. Escriban una función booleana recursiva llamada Son Iguales que reciba
dos listas de la misma longitud
como parámetros, y devuelva TRUE si son iguales (mismos elementos en el mismo
orden), o FALSE en caso
contrario.
*/
public boolean ejercicio19 (LinkedList<Integer> l1, LinkedList<Integer> l2, int
n, ArrayList<Integer> a1)
{
if (n == l1.size()) return false;
if (l1.get(n) == l2.get(n))
{
a1.add(1);
}
boolean temp = ejercicio19(l1, l2, n + 1, a1);
if (a1.size() == l1.size())
{
temp = true;
}
else
{
temp = false;
}
return temp;
}
/*
20. Escriban una función recursiva llamada Existe Elemento que verifique si
un elemento x se encuentra
en una lista L por lo menos una vez retorna el mensaje “Existe” de lo contrario
“No existe”.
*/
public String ejercicio20 (LinkedList<Integer> l1, ArrayList<Integer> a1, int
a, int n, boolean b)
{
// a: numero que quiero saber si se encuentra
// n: contador para salir
// a1: mi forma de resolver que no se resetee mi requetimiento
if (n == l1.size()) return ""; // Condicion de salida
// BAJADA
if (a == l1.get(n)) //Forma que lo resolvi
{
a1.add(1); // Teniendo un ArrayList puedo usar su tamaño para contar
sin temer de que se reinicie
b = true; // Forma del compañero
}
String temp = ejercicio20(l1, a1, a, n + 1, b);
System.out.println(b);
System.out.println("f " + a1.size());
// BACKTRAKING
if (a1.size() > 0) // Si el tamaño es mayor a 0 significa que almenos una
vez esta mi a
{
temp = "Existe"; // Se envia la respuesta de que efectivamente
"Existe"
}
else
{
temp = "No Existe"; // De lo contrario significa que "No Existe"
}
return temp;
}
/*
21. Describa una función recursiva que retorne el factorial de un numero
dado.
*/
public int ejercicio21 (int a, int n)
{
if ( n == a) return 1;
int temp = ejercicio21(a, n + 1);
System.out.println(temp);
temp *= (n + 1);
return temp;
}
/*
22. Escribir una función recursiva que devuelva la suma de los primeros N
enteros
*/
public int ejercicio22 (int a, int n)
{
if (n > a) return 0;
int temp = ejercicio22(a, n + 1);
if (veces(n) == 2)
{
temp += n;
}
System.out.println(temp);
return temp;
}
// 23.Crear un método recursivo que solucione al siguiente laberinto
public int[][] ejercicio23(int [][] m,int [][] n, int a, int b)
{
if(a == 1) return n;
for (int i = 0; i < m.length; i++)
{
for (int j = 0; j < m[i].length; j++)
{
b = m[i][j];
}
}
int [][] temp = ejercicio23(m, n, a + 1, b);
return null;
}
}
