• Sábado 21 de Diciembre de 2024, 17:41
« anterior próximo »
Páginas: [1]

Autor Tema:  Trabajar con arrays de distintos tipos de datos(C#)  (Leído 9491 veces)

The_Reaper22

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Trabajar con arrays de distintos tipos de datos(C#)
« en: Sábado 18 de Septiembre de 2010, 12:13 »
0
Antes de nada saludaros a todos ya que soy nuevo en el foro  :): . Mi duda es la siguiente; toy programando una aplicación que trabaje con distintos algoritmos de ordenación, y estoy planteandome la posibilidad de que pueda trabajar con datos int, double o incluso char, pero no se me ocurre el modo de hacerlo, os comento un poco por encima la estructura del programa que estoy realizando para ver si es posible añadir esta funcionalidad:

De momento mi programa consta de una clase "Ordenación", que tiene los métodos "Insertar", "Insertar aleatorio", "Mostrar", "Ordenar"... de la cual heredan una serie de clases que serán los distintos algoritmos de ordenación; "Burbuja", "QuickSort", "Inserción"...Luego tengo el main, desde el cual por medio de menús, selecciono el tipo de algoritmo a utilizar y las operaciones que se quieran realizar con ellos, todo esto instanciando objetos de tipo "Ordenación" ya que por medio del poliformismo se ejecutará en cada caso el método ordenar requerido. Pues bien, el caso es que no veo el modo de poder trabajar con arrays de distintos tipos...Si teneis alguna idea o sugerencia.. Os adjunto algo de código que tengo hecho:


Código: Text
  1.  
  2. /// método llamado desde otro menú del main una vez hayamos elegido ///el tipo de algoritmo con el que vamos a trabajar
  3. /// el objeto algoritmo es de tipo Ordenación
  4.  
  5. public static void MenúModo(Ordenación algoritmo,int tamaño)
  6.         {
  7.             int modo;
  8.             int[] vector = new int[tamaño];
  9.             do
  10.             {
  11.                 Console.Clear();
  12.                 Console.WriteLine(".- SELECCIONA UNA OPCIÓN");
  13.                 Console.WriteLine("1.- INTRODOCIR VECTOR MANUALMENTE");
  14.                 Console.WriteLine("2.- GENERAR VECTOR ALEATORIO");
  15.                 Console.WriteLine("3.- ORDENAR VECTOR: ORDEN ASCENDENTE");
  16.                 Console.WriteLine("4.- ORDENAR VECTOR: ORDEN DESCENDENTE");
  17.                 Console.WriteLine("5.- MOSTRAR VECTOR");
  18.                 Console.WriteLine("6.- BORRAR VECTOR");
  19.                 Console.WriteLine("7.- VOLVER AL MENÚ");
  20.                 Console.Write("Elija opción(1-7): ");
  21.                 modo = Convert.ToInt32(Console.ReadLine());
  22.                 switch (modo)
  23.                 {
  24.                     case 1:
  25.                         algoritmo.Insertar(vector);
  26.                         Console.WriteLine("Pulse entrar para continuar");
  27.                         Console.ReadLine();    
  28.                         break;
  29.  
  30.                     case 2:
  31.                         algoritmo.InsertarAleatorio(vector);
  32.                         Console.WriteLine("Pulse entrar para continuar");
  33.                         Console.ReadLine();
  34.                         break;
  35.  
  36.                     case 3:
  37.                         Console.WriteLine("Ordenando....");
  38.                         algoritmo.Ordenar(vector);
  39.                         Console.WriteLine("¡Vector ordenado en orden ascendente!");
  40.                         Console.WriteLine("Tiempo empleado"+algoritmo.TiempoEjecución);
  41.                         Console.WriteLine("nº comparaciones:" + algoritmo.NumComparaciones);
  42.                         Console.WriteLine("nº intercambios" + algoritmo.NumIntercambios);
  43.                         Console.WriteLine("Pulse entrar para continuar");
  44.                         Console.ReadLine();
  45.                         break;
  46.  
  47.  
  48. ///Clase ancestro de clases; "Burbuja", "Selección"..., cada cual con su propio método ordenar
  49.  
  50. public class Ordenación
  51.     {
  52.         protected long tiempoEjecución;
  53.         protected int numComparaciones;
  54.         protected int numIntercambios;
  55.  
  56.         public void Insertar(int[] vector)
  57.         {
  58.             for (int i = 0; i < vector.Length; i++)
  59.             {
  60.                 Console.Write("Introduzca elemento["+i+"]");
  61.                 try
  62.                 {
  63.                     int elemento = Convert.ToInt32(Console.ReadLine());
  64.                    
  65.                     vector[i] = elemento;
  66.                 }
  67.                 catch (FormatException )
  68.                 {
  69.                     Console.WriteLine("Elemento incorrecto");
  70.                 }
  71.                
  72.             }
  73.            
  74.         }
  75.  
  76.  
  77. ///Clase Burbuja
  78.  
  79. public class Burbuja: Ordenación
  80.     {
  81.         private int nComparaciones = 0;
  82.         private int nIntercambios = 0;
  83.  
  84.         public override void Ordenar(int[] vector)
  85.         {
  86.             Stopwatch temporizador = new Stopwatch();
  87.             temporizador.Start();
  88.             int sup = vector.Length - 1;
  89.             int temp;
  90.             for (int i = sup; i >= 1; i--)
  91.             {
  92.                 for (int j = 0; j <= i - 1; j++)
  93.                     if (vector[j] > vector[j + 1])
  94.                     {
  95.                         temp = vector[j];
  96.                         vector[j] = vector[j + 1];
  97.                         vector[j + 1] = temp;
  98.                         nIntercambios++;
  99.                     }
  100.                     nComparaciones ++;
  101.             }
  102.             temporizador.Stop();
  103.             TiempoEjecución = temporizador.ElapsedMilliseconds;
  104.             NumComparaciones = nComparaciones;
  105.             NumIntercambios = nIntercambios;
  106.         }
  107.  
  108.  
  109.  

morringos

  • Miembro activo
  • **
  • Mensajes: 65
  • Nacionalidad: 00
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #1 en: Domingo 19 de Septiembre de 2010, 17:47 »
0
Una consulta The_Reaper22:

Quieres que te de la opción de ordenar tanto para char, int y double, pero... ¿Todos los elementos del mismo tipo o diferentes dentro del mismo arreglo? Esto es, que si quieres que te ordene tipo char, ¿Que sean puros chars o que dentro del arreglo hayan elementos tipo int, tipo char y double?.
Si es para el caso de que el arreglo contenga de todo tipo de elemento, se me ocurre hacer un arreglo tipo object e irlos almecenando ahí todos los elementos de cualquier tipo primitivo de dato  y con la función GetType vas sabiendo en realidad qué tipo de dato es el elemento y lo almacenas en un arreglo del tipo que del objeto, o sea...

Si el elemento es entero, lo almacena en el arreglo elementosEnteros[ ] por decir así, la otra sería trabajar con colecciones, no sé que sepas sobre colecciones. Espero y te sirva o te guíe la lógica que tuve para tu problema bro, sinceramente no he trabajado con métodos de ordenación, pero me suena interesante, en lo que te pueda ayudar bro.


Saludos!;
Morringos ^_^

The_Reaper22

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #2 en: Domingo 19 de Septiembre de 2010, 21:05 »
0
Muchas gracias!!, la idea sería pedir el tipo de datos con el que trabajar(char,double,float), y una vez seleccionado utilizar sólo ese tipo de dato. El problema lo tendría a la hora de declarar las cabeceras de los métodos, por ejemplo; public void Burbuja(int[] vector), es este caso especifico el tipo, pero la idea que yo tenía era declarar una sola cabecera de forma que para cualquier array pasado como argumento sea del tipo que sea, pudiera trabajar con el, y en este caso pudiera ordenarlo. No obstante me sirven las ideas, quizás utilizar un ArrayList sea la solución... Lo probaré estos días.. muchas gracias por tu ayuda.

morringos

  • Miembro activo
  • **
  • Mensajes: 65
  • Nacionalidad: 00
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #3 en: Domingo 19 de Septiembre de 2010, 21:56 »
0
Pues para en ese caso de no escribir métodos diferentes sería un poco de ayuda el uso de métodos sobre cargados ó la otra es que si quisieras trabajar con un vector que el usuario va a ir ingresando o que no sabes de qué longitud será el vector, podrás trabajar con el ArrayList (no genérico) de modo que tu variable de tipo ArrayList se irá incrementando sin que te preocupes por el tamaño y ya después podrás ir descartando los tipos de datos que el usuario ingresó, esto es, si al usuario anteriormente se le preguntó qué tipos de datos y el usuario eligió la opción de números enteros (int), ir descartando todos aquellos elementos que no sean de tipo Int, para eso, te puede servir un código sencillo que hice rápido, te lo pongo abajo:

Código: C#
  1.  
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Collections;
  5. using System.Linq;
  6. using System.Text;
  7.  
  8. namespace ArraysDifTipos
  9. {
  10.     class Program
  11.     {
  12.        
  13.         static void Main(string[] args)
  14.         {
  15.             ArrayList elementos = new ArrayList();
  16.             elementos.Add(2);
  17.             elementos.Add("hoo");
  18.             elementos.Add(2.32);
  19.             elementos.Add('c');
  20.             Program test = new Program();
  21.             test.Sumatoria(elementos);
  22.             Console.ReadKey();
  23.         }//Fin del Main
  24.  
  25.  
  26.         public void Sumatoria(ArrayList lista)
  27.         {
  28.             for (int i = 0; i < lista.Count; i++)
  29.             {
  30.                 if (lista[i].GetType().ToString() == "System.Int32")
  31.                 {
  32.                     Console.WriteLine("Es de tipo enetero");
  33.                 }
  34.                 else if (lista[i].GetType().ToString() == "System.Double")
  35.                 {
  36.                     Console.WriteLine("Es de tipo Double");
  37.                 }
  38.                 else if (lista[i].GetType().ToString() == "System.String")
  39.                 {
  40.                     Console.WriteLine("Es de tipo string");
  41.                 }
  42.                 else if (lista[i].GetType().ToString() == "System.Char")
  43.                 {
  44.                     Console.WriteLine("Es de tipo char");
  45.                 }//Fin del If
  46.  
  47.             }//Fin del for
  48.  
  49.         }//Fin del método
  50.  
  51.     }//Fin de la clase
  52.  
  53. }//Fin del nombre de espacios
  54.  
  55.  
  56.  

No sé cómo es que quieras trabajar con tu programa bro, esque si eliges una opción, te salen unas validaciones, pero si eliges otra opción son otras validaciones o preguntas diferentes que te salen en cuanto a la validación de tu programa, como por ejemplo, el caso que te mencioné anteriormente, si le preguntas que ingresará de tipo entero (int) avisarle que todos aquellos caracteres que no sean de tipo int serán eliminados y nada mas se trabajará con los de tipo entero.

No sé como se te haga más fácil bro, de todos modos, ya se ha avanzado un poco más en cuanto a lo de las opciones de tu programa.  :lol:



Saludos bro!;
Morringos Phyps!;  ^_^

The_Reaper22

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #4 en: Lunes 20 de Septiembre de 2010, 09:25 »
0
Muchas gracias compi!!, la verdad es que me será de mucha ayuda, no conocía ese modo de validar el tipo de datos introducido, me parece muy interesante... Seguiré intentando avanzar con el programa. Mil gracias de nuevo!!

tannke

  • Miembro MUY activo
  • ***
  • Mensajes: 152
  • Nacionalidad: es
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #5 en: Lunes 20 de Septiembre de 2010, 12:32 »
0
Buenas, tenia por ahi un codigo utilizando el metodo de la burbuja para ordenar cualquier tipo de valor.
En el ejemplo solo están para ordenar en ascendiente y descendiente los tipos "string" y "double", pero si te fijas es muy sencillo añadir todos los demás, solo con crear un metodo booleano comparando cual de los dos valores es mayor.

Código: C#
  1.  
  2. class Program
  3.     {
  4.         static void Main(string[] args)
  5.         {
  6.             //prueba ordenar double ascendente
  7.             double[] matriz1 = { 2, 3, 5, 1, 4 };
  8.             ClaseMatriz<double>.Burbuja(matriz1, DoubleAscndente);
  9.             for (int i = 0; i < matriz1.Length; i++)
  10.                 Console.Write(matriz1[i] + " ");
  11.             Console.WriteLine();
  12.  
  13.             //prueba ordenar double descendiente
  14.             double[] matriz2 = { 2, 3, 5, 1, 4 };
  15.             ClaseMatriz<double>.Burbuja(matriz2, DoubleDesendiente);
  16.             for (int i = 0; i < matriz2.Length; i++)
  17.                 Console.Write(matriz2[i] + " ");
  18.             Console.WriteLine();
  19.  
  20.             //prueba ordenar STRING ascendente
  21.             string[] matriz3 = {"bb", "cc", "ee", "aa", "dd"};
  22.             ClaseMatriz<string>.Burbuja(matriz3, StringAscendiente);
  23.             for (int i = 0; i < matriz3.Length; i++)
  24.                 Console.Write(matriz3[i] + " ");
  25.             Console.WriteLine();
  26.  
  27.             //prueba ordenar STRING descendiente
  28.             string[] matriz4 = { "bb", "cc", "ee", "aa", "dd" };
  29.             ClaseMatriz<string>.Burbuja(matriz4, StringDescendiente);
  30.             for (int i = 0; i < matriz4.Length; i++)
  31.                 Console.Write(matriz4[i] + " ");
  32.             Console.WriteLine();
  33.  
  34.             Console.ReadLine();
  35.  
  36.         }
  37.  
  38.         public static bool DoubleAscndente(double x, double y)
  39.         {
  40.             return x > y;
  41.         }
  42.  
  43.         public static bool DoubleDesendiente(double x, double y)
  44.         {
  45.             return x < y;
  46.         }
  47.  
  48.         public static bool StringAscendiente(string x, string y)
  49.         {
  50.             return x.CompareTo(y) > 0;
  51.         }
  52.        
  53.         public static bool StringDescendiente(string x, string y)
  54.         {
  55.             return x.CompareTo(y) < 0;
  56.         }
  57.  
  58.     }
  59.  
  60.     class ClaseMatriz<Tip>
  61.     {
  62.         public delegate bool Tipoordenacion(Tip x, Tip y);
  63.  
  64.         public static void Burbuja(Tip[] m, Tipoordenacion comparar)
  65.         {
  66.             Tip temp;
  67.             int i, numElementos = m.Length;
  68.             bool s = true;
  69.  
  70.             while (s && (--numElementos > 0))
  71.             {
  72.                 s = false;
  73.  
  74.                 for (i = 1; i <= numElementos; i++)
  75.                 {
  76.                     if(comparar(m[i-1],m[i]))
  77.                     {
  78.                         temp= m[i-1];
  79.                         m[i-1] = m [i];
  80.                         m[i]=temp;
  81.                         s=true;
  82.                     }
  83.                 }
  84.             }
  85.         }
  86.     }
  87.  
  88.  

Espero te sirva.  Si tienes cualquier duda con el codigo avisa.  Saludos

The_Reaper22

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #6 en: Lunes 20 de Septiembre de 2010, 14:17 »
0
Eso es justamente lo que quería hacer yo... mil millones de gracias, probaré a adaptar esa idea al código que tengo. Gracias!!

The_Reaper22

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #7 en: Viernes 24 de Septiembre de 2010, 20:40 »
0
He conseguido hacer funcionar el programa, combinando vuestras ideas, mil gracias. Pero pienso que no está demasiado optimizado... Mi idea sería no utilizar los métodos estáticos en cada algoritmo de ordenación como en el código que me adjuntó tannke, y hacer una clase Ordenación<Tip> que sea clase ancestro de burbuja, inserción, selección.... de modo que no tenga que hacer una llamada distinta para cada algoritmo, y mediante polimorfismo con objeto tipo Ordenación<Tip> pueda instanciar cualquiera de sus descendientes; burbuja, inserción....Las clases que contienen los métodos de ordenación están implementadas tal y como está en el ejemplo de tannke.  Mi main tiene el siguiente aspecto de momento:

Código: C#
  1. static void Main(string[] args)
  2.         {
  3.             int opcAlgoritmo,tam;
  4.             string tipo;            
  5.             ProcesadorDatos datosAOrdenar;
  6.             int[] vectorInt=null;
  7.             double[] vectorDouble=null;
  8.             char[] vectorChar=null;
  9.             char función;
  10.             do
  11.             {
  12.                 NanoTemporizador temporizador = new NanoTemporizador();
  13.                 opcAlgoritmo = MenúAlgoritmo();
  14.                 if (opcAlgoritmo != 8)
  15.                 {
  16.                     tipo = MenúTipo();
  17.                     tam = MenúTamaño();
  18.                     datosAOrdenar = new ProcesadorDatos(tam, tipo);
  19.                     datosAOrdenar = MenúModo(tipo, tam);
  20.                     función = MenúFunción();
  21.                     //creamos el array en función del tipo
  22.                     if (tipo.CompareTo("int") == 0)
  23.                     {
  24.                         vectorInt = new int[tam];
  25.                         datosAOrdenar.listaToArray(vectorInt);
  26.                     }
  27.                     else if (tipo.CompareTo("char") == 0)
  28.                     {
  29.                         vectorChar = new char[tam];
  30.                         datosAOrdenar.listaToArray(vectorChar);
  31.                     }
  32.                     else
  33.                     {
  34.                         vectorDouble = new double[tam];
  35.                         datosAOrdenar.listaToArray(vectorDouble);
  36.                     }
  37.                     switch (opcAlgoritmo)
  38.                     {
  39.                         //Caso de la burbuja
  40.                         case 1:
  41.                             if (tipo.CompareTo("int") == 0)
  42.                             {
  43.                                 temporizador.Start();
  44.                                 if (función.CompareTo('A') == 0)
  45.                                     Burbuja<int>.Ordenar(vectorInt, Gener.IntAscendente);
  46.                                 else
  47.                                     Burbuja<int>.Ordenar(vectorInt, Gener.IntDescendente);
  48.                                 temporizador.Stop();
  49.                                 Burbuja<int>.Mostrar(vectorInt);
  50.                             }
  51.                             else if (tipo.CompareTo("char") == 0)
  52.                             {
  53.                                 temporizador.Start();
  54.                                 if (función.CompareTo('A') == 0)
  55.                                     Burbuja<char>.Ordenar(vectorChar, Gener.CharAscendente);
  56.                                 else
  57.                                     Burbuja<char>.Ordenar(vectorChar, Gener.CharDescendente);
  58.                                 temporizador.Stop();
  59.                                 Burbuja<char>.Mostrar(vectorChar);
  60.                             }
  61.                             else
  62.                             {
  63.                                 temporizador.Start();
  64.                                 if (función.CompareTo('A') == 0)
  65.                                     Burbuja<double>.Ordenar(vectorDouble, Gener.DoubleAscendente);
  66.                                 else
  67.                                     Burbuja<double>.Ordenar(vectorDouble, Gener.DoubleDescendente);
  68.                                 temporizador.Stop();
  69.                                 Burbuja<double>.Mostrar(vectorDouble);
  70.                             }
  71.                             break;
  72.  
  73.                         //Caso de la burbuja bidireccional
  74.                         case 2:
  75.                             if (tipo.CompareTo("int") == 0)
  76.                             {
  77.                                 temporizador.Start();
  78.                                 if (función.CompareTo('A') == 0)
  79.                                     BurbujaBidireccional<int>.Ordenar(vectorInt, Gener.IntAscendente);
  80.                                 else
  81.                                     BurbujaBidireccional<int>.Ordenar(vectorInt, Gener.IntDescendente);
  82.                                 temporizador.Stop();
  83.                                 BurbujaBidireccional<int>.Mostrar(vectorInt);
  84.                             }
  85.                             else if (tipo.CompareTo("char") == 0)
  86.                             {
  87.                                 temporizador.Start();
  88.                                 if (función.CompareTo('A') == 0)
  89.                                     BurbujaBidireccional<char>.Ordenar(vectorChar, Gener.CharAscendente);
  90.                                 else
  91.                                     BurbujaBidireccional<char>.Ordenar(vectorChar, Gener.CharDescendente);
  92.                                 temporizador.Stop();
  93.                                 BurbujaBidireccional<char>.Mostrar(vectorChar);
  94.                             }
  95.                             else
  96.                             {
  97.                                 temporizador.Start();
  98.                                 if (función.CompareTo('A') == 0)
  99.                                     BurbujaBidireccional<double>.Ordenar(vectorDouble, Gener.DoubleAscendente);
  100.                                 else
  101.                                     BurbujaBidireccional<double>.Ordenar(vectorDouble, Gener.DoubleDescendente);
  102.                                 temporizador.Stop();
  103.                                 BurbujaBidireccional<double>.Mostrar(vectorDouble);
  104.                             }
  105.                             break;
  106.  
  107.  

La clase ProcesadorDatos la utilizo para insertar elementos en los arrays y para transformar los ArrayList en los arrays del tipo que corresponda. Adjunto algo de código de dicha clase:

Código: C#
  1. namespace MétodosOrdenación
  2. {
  3.     class ProcesadorDatos
  4.     {
  5.         private ArrayList lista;
  6.         private string tipo;
  7.         private int tamaño;
  8.  
  9.         public ProcesadorDatos(int tamaño, string tipo)
  10.         {
  11.             lista = new ArrayList(tamaño);
  12.             this.tipo = tipo;
  13.             this.tamaño = tamaño;
  14.         }
  15.  
  16.         public void insertaAleatorio()
  17.         {
  18.             int semilla = System.Convert.ToInt32(DateTime.Now.Millisecond);
  19.             if (this.tipo == "int")
  20.             {
  21.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  22.                 Random rnd = new Random(semilla);
  23.                 for (int i = 0; i < this.tamaño; i++)
  24.                     lista.Add((int)(rnd.NextDouble() * 1000));    
  25.                
  26.             }            
  27.             else if (this.tipo == "double")
  28.             {
  29.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  30.                 Random rnd = new Random(semilla);
  31.                 for (int i = 0; i < this.tamaño; i++)
  32.                     lista.Add((double)(rnd.NextDouble() * 1000));
  33.             }
  34.             else
  35.             {
  36.                
  37.                 Random prRand = new Random(semilla);
  38.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  39.                 Random rnd = new Random(semilla);
  40.                 for (int i = 0; i < this.tamaño; i++)
  41.                     lista.Add((char)(prRand.Next(97, 123)));
  42.             }
  43.         }
  44.  
  45.  
  46.         public void listaToArray(int[] vectorInt)
  47.         {
  48.             int posicion = 0;
  49.             foreach (Object obj in this.Lista)
  50.             {
  51.                 vectorInt[posicion] = Convert.ToInt32(obj);
  52.                 posicion++;
  53.             }
  54.  
  55.         }
  56.  
  57.         public void listaToArray(double[] vectorDouble)
  58.         {
  59.             int posicion = 0;
  60.             foreach (Object obj in this.Lista)
  61.             {
  62.                 vectorDouble[posicion] = Convert.ToDouble(obj);
  63.                 posicion++;
  64.             }
  65.  
  66.         }
  67.  
  68.         public void listaToArray(char[] vectorChar)
  69.         {
  70.             int posicion = 0;
  71.             foreach (Object obj in this.Lista)
  72.             {
  73.                 vectorChar[posicion] = Convert.ToChar(obj);
  74.                 posicion++;
  75.             }
  76.  
  77.         }
  78.  
  79.  
Pienso que tengo bastantes "apaños" en el código y que podría estar más depurado apoyándome en la genericidad utilizando la clase Ordenación<Tip> mencionada y creo que podría también implementar la interfaz IComparable, pero no me desenvuelvo muy bien con la genericidad, agradecería alguna idea.

infa

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #8 en: Miércoles 6 de Octubre de 2010, 15:36 »
0
Solicito una Ayuda con lo siguiente, por favor.

Crear un arreglo de 10 elementos de listas enlazadas, para guardar números enteros entre 1 y 100. En la posición 0 del arreglo irán todos los números ingresados de menores a 10, en la posición 1 todos los números ingresados mayores o iguales a 10 y menores que 20, en la posición 2 irán todos los números mayores o iguales a 20 pero menores que 30, etc.
 
Una vez ingresados n elementos indicar: de que rango se ingresaron más, buscar un elemento dado y obtener la cantidad de repeticiones de un número dado.

morringos

  • Miembro activo
  • **
  • Mensajes: 65
  • Nacionalidad: 00
    • Ver Perfil
Re: Trabajar con arrays de distintos tipos de datos(C#)
« Respuesta #9 en: Jueves 7 de Octubre de 2010, 06:00 »
0
Trata de ponerlo en otro post aparte, no dentro del mismo, aparte, especifíca un poco más sobre qué tipo de listas enlazadas, simples, circulares o de cuáles listas.
Si mostraras tu código o tu planteamiento, estaría mejor, para que te podamos decir en qué andas mal y en qué no.


Saludos!;
Morringos Phyps!; ^_^

Páginas: [1]
« anterior próximo »