Modelo de como funciona la interacción y la herencia.

Su código:
public class Jugada
{
public boolean esMejor(Jugada otra){
return false;
}
public String tipoJugada(){
return "Jugada ";
}
}
public class JuegoPPT
{
private int nroPartidas;
private Jugador jug1;
private Jugador jug2;
public JuegoPPT(int nroPartidas, Jugador jug1, Jugador jug2){
this.nroPartidas = nroPartidas;
this.jug1 = jug1;
this.jug2 = jug2;
}
public Jugador jugar(){
Jugador ganador;
int i;
for(i = 1; i <= nroPartidas; i = i + 1){
partida();
}
if(jug1.mejor(jug2)){
ganador = jug1;
}else{
if(jug2.mejor(jug1)){
ganador = jug2;
}else{
ganador = null;
}
}
 return ganador;
}
private void partida(){
Jugada jugada1;
Jugada jugada2;
jugada1 = jug1.jugar();
jugada2 = jug2.jugar();
if(jugada1.esMejor(jugada2)){
jug1.aumentarPts();
}else{
if(jugada2.esMejor(jugada1)){
jug2.aumentarPts();
}
}
}
}
public class Jugador
{
private String nombre;
private int puntaje;
public Jugador(String nombre){
 this.nombre = nombre;
puntaje = 0;
}

public boolean mejor(Jugador otro){

return puntaje > otro.getPuntaje();
}
public int getPuntaje(){
return puntaje;
}
public void aumentarPts(){
puntaje++;
}
public Jugada jugar(){
Jugada jugada;
int opc = (int)(Math.random()*3);
switch(opc){
case 0 : jugada = new Piedra();break;
case 1 : jugada = new Papel(); break;
default : jugada = new Tijeras();
}
 return jugada;
}
}
public class Piedra extends Jugada
{
public boolean esMejor(Jugada otra){
return otra instanceof Tijeras;
}
public String tipoJugada(){
return super.tipoJugada() + "Piedra";
}
}
public class Papel extends Jugada
{
public boolean esMejor(Jugada otra){
return otra instanceof Piedra;
}
}
public class Tijeras extends Jugada
{
public boolean esMejor(Jugada otra){
 return otra instanceof Papel;
}
}
Fin del code
INICIO DE CODIGOS 1
Todo recursivo desde ahora;
import java.util.ArrayList;
//import java.util.ArrayList;

public class Secuencia{

private ArrayList<Integer> num;
private int res;
public Secuencia(){
num = new ArrayList<Integer>();
res = 0;
}

public void quicksort(ArrayList<Integer> lista){

quicksort(lista, 0, lista.size() - 1);
}
private void quicksort(ArrayList<Integer> lista, int inicio, int fin){
if(inicio >= fin){ // Identificar el caso base:
// no hace nada
} else{ // caso recursivo
int indicePivote = particionar(lista, inicio, fin);
quicksort(lista, inicio, indicePivote - 1);
quicksort(lista, indicePivote + 1, fin);
}
}

private int particionar(ArrayList<Integer> lista, int inicio, int fin) {

int pivote = lista.get(fin);
int i = inicio;
int j = fin;
int res = 0;

if (inicio < fin){

if (lista.get(i) > lista.get(fin)){
lista.set(i, lista.set(fin, lista.get(i)));
}
res = particionar(lista, i + 1, fin);
 }else{
res = fin;
}
return res;
}

public void ordenarInsercion(ArrayList<Integer> lista) {

if(lista.size() > 1){
int ultimo = lista.remove(lista.size() - 1);
ordenarInsercion(lista);
insertar(lista, ultimo);
}
}

private void insertar(ArrayList<Integer> lista, int elemento) {

if (lista.isEmpty() || lista.get(lista.size() - 1) <= elemento) {
lista.add(elemento);
}else{
int ultimo = lista.remove(lista.size() - 1);
insertar(lista, elemento);
lista.add(ultimo);
 }
}

public ArrayList<Integer> mergeSort(ArrayList<Integer> list) {

if (list.size() <= 1) {
return list; // Caso base: la lista ya está ordenada
}
// Dividir la lista en dos sublistas más pequeñas y ordenarlas de
forma recursiva
int puntoMedio = list.size() / 2;
ArrayList<Integer> izq = new ArrayList<Integer>(list.subList(0,
puntoMedio));
ArrayList<Integer> der = new
ArrayList<Integer>(list.subList(puntoMedio, list.size()));
izq = mergeSort(izq);
der = mergeSort(der);
// Combinar las dos sublistas ordenadas en orden ascendente
return mezcla(izq, der); // Devolver la lista ordenada resultante
}

private ArrayList<Integer> mezcla(ArrayList<Integer> left

,ArrayList<Integer> right){
 ArrayList<Integer> result = new ArrayList<Integer>();
// Verificar si las sublistas no están vacías
if (!left.isEmpty() && !right.isEmpty()) {
// Comparar los primeros elementos de las sublistas y agregar el
menor
//a la lista resultante
if(left.get(0)<=right.get(0)){
result.add(left.get(0));
// Llamar a mezcla de forma recursiva con la sublista izquierda
//sin el primer elemento y la sublista derecha
result.addAll(mezcla(new ArrayList<Integer>(left.subList(1,
left.size())), right));
}else{
result.add(right.get(0));
// Llamar a mezcla de forma recursiva con la sublista izquierda
y
//la sublista derecha sin el primer elemento
result.addAll(mezcla(left, new
ArrayList<Integer>(right.subList(1, right.size()))));
}
}
// Verificar si solo la sublista izquierda está vacía
 else if(left.isEmpty()){
result.addAll(right);
}
// Verificar si solo la sublista derecha está vacía
else if(right.isEmpty()){
result.addAll(left);
}
return result;
}
public int busquedaBinaria(ArrayList<Integer> lista, int
valorBuscado) {

return busquedaBinariaRecursiva(lista, valorBuscado, 0, lista.size()

- 1);
}
private int busquedaBinariaRecursiva(ArrayList<Integer> lista, int
valorBuscado,
int inicio, int fin) {
if (inicio > fin) { // se revisó todo, no se encontro, caso BASE
return -1;
}
int medio = (inicio + fin) / 2;
 if (lista.get(medio) == valorBuscado) {
return medio;
}
// buscamos de inicio a medio-1
if (valorBuscado < lista.get(medio)) {
return busquedaBinariaRecursiva(lista, valorBuscado, inicio,
medio - 1);
}
// buscamos de medio +1 hasta fin
return busquedaBinariaRecursiva(lista, valorBuscado, medio + 1,
fin);
}

public int buscarSecuencial(ArrayList<Integer> lista, int elemento) {

return buscarSecuencial(lista, elemento, 0);
}

private int buscarSecuencial(ArrayList<Integer> lista, int elemento,

int indice) {
if (indice >= lista.size()) {
return -1;
}
 if (lista.get(indice) == elemento) { // se ha encontrado el elemento
return indice;
}
return buscarSecuencial(lista, elemento, indice + 1); // seguir
buscando
//recursivamente
}
}
Fin del código 1
JUEGO DE CADENAS EN ARRAYLIST
Codigo 2
import java.util.ArrayList;
public class Diccionario{
private ArrayList<String> listaDePalabrasProhibidas;

public Diccionario(String[] palabrasProhibidas){

listaDePalabrasProhibidas = new ArrayList<String>();
añadirPalabrasProhibidasEnLista(palabrasProhibidas);
}

public int buscarPalabrasProhibidas(String texto){

 return buscarPalabrasProhibidas(texto,0,0,0);
}
private int buscarPalabrasProhibidas(String texto, int i, int j, int con){
int res;
ArrayList<String> cor = listaDePalabrasProhibidas;//j
ArrayList<String> sol= rellenar(texto);//i
if(i > sol.size()-1){
res = con;
}else{
String a = cor.get(j), b = sol.get(i);
if(a.equalsIgnoreCase(b)){
res = buscarPalabrasProhibidas(texto,i+1,0,con +1);
}else{
if(j<cor.size()-1){
res = buscarPalabrasProhibidas(texto,i,j+1,con);
}else{
res = buscarPalabrasProhibidas(texto,i+1,0,con);
}

}
}
 return res;
}

private ArrayList<String> rellenar(String cad){

ArrayList<String> res = new ArrayList<String>();
if(cad.equals("")){
res.add(null);
}else{
char a = cad.charAt(0);
if(a == ' '||a == ','||a == '.'){
res.addAll(rellenar(cad.substring(1)));
}else{
int pF;
if(soloPalabra(cad)){
pF = hallarFin(cad+" ");
}else{
pF = hallarFin(cad);
}
String nuCad = cad.substring(0,pF);
res.add(nuCad);
res.addAll(rellenar(cad.substring(pF)));
 }
}
return res;
}

private boolean soloPalabra(String cad){

boolean res;
if(cad.equals("")){
res = true;
}else{
if(cad.charAt(0) == ' '||cad.charAt(0) == ','||cad.charAt(0) == '.'){
res = false;
}else{
res = soloPalabra(cad.substring(1));
}
}
return res;
}

private int hallarFin(String cad){

return hallarFin(cad,1);
 }
private int hallarFin(String cad, int i){
int res;
if(cad.equals("")||i>cad.length()){
res =cad.length();
}else{
char a = cad.charAt(i);
if(a == ' '||a == ','||a == '.'){
res = hallarFin(cad.substring(0,i),i+1);
}else{
res = hallarFin(cad,i+1);
}
}
return res;
}

public void añadirPalabrasProhibidasEnLista(String[]

palabrasProhibidas){
añadirPalabrasProhibidasEnLista(palabrasProhibidas,0);
}
 private void añadirPalabrasProhibidasEnLista(String[]
palabrasProhibidas, int i){
if(i<palabrasProhibidas.length){
añadirPalabrasProhibidasUnoEnUno(palabrasProhibidas[i]);
añadirPalabrasProhibidasEnLista(palabrasProhibidas,i+1);
}
}
public void añadirPalabrasProhibidasUnoEnUno(String
palabraProhibida){
if(!verificarRepetidos(palabraProhibida)){
listaDePalabrasProhibidas.add(palabraProhibida);
}
}

public void eliminarListaDePalabrasProhibidas(){

ArrayList<String> nuevaLista = new ArrayList<String>();
listaDePalabrasProhibidas = nuevaLista;
}
private boolean verificarRepetidos(String a){
return verificarRepetidos(a,0);
}
private boolean verificarRepetidos(String a, int i){
 boolean res;
ArrayList<String> cor = listaDePalabrasProhibidas;
if(i>cor.size()-1){
res = false;
}else{
String c = cor.get(i);
if(c.equals(a)){
res = true;
}else{
res = verificarRepetidos(a,i+1);
}
}
return res;
}
}
fin
Codigo 3
import java.util.ArrayList;
public class RecorerArray
{
//POO
public ArrayList<Integer> LlenandoArray(int n){
ArrayList<Integer> nuevo = new <Integer>ArrayList();
for(int i = 1;i <= n; i++){
nuevo.add(i);
}
return nuevo;
}
//Recursivo;
public ArrayList<Integer> LlenandoArrayRecur(int n){
return LlenandoArrayRecur(n,0,1);
}
private ArrayList<Integer> LlenandoArrayRecur(int n, int i, int con){
ArrayList<Integer> nuevo = new <Integer>ArrayList();
if(i>=n){
nuevo.add(null);
}else{
nuevo.add(con);
nuevo.addAll(LlenandoArrayRecur(n,i+1,con+1));
}
return nuevo;
}
 public ArrayList<Integer> eliminandoImpares(int n){
ArrayList<Integer> res = new ArrayList<Integer>();
res = LlenandoArrayRecur(n);
return eliminandoImpares(res, 0);
}
private ArrayList<Integer> eliminandoImpares(ArrayList<Integer> res,
int i){
int t = res.size();
if(i > t|| res.get(i) == null){
res = res;
}else{
int a = res.get(i);
if(a%2 != 0){
res.remove(i);
res = eliminandoImpares(res, i+1);
}else{
res = eliminandoImpares(res, i+1);
}
}
 return res;
}
}
public class arreglosBidiRecur{
//recursivo
public int[][] rellenandoMat(int n){
int[][] res= new int[n][n];
return rellenandoMat(res, 0,0, 1);
}

private int[][] rellenandoMat(int[][] res, int i, int j, int con){

int[][] al = res;
if(j < al[i].length - 1 ){
al[i][j] = con;
rellenandoMat(res,i,j+1,con+1);
}else if(i < al.length - 1){
al[i][j] = con;
rellenandoMat(res,i + 1,0,con+1);
}else{
if(i == j){
al[i][j] = con;
 }
}

return al;
}

//POO
private int[][] matriz(int n){
int[][] nu = new int[n][n];
int con = 1;
int ia = nu.length, jb = nu[0].length;
for(int i = 0; i < ia; i++){
for(int j = 0; j < jb; j++){
nu[i][j] = con;
con++;
}
}
return nu;
}
}
public class arreglosRecursivos{
public int[] llenarArregloRecur(int n){
 int[]res = new int[n];
return llenarArregloRecur(res,res.length-1,res.length);
}
private int[] llenarArregloRecur(int[] res,int i, int con){

if(i == -1){
res = res;
}else{
res[i] = con;
llenarArregloRecur(res, i-1, con-1);
}
return res;
}
}
Fin
Código 4
public class Recurrente
{
public int contarLineas(int n){
return contarLineas(n,2,3,1,1);
}
 private int contarLineas(int n,int a, int b,int con1,int con2){
int res;
if(n == 1){
res = 4;
}else{
int e =(int)(Math.pow(2,con1));
int e1 =(int)(Math.pow(2,con2));
res = contarLineas(n-1 ,a+e ,b+e ,con1+1 ,con2+2)+(a*b)+e1;
}
return res;
}
}
Fin
Codigo 5
public class Recurrente{
public String explotar(int n, int b){
String res;
if(n<=b){
res =""+n;
}else{
int n1 = n/b;
 int n2 = n-n1;
res = explotar(n1, b) + "," + explotar(n2, b);
}
return res;
}
}
Fin
Código 6
public class Recurrente{
public int ack(int m, int n){
int res;
if(m == 0){
res = n+1;
}else{
if(n == 0){
res = ack(m-1,1);
}else{
res = ack(m-1, ack(m,n-1));
}
}
return res;
 }
}
Fin
Código 7
import java.util.ArrayList;
public class Orbita{
public ArrayList<Integer> orbita1(int n){
ArrayList<Integer> or=new ArrayList<Integer>();
if(n == 1){
or.add(1);
}else{
if(n%2 != 0){
or.add(n);
or.addAll(orbita1(((3*n)+1)));
}else{
or.add(n);
or.addAll(orbita1(n/2));
}
}
return or;
}
}
Fin
Código 8
public class Cost
{
public int sucesion(int n){
return sucesion(n,4);
}

private int sucesion(int n, int o){

int res;
if(n == 1){
res = 1;
}else{
res = sucesion(n-1, o+3) + o;
}
return res;
}
}
Fin
Codigo 9
public class Potencia{
public int potenciaDeUnNumero(int base, int exp){
int res;
if(base == 0){
res= 0;
}else{
if(exp == 0){
res = 1;
}else{
res = base*potenciaDeUnNumero(base, exp -1);
}
}
return res;
}
}
Fin
Código 10
public class Primos{
public boolean esPrimo(int n, int divisor) {
// Casos base
if (n <= 2) {
 return (n == 2);
}
if (n % divisor == 0) {
return false;
}
if (divisor * divisor > n) {
return true;
}
// Llamada recursiva
return esPrimo(n, divisor + 1);
}

public boolean esPrimo(int n) {

return esPrimo(n, 2);
}
}
Fin
Código 11
public class Digito{
public int cantidadDigitosDeUnNumero(int numero){
int res;
 int con = 1;
if(numero <= 9){
res = 1;
}else{
res = 1 + cantidadDigitosDeUnNumero( numero/10);
}
return res;
}
}
Fin
Código 12
public class Ejer17{
public int sumaPareImparesDePosicion(int num){
int res;
int es = (int)(Math.log10(num)+1);
if(num == 0){
res = 0;
}else{
if(es%2 == 0){

int a = num%10;
 res = a + sumaPareImparesDePosicion(num/10);

}else{
int b = -(num%10);
res = b + sumaPareImparesDePosicion(num/10);

}
}
return res;
}
}
Fin
Código 13
public class Prueba{
public int contarUnCaracter(String c, char x){
int contar;
if(c.length() == 0){
contar = 0;
}else{
contar = contarUnCaracter(c.substring(1), x);
if(c.charAt(0) == x){
contar = contar + 1;
 }else{
contar = contar;
}
}
return contar;
}

public String cadenaInversa(String c){

String res;
if(c.length() == 0){
res = "";
}else{
char primerCaracter = c.charAt(0);
String restarCadena = c.substring(1);
res = cadenaInversa(restarCadena) + primerCaracter;
}
return res;
}

public int contarVocales(String c){

int contador;
if(c.length() == 0){
 contador = 0;
}else{
char primerCaracter = c.charAt(0);
contador = contarVocales(c.substring(1));

if(lasVocales(primerCaracter)){
contador = contador + 1;
}else{
contador = contador;
}
}
return contador;
}

private boolean lasVocales(char c){

return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');
}

}
Fin
Código 14
public class OrdenamientoBurbuja{
public int[] ordenarRec(int[]arr){
return ordenarRec(arr,0,1);
}
private int[] ordenarRec(int[] coll, int j, int i){
int[] arr = coll;
if(i<= arr.length-1){
if(j<= arr.length-i-1){
if(arr[j] > arr[j+1]){
int aux = arr[j];
arr[j] = arr[j+1];
arr[j+1] = aux;
}
arr = ordenarRec(arr,j+1,i);
}else{
j=0;
arr = ordenarRec(arr,j,i+1);
}
}else{
arr = arr;
 }
return arr;
}
}
Fin
Código 15
public class Laberinto
{
private int[][] laberinto; // 0=via libre, 1=obstaculo, 2=visitada
private int xQ, yQ, xR, yR;

public Laberinto(int[][] lab, int xQ, int yQ, int xR, int yR){
laberinto = lab;
this.xQ = xQ;
this.yQ = yQ;
this.xR = xR;
this.yR = yR;
}

public boolean buscar(){

return buscar(xR,yR);
}
private boolean buscar(int x, int y){
boolean encontro;
if(valida(x,y)){
if(laberinto[x][y] == 0){
if(!estaQueso(x,y)){
laberinto[x][y] = 2;
encontro = buscar(x-1, y);
if(!encontro){
encontro = buscar(x, y+1);
if(!encontro){
encontro = buscar(x+1,y);
if(!encontro)
encontro = buscar(x, y-1);
}
}
laberinto[x][y] = 0;
}else{
encontro = true;
}
}else{
 encontro = false;
}
}else{
encontro = false;
}
return encontro;
}
private boolean valida(int x, int y){
return x >= 0 && x < laberinto.length &&
y >= 0 && y < laberinto[0].length;
}
private boolean estaQueso(int x, int y){
return x == xQ && y == yQ;
}
}
Fin
Código 16
public class Recurrente
{
public String inversoSimple(String cad){
String res = "";
 if(cad.length() == 1){
res += cad.charAt(cad.length()-1);
}else{
if(cad.length()>1){
char ultmaLetra = cad.charAt(cad.length()-1);
res = ultmaLetra+""; //Mandamos nuestra ultima pos de
nuestra cadena
return inversoSimple(cad,ultmaLetra,res,cad.length()-2);
}
}
return res;
}
private String inversoSimple(String cad, char ultmaLetra,String res,int
longCadPnultma){
if(longCadPnultma < 0 ){
return res;
}
else{
char actual = cad.charAt(longCadPnultma);
if(actual != ultmaLetra){
res+= actual;
ultmaLetra = actual;
 }
res = inversoSimple(cad,ultmaLetra,res,longCadPnultma-1);
return res;
}

}
Fin