public class PotenciaDeUnNumero res=false;

{ public class esPrimo?

public double producto (int a, int b) { }
{ public String verificar(int n) else{
double res; { res=primo(n, d+1);
if(a==0) String res; }
res=0; boolean aux; }
else{ int d=2; return res;
if(b>=0) if(n>1){ }
res=producto2(a,b); aux=primo(n,d); }
else if(aux==true){
res=1/producto2(a,-b); res="Es primo";
} }
return res; else{ public class cantidadDeDigitos
} res="No es primo"; {
private double producto2(int a, int } public int contador(int n)
b) } {
{ else{ int res;
double res; res="no es primo"; if(n<=9)
if(b==0) } res=1;
res=1; return res; else{
else } res=contador(n/10)+1;
res=a*producto2(a,b-1); private boolean primo(int n, int d) }
return res; { return res;
} boolean res; }
} if(d>=n/2){ }
res=true;
}
else{
if(n%d==0){
 { s.ordenar();
import java.util.*; int res=n; System.out.println("Secuencia s: "
public class if(d>=n/2) + s.toString());
factoresPrimosDeUnNumero res=n; s.suma(s1);
{ else{ System.out.println("Secuencia s: "
public ArrayList<Integer> if(n%2==0) + s.toString());
factoresPrimos(int n) primos(n+1,2); System.out.println("Prod. Escalar
{ else s*s1: " + s.productoEscalar(s1));
ArrayList<Integer> res=new primos(n,d+1); System.out.println("Suma Primos
ArrayList<Integer>(); } de s: " + s.sumaPrimos());
res=primos(n,res,2); return n; System.out.println("Suma Primos
return res; } de s1: " + s1.sumaPrimos());
} } System.out.println();
private ArrayList<Integer> primos(int }
n, ArrayList<Integer> res,int x) public class }
{ Ejercicio5_6_7_8_9_11_12_13
ArrayList<Integer> resp; {
if(n==1) public void secuencia(){ public class Secuencia
resp=res; Secuencia s = new Secuencia(new {
else{ int[]{9,8,7,6,5,4,3,2,1}); private int[] sec;
if(n%x==0){ Secuencia s1 = new public Secuencia(int[] s){
res.add(x); Secuencia(new int[]{1,2,3,4,5,6,7,8,9}); sec = s;
n=n/x; System.out.println("Suma de elem. }
} de s: " + s.suma()); public int suma(){
else{ System.out.println("Minimo de s: " return suma(0);
x=primos(x+1,2); + s.minimo()); }
} System.out.println("Buscar 5 en s: private int suma(int i){
resp=primos(n,res,x); " + s.buscar(5)); int sum = 0;
} System.out.println("Secuencia s: " if(i < sec.length){
return resp; + s.toString()); sum = sec[i] + suma(i+1);
} System.out.println("Secuencia s1: }
private int primos(int n, int d) "+s1.toString()); return sum;
} } if(sec.length == s.sec.length)
public int minimo(){ private boolean buscar(int i, int x){ res = productoEscalar(s, 0);
return minimo(0); boolean res = false; return res;
} if(i < sec.length){ }
private int minimo(int i){ if(sec[i] == x) private int
int res = Integer.MAX_VALUE; res = true; productoEscalar(Secuencia s, int i){
if(i < sec.length){ else int res = 0;
res = sec[i]; res = buscar(i+1, x); if(i < sec.length){
int sigMin = minimo(i+1); } res = sec[i]*s.sec[i] +
if(sigMin < res) return res; productoEscalar(s,i+1);
res = sigMin; } }
} @Override return res;
return res; public String toString(){ }
} String res = ""; private boolean esPrimo(int n){
public void ordenar(){ for(int a : sec) return esPrimo(n, 0, 1);
ordenar(0,1); res += a + " "; }
} int a = 5 & 3; private boolean esPrimo(int n, int
private void ordenar(int i, int j){ return res; cant, int div){
if(i < sec.length-1){ } boolean res = true;
if(j < sec.length){ public void suma(Secuencia s){ if(div <= n/2 && cant < 2){
if(sec[i] > sec[j]){ if(sec.length == s.sec.length) if(n % div == 0)
int aux = sec[i]; suma(s, 0); res = esPrimo(n, cant+1,
sec[i] = sec[j]; } div+1);
sec[j] = aux; private void suma(Secuencia s, int i){ else
} if(i < sec.length){ res = esPrimo(n, cant, div+1);
ordenar(i, j+1); sec[i] = sec[i] + s.sec[i]; }else if(cant > 1)
}else suma(s, i+1); res = false;
ordenar(i+1, i+2); } return res;
} } }
} public int productoEscalar(Secuencia public int sumaPrimos(){
public boolean buscar(int x){ s){ return sumaPrimos(0);
return buscar(0, x); int res = 0; }
 private int sumaPrimos(int i){ return res; par=false;
int res = 0; }
if(i < sec.length){ } posicionPar=n%10+posicionPar(n/10,p
if(esPrimo(sec[i])) ar,posicionPar);
res = sec[i] + //saber si un numero es divisible entre }else{
sumaPrimos(i+1); 11 par=true;
else public class Ejercicio15
res = sumaPrimos(i+1); { posicionPar=posicionPar(n/10,par,posi
} public boolean divisible(int n) cionPar);
return res; { }
} boolean res; }
} int return posicionPar;
//saber si todos los dígitos de un posicionPar=posicionPar(n,true,0); }
numero son pares int private int posicionImpar(int n,
public class Ejercicio14 posicionImpar=posicionImpar(n,true,0); boolean impar,int posicionImpar)
{ int nuevoN; {
public boolean verificar(int n) nuevoN=posicionPar- if(n<=9){
{ posicionImpar; if(impar==false)
boolean res; if(nuevoN%11==0) posicionImpar=n;
int d; res=true; }else{
if(n<=9){ else if(impar==false){
if(n%2==0) res=false; impar=true;
res=true; return res;
else } posicionImpar=n%10+posicionImpar(n/
res=false; private int posicionPar(int n,boolean 10,impar,posicionImpar);
}else{ par,int posicionPar) }else{
d=n%10; { impar=false;
if(d%2==0) if(n<=9){
res=verificar(n/10); if(par==true) posicionImpar=posicionImpar(n/10,im
else posicionPar=n; par,posicionImpar);
res=false; }else{ }
} if(par==true){ }
 return posicionImpar; //veces que se repite un carácter vocal=esvocal(c,0,vocal);
} Invertir una cadena if(vocal==true)
} Cantidad de vocales
public class Ejercicio17 contador=vocales(cad,contador+1,pos
//pedazos del numero { +1);
import java.util.ArrayList; public int cantidadVeces(String else
public class Ejerfcicio16 cad,char c){
{ return contador=vocales(cad,contador,pos+1);
public ArrayList<Integer> explotar(int cantidadVeces(cad,c,0,0,cad.length()-1); }
n,int b) } res=contador;
{ public String invertir(String cad) return res;
ArrayList<Integer> res=new { }
ArrayList(); String c1; private boolean esvocal(char c,int
explotar(res,n,b); c1=invertir(cad,cad.length()-1); pos,boolean vocal)
return res; return c1; {
} } boolean res;
private void public int vocales(String cad) char[] vocales=new
explotar(ArrayList<Integer> res,int n,int { char[]{'a','e','i','o','u'};
b) int res; if(pos==vocales.length)
{ res=vocales(cad,0,0); res=false;
if(n<=b){ return res; else{
res.add(n); } char aux=vocales[pos];
}else{ private int vocales(String cad,int if(c==aux)
int n1; contador, int pos) res=true;
int n2; { else
n1=n/b; boolean vocal; res=esvocal(c,pos+1,vocal);
n2=n-n1; int res; }
explotar(res,n1,b); vocal=false; return res;
explotar(res,n2,b); if(pos==cad.length()) }
} res=0; private int cantidadVeces(String
} else{ cad,char c,int contador, int i,int f){
} char c=cad.charAt(pos); if(i<=f){
 if(c==cad.charAt(i)){ int res; //función de ackerman
res=0; public class Ejercicio19
contador=cantidadVeces(cad,c,contad res=promedio(n,true); {
or+1,i+1,f); return res; public int fAckerman(int m,int n)
}else {
} {
private int promedio(int n,boolean int res;
contador=cantidadVeces(cad,c,contad
or,i+1,f); bandera) if(m==0){
} { n=n+1;
} int res; res=n;
return contador; res=0; }else{
} if(n<=9){ if(n==0){
private String invertir(String cad,int if(bandera==true) m=m-1;
ultpos) res=n; n=1;
{ else res=fAckerman(m,n);
String c1; res=-n; }else{
if(ultpos==0){
}else{ n=n-1;
c1=""+cad.charAt(ultpos);
if(bandera==true){ n=fAckerman(m,n);
}
else{
bandera=false; m=m-1;
res=fAckerman(m,n);
c1=cad.charAt(ultpos)+invertir(cad,ultp res=n%10+promedio(n/10,bandera); }
os-1); }else{ }
} bandera=true; return res;
return c1; res=n%10- }
} promedio(n/10,bandera); }
} } //es palíndromo?
//numero promedio } public class Ejercicio20
public class Ejercicio18 {
{ return res; public boolean palindromo(String
public int promedio(int n) } cad)
{ } {
 boolean res; int res; limite)
res=sumarPares(n,1,2); {
res=palindromo(cad,0,cad.length()- return res; int aux;
1); } if(inicio<=limite){
return res; private int sumarPares(int n,int aux=inicio;
} contador, int par)
private boolean palindromo(String { imprimirPiramide(aux,inicio,limite);
cad, int i, int j) int res; }
{ if(contador>n) }
boolean res; res=0; private void imprimirPiramide(int
if(i>j) else{ aux,int inicio,int limite)
res=true; if(par%4==0) {
else{ int i=aux;
char c1=cad.charAt(i); res=sumarPares(n,contador,par+2); if(i==1){
char c2=cad.charAt(j); else System.out.println(i);
if(c1==c2) piramide(inicio+1,limite);
res=palindromo(cad,i+1,j-1); res=par+sumarPares(n,contador+1, }else{
else par+2); System.out.print(i);
res=false; } imprimirPiramide(i-
} return res; 1,inicio,limite);
return res; } }
} } }
} //mediana piramide }
//suma de n números pares que no public class Ejercicio22 //numero con dígitos incrementales
son múltiplos de 4 { public class Ejercicio23
import java.util.ArrayList; public void piramide(int limite) {
public class Ejercicio21 { public boolean
{ piramide(1,limite); digitosIncrementales(int n)
public int sumarPares(int n) } {
{ private void piramide(int inicio, int boolean res;
 if(n<=9) res=false; }
res=true; } return res;
else{ return res; }
int d1=n%10; } private String
int d2=(n/10)%10; } simplificarCadena(String cad, int
if(d1>=d2) //inverso simple de una cadena pos, int fin)
public class Ejercicio25 {
res=digitosIncrementales(n/10); { String res;
else public String inversaSimple(String if(pos==fin){
res=false; cad) res=""+cad.charAt(pos);
} { }else{
return res; String cadSimple,res; char c1=cad.charAt(pos);
} char c2=cad.charAt(pos+1);
} cadSimple=simplificarCadena(cad,0, if(c1==c2){
//numero de dígitos decrementales cad.length()-1);
public class Ejercicio24 res=""+simplificarCadena(cad,pos+
{ res=inversa(cadSimple,0,cadSimple. 1,fin);
public boolean length()-1); }else{
digitosDecrementales(int n) return res;
{ } res=c1+simplificarCadena(cad,pos+
boolean res; private String inversa(String 1,fin);
if(n<=9) cad,int inicio, int pos) }
res=true; { }
else{ String res; return res;
int d1=n%10; if(pos==inicio) }
int d2=(n/10)%10; res=""+cad.charAt(pos); }
if(d1<=d2) else{ //es de forma anbn?
char c=cad.charAt(pos); public class Ejercicio26
res=digitosDecrementales(n/10); res=c+inversa(cad,inicio,pos- {
else 1); public boolean
reconocerAnBn(String cad,int n) res = a[n-1]; prefijo de \"arboles\"? " +
{ } prefijo("aro", "arboles"));
boolean res; return res; System.out.println("\"soga\" es
if(cad.length()>=n) } sufijo de \"mantel\"? " +
private void ordenar(int[] a, int i, sufijo("soga", "mantel"));
res=reconocerAnBn(cad,n,cad.lengt int j){ }
h()-1); if(i < a.length - 1){ public boolean prefijo(String c1,
else if(j < a.length){ String c2){
res=false; if(a[i] > a[j]){ boolean res = false;
return res; int aux = a[i]; if(c1.length() <= c2.length())
} a[i] = a[j]; res = prefijo(c1, c2, 0);
private boolean a[j] = aux; return res;
reconocerAnBn(String cad,int n, int } }
fin) ordenar(a, i, j+1); private boolean prefijo(String c1,
{ }else String c2, int i){
boolean res=true; ordenar(a, i+1, i+2); boolean res = true;
} if(i < c1.length()){
} if(c1.charAt(i) == c2.charAt(i))
return res; } res = prefijo(c1, c2, i+1);
} // es prefijo o sufijo? else
} public class Ejercicio28 res = false;
//devuelve el n-esimo numero { }
menor de una secuencia de public void ejerCad2(){ return res;
numeros System.out.println("\"lo\" es }
public class Ejercicio27 prefijo de \"lombriz\"? " + prefijo("lo", public boolean sufijo(String c1,
{ "lombriz")); String c2){
public int nMinimo(int[] a, int n){ System.out.println("\"ado\" es boolean res = false;
int res = -1; sufijo de \"teclado\"? " + sufijo("ado", if(c1.length() <= c2.length())
if(n > 0 && n <= a.length){ "teclado")); res = sufijo(c1, c2, c1.length()
ordenar(a, 0, 1); System.out.println("\"aro\" es -1, c2.length()-1);
 return res; } }
} return res; }
private boolean sufijo(String c1, } //cuantos dígitos pares ocupan
String c2, int i, int j){ public boolean esParTrucho2(int posiciones impares?
boolean res = true; n){ public class Ejercicio30
if(i >= 0){ boolean res; {
if(c1.charAt(i) == c2.charAt(j)) if(n == 0){ public int digParPosPar(int n){
res = sufijo(c1, c2, i-1, j-1); res = true; return digParPosPar(n,
else }else{ digitos(n)-1);
res = false; if(esImparTrucho2(n-1)) }
} res = true; private int digParPosPar(int n, int
return res; else dig){
} res = false; int res = 0;
} } if(dig >= 0)
return res; if(n%2 == 0 && dig % 2 == 0)
//es par o impar? } res = 1 +
public class Ejercicio29 public boolean digParPosPar(n/10, dig-1);
{ esImparTrucho2(int n){ else
public boolean esParTrucho(int boolean res; res = digParPosPar(n/10,
n){ if(n == 1){ dig-1);
boolean res; res = true; return res;
if(n == 0) }else if(n == 0){ }
res = true; res = false; public int digitos(int n){
else if(n == 1){ }else{ int res;
res = false; if(esParTrucho2(n-1)) if(n / 10 == 0)
}else{ res = true; res = 1;
if(!esParTrucho(n-1)){ else else
res = true; res = false; res = 1 + digitos(n/10);
}else } return res;
res = false; return res; }
} for(int i = 0; i < cantPes.length; int res;
//dar la menor cantidad de billetes y i++){ boolean[] bandera=new
monedas System.out.println(pesos[i] + boolean[10];
public class Ejercicio31 " peso(s) -> " + cantPes[i]);
{ } res=segundasOcurrencias(n,0,band
public void detalleDinero(double System.out.println("Monedas"); era);
m){ for(int i = 0; i < cantCtv.length; return res;
int[] pesos = new i++){ }
int[]{100,50,20,10,5,2,1}; System.out.println(ctvs[i] + " private int
int[] ctvs = new ctv (s) -> " + cantCtv[i]); segundasOcurrencias(int n,int
int[]{50,25,10,5,1}; } pos,boolean[] bandera)
int[] cantPes = new } {
int[pesos.length]; private void detalleDinero(int m, int res;
int[] cantCtv = new int[] d, int[] cant, int i){ if(n<=0)
int[ctvs.length]; if(i < cant.length && m > 0) res=0;
if(m >= d[i]){ else{
String d = String.valueOf(m); cant[i]++; if(bandera[n%10]==false){
int entero = detalleDinero(m-d[i], d, cant, bandera[n%10]=true;
Integer.parseInt(d.substring(0, i);
d.indexOf('.'))); }else res=n%10*(int)Math.pow(10,pos)+s
int decimal = detalleDinero(m, d, cant, egundasOcurrencias(n/10,pos+1,ba
Integer.parseInt(d.substring(d.index i+1); ndera);
Of('.')+1)); } }else{
} bandera[pos]=false;
detalleDinero(entero, pesos, //eliminar segundas ocurrencias
cantPes, 0); public class Ejericio32 res=segundasOcurrencias(n/10,pos,
detalleDinero(decimal, ctvs, { bandera);
cantCtv, 0); public int }
segundasOcurrencias(int n) }
System.out.println("Billetes"); { return res;
 } pos),pos+1,bandera,digitos,res);
} }else subsecuencia(secuencia,res,0,secu
//primeras ocurrencias encia.size());
public class Ejercicio33 res=primerasOcurrencias(n%(int)Ma return res;
{ th.pow(10,digitos- }
public int primerasOcurrencias(int pos),pos+1,bandera,digitos,res); private void
n) } subsecuencia(ArrayList<Integer>
{ return res; secuencia,ArrayList<Integer> sub,int
int res; } pos,int tamaño)
boolean[] bandera=new private int cantidadDigitos(int n) {
boolean[10]; { if(tamaño-pos>0){
int res; Integer
res=primerasOcurrencias(n,0,bande if(n<=9) elemento1=secuencia.get(pos);
ra,cantidadDigitos(n)-1,0); res=1; Integer
return res; else elemento2=secuencia.get(pos);
} res=1+cantidadDigitos(n/10); if(elemento1>=elemento2){
private int return res; sub.add(elemento1);
primerasOcurrencias(int n,int }
pos,boolean[] bandera,int digitos,int } subsecuencia(secuencia,sub,pos+1,
res) //subsecuencia desendente mas tamaño);
{ larga de una secuencia }else{
if(n>0){ import java.util.ArrayList; sub.add(elemento2);
int public class Ejercicio34
d=n/(int)Math.pow(10,digitos-pos); { subsecuencia(secuencia,sub,pos+1,
if(bandera[d]==false){ public ArrayList<Integer> tamaño);
bandera[d]=true; subsecuencia(ArrayList<Integer> }
res=res*10+d; secuencia) }
{ }
res=primerasOcurrencias(n%(int)Ma ArrayList<Integer> res=new }
th.pow(10,digitos- ArrayList(); //triangulo de pascal
public class Ejercicio35 public void mostrarPascal(int char[][] res = new
{ nfilas){ char[h[0].length][h.length];
public int[] pascal(int n){ int[] a = new int[1]; transponer(h, res, 0, h[0].length-
int[] ant = new int[1]; for (int i = 1; i < nfilas+1; i++) { 1);
return pascal(1, n, ant); int[] x = new int[i]; for(char[] cs : res){
} for (int j = 0; j < i; j++) { for(char c : cs)
private int[] pascal(int i, int n, int[] if (j == 0 || j == (i - 1)) { System.out.print(c);
ant){ x[j] = 1; System.out.println();
if(i < n+1){ } else { }
int[] act = new int[i]; x[j] = a[j] + a[j - 1]; return res;
generarNivelPascal(0, i, ant, } }
act); if(j == 0) private void transponer(char[][] h,
ant = act; for(int k = 0; k < (nfilas-i); char[][] res, int i, int j){
ant = pascal(i+1, n, ant); k++) if(i < h.length){
} System.out.print(" "); if(j >= 0){
return ant; System.out.print(x[j] + " "); res[j][i] = h[i][j];
} } transponer(h, res, i, j-1);
private void a = x; }else
generarNivelPascal(int j, int i, int[] System.out.println(); transponer(h, res, i+1,
ant, int[] act){ } h[0].length-1);
if(j < i){ } }
if (j == 0 || j == (i - 1)) { } }
act[j] = 1; //transponer un histograma }
} else { cambiar filas por columnas //rotar onda en campana cambiar
act[j] = ant[j] + ant[j - 1]; fila por columna
} public class Ejercicio37
generarNivelPascal(j+1, i, ant, public class Ejercicio36 {
act); { public void rotar(char[][] o){
} public char[][] transponer(char[][] char[][] res = new
} h){ char[o[0].length][o.length];
 rotar(o, res, 0, 0); } int i){
for(char[] cs : res){ private void generarConj(int[] arr, int tam = 0;
for(char c : cs) int[][] mat, int[] indMat, int i){ if(i <= l)
System.out.print(c); if(i <= arr.length){ tam = numComb(l, i) +
System.out.println(); combinacion(arr, new int[i], i, tamanioClausura(l, i+1);
} arr.length, 0, 0, new boolean[]{false}, return tam;
} mat, indMat); }
private void rotar(char[][] o, char[][] generarConj(arr, mat, indMat, private void combinacion(int[]
res, int i, int j){ i+1); elem, int[] act, int r, int n, int ind, int
if(i < o.length){ } indAct, boolean[] comb, int[][] mat,
if(j < o[i].length){ } int[] indMat) {
res[res.length-1-j][i] = o[i][j]; private void tamanioConj(int[][] if (r == 0){
rotar(o, res, i, j+1); mat, int l, int i, int j){ clonar(mat[indMat[0]], act, 0);
}else if(i <= l){ comb[0] = true;
rotar(o, res, i+1, 0); int length = numComb(l, i); }else{
} tamanioArreglo(mat, length, j, combinacion(elem, act, r, n,
} i); ind, indAct, comb, mat, indMat, ind);
} tamanioConj(mat, l, i+1, }
//conjunto clausura j+length); }
public class Ejercicio38 } private void combinacion(int[]
{ } elem, int[] act, int r, int n, int ind, int
public int[][] clausura(int[] arr){ private void tamanioArreglo(int[][] indAct, boolean[] comb, int[][] mat,
int tam = mat, int l, int j, int i){ int[] indMat, int i){
tamanioClausura(arr.length, 0); if(l > 0){ if(i < n){
int[][] res = new int[tam][]; mat[j] = new int[i]; act[indAct] = elem[i];
tamanioConj(res, arr.length, 0, tamanioArreglo(mat, l-1, j+1, combinacion(elem, act, r - 1,
0); i); n, i+1, indAct+1, comb, mat, indMat);
generarConj(arr, res, new } if(comb[0]){
int[]{1}, 1); } comb[0] = false;
return res; private int tamanioClausura(int l, indMat[0] = indMat[0]+1;
 if(indMat[0] < mat.length){ return f; return res;
clonar(mat[indMat[0]], } }
act, 0); } /*
act = mat[indMat[0]]; //formatoreducido carácter y * Ejercicio 47
} cantidad de veces que se repite */
} public class Ejercicio39 public String mafiaChina(int n){
combinacion(elem, act, r, n, { String res = "";
ind, indAct, comb, mat, indMat, i+1); public String cadReducida(String if(n == 1){
} c){ res = "(-.-)";
} return cadReducida(c, 0, ""); }else if(n > 1){
private void clonar(int[] des, int[] } res = "(-." + mafiaChina(n-1) +
ori, int i){ private String cadReducida(String ".-)";
if(i < ori.length){ c, int i, String res){ }
des[i] = ori[i]; if(i < c.length()){ return res;
clonar(des, ori, i+1); char car = c.charAt(i); }
} int cant = cantidadRep(car, c, /*
} i); * Ejercicio 49
private int numComb(int n, int r){ res += car + (cant + ""); */
int res = -1; res = cadReducida(c, i+cant, public int cantOndDig(String cad){
if(n >= r) res); return cantOndDig(cad, 0, ' ', ' ');
res = factorial(n)/(factorial(n- } }
r)*factorial(r)); return res; private int cantOndDig(String cad,
return res; } int i, char c1, char c2){
} private int cantidadRep(char car, int res = 0;
private int factorial(int n){ String c, int i){ if(i < cad.length()){
int f = 0; int res = 0; if(i == 0){
if(n == 0) if(i < c.length() && car == res = cantOndDig(cad, i+1,
f = 1; c.charAt(i)) c1, c2);
else res = 1 + cantidadRep(car, c, }else{
f = n*factorial(n-1); i+1); char cad1 = cad.charAt(i-1);
 char cad2 = cad.charAt(i); } return res;
if(cad2 != cad1){ private String }
if(c1 == ' '){ ocurrenciasImpar(String cad, int i, //veces que existe un patrón exacto
c1 = cad1; String res){ public class ejercicio42
c2 = cad2; if(i < cad.length()){ {
res = 1 + char car = cad.charAt(i); public int vecesPatron(String cad,
cantOndDig(cad, i+1, c1, c2); int cant = cantidadRep(car, String patron){
}else if(c1 == cad1 && c2 cad, i); int cont;
== cad2){ res += copiarPares(cant/2, int tamPatron=patron.length();
res = 2 + car);
cantOndDig(cad, i+1, c1, c2); res = ocurrenciasImpar(cad, cont=vecesPatron(cad,patron,0,0,ta
}else i+cant, res); mPatron);
res = cantOndDig(cad, } return cont;
i+1, c1, c2); return res; }
}else } private int vecesPatron(String
res = cantOndDig(cad, private String copiarPares(int cad,String patron,int contador,int
i+1, c1, c2); cant, char c){ i,int tamPatron){
} String res = ""; String
} if(cant > 0) cad1=cad.substring(i,tamPatron);
return res; res = (c+"") + (c+"") + if(cad.length()-1==tamPatron-
} copiarPares(cant-1, c); 1){
} return res; if(cad1.equals(patron)){
//reducir en uno ocurrencias } contador+=1;
repetidas impares private int cantidadRep(char car, }else{
public class Ejercicio40 String c, int i){ contador+=0;
{ int res = 0; }
public String if(i < c.length() && car ==
ocurrenciasImpar(String cad){ c.charAt(i)) }else{
return ocurrenciasImpar(cad, 0, res = 1 + cantidadRep(car, c, if(cad.length()-1>tamPatron-1){
""); i+1); if(cad1.equals(patron)){
 contador= i+1, j+1); }else if(cant > 1)
vecesPatron(cad.substring(1),patro }else res = false;
n,contador+1,i,tamPatron); nPrimosFibonacci(n, res, i, return res;
}else{ j+1); }
contador= } }
vecesPatron(cad.substring(1),patro } //palabras que se repiten y cantidad
n,contador,i,tamPatron); public int fibonacci(int i){ de veces
} int res; public class ejercicio45
} if(i == 0) {
} res = 1; public ArrayList<Dupla>
return contador; else if( i == 1) repeticiones(String cad){
} res = 1; String[] palabras = cad.split(" ");
} else ArrayList<Dupla> res = new
//n números primos de fibonacci res = fibonacci(i-1) + ArrayList();
public class Ejercico44 fibonacci(i-2); repeticiones(palabras, 0, res);
{ return res; for(Dupla d : res){
public int[] nPrimosFibonacci(int }
n){ public boolean esPrimo(int n){ System.out.println(d.toString());
int[] res = new int[n]; return esPrimo(n, 0, 1); }
nPrimosFibonacci(n, res, 0, 2); } return res;
return res; private boolean esPrimo(int n, int }
} cant, int div){ private void repeticiones(String[]
private void nPrimosFibonacci(int boolean res = true; ps, int i, ArrayList<Dupla> res){
n, int[] res, int i, int j){ if(div <= n/2 && cant < 2){ if(i < ps.length){
if(n > 0){ if(n % div == 0) int ind = contiene(res, ps[i], 0);
int fib = fibonacci(j); res = esPrimo(n, cant+1, if(ind != -1){
if(esPrimo(fib)){ div+1); Dupla encontrada =
res[i] = fib; else res.get(ind);
n--; res = esPrimo(n, cant, encontrada.aumentar();
nPrimosFibonacci(n, res, div+1); }else{
 Dupla d = new Dupla(ps[i], public void aumentar(){ public class Reina {
1); cant = cant+1; private int fila;
res.add(d); } private int columna;
} public String getPal(){ private Reina vecina;
repeticiones(ps, i+1, res); return pal; private int tam;
} } Reina (int c, Reina v, int t) {
} public String toString(){ fila = (int)(Math.random()*t)+1;
private int return "("+pal+","+cant+")"; columna = c;
contiene(ArrayList<Dupla> res, } vecina = v;
String c, int i){ } tam = t;
int ind = -1; //ubicar 8 reinas }
if(i < res.size()){ public class Ejercicio46 private boolean puedeAtacar(int
Dupla d = res.get(i); { testfila, int testcolumna) {
if(d.getPal().equals(c)) public void reinas(){ boolean res = false;
ind = i; Reina ultimaReina = null; int diferenciaColumnas =
else reinas(0, 8, ultimaReina); testcolumna - columna;
ind = contiene(res, c, i+1); } if ((fila == testfila) ||
} private void reinas(int i, int tam, (fila + diferenciaColumnas ==
return ind; Reina u){ testfila) ||
} if(i < tam){ (fila - diferenciaColumnas ==
} u = new Reina(i, u, tam); testfila))
//CLASE DUPLA u.buscaSolucion(); res = true;
public class Dupla reinas(i+1, tam, u); else if (vecina != null)
{ }else res =
private String pal; vecina.puedeAtacar(testfila,
private int cant; System.out.println(u.toString()); testcolumna);
public Dupla(String p, int c){ } return res;
pal = p; } }
cant = c; //clase reina public boolean buscaSolucion() {
} import java.util.*; boolean res = false;
 if ( vecina == null || return res; return onda;
!vecina.puedeAtacar(fila, columna) ) } }
res = true; } private void ondaDig(String[] onda,
else if ( avanzar() ) //chinos String cad, int i, boolean up, boolean
res = true; public class ejercicio47 down){
return res; { if(i < cad.length()){
} public String mafiaChina(int n){ char c = cad.charAt(i);
public boolean avanzar() { String res = ""; if(!up && !down){
boolean res; if(n == 1){ if(c == 'H'){
if ( fila < tam - 1) { res = "(-.-)"; onda[0] += "_";
fila++; }else if(n > 1){ onda[1] += " ";
res = buscaSolucion(); res = "(-." + mafiaChina(n-1) + ondaDig(onda, cad, i+1,
}else if ( vecina != null && ".-)"; true, false);
!vecina.avanzar() ) } }else if(c == 'L'){
res = false; return res; onda[0] += " ";
else{ } onda[1] += "_";
fila = 0; ondaDig(onda, cad, i+1,
res = buscaSolucion(); } false, true);
} //cantidad de ondas }
return res; public class ejercicio49 }else if(up && !down){
} { if(c == 'H'){
@Override public String[] ondaDig(String onda[0] += "_";
public String toString(){ cad){ onda[1] += " ";
String res = ""; String[] onda = new String[2]; ondaDig(onda, cad, i+1,
Reina r = this; onda[0] = ""; true, false);
while(r != null){ onda[1] = ""; }else if(c == 'L'){
res += r.fila + " " + r.columna ondaDig(onda, cad, 0, false, onda[0] += " ";
+ "\n"; false); onda[1] += "|_";
r = r.vecina; System.out.println(onda[0]); ondaDig(onda, cad, i+1,
} System.out.println(onda[1]); false, true);
 } private void rotarMatriz(int[][] mat, else{
}else if(!up && down){ int n, int i){ if(n % 2 == 0){
if(c == 'H'){ if(i < mat.length && n > 0){ res = n +
onda[0] += " _"; int[] recorrido = new sumaMensajes(n/2);
onda[1] += "| "; int[mat[i].length]; }else{
ondaDig(onda, cad, i+1, recorrer(mat[i], 0, res = n +
true, false); n%mat[0].length, recorrido); sumaMensajes(3*n + 1);
}else if(c == 'L'){ mat[i] = recorrido; }
onda[0] += " "; rotarMatriz(mat, n-1, i+1); }
onda[1] += "_"; }else if(n != 0) return res;
ondaDig(onda, cad, i+1, rotarMatriz(mat, n, 0); }
false, true); } }
} private void recorrer(int[] ori, int i, //dado un numero n permite
} int j, int[] des){ mostrar Sn
} if(i < ori.length){ public class Ejercicio53
} if(j < des.length){ {
} des[j] = ori[i]; public String funcionSin(int n){
//rotar a derecha una matriz en recorrer(ori, i+1, j+1, des); String res = funcionSin(n, 1);
forma de tornillo }else System.out.println(res);
public class ejercicio51 recorrer(ori, i, 0, des); return res;
{ } }
public void rotarMatriz(int[][] mat, } private String funcionSin(int n, int
int n){ } j){
rotarMatriz(mat, n, 0); //mensajes enviados String res = "";
for(int[] a : mat){ public class ejercicio52 if(n == 1){
for(int b : a) { res = "(" + funcionA(n) + " + "
System.out.print(b + " "); public int sumaMensajes(int n){ + (j) + ")";
System.out.println(); int res = 0; }else if (j == 1)
} if(n == 1) res = funcionSin(n-1, j+1) +
} res = 1; funcionA(n) + " + " + (j);
 else public class Saltarin buscarLetraAtras(c, posCinta-1, 1);
res = "(" + funcionSin(n-1, j+1) { if (saltosAdelante == -1 &&
+ funcionA(n) + " + " + (j) + ")"; private String cinta; saltosAtras == -1) {
return res; public Saltarin(String c) { res.clear();
} cinta = c; } else {
public String funcionA(int n){ } Par par;
return funcionA(n, 1, false); public String if (saltosAdelante > 0 &&
} buscarCadena(String cad) { saltosAtras == -1) {
private String funcionA(int n, int i, ArrayList<Par> res = new par = new
boolean signo){ ArrayList(); Par(saltosAdelante, "Adelante");
String res = ""; buscarCadena(cad, 0, 0, res); posCinta = posCinta +
if(i <= n){ String msg; saltosAdelante;
if(i == 1) if (res.size() == 0) { } else if (saltosAtras > 0
res = "sin(1" + funcionA(n, msg = "Imposible"; && saltosAdelante == -1) {
i+1, false) + ")"; } else { par = new
else{ msg = convertirACadena(res, Par(saltosAtras, "Atras");
if(signo){ 0); posCinta = posCinta -
res = " + sin(" + i + } saltosAtras;
funcionA(n, i+1, false) + ")"; System.out.println(msg); } else if (saltosAdelante ==
}else return msg; saltosAtras) {
res = " - sin(" + i + } par = new
funcionA(n, i+1, true) + ")"; private void buscarCadena(String Par(saltosAdelante, "Adelante");
} cad, int posCinta, int posCad, posCinta = posCinta +
} ArrayList<Par> res) { saltosAdelante;
return res; if (posCad < cad.length()) { } else if (saltosAdelante <
} char c = cad.charAt(posCad); saltosAtras) {
} int saltosAdelante = par = new
//EJERCICIO 54 buscarLetraAdelante(c, posCinta+1, Par(saltosAdelante, "Adelante");
import java.util.ArrayList; 1); posCinta +=
int saltosAtras = saltosAdelante;
 } else { private int buscarLetraAtras(char public class Ejercicio55
par = new c, int posCinta, int resP) { {
Par(saltosAtras,"Atras"); int res; public int[][] secEnterosGen(int[]
posCinta -= saltosAtras; if (posCinta == -1) { sec){
} res = -1; int[][] secSec = new
res.add(par); } else { int[contarPrimos(sec,0)][];
buscarCadena(cad, char letraActual = secEnterosGen(sec, 0, 0,
posCinta, posCad + 1, res); cinta.charAt(posCinta); secSec);
} if (letraActual == c) { //solo para mostrar los
} res = resP; resultados//
} } else { for(int[] a : secSec){
private int res = buscarLetraAtras(c, for(int b : a)
buscarLetraAdelante(char c, int posCinta-1, resP+1); System.out.print(b + " ");
posCinta, int resP) { } System.out.println();
int res; } }
if (posCinta == cinta.length()) { return res; return secSec;
res = -1; } }
} else { private String private void secEnterosGen(int[]
char letraActual = convertirACadena(ArrayList<Par> sec, int i, int j, int[][] secSec){
cinta.charAt(posCinta); res, int pos) { if(j < secSec.length){
if (letraActual == c) { String msg = ""; if(i < sec.length){
res = resP; if (pos < res.size()) { if(esPrimo(sec[i]))
} else { Par p = res.get(pos); secSec[j++] =
res = msg = p.toString() + generarSecuencia(sec[i], new
buscarLetraAdelante(c, posCinta+1, convertirACadena(res, pos+1); int[sec[i]]);
resP+1); } secEnterosGen(sec, i+1, j,
} return msg; secSec);
} } }
return res; } }
} //secuencia de suecuencias }
 private int[] generarSecuencia(int i, div+1); autocontenciones(String n, int
int[] res){ else base){
if(i > 0){ res = esPrimo(n, cant, return autocontenciones(n,
res[i-1] = i; div+1); base, 0);
generarSecuencia(i-1, res); }else if(cant > 1) }
} res = false; private int
return res; return res; autocontenciones(String n, int base,
} } int exp){
private int contarPrimos(int[] sec, } int res = 0;
int i){ //es divisible entre 7? if(!n.isEmpty()){
int res = 0; public class ejercicio56 String num =
if(i < sec.length){ { ((int)Math.pow(base, exp))+"";
if(esPrimo(sec[i]) && sec[i] != public boolean multiplo7(int n){ String comparado = cortar(n,
1) boolean res = false; 0, num.length());
res = 1 + contarPrimos(sec, if(n < 10){ if(num.equals(comparado)){
i+1); res = n % 7 == 0; res =
else }else{ autocontenciones(n.substring(num.
res = contarPrimos(sec, int dig = n % 10; length()), base, exp+1);
i+1); n = n/10; }else
} dig = dig*2; res = -1;
return res; res = multiplo7(n-dig); }else
}public boolean esPrimo(int n){ } res = exp-1;
return esPrimo(n, 0, 1); return res; return res;
} } }
private boolean esPrimo(int n, int } private String cortar(String n, int i,
cant, int div){ //CANTIDAD DE int j){
boolean res = true; AUTOCONTENCIONES String res = "";
if(div <= n/2 && cant < 2){ public class ejercicio57 if(i < j){
if(n % div == 0) { res += n.charAt(i) + cortar(n,
res = esPrimo(n, cant+1, public int i+1, j);
 } } res=segundasOcurrencias(n/10,pos
return res; } +1,bandera)+(int)Math.pow(10,pos)
} return res; *digito;
} } }else
//NUMERO SIAMES }
public class Ejericio60{ //NUMERO SIN DIGITOS res=segundasOcurrencias(n/10,pos,
public boolean siames(int n){ REPETIDOS bandera);
boolean res=true; public class Ejercicio62 }
int contd=(int)Math.log10(n)+1; { return res;
if(n!=0){ public int }
if(contd%2==0){ segundasOcurrencias(int n) }
int { //CANTIDAD DE
aux=n/(int)Math.pow(10,(contd/2)); int res; TRANSFORMACIONES PARA
int boolean[] bandera=new VOLVER A SER EL NUMERO
aux2=n%(int)Math.pow(10,(contd/2)) boolean[10]; ORIGINAL
; public class Ejercicio63
if(aux%10==aux2%10){ res=segundasOcurrencias(n,0,band {
aux=aux/10; era); public int transformaciones(int n)
aux2=aux2/10; return res; {
} int res;
aux*=(int)Math.pow(10,(contd/2)-1); private int if(n<100){
n=aux+aux2; segundasOcurrencias(int n,int int aux=n%10+n/10;
res=siames(n); pos,boolean[] bandera) int nuevoN=n%10*10+aux%10;
} {
else{ int res=0; res=transformaciones(nuevoN,n,1);
res=false; if(n>0){ }else
} int digito=n%10; res=-1;
} if(bandera[digito]==false){ return res;
else{ bandera[digito]=true; }
res=false; private int transformaciones(int
nuevoN,int n,int contador) res=verificar(palabras,0,palabras.len boolean[n];
{ gth-1); for(int i = 0; i < n; i++)
if(nuevoN==n) return res; nums[i] = true;
contador=1; } for(int i = 2; i*i <= n; i++){
else{ private boolean verificar(String[] for(int j = 2; j < n; j++){
int digito1=nuevoN%10; palabras,int pos,int tamaño) if(i*j < n){
int digito2=nuevoN/10; { nums[i*j] = false;
int boolean res; }
sumaDigitos=digito1+digito2; if(pos==tamaño) }
res=true; }
nuevoN=digito1*10+sumaDigitos%1 else{ }
0; char }
l1=palabras[pos].charAt(0); //NUMERO DE LEONES
contador=1+transformaciones(nuev char public class Ejercicio78
oN,n,contador); l2=palabras[pos+1].charAt(0); {
} if(l1==l2) public int cantLeones(String c){
return contador; return cantLeones(c, 0, 0,
} res=verificar(palabras,pos+1,tamañ "LEON");
} o); }
//TAUTOGRAMA else private int cantLeones(String c,
import java.util.*; res=false; int i, int j, String leon){
public class Ejercicio67 } int res = 0;
{ return res; if(j < leon.length()){
public boolean verificar(String } if(i < c.length()){
cad) } if(c.charAt(i) ==
{ //CRIBA leon.charAt(j)){
boolean res; public class Criba res = cantLeones(c, i+1,
String aux=cad.toLowerCase(); { j+1, leon);
String[] palabras=aux.split(" "); public void criba(int n){ }else
boolean [] nums = new res = cantLeones(c, i+1, j,
leon); if(mapa[i][j] == 'E'){ sol.clear();
} caminoSeguro(i, j, 0, new sol.addAll(act);
}else{ ArrayList<String>(), ""); }
res = 1 + cantLeones(c, i, 0, if(min == 0){ act.remove(act.size()-1);
leon); caminoMenosMinas(i, }else if(mapa[i][j] == 'S' ||
} j, 0, new ArrayList<String>(), ""); mapa[i][j] == 'E'){
return res; } char c = mapa[i][j];
} }else mapa[i][j] = 'P';
} solucion(i, j+1); if(c != 'E')
//EXPLORAR CAMINOS MINADOS }else act.add("(" + mov + ", "
import java.util.ArrayList; solucion(i+1, 0); + c + ")");
} caminoMenosMinas(i-1,
public class Ejercicio86 } j, minas, act, "U");
{ private void caminoMenosMinas(i+1,
private char[][] mapa; caminoMenosMinas(int i, int j, int j, minas, act, "D");
private int min; minas, ArrayList<String> act, String caminoMenosMinas(i,
private ArrayList<String> sol; mov){ j+1, minas, act, "R");
public Ejercicio86(char[][] m){ if(i >= 0 && i < mapa.length){ caminoMenosMinas(i, j-
mapa = m; if(j >= 0 && j < 1, minas, act, "L");
min = 0; mapa[i].length){ if(c != 'E')
sol = new ArrayList(); if(mapa[i][j] == 'D'){ act.remove(act.size()-
} act.add("(" + mov + ", " + 1);
public void solucion(){ mapa[i][j] + ")"); mapa[i][j] = c;
solucion(0, 0); if(minas < min || min == }else if(mapa[i][j] == 'M'){
for(String t : sol) 0){ minas++;
System.out.println(t); min = minas; mapa[i][j] = 'P';
} sol.clear(); act.add("(" + mov + ", " +
private void solucion(int i, int j){ sol.addAll(act); 'M' + ") Hay mina en " + i + " " + j);
if(i < mapa.length){ }else if(minas == min && caminoMenosMinas(i-1,
if(j < mapa[i].length){ act.size() < sol.size()){ j, minas, act, "U");
 caminoMenosMinas(i+1, char c = mapa[i][j]; res=x+y+x;
j, minas, act, "D"); mapa[i][j] = 'P'; }
caminoMenosMinas(i, if(c != 'E') else{
j+1, minas, act, "R"); act.add("(" + mov + ", " res=x+y+cancer(a,b,n-1)+y+x;
caminoMenosMinas(i, j- + c + ")"); }
1, minas, act, "L"); caminoSeguro(i-1, j, return res;
act.remove(act.size()-1); pasos+1, act, "U"); }
mapa[i][j] = 'M'; caminoSeguro(i+1, j, }
} pasos+1, act, "D"); //EJERCICIO 83
} caminoSeguro(i, j+1, PAC-MAN
} pasos+1, act, "R"); public class Juego
} caminoSeguro(i, j-1, {
private void caminoSeguro(int i, pasos+1, act, "L"); Elemento[][] plano = {{new
int j, int pasos, ArrayList<String> act, if(c != 'E') Impasable(),new Impasable(),new
String mov){ act.remove(act.size()- Impasable(),new Impasable(),new
if(i >= 0 && i < mapa.length){ 1); Impasable(),new Impasable(),new
if(j >= 0 && j < mapa[i][j] = c; Impasable(),new Impasable(),new
mapa[i].length){ } Impasable(),new Impasable(),new
if(mapa[i][j] == 'D'){ } Impasable(),new Impasable(),new
act.add("(" + mov + ", " + } Impasable(),new Impasable(),new
mapa[i][j] + ")"); } Impasable(),new Impasable(),new
if(pasos < min || min == } Impasable(),new Impasable(),new
0){ //CADENA CANCEROSA Impasable(),new Impasable()},
min = pasos; public class Ejercicio82{ {new
sol.clear(); public String cancer(char a, char b, Impasable(),new Pasable(0),new
sol.addAll(act); int n){ Pasable(0),new Pasable(0),new
} String res=""; Pasable(500),new Pasable(0),new
act.remove(act.size()-1); String x=Character.toString(a); Pasable(0),new Impasable(),new
}else if(mapa[i][j] == 'S' || String y=Character.toString(b); Pasable(5000),new Pasable(0),new
mapa[i][j] == 'E'){ if(n==1){ Pasable(0),new Pasable(0),new
Impasable(),new Pasable(0),new
Pasable(0),new Pasable(5000),new
Pasable(0),new Pasable(0),new
Pasable(5000),new Impasable()},
{new
Impasable(),new Pasable(0),new
Impasable(),new Impasable(),new
Pasable(0),new Pasable(0),new
Pasable(100),new Impasable(),new
Impasable(),new
Pasable(1000),new
Impasable(),new Impasable(),new
Impasable(),new Pasable(700),new
Pasable(0),new Pasable(0),new
Impasable(), new Impasable(),new
Impasable(),new Impasable()},
{new
Impasable(),new Pasable(0),new
Impasable(), new Impasable(),new
Pasable(0),new Impasable(),new
Pasable(100), new Pasable(0),new
Pasable(0),new Pasable(0),new
Pasable(0),new Pasable(0),new
Pasable(0),new Pasable(1000),new
Impasable(),new Pasable(0),new
Pasable(0),new Impasable(),new
Pasable(0),new Impasable()},
{new
Impasable(),new Pasable(0),new
Impasable(),new Impasable(),new
Impasable(),new Impasable(),new int posXP, posYP;
Pasable(0),new Impasable(),new public Juego(int x, int y ){
Impasable(),new Impasable(),new posXP = x;
Impasable(),new Impasable(),new posYP = y;
Impasable(),new Pasable(0),new }
Impasable(),new Impasable(),new public int caminoMax(){
Impasable(),new Impasable(),new plano[posXP][posYP] = new
Pasable(0),new Impasable()}, Impasable();
{new int res1 =
Impasable(),new Pasable(300),new caminoMaximo(posXP-1,posYP);
Pasable(0),new Pasable(0),new int res2 =
Pasable(0),new Impasable(),new caminoMaximo(posXP, posYP+1);
Pasable(0),new Pasable(0),new int res3 =
Pasable(0),new Impasable(),new caminoMaximo(posXP+1,posYP);
Pasable(0),new Pasable(0),new int res4 =
Pasable(0),new Impasable(),new caminoMaximo(posXP,posYP-1);
Pasable(0),new Pasable(500),new int mayor1 =
Pasable(0),new Pasable(0),new Integer.max(Integer.max(res1,res2),
Pasable(0),new Impasable()}, Integer.max(res3,res4));
{new int mayor2;
Impasable(),new Impasable(),new if(mayor1 == res1){
Impasable(),new Impasable(),new mayor2 =
Impasable(),new Impasable(),new Integer.max(Integer.max(res2,res3),
Impasable(),new Impasable(),new res4);
Impasable(),new Impasable(),new }else if(mayor1 == res2){
Impasable(),new Impasable(),new mayor2 =
Impasable(),new Impasable(),new Integer.max(Integer.max(res1,res3),
Impasable(),new Impasable(),new res4);
Impasable(),new Impasable(),new }else if(mayor1 == res3){
Impasable(),new Impasable()}}; mayor2 =
Integer.max(Integer.max(res2,res1), } public class Impasable extends
res4); return res; Elemento
}else{ } {
mayor2 = } public Impasable(){
Integer.max(Integer.max(res2,res3), //JUEGO TIENE UN CLASE super(0);
res1); ELEMENTO }
} }
int resTotal = mayor1+mayor2; public class Elemento //EJERCICIO 112
return resTotal; { public class DamasJP
} int bono; {
private int caminoMaximo(int x, public Elemento(int valor){ /*
int y){ bono = valor; {
int res = 0; } {'.','.','.','.','.'},
Elemento actual = plano[x][y]; {'.','B','.','.','.'},
int valor = actual.getBono(); public int getBono(){ {'N','.','.','.','.'},
plano[x][y] = new Impasable(); return bono; {'.','B','.','B','.'},
if(actual instanceof } {'.','.','.','.','.'}
Impasable){ } }
//UN ELEMENTO PUEDE SER
}else{ PASABLE {
int res1 = caminoMaximo(x- public class Pasable extends {'.','.','.','.','.'},
1,y); Elemento {'.','B','.','N','.'},
int res2 = { {'.','.','B','.','.'},
caminoMaximo(x,y+1); public Pasable(int val){ {'.','.','.','B','.'},
int res3 = super(val); {'.','.','.','.','N'}
caminoMaximo(x+1,y); } }
int res4 = caminoMaximo(x,y- } */
1); //UN ELEMENTO PUEDE SER
res = IMPASABLE private char[][] tab;
valor+res1+res2+res3+res4; private int alto, ancho;
 private int maxBlancas; tab[i][j] = '.'; tab[i+2][j+2] = '.';
public DamasJP(char[][] t){ tab[i-1][j-1] = '.'; cont--;
tab = t; tab[i-2][j-2] = 'N'; }
alto = tab.length; blancas(0,0,cont); blancas(i, j+1, cont);
ancho = tab[0].length; tab[i][j] = 'N'; }else{
maxBlancas = 0; tab[i-1][j-1] = 'B'; blancas(i+1, 0, cont);
} tab[i-2][j-2] = '.'; }
public int blancas(){ cont--; }else{
blancas(0, 0, 0); } if(maxBlancas < cont)
return maxBlancas; if(movimientoValido(i, j, 1, - maxBlancas = cont;
} 1, 'N')){ }
private void blancas(int i, int j, int cont++; }
cont){ tab[i][j] = '.'; private boolean
if(i >= 0 && i < alto){ tab[i+1][j-1] = '.'; movimientoValido(int i, int j, int
if(j >= 0 && j < ancho){ tab[i+2][j-2] = 'N'; aumI, int aumJ, char c){
if(movimientoValido(i, j, -1, blancas(0,0,cont); boolean res = false;
1, 'N')){ tab[i][j] = 'N'; if(i >= 0 && i < alto){
cont++; tab[i+1][j-1] = 'B'; if(j >= 0 && j < ancho){
tab[i][j] = '.'; tab[i+2][j-2] = '.'; if(tab[i][j] == c){
tab[i-1][j+1] = '.'; cont--; if(c == 'N')
tab[i-2][j+2] = 'N'; } res =
blancas(0,0,cont); if(movimientoValido(i, j, 1, movimientoValido(i+aumI, j+aumJ,
tab[i][j] = 'N'; 1, 'N')){ aumI, aumJ, 'B');
tab[i-1][j+1] = 'B'; cont++; else if(c == 'B')
tab[i-2][j+2] = '.'; tab[i][j] = '.'; res =
cont--; tab[i+1][j+1] = '.'; movimientoValido(i+aumI, j+aumJ,
} tab[i+2][j+2] = 'N'; aumI, aumJ, '.');
if(movimientoValido(i, j, -1, blancas(0,0,cont); else if(c == '.')
-1, 'N')){ tab[i][j] = 'N'; res = true;
cont++; tab[i+1][j+1] = 'B'; }
 } obtenerLomas(); obtenerLomas(pos+1,comienzo);
} colinaRespuesta = new }
return res; Integer[0];
} } }
}
//INDUCCION private void obtenerLomas(){ private Integer[] copiar(int inicio,
public class Ejercicio95{ obtenerLomas(0,0); int fin, Integer[] colina,int puntero){
public int kotch(int n){ } if(inicio <= fin){
int res=0; colina[puntero] =
if(n==1){ private void obtenerLomas(int camino[inicio];
res=1; pos, int comienzo){ copiar(inicio+1,fin, colina,
} if(pos == camino.length-3){ puntero+1);
else{ Integer[] colina = new }
res=4*kotch(n-1)+1; Integer[((pos+1)-comienzo)+1]; return colina;
} colina = }
return res; copiar(comienzo,pos+1,colina,0);
} colinas.add(colina); public Integer[] mejorColina(){
} }else{ return mejorColina(0);
//EJERCICIO 98 if(camino[pos+1] < }
import java.util.ArrayList; camino[pos] && camino[pos+1] <
public class Recorrido camino[pos+2]){ private Integer[] mejorColina(int
{ Integer[] colina = new pos){
private int[] camino; Integer[((pos+1)-comienzo)+1]; if(pos >= colinas.size()){
private int pendiente; colina =
ArrayList<Integer[]> colinas; copiar(comienzo,pos+1,colina,0); }else{
Integer[] colinaRespuesta; colinas.add(colina); Integer[] colinaActual =
public Recorrido(int[] c, int p){ comienzo = pos+1; colinas.get(pos);
camino = c; Integer[] respuesta =
pendiente = p; } analizarColina(colinaActual,0);
colinas = new ArrayList(); if(respuesta.length >
colinaRespuesta.length){ public Laberinto(int[][] lab){ res = solucion(i, j+1, ind
colinaRespuesta = l = lab; + "Derecha ");
respuesta; largo = lab.length; if(!res)
} ancho = lab[0].length; res = solucion(i, j-1, ind +
mejorColina(pos+1); } "Izquierda ");
} public boolean solucion(){ l[i][j] = 1;
return colinaRespuesta; return solucion(0,0,""); }else if(l[i][j] == 2){
} } res = true;
/* System.out.println(ind);
private Integer[] { }
analizarColina(Integer[] colina,int {1,1,1,0}, }
pos){ {1,0,1,0}, return res;
Integer[] res; {1,0,0,0}, }}
if((colina[pos+1]-colina[pos]) {1,0,0,0}, //MOVIMIENTO DEL CABALLO
> pendiente){ {1,1,1,2} public class SaltoCaballo
res = new Integer[0]; } {
}else if(pos < colinas.size()- */ private int[][] tablero;
2){ private boolean solucion(int i, int j, public SaltoCaballo(){
res = colina; String ind){ tablero = new int[8][8];
}else{ boolean res = false; }
res = if(i >= 0 && i < largo && j >=0 &&
analizarColina(colina,pos+1); j < ancho){ public int canSaltos(int f, int c){
} if(l[i][j] == 1){ int res = 0;
return res; l[i][j] = 0; f--; c--;
} res = solucion(i-1, j, ind + res += mover(f-2,c+1);
} "Arriba "); res += mover(f-2,c-1);
//LABERINTO if(!res) res += mover(f+1,c+2);
public class Laberinto{ res = solucion(i+1, j, ind res += mover(f+2,c+1);
private int[][] l; + "Abajo "); res += mover(f+2,c-1);
private int ancho, largo; if(!res) res += mover(f+1,c-2);
 res += mover(f-1,c-2); int y){ }
res += mover(f-1,c+2); int res = cantMov(x-1, y-1)-1; }
return res; return res; //PERMUTACION SIN REPETICION
} } import java.util.*;
private int cantMov(int f, int c){ public class Permutacion
private int mover(int f,int c){ int res; {
int res = 0; if(!valido(f,c)){ public ArrayList<String>
if(control(f,c)){ res = 0; permutar(char[] s){
if(tablero[f][c] != -1){ }else{ ArrayList<String> res = new
res = 1; if(tablero[f][c]==2){ ArrayList<String>();
tablero[f][c] = -1; res = 0; ArrayList<Character> sec = new
res = res + }else{ ArrayList<Character>();
canSaltos(f+1,c+1); res = 1; transformar(s,sec,0);
} tablero[f][c] = 2; perm(0,"",sec,res);
} //marcar return res;
return res; res += cantMov(f-1,c-2); }
} res += cantMov(f+1,c-2);
res += cantMov(f-2,c-1); private void transformar(char[] s,
private boolean control(int f,int c){ res += cantMov(f+2,c-1); ArrayList<Character> sec,int cont){
return f>=0 && f<8 && c>=0 && res += cantMov(f-1,c+2); if(cont<s.length){
c<8; res += cantMov(f+1,c+2); sec.add(s[cont]);
} res += cantMov(f-2,c+1); transformar(s,sec,cont+1);
res += cantMov(f+2,c+1); }
} } }
//OTRO SALTO DEL CABALLO }
public class SaltoCaballoOP2 return res; private void perm(int i,String a,
{ } ArrayList<Character>
private int[][] tablero = new private boolean valido(int f, int c){ s,ArrayList<String> res){
int[8][8]; return f>= 0 && f<tablero.length if(s.size()==1 && i==0){
public int cantMovCaballo(int x, && c >= 0 && c < tablero[0].length; String aux = a+s.get(0);
 if(!res.contains(aux)) if(cadena.length() == k){ sumar(res,nivel,nuevoS,0);
//Control sin repetir res.add(cadena); return res;
res.add(aux); }else if(pos < s.length){ }
} String cad1 = cadena + private void
if(i<s.size()){ s[pos]; sumar(ArrayList<ArrayList<Integer>
char car = s.remove(i); permutar(res,s,0,cad1,k); > res, ArrayList<Integer> nivel,
perm(0,a+car,s,res); ArrayList<Integer> nuevoS, int pos)
s.add(i,car); permutar(res,s,pos+1,cadena,k); {
perm(i+1,a,s,res); } if(pos<nuevoS.size()-1){
} } Integer
} } suma=nuevoS.get(pos)+nuevoS.get
//SUMA TRIANGULAR (pos+1);
public int fact(int n){ import java.util.ArrayList; nivel.add(suma);
return n > 1? n * fact(n-1) : 1; public class SumaTriangular
} { sumar(res,nivel,nuevoS,pos+1);
} public }
//PERMUTACION CON REPETICION ArrayList<ArrayList<Integer>> if(nivel.size()==1){
import java.util.ArrayList; sumar(int[] s) res.add(nivel);
public class Permutacion { }else{
{ ArrayList<ArrayList<Integer>>
public ArrayList<String> res=new ArrayList(); ArrayList<Integer> nivelCopia=nivel;
permutar(char[] s,int k){ ArrayList<Integer> nivel=new
ArrayList<String> res=new ArrayList(); res.add(nivelCopia);
ArrayList();; ArrayList<Integer> nuevoS=new nuevoS.clear();
permutar(res,s,0,"",k); ArrayList(); nuevoS.addAll(nivel);
return res; convertirS(nuevoS,s,0); nivel.clear();
} sumar(res,nivel,nuevoS,0);
private void ArrayList<Integer>nuevoScopia=nue }
permutar(ArrayList<String> res,char[] voS; }
s, int pos, String cadena,int k){ res.add(nuevoScopia); private void
convertirS(ArrayList<Integer> }
nuevoS, int[]s,int pos) encontrarListaP(s[cont],listaP,cont+ }
{ 1,s,x); }
if(pos<s.length){ }
nuevoS.add(s[pos]); if(!listaP.isEmpty())
convertirS(nuevoS,s,pos+1); res.add(listaP);
} recorrerS(x,s,cont+1,res);
} }
} }
//PRACTICA DE AUXILIAR private void encontrarListaP(int
import java.util.ArrayList; elemento, ArrayList<Integer>
public class BuscandoANemo listaP,int cont,int[] s,int x)
{ {
public int suma;
ArrayList<ArrayList<Integer>> if(elemento!=x){
buscando(int x, int[] s) if(cont<s.length){
{ suma=(elemento+s[cont]);
ArrayList<ArrayList<Integer>> if(suma==x){
res=new ArrayList(); listaP.add(s[cont]);
recorrerS(x,s,0,res); }else{if(suma<x){
return res; listaP.add(s[cont]);
} elemento=suma;
private void recorrerS(int x,int[] }
s,int cont,
ArrayList<ArrayList<Integer>> res) encontrarListaP(elemento,listaP,co
{ nt+1,s,x);
if(cont <= s.length-1){ }
ArrayList<Integer> }else{
listaP=new ArrayList<Integer>(); if(elemento!=x)
listaP.add(s[cont]); listaP.clear();