18
Feb
10

RECURSIVIDAD PARTE No. 1


Ejercicios de recursividad (lo mas sencillo posible)
Ejercicios propuestos por el profesor Justo Sarabia para las clases de matemáticas discretas

public class Recursividad {

    public Recursividad() {
    }
    //este metodo recibe el numero hasta el cual llega la sumatoria
    //y el valor de la suma hasta el momento
    //precondicion suma=0;
         //
    public static int sumatoriaNumerosNaturales(int numero, int suma){
    	if(numero<=0){
    		return suma;
    	}
    	suma=suma+numero;
    	numero=numero-1;
    	return sumatoriaNumerosNaturales(numero, suma);
    }
    //este metodo recibe la base y el exponente para la operacion
    //ademas el resultado de esta hasta el momento
    //precondicion resultado=1;
         //
    public static int potenciaNumeroEnteros(int base, int exponente, int resultado){
    	if(exponente<=0){
    		return resultado;
    	}
    	resultado=resultado*base;
    	exponente=exponente-1;
    	return potenciaNumeroEnteros(base, exponente,resultado);
    }

    //este metodo recibe la cadena original, la cadena en forma inversa
    //ademas la posicion de esta hasta el momento
    //precondicion posicion=0;
    //precondicion invertida="";
         //
    public static String invertirCadena(String original, String invertida, int posicion){
    	if(posicion>=original.length()){
    		return invertida;
    	}
    	invertida=original.charAt(posicion)+invertida;
    	posicion=posicion+1;
    	return invertirCadena(original, invertida,posicion);
    }

    //este metodo recibe la matriz, la recorre y va sumando todos sus valores
    //precondicion i=0;
    //precondicion j=0;
    //precondicion resultado =0;
         //
    public static int sumarMatriz(int matriz[][], int i, int j, int resultado){
    	if(i>=matriz.length){
    		return resultado;
    	}
    	resultado=resultado+matriz[i][j];
    	j++;
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	return sumarMatriz(matriz, i,j,resultado);
    }

    //este metodo recibe la matriz, la recorre y va sumando solo los valores impares
    //precondicion i=0;
    //precondicion j=0;
    //precondicion resultado =0;
         //
    public static int sumarMatrizImpares(int matriz[][], int i, int j, int resultado){
    	if(i>=matriz.length){
    		return resultado;
    	}
    	if(matriz[i][j]%2!=0){
    		resultado=resultado+matriz[i][j];
    	}

    	j++;
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	return sumarMatrizImpares(matriz, i,j,resultado);
    }

    //este metodo recibe la matriz, la recorre y va sumando solo los valores pares
    //precondicion i=0;
    //precondicion j=0;
    //precondicion resultado =0;
         //
    public static int sumarMatrizPares(int matriz[][], int i, int j, int resultado){
    	if(i>=matriz.length){
    		return resultado;
    	}
    	if(matriz[i][j]%2==0){
    		resultado=resultado+matriz[i][j];
    	}

    	j++;
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	return sumarMatrizPares(matriz, i,j,resultado);
    }

    //este metodo recibe la matriz, las posicion (i,j)
    //y retorna la cantidad de elemntos que hay en la diagonal de (i,j)
         //
    public static int cantidadDeElemntosDiagonal(int matriz[][], int i, int j, int resultado){
    	if(i>=matriz.length||j>=matriz[0].length){
    		return resultado;
    	}
    	resultado++;

    	j++;
    	i++;
    	return cantidadDeElemntosDiagonal(matriz, i,j,resultado);
    }

    //este metodo recibe un vector y el indice por donde esta evaluando
    //y retorna el vector ordenado ascendentemente
         //
    public static int[][] ordenarMatriz(int matriz[][], int i,int j){
    	int i_sig=0;
    	int j_sig=0;

    	if(i==matriz.length-1 && j==matriz[0].length-1){
    		return matriz;
    	}

    	if(j==matriz[0].length-1){
    		i_sig=1+i;
    		j_sig=0;
    	}else{
    		i_sig=i;
    		j_sig=j+1;
    	}
   		if(matriz[i][j]>matriz[i_sig][j_sig]){
    		int aux=matriz[i][j];
    		matriz[i][j]=matriz[i_sig][j_sig];
    		matriz[i_sig][j_sig]=aux;
    		return ordenarMatriz(matriz, 0,0);
    	}else{
			return ordenarMatriz(matriz, i_sig,j_sig);
    	}
    }

    //este metodo recibe un vector y el indice por donde esta evaluando
    //y retorna el vector ordenado ascendentemente
         //
    public static int[] ordenarVectorAscendente(int vector[], int i){
    	if(i>=vector.length-1){
    		return vector;
    	}
    	if(vector[i]>vector[i+1] ){
    		int aux=vector[i];
    		vector[i]=vector[i+1];
    		vector[i+1]=aux;
    		return ordenarVectorAscendente(vector, 0);
    	}else{
			return ordenarVectorAscendente(vector, i+1);
    	}

    }

    //este metodo recibe una matriz los indices i-j por donde esta evaluando
    //y retorna el la matriz ordenada ascendentemente
         //
    public static int[] ordenarVectorDescendente(int vector[], int i){
    	if(i>=vector.length-1){
    		return vector;
    	}
    	if(vector[i]<vector[i+1] ){
    		int aux=vector[i];
    		vector[i]=vector[i+1];
    		vector[i+1]=aux;
    		return ordenarVectorDescendente(vector, 0);
    	}else{
			return ordenarVectorDescendente(vector, i+1);
    	}

    }

    //
    //recive el numero1 y el numero2 ademas el numero a evaluar y el mcd
    //precondiciones
    //n1>0
    //n2>0
    //n3=1;
    //mcd=0;
         //
    public static int MCD(int n1, int n2,int n3, int mcd){
    	if(n3>n1||n3>n2){
    		return mcd;
    	}else{
    		if(n1%n3==0 && n2%n3==0){
    			mcd=n3;
    		}
    		return MCD(n1,n2,n3+1,mcd);
    	}
	}

    //
    //recive el numero, el indice por cual numero vamos, y la cantidad de vivisores encontrados
    //precondiciones
    //numuero>0
    //indice=1
    //divisores=0;
         //
    public static boolean esPrimo(int numuero,int indice, int divisores){
    	if(divisores>2){return false;}
    	if(indice==numuero){
    		if(divisores<=1){
    			return true;
    		}else{
    			return false;
    		}
    	}
    	if(numuero%indice==0){
    		divisores=divisores+1;
    	}
    	return esPrimo(numuero,indice+1,divisores);
	}

	//intercambiar elementos de un vector, primero con ultico
//segundo con penultimo
         //
    public static int[] interCambiarPosicionesVector(int vector[], int i){
    	if(i>=vector.length/2){
    		return vector;
    	}
    	int aux=vector[i];
    	vector[i]=vector[vector.length-1-i];
    	vector[vector.length-1-i]=aux;
    	return interCambiarPosicionesVector(vector, i+1);
    }

    //recorre un vector e imprime las posiciones de este
         //
    public static void imprimirVector(int vector[], int i){
    	if(i<vector.length){
    		System.out.print("| "+vector[i]+" ");
    		imprimirVector( vector, i+1);
    	}else{
    		System.out.print("| ");
    		System.out.println("");
    	}
    }

    //recorre un vector e imprime las posiciones de este
    //
    public static void imprimirMatriz(int matriz[][], int i,int j){
    	if(i<matriz.length){
    		System.out.print("| "+matriz[i][j]+" ");
    		j++;
    		if(j>=matriz[0].length){
    			System.out.println("|");
    			i=i+1;
    			j=0;
    		}
    		imprimirMatriz(matriz, i,j);

    	}
    }

    //division de 2 numeros enteros
    //
    public static int divisionNumerosEnteros(int n1, int n2,int resultado){
    	if(n1<n2){
    		return resultado;
    	}
    	n1=n1-n2;
    	resultado=resultado+1;
    	return divisionNumerosEnteros(n1,n2,resultado);
    }
    //residuo de 2 numeros enteros
    //
    public static int residuoNumerosEnteros(int n1, int n2){
    	if(n1<n2){
    		return n1;
    	}
    	n1=n1-n2;
    	return residuoNumerosEnteros(n1,n2);
    }

    //serie de Fibonacci
    //precondiciones
    //t1=0;
    //t2=1;
    //numero>0;
    public static void serieDeFibonacci(int t1, int t2, int numero){
    	if(numero>1){
    		if(t1==0 && t2==1){
    			numero=numero-2;
    			System.out.print(t1+", ");
    			System.out.print(t2+", ");
    		}
    		System.out.print(t1+t2+", ");
    		serieDeFibonacci(t2,t1+t2,numero-1);
    	}else{
    		if(numero==1){
    			System.out.print(t1+" ");
    		}
    	}
    }

    //particiones de un numero natural
    //precondiciones
    public static void particionesNumeroNatural(int numero){
    }

    public static void main (String[] args) {
    	System.out.println (Recursividad.sumatoriaNumerosNaturales(4,0) );
    	System.out.println (Recursividad.potenciaNumeroEnteros(2,3,1));
    	System.out.println (Recursividad.invertirCadena("original","",0));
    	int matriz[][]= new int[][]{{4,7,3,8},
    								{1,0,6,2},
    								{9,5,0,8}
    								};
    	System.out.println (Recursividad.sumarMatriz(matriz,0,0,0));
    	System.out.println (Recursividad.sumarMatrizPares(matriz,0,1,0));
    	System.out.println (Recursividad.sumarMatrizImpares(matriz,0,2,0));
    	System.out.println (Recursividad.cantidadDeElemntosDiagonal(matriz,0,3,0));

    	int vector[]= new int[]{1,2,3,4,5,6,7};
    	vector=Recursividad.ordenarVectorAscendente(vector,0);
    	Recursividad.imprimirVector(vector,0);
    	vector=Recursividad.ordenarVectorDescendente(vector,0);
    	Recursividad.imprimirVector(vector,0);

    	System.out.println (Recursividad.MCD(24*3,24,1,0));
    	matriz=Recursividad.ordenarMatriz(matriz,0,0);
    	Recursividad.imprimirMatriz(matriz,0,0);
    	System.out.println (Recursividad.esPrimo(2,1,0));
    	System.out.println (Recursividad.esPrimo(3,1,0));
    	System.out.println (Recursividad.esPrimo(4,1,0));
    	vector=Recursividad.interCambiarPosicionesVector(vector,0);
    	Recursividad.imprimirVector(vector,0);
    	Recursividad.imprimirMatriz(matriz,0,0);

    	System.out.println (Recursividad.divisionNumerosEnteros(11,2,0));
    	System.out.println (Recursividad.residuoNumerosEnteros(11,2));
    	serieDeFibonacci(0,1,19 );

	}

}

0 Responses to “RECURSIVIDAD PARTE No. 1”



  1. Dejar un comentario

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s


I+Ds

Dudas consultas
Facebook
Twiter
Google +

Escribe tu dirección de correo electrónico para suscribirte a este blog, y recibir notificaciones de nuevas publicaciones por correo.

Únete a otros 348 seguidores

Ingenio DS en Facebook

Redes Sociales y Archivos

Entradas

febrero 2010
L M X J V S D
« Sep   Mar »
1234567
891011121314
15161718192021
22232425262728

IngenioDS en twiter


A %d blogueros les gusta esto: