¿Qué es la genericidad? Primero lo primero. La genericidad nos permite pasar un tipo genérico (o más), como parámetro a un método, clase, estructura o interfaz. O sea, este nuevo tipo (que llamaremos <T>), viene a sustituir al tipo object, que es usado sobre todo en estructuras de propósito general, como son los arraylist, pilas (stack), colas (queue) y otras que usamos frecuentemente, en las cuales todos los elementos deben ser de un mismo tipo. Por ejemplo, en una lista de números, en la que no queremos que hayan datos de tipo strings o char, solo de tipo int. Ahora se preguntarán ¿Por qué sustituir el tipo Object?

Recuerden que todos los tipos en C# (int, long, string, char, etc) heredan de la clase Object, lo cual es una ventaja para algunas cosas, pero a la vez es un problema a la hora de chequear el tipo de los elementos que se insertan en estas estructuras, ya que no hay una forma rápida y eficaz de verificar que todos los elementos sean del mismo tipo, para controlar esto, tendríamos que castear* cada vez que queramos obtener un valor de dicha estructura, lo cual puede llevar a errores, por no mencionar que es algo muy pesado, incómodo de programar y hay una gran posibilidad de errores en tiempo de ejecución.

Al usar genericidad también tenemos que tener en cuenta algunos cambios (para bien) en nuestra forma de programar, pero es mejor verlo en la práctica, veamos un ejemplo: Supongamos que queremos crear una clase con un método o función que nos devuelva el menor de dos valores de un mismo tipo. Utilizando la genericidad, tendríamos algo así:

class Ejemplo<T> //T es el tipo de dato genérico
{
    //Método que devuelve un elemento de tipo T que es el mínimo
    //entre el elemento x y el elemento <em>y</em>
    T Minimo(T x, T y)
    {
       if(x < y)
          return x;
       else
          return y;
    }
 
}

Ahora veamos qué pasa cuando invocamos este método:

//Supongamos que tenemos una clase Figura
Figura f1 = new Figura();
Figura f2 = new Figura();
Ejemplo ej = new Ejemplo();
Figura min = ej.Minimo(f1, f2);

Este código ni siquiera se ejecutaría, y dará un error en tiempo de compilación en la línea marcada de la clase Ejemplo<T> donde T es la clase Figura, ya que en ninguna parte especificamos cuando una instancia de Figura es menor, mayor o igual que otra, sin embargo, para el tipo int esto no supondría ningún problema verdad?

¿Qué quiere decir esto?

Cuando usemos genericidad tenemos que ser mucho más cuidadosos y formales cuando programemos, lo cual no es una mala práctica y es bueno ir acostumbrándose. Ahora arreglemos la clase Ejemplo para que el método Minimo(T x, T y) funcione con cualquier tipo de dato en general (que se pueda comparar):

class Ejemplo<T> where T: IComparable<T>;
{
    T Minimo(T x, T y)
    {
        int c = x.CompareTo(y);
        if(c<0)
            return x;
        else
            return y;
    }
}

Ahora ya especificamos que T es un tipo que debe implementar la interfaz IComparable<T>. En otras palabras, obligamos a que los elementos de tipo T se pueden comparar entre ellos, ya que en otro caso, hallar el mínimo pierde el sentido. En estos casos, se utiliza la palabra reservada where: y a continuación todas las restricciones que debe cumplir T, separadas por coma.

Entonces usamos el método CompareTo que debe implementar toda clase T que sea IComparable para saber cuál es el menor elemento. Este método deberá devolver 0 si x=y, 1 si x>y,-1 si x<y. Por tanto, el resultado de ejecutar Minimo, depende completamente de cómo implementemos el método CompareTo(). Por ejemplo, si tenemos la clase Figura:

class Figura: IComparable<Figura>
{
    //Supongamos que tenemos estos métodos implementados
    public long Area();
    public long Perimetro();
 
    //Ahora implementamos el método <em>CompareTo</em>
    public int CompareTo(Figura f)
    {
        if(this.Area>f.Area)
            return 1;
        else if(this.Area<f.Area)
            return -1;
        else
            return 0;
    }
}

En este caso, decidimos que una Figura es mayor que otra, en función del área, pero podemos definir que se comparen por el diámetro, por el perímetro, etc. Noten que aquí si podemos usar los operadores binarios dentro del CompareTo, ya que en este caso comparamos implícitamente elementos de tipo long, que son IComparables por defecto. Ya vas notando algunas ventajas de usar genericidad?

Ahora en un mismo método Mínimo, podemos devolver el elemento menor de cualquier tipo de dato que se pueda comparar, noten que este método nos servirá para Int, String, Long, Figuras, Personas y toda clase o tipo que implemente la interfaz IComparable.

Les dejo dos implementación de la clase Queue<T>, que es una cola con algunos métodos genéricos. En una de las implementaciones uso arrays, y en la otra colas enlazables. No lo he probado muy bien, pero funcionaba hace dos años cuando la implementé, jeje.

Veremos algunas otras cosas que podemos hacer con la genericidad en la segunda entrega de este tutorial, la semana próxima. Cualquier duda en los comentarios.

Descarga aquí el archivo en .zip:  Cola en C#

Entradas relacionadas

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

En este post trataré de explicar de la forma más sencilla posible, lo que es la herencia en programación, y pondré algunos ejemplos al final para ver si se llevan la idea, aunque seguro se quedan con algunas dudas, ya que es un concepto fácil de entender, pero difícil de aplicar en programación… después hablaremos entonces de lo que es la encapsulación y el polimorfismo

Por definición, la herencia no es más que la capacidad de un objeto de heredar las características de otro. Bueno, en programación, la herencia es la capacidad de una clase de heredar los métodos, las variables y las propiedades de otra (los constructores no se heredan). Esto permite ahorrar código, ya que varias funcionalidades no tendríamos que implementarlas nuevamente.

Una clase que herede de otra, puede usar los métodos, las propiedades o las variables de la clase padre. También se puede redefinir o modificar los métodos y propiedades, usando algunas palabras reservadas para esto, creando así un nuevo comportamiento del objeto. Una condición necesaria para que una clase herede de otra, es que la clase hija (la que hereda), debe poder usarse donde se use la clase padre (de la cual va a heredar). Si hay al menos un caso donde se puede usar la clase padre, y no se puede usar la clase hija, la herencia no tiene sentido.

En C#, una clase solo puede heredar de otra (por algunas razones difíciles de explicar). O sea, una clase no puede heredar de varias clases a la vez. Para que una clase herede de otra nada más hay que ponerle ‘:‘ después de su declaración, y seguido poner el nombre de la clase de la que se quiere heredar.

Ejemplo:

class Circulo: Figura
{
    // Implementación de la clase
}

Si una clase hija tiene un constructor que recibe los mismos parámetros que un constructor de la clase padre, y este constructor cumple las mismas funciones, que en la clase padre, el de la clase padre puede ser llamado desde la clase hija poniendo después de la declaración del constructor en la clase hija : y después la palabra reservada base. Dentro de los paréntesis van los parámetros del constructor base, (también veremos un ejemplo).

También es importante saber que si una clase hereda de otra, que a su vez hereda de otra, esta clase hereda también de la clase más arriba.

Por ejemplo, si un cuadrilátero es una figura y un paralelogramo es un cuadrilátero, entonces un paralelogramo es una figura…

Para que una clase padre permita que uno de sus métodos sea redefinido por sus clases herederas (las que heredan de ella) este método debe ser declarado usando la palabra reservada virtual, y cuando la clase hija vaya a redefinirlo, debe declararlo usando la palabra reservada override.

Ejemplo:

public <strong>virtual</strong> void Método()
//declaración del método en la clase Padre
{
//aquí va el codigo
}
 
public override void Método()
//declaración del método en la clase Hijo
{
//nuevas instrucciones
}

Si una clase hijo quiere redefinir un método de una clase padre, y este no fue declarado virtual en la clase padre, entonces hay que poner la palabra reservada new en la declaración del método.

Ejemplo:

public void Método()
//declaración del método en la clase Padre
{
   //aquí va el codigo
}
 
public new void Método()
//declaración del método en la clase Hijo
{
   //nuevas instrucciones
}

Ejemplo de herencia:

public class Hijo:Padre
{
 
//la clase Hijo hereda de la clase Padre
public Hijo(int n):base(n){}
}

El constructor de la clase Hijo que recibe como parámetros un entero llama al constructor de la clase Padre que recibe un entero pasándoselo como parámetro.

Ahora veremos un ejemplo real donde se vea la importancia de este importante mecanismo. Imaginen, que queremos tener algunas figuras geométricas, poder calcular el area, perimetro, moverlas en un plano, etc. Pero nos damos cuenta enseguida, que todas las figuras tienen area y perímetro, solo que se calculan de diferentes formas. Todas se pueden ocultar, mostrar y mover de igual forma, no? Veamos ya el código, para que sigan esta idea:

Antes de pasar al código, hay que definir que una jerarquía de clases es un grupo de clases, que heredan unas de otras, donde existe una clase base de la cual heredan todos los integrantes de la jerarquía, en este caso, la clase base es la clase figura.

//Declaramos la clase padre, de la que todas las figuras heredarán
//Es abstracta porque tendrá algunos metodos abstractos
 
public abstract class Figura
{
//Usamos <strong>protected,</strong> para que solo tengan acceso
//a estas variables, las clases que heredan de ella
protected int x,y;
protected Control control;
protected Pen myPen;
protected bool visible;
 
//Un constructor por defecto para todas las figuras
public Figura(int x, int y, Color color, Control control)
{
//Validar parametros
this.x = x;
this.y = y;
this.control = control;
myPen = new Pen(color,4);
 
}
public abstract void Muestra();
public abstract int Area();
public virtual void Oculta()
{
Color temp = myPen.Color;
myPen.Color = control.BackColor;
Muestra();
myPen.Color = temp;
visible = false;
}
public virtual void Traslada(int plusX, int plusY)
{
   if(visible)
   {
      Oculta();
      x += plusX;
      y += plusY;
      Muestra();
   }
   else
   {
      x += plusX;
      y += plusY;
   }

Ahora veremos el código de otras dos figuras en concreto que heredarán de la clase figura, un circulo y un rectángulo.

public class Circulo:Figura
{
//Vemos que en esta clase solo hay que declarar
//una variable
protected int radio;
//Este constructor tendrá todos los parámetros
//por defecto y un radio porque es un circulo
public Circulo(int x, int y, Color miColor, Control miControl,
 int radio)
:base(x,y,miColor,miControl)
{
   //Validacion
   this.radio = radio;
}
//Ahora hay que programar como se mostrará la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawEllipse(myPen,x-radio,y-radio,radio*2,radio*2);
   visible = true;
}
 
//Decimos como se calcula el area en este caso
public override int Area()
{
   return Math.PI * Math.PI * radio;
}
 
//Le podemos añadir otro método independiente
public int Perimetro()
{
    return 2 * Math.PI * radio;
}
}
 
//Esta clase también heredará de figura
public class Rectangulo:Figura
{
   protected int ancho,alto;
 
public Rectangulo(int x, int y, Color miColor, Control miControl, 
int ancho, int alto)
:base(x,y,miColor,miControl)
{
   //Validar
   this.ancho = ancho;
   this.alto = alto;
}
//Redefinimos como mostrar la figura
public override void Muestra()
{
   Graphics g = control.CreateGraphics();
   g.DrawRectangle(myPen,x,y,ancho,alto);
   visible = true;
}
//Redefinimos como calcular el area
public override int Area()
{
   return alto * ancho;
}
}

Bueno, hasta aquí este pequeño tutorial sobre herencia en C#, próximamente estaremos hablando sobre polimorfismo, y después de encapsulación. Cualquier duda en los comentarios. Hasta la próxima

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

Random r = new Random
// Creamos el objeto Random, que tiene un constructor por defecto
// O para los más exigentes, añadimos un plus de
// aleatoriedad, algo así:
Random r = new Random(DateTime.Now.Millisecond);

Y una vez tenemos el objeto, utilizaremos uno de esos tres métodos.

1.- El método Next Tiene tres sobrecargas:

int aleatorio1 = r.Next();
 
// Le imponemos un máximo
int aleatorio2 = r.Next(100);
 
// Le imponemos un rango, por ejemplo queremos
// un número de 3 cifras
int aleatorio3 = r.Next(100, 999);
 
// Queremos un número entre el 3 y el 12,
int aleatorio4 = r.Next(3, 12);

2.- El método NextDouble

// Devuelve un double entre 0 y 1
int aleatorio5 = r.NextDouble();

3.- El método NextBytes

byte[] buffer = new byte[100];
r.NextBytes(buffer);

¡¡Como ven, es super sencillo trabajar con esta clase, ahora veamos un ejemplo de como trabajar con esta clase.

1 – Crear un array de tamaño aleatorio con números aleatorios. Esto nos puede servir para probar varios métodos que usan arrays (ordenación, búsqueda, etc).

//Inicializamos la clase Random
Random r = new Random();
 
//Creamos un array que va a contener cantidad
//aleatoria de elementos menor que 50.
int [] numeros = new int [r.Next(0,50)];
 
//Recorremos el array y vamos asignando a cada
//posición un número aleatorio
for(int i=0; i<numeros.Lenght; i++)
   numeros[i] = r.Next(0,50);

Y hasta aquí, ya veremos después como es por dentro esta clase…

Entradas relacionadas

Aclarar que seguro hay mejores soluciones y mucho menos costosas a estos problemas con arrays, pero traté de resolverlos por la forma más instuitiva, para que les sirva a la mayoría. Bueno, empezemos ya:

1- Como saber cual es el número menor, el mayor y el promedio entre los elementos de un array:

Respuesta:
Para hacer todo esto recorriendo una sola vez el array, hice un método que recibe un array de int y devuelve un array de 3 elementos, donde el primero es el mayor numero del array, el segundo es el menor y el tercero el promedio entre todos los elementos del array.

Este sería el código:

2- Ahora queremos saber cual es el número que más se repite en un array. O sea, el número que “está de moda”.

Respuesta:
Como dije antes, este es un claro ejemplo donde hay muchas formas de resolver el problema planteado. Vamos a ver la forma más instuitiva (y no la más sencilla). Primero crearemos un array auxiliar del mismo tamaño que el array dado, donde cada elemento del array auxiliar va a ser la cantidad de veces que se repite cada numero. Así, luego solo tenemos que retornar el elemento cuya posición es la del mayor elemento del array auxiliar. Quizás me estoy enredando un poco, vamos a ver:

Proponemos al lector que solucione este problema por otra vía usando solamente un contador y dos ciclos for.

3- Ahora veremos un método para insertar un elemento en un array dada una posición.

Respuesta:
Esto se convierte en una tarea muy sencilla utilizando el método Array.Copy(), pero en este caso lo haremos todo nosotros. Crearemos un nuevo array del mismo tamaño que el original+1. Despues copiamos los elementos del array hasta la posicion donde se quiere ubicar el elemento x, luego a partir de ahi volvemos a copiar los elementos hasta la ultima posicion del array. Veamos:

Como ejercicio para entrenar te recomiendo que hagas el método Eliminar, con la siguiente signatura.

public int[] Elimina(int [] array, int posicion, int elemento){};

4- Veamos ya el último problema de estos primeros ejemplos. Supongamos que tenemos dos cadenas de texto. Necesitamos un método que devuelva true si una cadena de texto está contenida dentro de otra.
O sea, si tenemos un string “palanca”, y queremos saber si la cadena “pala” esta contenida dentro de “palanca”, el método devolvería true, en caso contrario devolvería false.
El código del método sería el siguiente:

Bueno, hasta aquí esta entrega, mañana o pasado mañana pondré otros 4 o 5 ejemplos resueltos sobre trabajo con arrays.

Algunos adelantos
Entre los ejercicios que veremos en próximas entregas están:
1- Invertir un array
2- Saber si una cadena de texto es palíndromo. Es decir, que se lee igual de derecha a izquierda, que de izquierda a derecha. Por ejemplo: “otto”, “somos”.
3- Sabremos como calcular el n-simo número primo
4- Rotar un array. Por ejemplo, rotar el array (1,2,3,4,5) 3 veces a la derecha, devolvería (4,5,1,2,3).

También puedas enviar un ejercicio en los comentarios y lo resolvemos aquí entre todos.

Ya está completa esta colección de ejercicios resueltos de array con C#. Estas son las otras partes:

Ejercicios resueltos de array con C# (2da. parte)

Ejercicios resueltos de array con C# (3ra. parte)

Y por si no sabes ni trabajar con arrays, debes leer esto

Entradas relacionadas