Métodos y propiedades fundamentales

public char this[int index] {get;}
Devuelve el caracter de la posición especificada de la cadena.

public int Length {get;}
Devuelve la longitud de la cadena (cantidad de caracteres que contiene) empezando a contar desde 1.

public string Insert(int startIndex, string value);
Inserta la cadena especificada a partir de la posición dada.

public string Remove(int startIndex,int count);
Elimina el número especificado de caracteres a partir de la posición dada.

public string[] Split(params char[] separator);
Busca las subcadenas contenidas dentro de la cadena, delimitándolas por los separadores que se le especifiquen, y las copia a un arreglo de cadenas.

public string Substring(int startIndex);
Devuelve la subcadena contenida a partir de la posición especificada.

public string Substring(int index, int length);
Devuelve la subcadena que empieza a partir del índice específico, y tiene la longitud indicada.

Ejercicios resueltos

1- Implemente un método que dado un string s cualquiera, devuelva un nuevo string que se el inverso de s. (ej: entrada: “puntopeek”; salida: “keepotnup”)

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

Primero veremos y comentaremos el algoritmo que nos permite saber cuantas combinaciones posibles se pueden hacer con ciertas letras.

Veamos el código:

public static void Combina(string s)
{
        //Iniciamos este array auxiliar para
        //marcar los caracteres que ya combinamos
	bool []marcas = new bool[s.Length];
        //Llamamos al método recursivo
	Combina(s, "", marcas);
}
 
static void Combina(string original, string combinado, bool[]marcas)
{
        //Imprimimos la combinación si ya cambiamos
        //todas las letras una vez
	if(original.Length == combinado.Length)
		Console.WriteLine(combinado);
 
	for(int i = 0; i < marcas.Length; i++)
	{
           //Vemos si está marcada para no volverla a combinar
	   if(!marcas[i])
	   {
                //Marcamos el caracter que vamos a combinar
		marcas[i] = true;
                //Invocamos al metodo recursivo añadiendo
                //un caracter al string que combinamos
		Combina(original, combinado + original[i], marcas);
                //Desmarcamos el caracter para poder usarlo
                //en otras combinaciones
		marcas[i] = false;
	   }
	}
}

Como ven es un algoritmo muy sencillo, y no tan largo, donde usamos la técnica de backtracking, o vuelta atrás, que vimos hace un tiempo en este post. Espero les halla servido de ayuda este problemita, con esto podrá por ejemplo, saber de cuantas formas posibles se pueden combinar las letras a, n y c.

Si hacemos algo así:

Combina("abc");
Console.ReadLine();

esto es lo que devolvería el programa:

abc
acb
bac
bca
cab
cba

Ya se encargarán ustedes de buscarle las aplicaciones que lleva, también pueden tratar de hacer este algoritmo un poco más eficientes, piensen un poco en el como…

En el proximo post, veremos entonces todas las permutaciones que podemos hacer para descomponer un número en sumandos.

dudas=> comentarios

Entradas relacionadas

Que día de la semana cae el 20 de abril del 2020?

Que día de la semana será el 12 de agosto del 2011?

Estas respuestas sin la ayuda de la computadora solo algunos eruditos pueden responderlas (yo conozco a uno). El problema no es tan sencullo como dividir y hallar restos de división.

Primero hay que buscar una forma de guardar cuantos días tiene cada mes, teniendo en cuenta claro, si el año es bisiesto o no…

Recuerden que un año es bisiesto si es divisible entre 400 ó es divisible entre 4 y no entre 100.

Bueno, vamos a hacer un programa de consola, que primero le pida al usuario que entre una fecha válida, con su día, mes y año y luego imprimiremos en consola que día de la semana será o fue la fecha recibida.

Vamos al código:

using System;
 
namespace DiaDeLaSemana
{
   class Class1
   {
      //Esta es la aplicación de entrada
      static void Main()
      {
         while(true)
	 {
		//Pedimos que entre la fecha y validamos que
                //los datos sean correctos
                Console.WriteLine("Escribe una fecha"+'\n');
		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;
                //Creamos un array con los días de la semanas
		string[] days = {"Domingo", "Lunes", "Martes",
                "Miercoles", "Jueves", "Viernes", "Sabado"};
           //Esta es la respuesta, usando el método DayOfWeek()
	   Console.WriteLine("Ese dia es "+days[DayOfWeek(d,m,a)]);
	 }
    }
 
    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;
 
        //Vemos si es bisiesto y quitamos un día si
        //el mes es enero o febrero
	if(EsBisiesto(year) && (month==1 || month==2))
	    result += -1;	
 
        //Esto devuelve un número entre 0 y 7
        //que nos dá el día de la semana
	return result%7;
    }
 
    //Método para saber si un año es bisiesto
    private static bool EsBisiesto(int a)
    {
	return (a%4==0 && a%100!=0) || a%400==0;
    }
}
}

Interesante verdad? Pues ya saben algo nuevo, si quieren este método puede ser un poco más elegante y con menos código, piensen en alguna otra solución y la discutimos en los comentarios.

'\n'

Entradas relacionadas

Una pila tiene un constructor con tres sobre cargas:

Contructor por defecto que crea una pila vacía

Stack s = new Stack();

Podemos indicar la cantidad inicial de elementos que tendrá la pila

Stack s = new Stack(int initialCapacity);

Podemos también pasarle una colección de elementos (List, Quee, ArrayList). Este constructor copiará todos estos elementos a la pila iniciará

Stack s = new Stack(ICollection col);

Además de los métodos de la interfaz ICollection (Contains, Remove, GetEnumerator, etc), encontramos básicamente 3 métodos que explico ahora:

public object Peek()
//Retorna el último elemento que se agregó en la pila.
 
public object Pop()
// Retorna el último elemento de la pila al igual que Peek(), pero elimina dicho elemento de la pila una vez devuelto.
 
public void Push(object x)
//Agrega un nuevo elemento a la pila

Ahora veamos la implementación de la clase Pila (Stack) de CSharp:

public class Pila: IEnumerable
{
    Node primero;
    int cambios;
    int contador
 
    //El constructor
    public Pila()
    {
        contador=0;
        cambios=0;
    }
 
public object Peek()
{
     if(count<=0)
         throw new InvalidOperationException("La pila esta vacia");
     return primero.value;
}
 
public object Pop()
{
     object temp=primero.value;
     primero=primero.next;
     contador--;
     cambios++;
     return temp;
}
 
public void Push(object x)
{
    if(primero==null)
        primero= new Node(x);
    else
    {
        primero=new Node(x,primero);
        cambios++;
        contador++;
    }
}
 
public int Count
{
    get{
       return contador;
   }
}
 
public bool Contiene(object x)
{
    Node temp= primero;
    for(int i=0; i<contador;i++)
    {
       if(temp.value.Equals(x))
          return true;
       temp=temp.next;
    }
    return false;
}
}

Por supuesto, le faltan algunos métodos de la interfaz ICollection, pero esos ya los vimos cuando hablamos de  la clase LinkedNode en C# y la Interfaz Ilist.

También implementé esta clase usando nodos enlazables, pero por supuesto sería mucho más sencillo con arrays o listas…

Si tienen alguna duda o creen que falta algo, ya saben, comenten…

Proximamente hablaremos de otras dos estructuras (colas, lista generica) y de genericidad.

Entradas relacionadas

Arrays en C# (Para que veas bien que es un array)

Ejercicios resueltos de arrays en C# (Primera parte)

Más ejercicios resueltos de arrays en C# (Segunda parte)

1- Saber si una cadena es palíndromo o no.
Una cadena es palíndromo si se puede leer igual de derecha a izquierda que de izquierda a derecha, por ej: otto, sacas, etc. El método, que en este caso sería recursivo tendría la siguiente signatura:
public bool EsPalindromo(string s). Vamos a la implementación:

Como vemos, es un método muy sencillo haciendo uso de la recursividad, teniendo en cuenta que una cadena es palíndromo si al quitar los extremos del texto, este sigue siendo palíndromo, y así sucesivamente hasta que quede de longitud 1, que por supuesto es palíndromo. De todas formas traten de hacerlo iterativo, para que vean como se extiende un poco más el código… jjeje. Si quieren, pueden ver un poco más sobre recursividad aquí.

Invertir un array es algo que puede que hagamos muy seguido en nuestros programas, a través del siguiente método vemos como invertir un array de números enteros, de tal forma que si nos pasan un array de enteros con 1,2,3,4,5, este método devuelva 5,4,3,2,1… vamos al código:

Como vemos, lo único que va a tener este método que puede no entiendas es números[numeros.Lenght-i-1]. Si le vamos dando valores a la i a partir de 0, vemos como a medida que aumenta i, nos movemos un paso antes en el array numeros. Recuerden también que la ultima posición de un array es array[array.Lenght-1], que es cuando la i vale 0.

Buscar un elemento en un array bidimensional (tabla)

Método muy sencillo que nos muestra como movernos por un array bidimensional buscando si contiene un elemento dado. Veamos este ejemplo rápidamente:

Vemos como con dos ciclos for nos podemos mover fácilmente por todas las posiciones de la tabla. El método retornará true solamente si encuentra el elemento n en la tabla. Aclarar que la propiedad GetLenght(int dimension), nos da el ancho o el alto dependiendo de la dimensión. 1 es para el alto, y 0 es para el ancho.

Rotar un array
Entenderemos por rotar un array n veces, trasladar el elemento de la primera posición n veces a la derecha si n>0 o a la izquierda si n<0. Por ejemplo, si rotamos 3 veces el array 1,3,2,4,5 devolvería 2,4,5,1,3. Esto se puede lograr de varias formas, pero proponemos una muy poco costosa, calculando la posición del array donde debería caer el primer elemento del array que se desea rotar. Bueno, vamos a la práctica, el código es:

Vemos que es un poquito complicado esto de rotar un array calculando la posición a partir del resto de n con la longitud del array, pero si se ponen a analizar linea por línea se darán cuenta que no es tan difícil. Haciendo n%array.Lenght, calculamos la nueva posición donde quedaría el primer elemento del array. Interesante verdad? Ya veremos próximamente como armar un diccionario donde poder agregar y leer datos fácilmente sin necesidad de buscar por todos sus elementos utilizando mucho este operador % para el resto. Entonces practiquen con estos métodos, hagan modificaciones, busquen otras ideas, traten de mejorarlos… y todo lo que se les ocurra.
Para aprender a programar hay que “leer y escribir código”. Si tienen alguna duda, dejen un comentario. Próximamente estaremos viendo la clase Matriz con todos sus métodos y propiedades. Determinante, multiplicación escalar, multiplicación por otra matriz, suma, resta, etc…

Entradas relacionadas

Crear un array de números aleatorios

Una buena práctica para probar nuestros algoritmos, ya sean de búsqueda, de ordenación, o cualquiera de los que hagamos aquí es crear un array de números aleatorios a partir de un tamaño. Veamos como hacer esto con la clase system.Random de C#. Veamos el código:

public int[] ArrayAleatorio(int longitud){
//Creamos un nuevo array del tamaño especificado
int [] a = new int[longitud];
//Inicializamos la clase Random
Random r = new Random();
int aleatorio = 0;
//ahora en cada posición del array insertaremos
//un numero aleatorio entre -20, y 20
for(int i=0; i<a.Lenght; i++)
{
a[i]=aleatorio.Next(-20, 20);
}
}

Vemos como cada vez que aumenta i dentro del ciclo for creamos un nuevo número aleatorio. Así tendremos un array con numeros aleatorios entre -20 y 20. El método Next de la clase Random tiene varios constructores, nosotros usamos uno que permite crear un número en un intervalo especificado. Como funcionará la clase Random? Interesante verdad? Este método lo podemos usar de cierta forma para probar algún que otro método, y hacemos algo así:

int[] numeros = ArrayAleatorio(8);
Ordenar(numeros);
Buscar(3, numeros);

Invertir un array

Bueno, veamos ahora como invertir un array de numeros:

public void Invertir(int [] a)
{
//Creamos un nuevo array del mismo tamaño
int[] b = new int[a.Lenght];
//Empezamos a copiar desde la última
//posición de a en la primera
for(int i=0; i
{
b[i]= a[a.Lengt-i-1];
}
//Como el método no retorna nada
//guardamos en a el array b
a=b;
}

Tener en cuenta que cuando hacemos a[a.Lenght -i -1], a medida que aumenta i nos vamos moviendo por a desde la ultima posición (a.Lenght -1) hasta la primera.

Calcular la suma de un array

Ahora veremos como calcular la suma de todos los elementos de un array.

public int CalculaSuma(int [] a)
{
int suma=0;
for(int i=0; i<a.Lenght; i++)
{
suma+= a[i];
}
return suma;
}

Como ven es un método muy sencillo donde solo tenemos que recorrer el array e ir aumentando la variable suma con el operador +=, que es lo mismo que hacer suma = suma+a[i].

Si tienen alguna duda, ya saben, comenten… y practiquen. En la próxima entrega veremos ejercicios un poco más complejos. Pronto estaremos buscando y ordenando elementos en un array de forma más eficiente.

Entradas relacionadas