A continuación verás la implementación en C# del método Inserta(a, index, valor) que asigna el valor x en la posición index del array a, pero hay un detalle, y es que tenemos que desplazar los elementos a partir de la posición i en adelante. En este caso el elemento que esté en la última posición del array será eliminado, ya que en C#, el tamaño del array es fijo (no crece automáticamente como en otros lenguajes como Javascript) y no podemos insertar elementos en una posición negativa o que sea mayor que a.Length-1, que devuelve el tamaño del array – 1, ya que el primer índice del array es 0.

Código en C#:

public static void Inserta (int[] a, int index, int valor){
	if(index>=0 && index< a.Length){
              for(int i = a.Length-1; i>index; i--)
		  a[i]=a[i-1];
	      a[index] = valor;
	}
	else throw new Exception("Posición no válida");
}

Si tienen alguna duda o alguna otra implementación de este método, en los comentarios por favor.

Entradas relacionadas

Algoritmo

1. Buscamos los dos primeros caracteres que coincidan
2. A partir de esa posicion recorremos la palabra hasta ver si coincide completamente
3. Si no coinciden, volvemos al paso 1

Código en C#

public static bool Contiene(string palabra, string cadena)
{
	for (int i = 0; i <= palabra.Length-cadena.Length; i++)
		//Si encontramos dos letras iguales
		if(palabra[i]==cadena[0])
		{
			bool contenida = true;
			//Recorremos la cadena desde la posición 1
			//y comparamos con la palabra a partir de 
			//la posición donde las dos letras iguales
			for (int j = 1; j < cadena.Length; j++)
				if (palabra[i + j] != cadena[j])
					contenida = false;
			//Si esta contenida
			if(contenida) 
				return true;
		}
	//Si no está contenida
	return false;
}

Notas

Es importante notar que aunque String, es una clase en C#, se puede tratar como un array de caracteres, y que el for se hace hasta palabra.Length-subcadena.Length, para que no de excepción. Si quieres saber más sobre este tema, puedes ver un post que escribí hace un tiempo sobre la clase String en C#. También hay que decir que este ejercicio se puede hacer de otra forma más eficiente usando String Matching y algoritmos como KMP, pero no es el objetivo de este post.

Creo que el código está bien comentado, pero cualquier pregunta en los comentarios.

Descargar Ejemplo

Puedes descargar este y otros ejemplos de string usando C#

Entradas relacionadas

Se definen como métodos estáticos pertenecientes a una clase estática y no genérica; pero se llaman de la forma tradicional, como métodos de una instancia de una clase.

Se les pasa como primer parámetro this seguido del tipo de la clase a la cual se va a añadir el método; aquí tenemos un ejemplo de añadirle un método a la clase String de .Net:

public static class MyExtensions
{
     public static int WordCount(this String str)
     {
         //Split separa la cadena en un array de string utiizando los separadores especificados
         return str.Split(new char[] { ' ', '.', '?', ';' , ':' }, StringSplitOptions.RemoveEmptyEntries).Length;
     }
}

Utilizando este ejemplo:

  string s = "hello extension methods!";
  int count = s.WordCount();
  //Este código imprime: 3

Este método podrá ser usado en todas las variables de tipo string, IntelliSense también los reconoce ya que no violan los principios de encapsulación, pues en realidad no modifican a la clase ni acceden a sus variables privadas.

Los métodos extensores se usan para extender una clase o interface; pero no para sobreescribirla. Un método extensor con el mismo nombre y signatura (parámetros) que un método de la clase o la interface, nunca será llamado: en tiempo de compilación, los métodos extensores tienen menor prioridad que los métodos definidos en el propio tipo y están definidos en el ámbito del namespace.

Veamos otro ejemplo un poco más complejo usando interfaces y genericidad:

//Este método devuelve el mayor de una colección que sea 
//IEnumerable(List, array, LinkedList, etc)
public static T Mayor(this IEnumerable items) where T : IComparable
    {
      T max = default(T);
      bool empty = true;
      foreach (T x in items)
      {
        max = x; empty = false;  break;
      }
      if (empty) throw new Exception("The source cannot be empty");
      foreach (T x in items)
      {
        if (x.CompareTo(max) > 0)
          max = x;
      }
      return max;
    }

Como en el caso anterior, ahora en todas las clases que implementen la interfaz IEnumerable donde sus elementos se puedan comparar, tendremos un método Mayor, que devuelve el mayor elemento de la colección de objetos de tipo T genérico. Veamos algunos ejemplos de como usar este método:

int[] numeros = { 10, -60, 20, -50, 30, -40 };
Console.WriteLine(numeros.Mayor()=;
//se va a imprimir 30

Otro ejemplo podría ser:

List colores = new List { "rojo", "verde", "azul", "blanco", "negro"};
Console.WriteLine(colores.Mayor());
//se va a imprimir verde, que es el mayor en orden alfabético

Bueno, si quieren ver más ejemplos aquí les dejo unos cuantos métodos extensores en C# para descargar con sus probadores y todo, para que practiques y le saques el mayor partido a esta nueva característica de C#. Si tienes alguna duda, propuesta o no entiendes algo en los comentarios por favor. Proximamente estaremos hablando de LINQ, otra de las nuevas características de C# y .Net.

No hay entradas relacionadas.

Estrategia de Merge Sort

Merge Sort está basado en la técnica de diseño de algoritmos Divide y Vencerás, de la cual se habló aquí mismo hace un tiempo. Recordando un poco, esta técina consiste en dividir el problema a resolver en subproblemas del mismo tipo que a su vez se dividirán, mientras no sean suficientemente  pequeños o triviales.

Veamos una panorámica de la estrategia que sigue este algoritmo para ordenar una secuencia S de n elementos:

• Si S tiene uno o ningún elemento, está ordenada
• Si S tiene al menos dos elementos se divide en dos secuencias S1 y S2
• S1 contiene los primeros n/2 elementos y S2 los restantes
• Ordenar S1 y S2, aplicando recursivamente este procedimiento
• Mezclar S1 y S2 en S, de forma que ya S1 y S2 estén ordenados

Veamos ahora como sería la estrategia para mezclar las secuencias:

Se tienen referencias al principio de cada una de las secuencias a mezclar (S1 y S2). Mientras en alguna secuencia queden elementos, se inserta en la secuencia resultante (S) el menor de los elementos referenciados y se avanza esa referencia una posición.

Pseudocódigo

Como ven, la idea es bastante simple, pero programarla no tanto. Para no dar de golpe la solución, veamos primero un pseudocódigo del algoritmo:

function mergesort(array A[x..y])
begin
  if (x-y > 1)):
    array A1 := mergesort(A[x..(int( x+y / 2))])
    array A2 := mergesort(A[int(1+(x+y / 2))..y])
    return merge(A1, A2)
  else:
    return A
end

function merge(array A1[0..n1], array A2[0..n2])
begin
  integer p1 := 0
  integer p2 := 0
  array R[0..(n1 + n2 + 2)]//suponiendo que n1 y n2 son las posiciones
  //del array y no el length de este mismo, de otro modo seria (n1 + n2)
  while (p1 <= n1 or p2 <= n2):
    if (p1 <= n1 and A1[p1] <= A2[p2]):
      R[p1 + p2] := A1[p1]
      p1 := p1 + 1

    else
      if (p2 <= n2 and A1[p1] > A2[p2]):
        R[p1 + p2] := A2[p2]
        p2 := p2 + 1
  return R
end

El código

Básicamente, el pseudocódigo sigue la estrategia descrita anteriormente. Veamos el código en C# de una vez:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MergeSort
{
 class Program
 {
    static void Main(string[] args)
    {
       //Array desordenado inicial
       int[] nums = new int[] { 2, 7, 4, 7, 2, 9, 13, 4, 6, 8 };
       MergeSort(nums);

       //Imprimo el array ya ordenado
       for (int i = 0; i < nums.Length; i++)
          Console.Write(nums[i]+" ");
       Console.ReadLine();
    }

    //Método portal que llama al método recursivo inicial
    public static void MergeSort(int[] x)
    {
       MergeSort(x, 0, x.Length - 1);
    }

    static private void MergeSort(int[] x, int desde, int hasta)
    {
       //Condicion de parada
       if (desde == hasta)
          return;

       //Calculo la mitad del array
       int mitad = (desde + hasta) / 2;

       //Voy a ordenar recursivamente la primera mitad
       //y luego la segunda
       MergeSort(x, desde, mitad);
       MergeSort(x, mitad + 1, hasta);

       //Mezclo las dos mitades ordenadas
       int[] aux = Merge(x, desde, mitad, mitad + 1, hasta);
       Array.Copy(aux, 0, x, desde, aux.Length);
    }

    //Método que mezcla las dos mitades ordenadas
    static private int[] Merge(int[] x, int desde1, int hasta1, int desde2, int hasta2)
    {
       int a = desde1;
       int b = desde2;
       int[] result = new int[hasta1 - desde1 + hasta2 - desde2 + 2];

       for (int i = 0; i < result.Length; i++)
       {
          if (b != x.Length)
          {
             if (a > hasta1 && b <= hasta2)
             {
                result[i] = x[b];
                b++;
             }
             if (b > hasta2 && a <= hasta1)
             {
                result[i] = x[a];
                a++;
             }
             if (a <= hasta1 && b <= hasta2)
             {
                if (x[b] <= x[a])
                {
                   result[i] = x[b];
                   b++;
                }
                else
                {
                   result[i] = x[a];
                   a++;
                }
             }
          }
          else
          {
             if (a <= hasta1)
             {
                result[i] = x[a];
                a++;
             }
          }
       }
       return result;
    }
  }
}

Este código lo hice cuando estaba en 1er año, y ahora que lo veo (que ya estoy en 3ro), veo se que se pueden hacer unas cuantas mejoras, pero funciona perfectamente y está bastante comprensible, sobre todo para quien no está familiarizado con el algoritmo y la recursividad.

De todas formas dejo el zip para que puedan descargar el proyecto completo, lo único es que está en Visual Studio 2010. Si tienen alguna duda o aporte, en los comentarios.

Entradas relacionadas

La estructura cola (queue) está basada en el principio que plantea que “el primero en entrar a la cola es el primero en salir (First In First Out), de aquí que a estas estructuras se le llaman (FIFO). En este caso no se va a cumplir este principio, ya que los elementos van a estar ordenados en función de la prioridad. Las operaciones que definiremos sobre una cola con prioridad son:

Insertar – Inserta un elemento en la cola con prioridad. Luego de esta operación, el elemento insertado estará en su posición de acuerdo con su prioridad.

Extrae-Min (Extrae-Max) – Extrae el elemento de mayor prioridad de la cola.

Devuelve-Min (Devuelve-Max) – Retorna el elemento de mayor prioridad, pero no lo elimina.

Esta estructura pudiera ser útil, por ejemplo, en la sala de urgencia de un hospital, donde cada paciente debe ser atendido en función de su gravedad. Luego, con esta estructura podríamos formar un orden entre los pacientes logrando que los pacientes mas graves fueran atendidos primero.

Existen diversas formas de implementar esta estructura, pero en casi todas, alguna de las operaciones principales (ExtraeMin o Insertar) son de orden lineal respecto a la cantidad n de elementos que se almacenan. En este post, veremos cómo lograr una buena implementación de esta estructura usando un tipo de árbol binario que cumple ciertas características, llamado Árbol Parcialmente Ordenado (Heap), donde ambas operaciones serán O(log(n)). Veamos formalmente que es un heap.

Que es un Heap?

Un Heap es un árbol que tiene las siguientes características:

i. Es un árbol binario.
ii. Todos los niveles están llenos, excepto, quizás, el último.
iii. Los niveles se van llenando de izquierda a derecha. Si el árbol no es completo, en el último nivel, las hojas están agrupadas a la izquierda.
iv. Cada nodo tiene una prioridad mayor que la de sus dos hijos.

Heap como árbol parcialmente ordenado

Lo primero que podemos ver es que puede haber varios elementos con una misma prioridad, y lo segundo es que el árbol no está ordenado completamente, es decir, entre sus hijos no hay prioridad. Como vimos en el post anterior con los arboles binarios de búsquedas, donde el hijo izquierdo tenía que ser menor que el padre y este a su vez, menor que el hijo derecho. De aquí que este tipo de árbol binario se conoce como Árbol Parcialmente Ordenado, porque no define un orden total entre sus nodos.

Como hablamos de un árbol binario, podríamos pensar en representar un Heap con un arreglo donde A[0] es la raíz del árbol, el hijo izquierdo del nodo i será A[2*i+1] y el derecho A[2*i+2].

Operaciones con el Heap

Veamos ahora como serían los métodos para garantizar que las operaciones sean O(log(n)):
DEVUELVE-MIN(Heap h)
1 if(count(h)>0)
2  do return A[0]

Claramente este primer método es bastante sencillo, ya que el elemento de mayor prioridad siempre va a ser la raíz

EXTRAE-MIN(Heap H)
1  Intercambiar(0,n);
2  H[n] ←null;
3  n←n+1
4  HEAPIFY( 0);

En Extrae-Min lo que hacemos es eliminar el nodo raíz y poner el ultimo nodo a la derecha del primer nivel como raíz, disminuimos la cantidad de elementos y llamamos a un método llamado recursivo heapify que será el encargado de ubicar al elemento A[0] en su posición de acuerdo a su prioridad. Para esto, lo que hace es en cada paso del algoritmo ver si se viola alguna de las condiciones, y en caso positivo, lo intercambiar con el hijo de menor prioridad, esto es lo que hace que las operaciones sean O(log(n)), veamos un pseudocódigo para ilustrar mejor la idea:

HEAPIFY (Heap H, nodo i)
1  if(i<left(i) and i<right(i))
2  do return;
3  max = Max(left(i), right(i);
4  Intercambiar(i,max);
5  Heapify(H, max);

Luego, el método Insert(Heap H, x) sería agregar el nuevo elemento al final del array que representa el Heap y hacer heapify, pero en este caso en el orden contrario, desde las hojas hacia la raíz. A continuación el pseudocódigo:

INSERT(Heap H, x)
1  n←n+1
2  H[n] ←x;
4  HEAPIFY( n);

Esto es básicamente una buena implementación de Heap con array, que mejora un poco la representación por Arbol, ya que para insertar un nuevo elemento, nos evitamos el trabajo de buscar cual es la hoja más a la derecha, que como sabemos, en la representación por array será el nodo de la posición n.

Código en C# de un Heap

Bueno, aquí les dejo una implementación de Heap en C# que hice el año pasado como parte de una tarea. El código está bien comentado y entendible. De cualquier forma, si ves algún error o tienes alguna duda, en los comentarios. Otra implementación que he usado es proyectos más grandes es la que ofrecen en CodeProjects, que es una clase PriorityQueue mucho más completa, con más métodos y propiedades.

Entradas relacionadas

Informalmente, un árbol es una colección de objetos llamados nodos, de los cuales uno constituye la raíz. Sobre los nodos se define una relación “ser padre” que garantiza la estructura jerárquica entre los nodos. Como se puede apreciar, un hijo de un nodo de un árbol, es también un árbol, por lo que podemos definir un árbol recursivamente como una estructura formada por un nodo raíz r y un conjunto de árboles cuyas raíces son los hijos de r.

Algunas definiciones

Un nodo es hoja si no es padre de ningún nodo.
Un árbol que no tenga ningún nodo es un árbol nulo.
Un árbol es ordenado si existe una relación de orden entre los hijos de un nodo.
Un árbol binario es un árbol donde cada nodo tiene como máximo dos hijos. De igual forma podemos definir un árbol k-ario, donde cada nodo tiene a lo sumo k hijos.
Un árbol binario ordenado es un árbol donde cada nodo tiene un hijo izquierdo y un hijo derecho.
Veamos algunos métodos y propiedades que se pueden tener en un árbol:

public void Add(T x); (agrega un objeto al árbol)
public bool Contains(T x); (dice si el árbol contiene el objeto especificado)
public int Widht(); (devuelve el ancho del árbol, o sea el total de hojas)
public int Height(); (devuelve la altura del árbol, que es la mayor distancia desde la raíz a una de la hojas)
public object Value{get;} (devuelve el valor de la raíz del árbol)

Nota: Si no estás familiarizado con la notación “T x” utilizada para clases genéricas, puedes leer aquí sobre genericidad en C#.

Existen varias formas de recorrer un árbol, en dependencia de cómo estén ordenados, los recorridos más comunes son preorden, entreorden, a lo ancho y postorden.

PreOrden: Este recorrido imprime primero los padres y después los hijos en preorden. El algoritmo sería el siguiente:

public void Preorder(Tree t)
{
   foreach (T key in t.Keys)
     //Imprime la llave i-esima
     Console.WriteLine(key);
   foreach (Tree child in t.Childs)
     //Recorrer en preorden el hijo i-esimo
     Preorder(child);
}

El resultado de este recorrido para el árbol de la figura anterior sería A, B, C, D, E, F.

EntreOrden: Primero se imprime el primer hijo izquierdo con su recorrido EntreOrden, después la raíz, y luego el segundo hijo en EntreOrden, y así sucesivamente los restantes hijos. Si el árbol en cuestión es un árbol binario ordenado (ABB) el recorrido sería exactamente una ordenación de los elementos de dicho árbol, ya que hay un orden establecido entre los hijos, pero luego trataremos un post completo sobre los árboles binarios de búsqueda, que tienen algunas aplicaciones y propiedades importantes.

public static void EntreOrden (Tree t)
{
   if (t.Childs.Length>0)
      // Recorre en simétrico el primer hijo
      EntreOrden(t.Childs[0]);
   for (int i = 1; i < t.Childs.Length; i++)
   {
      // Imprime la llave (i-1)-esima
      Console.WriteLine(t.Keys[i - 1]);
      // Recorre en entreorden el hijo i-esimo
      EntreOrden(t.Childs[i]);
   }
}

Para el ejemplo anterior tendríamos el siguiente recorrido: B, A, D, C, E, F
PostOrden: Se recorren primero los hijos y luego los padres en postorden.

public static void PostOrden(Tree t)
{
   foreach (Tree child in t.Childs)
      // Recorre en postorden el hijo i-esimo
      PostOrden(child);
   foreach (T key in t.Keys)
      // Imprime la llave i-esima
      Console.WriteLine(key);
}

El recorrido postorden para el ejemplo sería B, D, E, F, C, A

Por último, le dejo algunos códigos que hice hace algunos años donde pueden ver otros métodos y funcionalidades de la clase árbol (añadir elementos, eliminar, altura, espejo, ancho, recorridos, dibujar arbol,  etc), también añadí la clase árbol binario, que hereda de la clase árbol, y una aplicación de consola donde se prueban varios métodos de estas clases.

Espero que les sirva de ayuda. Si tienen alguna duda con el código, dejen su comentario.

Descargar Código

Entradas relacionadas

Lo primero es saber q esto se puede hacer de muchas formas, pero hay que tener en cuenta algunas cosas, como por ejemplo, que pasa cuando el año es bisiesto, cuando febrero tiene 29 días, etc…

Bueno, aquí les dejo un código que hice cuando estaba en primer año para resolver este problema, sencillo pero nada trivial. Si tienen alguna otra solución estaría encantado de que la compartieran, para ver entre todos cual es la mejor forma de hacer esta función.

Bueno, aquí les pongo el código, que consiste en un método: DayOfWeek(int dia, int mes, int año) y la clase Main, en la que hice un pequeño programa de consola para que introduzcan una fecha, y imprima el día de la semana correspondiente, incluso en mi facultad, había uno de mis compañeros, que podía hacer esto en la mente, en menos de 2 segundos, aún me pregunto como lo hacía, sin más, el código:

using System;
 
namespace DiaDeLaSemana
{
   class Class1
   {
      //Esta es la entrada principal del programa
      static void Main()
      {
         while(true)
         {
            Console.WriteLine('\n'+"Escribe una fecha "+'\n'+"
            Escribe un numero menor q '0' para salir");
            Console.Write("Dia: ");
            int d = int.Parse(Console.ReadLine());
            if(d<=0) break;
            Console.Write("Mes: ");
            int m = int.Parse(Console.ReadLine());
            if(m<=0) break;
            Console.Write("Año: ");
            int a = int.Parse(Console.ReadLine());
            if(a<=0) break;
 
            string[] days = {"Domingo", "Lunes", "Martes",
            "Miercoles", "Jueves", "Viernes", "Sabado"};
            int dia= DayOfWeek(d,m,a);
            Console.WriteLine("Ese dia es "+days[dia]);
         }
      }
 
      public static int DayOfWeek(int day, int month, int year)
      {
         int[] mesCode = {0,6,2,2,5,0,3,5,1,4,6,2,4};
         int result = year%100 + (year%100)/4 + day + mesCode[month];
 
         if(year/100==17)
            result += 5;
         else if(year/100==18) result += 3;
         else if(year/100==19) result += 1;
         else if(year/100==20) result += 0;
         else if(year/100==21) result += -2;
         else if(year/100==22)  result += -4;
 
         if(EsBisiesto(year) && (month==1 || month==2))
            result += -1;
 
         return result%7;
      }
 
      private static bool EsBisiesto(int a)
      {
         return (a%4==0 && a%100!=0) || a%400==0;
      }
   }
}

Bueno, la tarea va a ser entender lo que hace este método, y para que se necesita el array mesCode. Cualquier duda en los comentarios.

No hay entradas relacionadas.

La idea de este algoritmo de ordenación es particionar el arreglo de elementos en dos subarreglos, no necesariamente de igual tamaño, donde cualquier elemento de la primera será menor que todo elemento de la segunda partición. Esto se logra seleccionando un valor aleatorio del arreglo, y una vez realizada esta parte del algoritmo, se aplica el algoritmo recursivamente a cada una de los subarreglos semiordenados.

En la práctica, se usa QuickSort hasta obtener subarreglos de un tamaño fijo mucho menor (una longitud que ha traído buenos resultados es 20). Entonces se aplica Ordenación por Inserción a estos subarreglos, que es bastante eficiente cuando el arreglo está casi ordenado y hay pocas inversiones.

Veamos ahora el pseudocódigo, para entender un poco mejor que hace este maravilloso algoritmo de búsqueda:

void QuickSort(int[] A) {
QuickSort(A, 0, A.Length - 1);
}
 
void QuickSort (int[] A, int p, int r){
   if (p < r)
   {
      int q = Partition(A, p, r);
      //ordena los primeros q elementos
      QuickSort (A, p, q);
      //ordena los restantes n - q elementos
      QuickSort (A, q + 1, r);
   }
}
 
int Partition(int[] A, int p, int r)
{
   //elemento pivote del arreglo
   int x = A[p];
   int i = p - 1;
   int j = r + 1;
 
   while (true)
   {
      do j--; while (x < A[j]);
      do i++; while (A[i] > x);
      if (i > j)
         Swap(A, i, j);
      else
         return j;
   }
}

El método Partition(), lo que hace es intercambiar elementos que estén invertidos, en función del pivote seleccionado. O sea, Pone a un lados, los elementos menores que el pivote, y al otro lado, los mayores.

Les dejo una implementación en C# que hice hace algún tiempo, si ven algún problema me dicen. Si tienen alguna duda o pregunta, en los comentarios.

//Ordenacion rapida (QuickSort)
public static void QuickSort(int[] a)
{
   QuickSort(0,a.Length-1,a);
}
 
private static void QuickSort(int ini,int fin,int[] a)
{
   int left=ini;
   int right=fin;
   int mid=a[(ini+fin)/2];
 
   do
   {
      //Este es el Partition
      while(a[left]<mid)
         left++;
      while(a[right]>mid)
         right--;
      if(left<=right)
      {
        //Intercambio los elementos
        //si estan invertidos
        int t=a[left];
        a[left]=a[right];
        a[right]=t;
        left++;
        right--;
      }
   }
   while(left<=right);
 
   //Ordeno recursivamente los dos subarreglos
   if(left<fin)
      QuickSort(left,fin,a);
   if(right>ini)
      QuickSort(ini,right,a);
}

Entradas relacionadas

public string Invierte(string a)
{
  string b = "";
  for (int i = 0; i < a.Length ; i++)
    b = a[i] + b;
  return b;
}

2- Implemente una función que dado un string, una posición de comienzo y una cantidad de caracteres, devuelva una subcadena (substring) de una cadena dada a partir de los parámetros dados (ej: entrada: “puntopeek”, pos= 2, cant= 4; salida: “ntop”.)

public string SubString(string a, int pos, int cant)
{
   string pedazo = "" ;
   if((pos + cant) > a.Length)
      throw new Exception("");
   else
   {
      for (int j = pos; j < cant + pos ; j ++ )
         pedazo += a[j];
      return pedazo;
   }
}

3- Implemente un método Replace, que reciba un string s, y dos caracteres old y new. Dicha función debe reemplazar todas las ocurrencias del caracter old por el carácter new, y devolver un nuevo string con dicha característica.  (ej: entrada: “programacion”, old= ‘a’, new=’i’; salida: “progrimicion”)

public string Replace (string a, char old, char new)
{
   string result = "";
   for (int i = 0; i < a.Length ; i++)
   {
      if(a[i] == old)
         result += new;
      else
         result += a[i];
   }
   return result;
}

4*- Implemente un método Combinar, que dado un string s, devuelva todas las combinaciones posibles que se pueden formar a partir de los caracteres de s. Este método es un poco más complicado, pero muy útil y práctico. Para esto usaremos recursividad, para ir generando todas las posibles combinaciones. (ej: entrada: “hoy”; salida: “hoy”, “hyo”, “ohy”, “oyh”, “yho”, “yoh”)

public void Combina(string s)
{
   bool[] marcas = new bool[s.Length];
   Combina(s, "", marcas);
}
void Combina(string original, string combinado, bool[] marcas)
{
   if (original.Length == combinado.Length)
      Console.WriteLine(combinado);
   for (int i = 0; i < marcas.Length; i++)
   {
      if (!marcas[i])
      {
         marcas[i] = true;
         Combina(original, combinado + original[i], marcas);
         marcas[i] = false;
      }
   }
}

Si tienes alguna duda sobre los códigos anteriores, o quieres agregar algo, en los comentarios. Bueno, hasta aquí esta entrega de ejercicios resueltos. Espero que te sirva, y si quieres practicar, guíate por estos ejemplos y trata de implementar otros métodos relacionados con string, como son: 1- Eliminar un carácter dado de una cadena.

    public string Eliminar(string s, char c).

2- Ver si un string es palíndromo ó no, o sea, se escribe igual al derecho que al revés.

    public  bool EsPalindromo(string s)

3- Ver cuál es el letra que más se repite en una cadena.

    public char MasPopular(string s)

Es muy aconsejable que traten de hacer estos ejercicios solos, auxiliándose de los ejemplos anteriores. De todos modos pondré la respuesta de estos ejercicios en una próxima entrega la semana que viene.

Entradas relacionadas

Veamos como invertir un string de tres formas distintas. Por ejemplo, si tenemos el string “puntopeek”, el método devolvería “keepotnup”.

Veamos el primer ejemplo, es el que casi todos conocemos, y es muy fácil de implementar, vamos recorriendo la palabra desde el ultimo caracter hasta el primero y vamos guardando cada letra en un nuevo string, que es el que devolverá el método. El código sería algo así:

public string Invertir(string s)
{
string aux = "";
 
//Recorremos el string en orden inverso
for (int i = s.Length - 1; i >= 0; i--)
aux += s[i];
 
//retornamos la nueva cadena
return aux;
}

Otra opción (pero hay que conocer que es una pila), es ir guardando cada letra en una pila (stack), y luego cuando esten todas las letras las sacamos de la pila. Noten que en esta estructura, el primer elemento que entra, es el último en salir, por eso nos sirve también para invertir un string. El código sería este:

public string Invertir2(string s)
{
//Declaramos una pila usando genericidad.
//Esto se puede hacer con el framework 2.0
Stack stack = new Stack();
 
//Recorremos el string y vamos metiendo en la pila
//cada caracter
for (int i = 0; i < s.Length; i++)
stack.Push(s[i]);
 
string aux = "";
 
//Vamos sacando de la pila los caracteres y los
//ponemos uno a uno en un nuevo string
for (int i = 0; i < s.Length; i++)
aux += stack.Pop();
 
return aux;
}

Ahora veremos la versión recursiva del problema. Si lo analizan paso a paso, verán que hace practicamente lo mismo que Invertir2. Como verán, este método no necesita almacenar ningun caracter, ni copiar, la recursividad se encarga de todo. En realidad la recursividad funciona como una pila (Invertir2) pero no hay que declarar variables ni nada de eso. A veces algunos métodos recursivos parecen mágicos, pero una vez dominemos esta técnica dominaremos el arte de programar. Al menos lo esencial. Veamos el código:

public string Invertir3 (string s, int lenght)
//El parametro lenght es el tamaño del string s
{
//Condicion de parada
if (lenght == 1)
return s;
else
//Llamado recursivo
return Invertir3 (s.Substring(1, s.Length - 1), lenght - 1)
+ s[0].ToString();
}

Para que se den cuenta de lo que hace el método, es necesario que le hagan un debug paso a paso, y vayan viendo como se transforman las variables locales. Si tienen alguna otra solución de como Invertir un string pueden ponerla en los comentarios. Y hasta aquí este post, espero escribir un poco más seguido, pero estoy con muchos proyectos en la universidad y mucho trabajo. Han oido hablar del WinZip o el WinRar? Proximamente estaremos hablando del Algoritmo de Huffman, que se utiliza mucho en el compactación de texto y archivos.

Entradas relacionadas