Mensajes

[Admin]

Vaya, al Admin le parece exagerado......pues vale, repuesto el hilo en el Libre.



(Sin comentarios.)


Saludos.

No obstante, desde mi punto de vista se le podría hacer algún cambio al título del tema, pues a mi me paso que el título me parecio algo extravagante, solo al leer el post completo fue que me di cuenta de que cosa era. Por lo que creo que se podría dar la información en el título de que es algo de ficción para literatura.

Hola a todos/as tengo una duda al cambiar mi windows! si yo instalo windows en el disco local D y guardo mis fotos, musica, juegos en el C a la hora de formatear y instalar el windows se borran los archivos del disco C o como es?
Por favor necesito ayuda urgente, desde ya muchas gracias

La verdad no he entendido completamente tu post.

¿En que disco o partición tienes instalado el sistema operativo?
¿Que sistema operativo tienes?
¿Donde quieres instalarlo?

Trata siempre de dar la mayor cantidad de información para que los demas puedan entender tu duda.

PD: En el disco o partición que instales (dígase C, D, o ...) Se van a borrar los datos que esten ahi siempre y cuando hagas un formateo.

[18 - Hallar la menor cantidad de inserciones necesarias para que una cadena sea palíndromo]

18 - Hallar la menor cantidad de inserciones necesarias para que una cadena sea palíndromo

Ya expliqué anteriormente que es un palíndromo.

Palíndromo es una palabra, número o frase que se lee igual hacia adelante que hacia atrás.

Este código es extremadamente sencillo. Supongamos que la entrada es un string y que no tiene espacios.

Este código lo hice de manera recursiva, tenemos también un método portal:

Código (csharp) [Seleccionar] Expandir

/// <summary>
       /// Método portal
       /// </summary>
       static int PalindromInsertions(string line)
       {
           if (line.Length == null)
               throw new NullReferenceException("La cadena no puede ser null");
           if (line.Length == 1)
               return 0;
           return PalindromInsertions(line, 0, line.Length - 1);
       }

       static int PalindromInsertions(string line, int inf, int sup)
       {
           if (inf > sup)
               return 0;
           if (line[inf] == line[sup])
               return PalindromInsertions(line, inf + 1, sup - 1);
           else
               return Math.Min(1 + PalindromInsertions(line, inf + 1, sup),
                   1 + PalindromInsertions(line, inf, sup - 1));
       }

El método portal lo utilicé para validar la entrada de que no sea null y si tiene longitud 1 entonces no es necesario hacer inserciones para que sea palíndromo, pues ya es palíndromo.

Luego se llama al método PalindromInsertions() pasándole la cadena, el límite inferior y el superior (en principio, 0 y line.Length - 1 respectivamente).

El objetivo del método y de la recursividad en este caso es ver si la los caracteres de la cadena evaluada en los límites son iguales, si lo son, se llama recursivo aumentado y disminuyendo los limites inferior y superior respectivamente, en caso de que no lo sea, se va a devolver el Mínimo de hacer una inserción por la izquierda y haber una inserción por la derecha. Para esto utilizamos el método Min() de la clase Math. Este método devuelve el mínimo entre dos enteros (tiene otras sobrecargas para distintos tipos de datos). Representamos hacer 1 inserción sumándole 1 al llamado recursivo del método manteniendo un límite y aumentando o disminuyendo el límite inferior o superior respectivamente.

Al principio del método, comprobamos si los límites se superpusieron (ya revisamos la cadena completa). En este caso base, devolvemos 0. (No es necesario hacer inserciones)

Espero se entienda.



19 - Rotar un array n veces a la derecha

En este caso utilizaré nuevamente un array de int para simplificar. El método recibe un array de int y un int que representa la cantidad de posiciones a rotar.

Código (csharp) [Seleccionar] Expandir

public static void RotarDerecha(int[] a, int veces)
       {
           if (veces == a.Length || veces % a.Length == 0) return;
           int aMover = a[0];
           int posicion = 0;
           int contador = 0;
           while (contador < a.Length)
           {
               int proxPosicion = (posicion + veces) % a.Length; //Calculamos nueva posición
               int proxValor = a[proxPosicion]; //Guardamos el elemento que esta en esa nueva posición
               a[proxPosicion] = aMover; //Ponemos el elemento a mover en la nueva posición
               aMover = proxValor; //Asignamos a la variable del elemento a mover el valor que estaba en la nueva posición
               posicion = proxPosicion; //Guardamos la posición del nuevo elemento
               contador++; //Hicimos un movimiento
           }
       }

Lo primero que tenemos que darnos cuenta es que rotar a la derecha significa mover cada elemento a la derecha n veces. En caso de que las rotaciones sobrepasen la longitud del array se deberá comenzar desde el inicio del array. ¿Cómo resolvemos esto? Bueno, cada posición nueva viene dada por el resto que deja la posición más la cantidad de rotaciones con la longitud del array. Esto nos garantiza que siempre nos va a quedar en una posición (y en la que es) dentro del array.

Lo primero que hacemos es comprobar si la cantidad de veces es igual a la longitud del array o si la cantidad de veces deja resto 0 con la longitud del array. En este caso no se hace ninguna rotación.

Luego, debemos tener una variable, para saber cuántas rotaciones estamos haciendo y saber cuándo vamos a parar. También una variable para llevar el elemento que estamos moviendo (en principio, el primero) y una variable para llevar su posición.

Ahora, utilizaremos el ciclo while para controlar la cantidad de movimientos que se han hecho. Vamos a ejecutar el ciclo while mientras la variable contador sea menor que la longitud del array.

Dentro del ciclo lo que haremos será calcular la posición nueva de ese elemento. Guardar en una variable el elemento en esa nueva posición y hacer un Swap entre el elemento que llevamos para mover y ese nuevo (que será el nuevo que queremos mover). También debemos guardar en la variable posicion la posición de ese nuevo elemento. Por último, incrementar la variable contador pues ya se hizo un movimiento.



He tenido poco tiempo, por eso solo dejo estos dos.
Salu2s

Solucionado!

¿Solucionado? 

No deberías haber borrado el problema, y además si solucionaste podrías haber dicho cual fue tu solución para que otros se beneficiaran si tienen el mismo problema!

Salu2s

[cuentaNombres()]

Trata siempre de dar la mayor información de tu problema, la verdad me ha costado entender y creo que quizás no he entendido bien

Una pregunta: en el método cuentaNombres() haces referencia a un método que se llama getNombre() ¿Que cosa hace getNombre()?

Salu2s

Hola. ¿En que necesitas ayuda? Tienes algo hecho ya, si es así dilo. Aquí no se realizan tareas, si tienes alguna duda en tu código te ayudamos. El ejercicio es sencillo, si entiendes recursividad, debes plantear el caso base y hacer que la llamada recursiva converga a él.

Salu2s

[x]

No estas inicializando la variable x del ciclo, y te debe estar obteniendo un valor que esté almacenado en ese espacio en memoria. (el que esté)

Espero te ayude.

Sobrecargar los operadores te permite realizar una implementación distinta para esos operadores. Por ejemplo, si crearas una clase para almacenar Fechas, ¿que sentido tendria para ti hacer una suma (+) entre dos fechas? Si sobrecargas el operador de suma entre las dos fechas puedes darle un sentido y devolver un resultado que tu consideres correcto de acuerdo al significado que tu le quieras dar a la suma entre esas dos fechas.

Espero hayas entendido algo.
Salu2s

[13 - Saber si una cadena (string) es palíndromo]

13 - Saber si una cadena (string) es palíndromo

Primero que todo ¿Qué es palíndromo? Bueno, palíndromo es una palabra, número o frase que se lee igual hacia adelante que hacia atrás.

Ejemplo: anita lava la tina (anitalavalatina)

Este código es extremadamente sencillo. Supongamos que la entrada es un string y que no tiene espacios.

Forma iterativa

Código (csharp) [Seleccionar] Expandir

public static bool EsPalindromo(string cadena)
       {
           for (int i = 0; i < cadena.Length / 2; i++)
           {
               if (cadena[i] != cadena[cadena.Length - 1 - i])
                   return false;
           }
           return true;
       }

Simplemente recorremos el string hasta la mitad, pues gracias a los índices y a la propiedad Length de la clase string podemos acceder a los caracteres de la segunda mitad del string

El objetivo es comprobar el primer carácter con el último, el segundo con el penúltimo y así sucesivamente. Si se encuentra que alguno es diferente del otro, se devuelve false (no es palíndromo). Si se llega al final del ciclo sin devolver false, entonces se devuelve true (es palíndromo)

Forma recursiva:

Código (csharp) [Seleccionar] Expandir

static bool EsPalindromo(string s)
       {
           int lIzq = 0;
           int lDer = s.Length - 1;
           if (lIzq >= lDer) return true;
           return s[lIzq] == s[lDer] &&
               EsPalindromo(s.Substring(lIzq + 1, lDer - 1));
       }

En la forma recursiva vamos a ir llevando un control de los índices manualmente. Utilizaremos también el método Substring() de la clase string. Este método devuelve un substring de un string dado desde una posición dada con una longitud dada.

Lo primero que hacemos es definir los índices del string. En este caso 0 y la s.Length-1. Luego comprobamos que no hayamos terminado de revisar el string completo. La comprobación viene dada por si los índices se superpusieron. Luego viene el llamado recursivo. Aqui viene dado por un AND entre si el string en las posiciones dadas son iguales y el llamado recursivo en sí. Al llamado recursivo en si se le pasa como parámetro el substring con la posición izquierda más 1 y la posición derecha menos 1. Desta forma garantizamos que seguir funcionando si en la posición actual los caracteres son iguales y solo si también es palíndromo lo que está entre esos caracteres.



14 - Saber el factorial de un número

El factorial de un número se define como el producto de todos los números enteros positivos desde 1 hasta el número.

Por ejemplo: 5! = 1*2*3*4*5 = 120

Forma iterativa

Código (csharp) [Seleccionar] Expandir

public static long Factorial(long numero)
       {
           long result = 1;
           for (long i = 2; i <= numero; i++)
               result *= i;
           return result;
       }

Este código es algo relativamente sencillo. Se basa en una productoria desde 1 hasta el número. Con un ciclo for resolvemos este problema sencillamente. Creamos una variable de tipo long, puesto que el factorial de un número puede llegar a ser un número grande y puede no caber en un int. La iniciamos en 1 pues el número 1 siempre se va a multiplicar. Luego el ciclo va desde 2 hasta el número y vamos multiplicando la variable result por la variable iteradora del ciclo y asignándosela a ella misma utilizando el operador *=

Nota: Quiero aclarar que el 0! es igual a 1. Y este código funcionara perfecto, pues si el número es 0, no se ejecutará nunca la instrucción dentro del ciclo pues nunca se cumplirá la condición de iteración y no se entrará al ciclo. Por lo tanto se devolverá result = 1

Forma recursiva

Código (csharp) [Seleccionar] Expandir

static long Factorial(long n)
       {
           if (n == 0) return 1;
           return n * Factorial(n - 1);
       }

Si entendemos recursividad esto sale straight-forward. El caso base es para n=0 devolvemos 1 sino, devolvemos n * la llamada recursiva del factorial de n-1. Si planteamos esto explícitamente quedaría algo así como:

n * Factorial(n - 1) * Factorial (n - 2) * ... * Factorial (n - i) * ... * Factorial(0)



15 - Saber si un año es bisiesto

Un año es bisiesto si es divisible entre 4 y no es divisible por 100, también es bisiesto si el año es divisible por 400.

Llevar esto a un código es algo muy sencillo. Aquí les dejo:

Código (csharp) [Seleccionar] Expandir

public static bool EsBisiesto(int anno)
       {
           return (anno % 4 == 0 && anno % 100 != 0 || anno % 400 == 0);
       }

Realizamos la comprobación si es divisible entre 4 (deja resto 0 con 4) y no es divisible por 100 (no deja resto 0 con 100), también comprobamos si es divisible por 400 (deja resto 0 con 400). Si se cumple alguna de estas dos condiciones entonces se devuelve true, si no se cumple ninguna de las dos, se devuelve false

16 - Hallar la potencia de un número

La potencia es el resultado de multiplicar un número por sí mismo una cantidad de veces n. Un número elevado a la 0 es igual a 1.

Forma iterativa

Código (csharp) [Seleccionar] Expandir

static long PotenciaIterativo(int _base, int _potencia)
       {
           long result = 1;
           for (int i = 1; i <= _potencia; i++)
               result *= _base;
           return result;
       }

Esto se plantea de una forma sencilla. Recibimos como parámetro la base y la potencia. (Utilizo el underscore (_base) para que no entre en conflicto pues en C# existe la palabra reservada base). El objetivo es multiplicar la base un cantidad de veces igual a la variable _potencia. Creamos una variable, que será que se va a devolver (long result), con el valor 1. Luego vamos a multiplicar la variable por _base dentro del ciclo que va a hacer tantas iteraciones como el valor de la variable _potencia. Cabe destacar que si la variable _potencia es 0. Nunca se ejecutará el ciclo pues no se cumplirá la condición de iteración por lo tanto no entrará al ciclo y se devolverá la variable result con el valor 1.

Forma recursiva

Código (csharp) [Seleccionar] Expandir

static long Potencia(int _base, int _potencia)
       {
           if (_potencia == 0) return 1;
           if (_potencia == 1) return _base;
           return _base * Potencia(_base, _potencia - 1);
       }

Básicamente es lo mismo, planteamos los casos bases. Si la potencia es 0 entonces se devuelve 1; Si la potencia es 1 se devuelve la base. En caso contrario se multiplica la base por el llamado recursivo. El llamado recursivo va a ir convergiendo a los casos bases, pues se le resta a la potencia 1.

Nota: También puedes hacer uso del método .Pow() dentro de la clase Math. Algo así como:

Código (csharp) [Seleccionar] Expandir

double potencia = Math.Pow(2, 4) //Esto eleva 2 a la 4



17 - Búsqueda binaria (colección ordenada)

Este código es algo más interesante. Este algoritmo reduce significativamente el número de comparaciones que se realiza para buscar en un array (previamente ordenado) un elemento que cumpla determinada propiedad. En este código voy a tratar con un array de int y voy a utilizar un método portal.

Código (csharp) [Seleccionar] Expandir

/// <summary>
       /// Método portal
       /// </summary>
      public static bool BusquedaBinaria(int[] numerosOrdenado, int aBuscar)
       {
           return BusquedaBinaria(numerosOrdenado, aBuscar, 0, numerosOrdenado.Length - 1);
       }

       private static bool BusquedaBinaria(int[] numerosOrdenado, int aBuscar, int inf, int sup)
       {
           if (inf > sup)
               return false;
           int medio = (inf + sup) / 2;
           if(aBuscar==numerosOrdenado[medio])
               return true;
           if (aBuscar > numerosOrdenado[medio])
               return BusquedaBinaria(numerosOrdenado, aBuscar, medio + 1, sup);
           return BusquedaBinaria(numerosOrdenado, aBuscar, inf, medio - 1);
       }


En este algoritmo se compara el elemento a buscar con el elemento del medio del array, si el valor a buscar es menor que este, se repite el procedimiento en la parte del array que va desde el principio hasta el elemento del medio, sino se toma la parte del array que va desde el elemento central hasta el final del array. De esta manera se realiza sucesivamente con los pedazos hasta que cada vez van a ser más pequeños, hasta que se obtenga un intervalo que no se pueda dividir. Si el elemento no se encuentra dentro de este último entonces se deduce que el elemento buscado no se encuentra en el array.

Desde el método portal llamamos al método recursivo que tiene otros parámetros. Los parámetros son el array de los números (ordenado), el elemento a buscar, la posición inferior y la posición superior.
Lo primero que se hace es comprobar los extremos del intervalo. Si el inferior es mayor que el superior significa que el array se acabó y no se encontró el elemento, por lo tanto se retorna false. Sino se calcula la posición del medio. Luego se revisa si este elemento del medio es el que se está buscando, si lo es, se devuelve true. Entonces si esto no se cumple, vamos a revisar las mitades del array. Si el elemento a buscar es mayor que el elemento del medio se retorna el llamado recursivo pasándole como índice inferior al medio + 1 y manteniendo el superior (mitad de la derecha). En caso contrario se retorna el llamado recursivo pasándole como índice superior al medio - 1 y manteniendo el inferior.

Espero que este algoritmo se haya entendido.

Nota: Si quieres buscar en un array también puedes hacer uso de el método Contains() dentro de la clase array que devuelve un bool dependiendo si el elemento esta dentro del array. Seria algo así:

Código (csharp) [Seleccionar] Expandir

int valor = 2;
bool estaElElemento = nombreArray.Contains(valor);

Mod: Agregado el método IndexOf(), utilizando el algoritmo de búsqueda binaria que a la vez devuelve el índice en el cual está el elemento buscado o devolviendo -1 si no se encuentra.

Código (csharp) [Seleccionar] Expandir

/// <summary>
        /// Método portal
        /// </summary>
        static int IndexOf(int[] orderedArray, int toSearch)
        {
            return IndexOf(orderedArray, toSearch, 0, orderedArray.Length - 1);
        }

        static int IndexOf(int[] orderedArray, int toSearch, int min, int max)
        {
            if (min > max)
                return -1;
            int medio = (min + max) / 2;
            if (toSearch > orderedArray[medio])
                return IndexOf(orderedArray, toSearch, medio + 1, max);
            if (toSearch < orderedArray[medio])
                return IndexOf(orderedArray, toSearch, min, medio - 1);
            return medio;
        }

Tenemos un método portal al igual que en el otro método. Lo único que cambia es lo que se devuelve, que en este caso se devuelve el valor del índice. En este método comprobamos si los límites del "sub-array" en el cual estamos comprobando se sobrepasan entre ellos. Luego calculamos la posición en el medio. Y comprobamos si el valor que se busca es mayor/menor que el elemento en la posición del medio calculada. En caso de que se cumpla una u otra, se llama recursivo, ajustando los límites del sub-array. Si no es mayor o menor, entonces se devuelve el valor "medio" o sea, es el elemento que está en el medio, por lo tanto se devuelve la posición.




Luego seguiré con más. Salu2s

[9 - Hallar el n-ésimo término de la sucesión de Fibonacci (Recursivo)]

9 - Hallar el n-ésimo término de la sucesión de Fibonacci (Recursivo)

La sucesión de Fibonacci es una sucesión infinita de números naturales:

1, 1, 2, 3, 5, 8, 13, 21...

la cual viene dada por la siguiente definición recursiva:

f_n = f_n-1 + f_n-2

donde los dos primeros valores son predeterminados:

f₀ = 0 y f₁ = 1

Lo que voy a mostrar es un método para calcular el n-ésimo término de la sucesión:

Código (csharp) [Seleccionar] Expandir

static int Fibonacci(int n)
        {
            if (n == 0) return 0;
            if (n == 1) return 1;
            return Fibonacci(n - 2) + Fibonacci(n - 1);
        }

Este código es muy sencillo de entender (si entendemos recursividad). Primero que todo planteamos los casos base. Si n=0 retornamos 0 (caso para f₀ = 0) y si n=1 retornamos 1 (caso para f₁ = 1). En caso contrario devolvemos el resultado de la suma de las llamadas recursivas de Fibonacci para n-2 y para n-1. Lo cual define la ecuación recursiva.

Esta definición nos lleva al siguiente código que quiero mostrar de acuerdo con la sucesión de Fibonacci. Si nos damos cuenta, esté código realiza operaciones duplicadas, puesto que si queremos calcular el 5 término de la sucesión, debido al llamado recursivo calculamos el 4 término y el 3 término, pero a su vez el 4 término debe calcular el 3 término y el 2 término, entonces nos damos cuenta que el 3 término se va a calcular 2 veces en el árbol de recursión. Esto se conoce como subproblemas superpuestos ¿Que podemos hacer? Utilizaremos programación dinámica.

Fibonacci Dinámico

Código (csharp) [Seleccionar] Expandir

static long[] fibonacci; //Para ir almacenando los valores de los términos calculados.

        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            fibonacci = new long[n+1];
            Console.WriteLine(Fibonacci(n));

        }

        static long Fibonacci(long n)
        {
            if (fibonacci[n] != 0)
                return fibonacci[n];
            if (n == 1 || n==2)
                return 1;
            fibonacci[n - 2] = Fibonacci(n - 2);
            fibonacci[n - 1] = Fibonacci(n - 1);
            return fibonacci[n - 2] + fibonacci[n - 1];
        }

Bueno, lo que vamos a hacer es ir almacenando los términos que se vayan calculando en un array cuya longitud va a ser el término de Fibonacci que se quiera calcular más 1. Y el método cambia un poco.

Primero que todo revisamos si ese término ya se calculó (comprobando si el array en esa posición es distinto de 0). Si se calculó lo devolvemos. Sino, vamos a analizar los casos base, en este caso añadimos una condición con un OR, para los 2 primeros términos de la sucesión. Retornamos 1 en caso de que n=1 o n=2. Luego de esto, en vez de devolver la suma de los llamados recursivos, llamamos recursivo asignándole los valores a las respectivas posiciones en el array. Una vez calculadas/devueltas los valores, entonces se devuelve la suma de los valores contenidos en el array.

Espero esto se haya entendido



10 - Devolver el Reverse de un string

El objetivo del siguiente código es devolver un string con sus char invertidos. El método recibe un string y devuelve un nuevo string. Por lo tanto lo primero que hacemos dentro del método es crear un string que será el que se devolverá. Recorreremos el string de entrada de atrás hacia adelante con un ciclo for. Luego solo nos queda dentro del ciclo concatenarle al string recién creado cada carácter que nos vayamos encontrando en el string original por medio de la posibilidad de indexar en el string.

Código (csharp) [Seleccionar] Expandir

public static string Reverse(string original)
        {
            string reverse = "";
            for (int i = original.Length-1; i >= 0; i--)
                reverse += original[i];
            return reverse;
        }

11 - Convertir de decimal a binario

Forma iterativa

Voy a mostrar como iterativamente convertir un número decimal (en este caso un int) a un número binario. La conversión de decimal a binario se realiza haciendo divisiones sucesivas por 2 al número y a sus cocientes. Luego, cuando el número a dividir sea 1 se finaliza la división y se ordena los restos en el orden inverso al que fueron apareciendo.

Lo primero que hacemos es comprobar si el número es 0, si lo es, devolvemos un string con el carácter 0. O sea, el número binario 0. Luego, lo que vamos hacer es ir almacenando los restos a medidas que aparezcan en un string que creamos dentro del método. Utilizamos un while para controlar el ciclo. Aquí utilizo un while(true), el cual va a estar corriendo siempre a no ser que se haga un break (el cual se hace). Lo primer que hacemos es establecer la condición para la cual se va a salir del ciclo, la cual es en el caso de que se divida y el número de 1. Por lo tanto concatenamos al principio el último resto, y luego el 1, que viene siendo el último número que apareció en la división. Entonces hacemos break. En caso de que no se cumpla la condición de n/2 == 1. Vamos a hacer el proceso de concatenar al principio el resto que encontremos y después dividir el número. Proceso que se ejecutará hasta que se cumpla la condición explicada anteriormente. Al final devolvemos el string.

Código (csharp) [Seleccionar] Expandir

public static string DecimalABinario(int n)
        {
            if (n == 0) return "0";
            string a = "";
            while (true)
            {
                if (n / 2 == 1)
                {
                    a = n % 2 + a;
                    a = 1 + a;
                    break;
                }
                a = n % 2 + a;
                n = n / 2;
            }
            return a;
        }

Quiero que esto podría hacerse de otra forma, en vez de concatenar al principio del string, podemos concatenar al final utilizando el operador += sobre el string a devolver, solo que la hora de devolver el string lo hacemos llamando al método Reverse, que explique anteriormente.

Forma recursiva

En esta forma iterativa voy a tener una cosa a la que yo llamo: "Método portal", el cuál es el método público (que se le muestra al usuario) el cual tiene una sobrecarga (método con otros parámetros) de tipo privado.

Código (csharp) [Seleccionar] Expandir

/// <summary>
        /// Método portal
        /// </summary>
        public static string DecimalABinario(int dec)
        {
            return DecimalABinario(dec, ""); //Llamamos al método
        }

        private static string DecimalABinario(int dec, string result)
        {
            if (dec == 0)
                return "0" + result;
            if (dec == 1)
                return "1" + result;
            return DecimalABinario(dec / 2, (dec % 2) + result);
        }

El método portal recibe el número a convertir a través de la variable dec (int) (cuyo significado semántico es "decimal"l). Entonces a partir de ahi le pasamos al método recursivo esa variable y un string vacío. Los casos bases vienen dado por si el número es 0, devolvemos 0 concatenado al principio del string, si el número es 1 devolvemos 1 concatenado al principio del string. En caso contrario se hace la llamada recursiva, donde el número que se le pasa es la el número dividido por 2 y el string es el resto que deja el número con 2 concatenado al principio del string.

Espero esto se entienda. La verdad es necesario que tengan conocimientos de recursividad para entender esto, sino, miren la forma iterativa.

12 - Convertir de binario a decimal

Convertir de binario decimal es un proceso que viene dado por la suma de las multiplicaciones sucesivas de los dígitos de un número por 2 elevado al índice que ocupa este número (comenzando por 0). Por ejemplo el número binario 1011 seria igual a 1*2³ + 0*2² + 1*2¹ + 1*2⁰ = 8 + 0 + 2 + 1 = 11 (decimal)

Forma iterativa

Primero que todo voy a aclarar que recibimos el número binario a través de un string, los números binarios es mejor representarlos en un string pues si la representación binaria de un número es muy grande puede no ser representable por un int.

Código (csharp) [Seleccionar] Expandir

static int BinarioADecimal(string bin)
        {
            int dec = 0;
            for (int i = 0; i < bin.Length; i++)
                dec += (bin[i] - '0') * (int)Math.Pow(2, bin.Length - 1 - i);
            return dec;
        }

Primero voy a explicar ue cosa es:

Código (csharp) [Seleccionar] Expandir

bin[i]-'0'

Lo que estamos aquí es convirtiendo un char a int. ¿Cómo? Pues como sabemos un char es básicamente un entero con un puntero a la tabla ASCII. A todos los chars le corresponden un valor entero. Haciéndole la substracción por el char '0' lo que hace es buscar el valor de este caracter en la tabla, el cual es el valor base y se los substrae al valor del char

Código (csharp) [Seleccionar] Expandir

bin[i], lo cual nos devuelve el número original.

Una vez entendido esto, veamos que el método lo que hace es crear un int para devolver el valor, e ir sumándole a él la multiplicación del dígito por la potencia de dos. Recorremos el string (representación binaria del número) y vamos sumándole al int creado la multiplicación del digito

Código (csharp) [Seleccionar] Expandir

bin[i]-'0' por la potencia.

La potencia la calculamos utilizando el método Pow() de la clase Math. El método recibe un double que  representa la base (en este caso 2) y un double que representa el exponente (en este caso bin.Length - 1 -i. Decimos -1 pues los índices de los dígitos van desde 0 hasta la longitud -1, y decimos -i pues queremos que este valor vaya disminuyendo a medida que avancemos en el string. Aclaro que al resultado de este método se le hace un cast a int pues el método devuelve un double, y no podemos multiplicar un int por un double sin hacer la conversión.

Cuando termine el ciclo devolvemos el número entero (representación decimal del número.

Forma recursiva

Código (csharp) [Seleccionar] Expandir


        /// <summary>
        /// Método portal
        /// </summary>
        static int BinarioADecimal(string bin)
        {
            return BinarioADecimal(bin, 0);
        }

        static int BinarioADecimal(string bin, int result)
        {
            if (bin.Length == 0)
                return result;
            return BinarioADecimal(bin.Remove(0, 1), result + (int)(Math.Pow(2, bin.Length - 1) * (bin[0] - '0')));
        }

En este método es casi lo mismo, solo con un pequeño cambio, en vez de ir recorriendo los índices vamos a utilizar el método Remove() dentro de la clase String, el cual devuelve un substring de un string con los caracteres eliminados desde una posición especificada y la cantidad que se le especifiquen.

Lo que hacemos es comprobar si el string ya está vacío, en este caso devolvemos el resultado.

Sino, llamamos recursivo con el resultado del método Remove sobre el string bin eliminándole el primer carácter. Y también le pasamos la suma de la variable result por la multiplicación del dígito (primer) por la potencia de dos.

Espero se entienda.



En cuanto tenga tiempo hago más.
Salu2s