18
Feb
10

RECURSIVIDAD PARTE No.2


Ejercicios de recursividad (no tan sencillo)
Ejercicios propuestos por el profesor Justo Sarabia para las clases de matematicas discretas

Estos son los mismos ejercicios a diferencia que algunos son mas cortos

public class Recursividad2 {

    public Recursividad2() {
    }
    //este metodo recibe el numero hasta el cual llega la sumatoria
    //y el valor de la suma hasta el momento
    //precondicion numero>=0;
         //
    public static int sumatoriaNumerosNaturales(int numero){
    	return (numero<=0)?0:numero+sumatoriaNumerosNaturales(numero-1);
    }
    
    //este metodo recibe la base y el exponente para la operacion
    //ademas el resultado de esta hasta el momento
    
    public static int potenciaNumeroEnteros(int base, int exponente){
    	return (exponente<=0)? 1:base*potenciaNumeroEnteros(base, exponente-1);
    }
    
    //este metodo recibe la cadena original, la cadena en forma inversa
    //ademas la posicion de esta hasta el momento
    public static String invertirCadena(String original, int posicion){
    	return (posicion>=original.length())?"":invertirCadena(original,posicion+1)+original.charAt(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){
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	if(i>=matriz.length){return 0;}
    	return matriz[i][j]+sumarMatriz(matriz, i,j+1);
    }
    
    //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){
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	if(i>=matriz.length){return 0;}
    	return (matriz[i][j]%2!=0)?matriz[i][j]+sumarMatrizImpares(matriz, i,j+1):sumarMatrizImpares(matriz, i,j+1);
    }
    
    //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){
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    	}
    	if(i>=matriz.length){return 0;}
    	return (matriz[i][j]%2==0)?matriz[i][j]+sumarMatrizPares(matriz, i,j+1):sumarMatrizPares(matriz, i,j+1);
    }
    
    //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){
    	return (i>=matriz.length||j>=matriz[0].length)?0:1+cantidadDeElemntosDiagonal(matriz, i+1,j+1);
    }
    
    //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=n1;
         //
    public static int MCD(int n1, int n2,int n3){
    	return (n1%n3==0 && n2%n3==0)?n3:MCD(n1,n2,n3-1);
	}
    
    //
    //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 String imprimirVector(int vector[], int i){
    	return (i<vector.length)?"| "+vector[i]+" "+imprimirVector( vector, i+1):"|\n";
    }
    
    //recorre un vector e imprime las posiciones de este
    //
    public static String imprimirMatriz(int matriz[][], int i,int j){
    	String salto="";
    	if(j>=matriz[0].length){
    		i=i+1;
    		j=0;
    		salto="|\n";
    	}
    	return (i>=matriz.length)?"|":salto+"| "+matriz[i][j]+imprimirMatriz(matriz, i,j+1);
    }
    
    //division de 2 numeros enteros
    //
    public static int divisionNumerosEnteros(int n1, int n2,int resultado){
    	return(n1<n2)?0:1+divisionNumerosEnteros(n1-n2,n2,resultado+1);
    }
    //residuo de 2 numeros enteros
    //
    public static int residuoNumerosEnteros(int n1, int n2){
    	return(n1<n2)?n1: residuoNumerosEnteros(n1-n2,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+" ");
    		}
    	}
    }
    
    public static void main (String[] args) {
    	System.out.println (Recursividad2.MCD(24,8,24));
    	/*System.out.println (Recursividad2.sumatoriaNumerosNaturales(4) );
    	System.out.println (Recursividad2.potenciaNumeroEnteros(3,3));
    	System.out.println (Recursividad2.invertirCadena("original",0));
    	int matriz[][]= new int[][]{{4,7,3,8},
    								{1,0,6,2},
    								{2,2,0,8}
    								};
		System.out.println (Recursividad2.imprimirMatriz(matriz,0,0));
    	System.out.println (Recursividad2.cantidadDeElemntosDiagonal(matriz,0,0));
    	System.out.println (Recursividad2.sumarMatrizPares(matriz,0,0));
    	System.out.println (Recursividad2.sumarMatrizImpares(matriz,0,0));
    	System.out.println (Recursividad2.sumarMatriz(matriz,0,0));
    	
    	
    	int vector[]= new int[]{1,2,3,4,5,6,7};
    	vector=Recursividad2.ordenarVectorAscendente(vector,0);
    	System.out.println (Recursividad2.imprimirVector(vector,0));
    	vector=Recursividad2.ordenarVectorDescendente(vector,0);
    	System.out.println (Recursividad2.imprimirVector(vector,0));
    	
    	
    	matriz=Recursividad2.ordenarMatriz(matriz,0,0);
    	
    	System.out.println (Recursividad2.esPrimo(2,1,0));
    	System.out.println (Recursividad2.esPrimo(3,1,0));
    	System.out.println (Recursividad2.esPrimo(4,1,0));
    	vector=Recursividad2.interCambiarPosicionesVector(vector,0);
    	Recursividad2.imprimirVector(vector,0);
    	Recursividad2.imprimirMatriz(matriz,0,0);
    	
    	
    	System.out.println (Recursividad2.divisionNumerosEnteros(11,5,0));
    	System.out.println (Recursividad2.residuoNumerosEnteros(11,2));
    	Recursividad2.serieDeFibonacci(0,1,19 );*/
    	
	}
    	  
    
}

0 Responses to “RECURSIVIDAD PARTE No.2”



  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: