martes, 8 de febrero de 2011

Ejemplos de Recursividad

  1. Planteamiento Ejercicio 1. Programar un algoritmo recursivo que calcule el factorial de un número.
    Solución:
    int factorial(int n){
    if(n==0){
    return 1; //Caso Base
    }
    else {
    return n * factorial(n-1); //Fórmula Recursiva
    }
    }

  2. Planteamiento Ejercicio 2: Programar un algoritmo recursivo que calcule un número de la serie fibonacci.
    Solución:

    int fibonaci(int n){
    if(n==1 || n==2) {
    return 1;
    }
    else{
    return fibonaci(n-1)+fibonaci(n-2);
    }
    }

  3. Planteamiento Ejercicio 3: Programar un algoritmo recursivo que permita hacer la división por restas sucesivas. ver mas...
    Solución:

    int division (int a, int b) {
    if(b > a) {
    return 0;
    }
    else {
    return division(a-b, b) + 1;
    }
    }

  4. Planteamiento Ejercicio 4: Programar un algoritmo recursivo que permita invertir un número.Ejemplo: Entrada:123 Salida:321
    Solución:

    int invertir (int n) {
    if (n < 10) { //caso base
    return n;
    }
    else {
    return (n % 10) + invertir (n / 10) * 10;
    }
    }
  5. Planteamiento Ejercicio 5: Programar un algoritmo recursivo que permita sumar los dígitos de un número.Ejemplo: Entrada:123 Resultado:6
    Solución:

    int sumar_dig (int n) {
    if (n == 0) { //caso base
    return n;
    }
    else {
    return sumar_dig (n / 10) + (n % 10);
    }
    }

  6. Planteamiento Ejercicio 6: Programar un algoritmo recursivo que permita hacer una multiplicación, utilizando el método Ruso. Para mas información: aquí.
    Solución:

    int mult_rusa(int A, int B) {
    if(A==1){
    return (B);
    }
    if(A%2!=0){
    return (B+mult_rusa( A/2 , B*2));
    }
    else{
    return(mult_rusa( A/2 , B*2));
    }
    }

  7. Planteamiento Ejercicio 7: Programar un algoritmo recursivo que permita sumar los elementos de un vector.
    Solución:

    int suma_vec(int v [], int n) {
    if (n == 0) {
    return v [n];
    }
    else {
    return suma_vec(v, n - 1) + v [n];
    }
    }

  8. Planteamiento Ejercicio 8: Programar un algoritmo recursivo que permita multiplicar los elementos de un vector.
    Solución:

    int multiplicar (int vec [], int tam) {
    if (tam == 0) {
    return (vec [0]);
    }
    return (vec [tam] * multiplicar (vec, tam - 1));
    }

  9. Planteamiento Ejercicio 9: Programar un algoritmo recursivo que calcule el Maximo comun divisor de dos números.
    Solución:

    int sacar_mcd(int a, int b) {
    if(b==0) {
    return a;
    }
    else {
    return sacar_mcd(b, a % b);
    }
    }

  10. Planteamiento Ejercicio 10: Programar un algoritmo recursivo que determine si un número es positivo/negativo.
    Solución:

    public boolean positivo(int n){
    if(n<0) return true;
    else return negativo(n);
    }

    public boolean negativo(int n){
    if(n>0) return false;
    else return positivo(n);
    }
  11. Planteamiento Ejercicio 11: rogramar un algoritmo recursivo que determine si un número es impar utilizando recursividad cruzada.
    Solución:

    public boolean par(int n){
    if(n==0) {
    return true;
    }
    else {
    return impar(n-1);
    }
    }

    public boolean impar(int n){
    if(n==0) {
    return false;
    }
    else {
    return par(n-1);
    }
    }

  12. Planteamiento Ejercicio 12: Programar un algoritmo recursivo que permita sumar los elementos de una matriz.
    Solución:

    int suma (int fila, int col, int orden, int mat [] [])
    {
    if (fila == 0 && col == 0)
    return mat [0] [0];
    else
    if (col < 0)
    return suma (fila - 1, orden, orden, mat);
    else
    return mat [fila] [col] + suma (fila, col - 1, orden, mat);
    }
  13. Planteamiento Ejercicio 13: Programar un algoritmo recursivo que muestre el numero menor de un vector.
    Solución:

    int menorvec (int x [], int n, int menor) {
    if (n == 0) {
    if (menor > x [n]) {
    return x [0];
    }
    else {
    return menor;
    }
    }
    else{
    if (menor > x [n]) {
    return menorvec (x, n - 1, x [n]);
    }
    else {
    return menorvec (x, n - 1, menor);
    }
    }
    }

    int mayorvec (int numeros [], int posicion) {
    int aux;
    if (posicion == 0) {
    return numeros [posicion];
    }
    else {
    aux = mayor (numeros, posicion - 1);
    if (numeros [posicion] > aux){
    return numeros [posicion];
    }
    else{
    return mayor (numeros, posicion - 1);
    }
    }
    }


1 comentario:

  1. Saludos por el blog con respecto a la recursividad del problema cuatro creo que te bota el mismo numero

    ResponderEliminar