A falta de tiempo para cosas más profesionales, voy a ir poniendo los algoritmos bonitos que desarrolle en la Universidad. En este caso, la especificación del ejercicio sería: Dado un arreglo de números, determinar la longitud del subarreglo creciente más largo del arreglo.

Ejemplo

Si recibiéramos un arreglo de naturales con los siguientes elementos: 2, 6, 5, 1, 3, 4, 9, 8 el resultado sería 4, puesto que es el subarreglo más largo de elementos crecientes (es decir, la longitud del subarreglo 1, 3, 4, 9)

Solución en palabras

El algoritmo que resuelve este problema debería recorrer el arreglo e ir verificando si el elemento en la posición a la que apunta es menor al de la siguiente posición. Esto supone además que, puesto que evaluaremos el elemento de la siguiente posición, debemos recorrer el arreglo desde la posición 0 hasta n-1 (siendo n la longitud del arreglo), ya que no queremos sobrepasar la longitud del mismo. Por otro lado, para cada elemento del arreglo contaremos sus sucesores que sean mayores que él mismo y con dicho conteo podremos determinar cual es la longitud de los subarreglos crecientes.

Solución en Java

El algoritmo en Java sería este:

public class SubarregloCreciente{
	public static void main(String args[]){
		//arreglo a evaluar
		int[] arr = {5,6,4,1,2,6,7,78,6,2,3,4,5,6,7,3,6,1};
		//la longitud al menos sera 0;
		//k contador por cada recorrido
		int longitud = 1, k;
		//recorremos el arreglo
		for(int i=0; i<arr.length-1;i++){
			//contamos desde el indice i cuantos
			//elementos hay en orden ascendente
			for(k = i; k < arr.length-1 && arr[k] < arr[k+1]; k++);
			//si la longitud es mayor que la anterior guardarla
			if(longitud < k - i + 1)
				longitud = k - i + 1;
		}
		System.out.println("Longitud del subarreglo creciente mas grande: "+longitud);
	}
}

Descargar código fuente

Solución en Python

from array import array
#arreglo a evaluar
arr = array('d',[5,6,4,1,2,6,7,78,6,2,3,4,5,6,7,3,6,1])
#la longitud al menos sera 0;
#k contador por cada recorrido
longitud = 1
#k=0
#recorremos el arreglo
for i in range (0, len(arr)-1):
	#contamos desde el indice i cuantos
	#elementos hay en orden ascendente
	for k in range(i, len(arr)-1):
		if not arr[k] < arr[k+1]: break
	#si la longitud es mayor que la anterior guardarla
	if longitud < k - i + 1:
		longitud = k - i + 1
print "Longitud del subarreglo creciente mas grande: "+str(longitud)

Descargar código fuente

Representación formal de la solución

Por supuesto, el algoritmo planteado es solo la aproximación más sencilla, mas no la más eficiente de todas.

Las matrices o arreglos de dos dimensiones, son arrays bidimensionales cuyos elementos tienen dos indices. En C Sharp existen dos tipos de arreglos bidimensionales, los rectangulares y los dinámicos. Por lo general, cuando accedemos a arreglos bidimensionales utilizamos los términos filas y columnas.

En los arreglos bidimensionales rectangulares, cada fila tiene la misma cantidad de columnas. Por otro lado, las filas de los arreglos bidimensionales dinámicos pueden tener diferente cantidad de columnas. A continuación, una serie de ejemplos en donde se explica cómo se declara e inician los dos tipos de arreglos:

Declaración e iniciación de arreglos de dos dimensiones

using System;
public class ArregloDosDimensiones {
  static void Main() {
     // declaracion e iniciación de arreglos rectangulares
     int[,] arreglo1 = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
     // declaración e iniciación de arreglos dinamicos
     int[][] arreglo2 = new int[ 3 ][];
     string salida = "";
     arreglo2[ 0 ] = new int[] { 1, 2 };
     arreglo2[ 1 ] = new int[] { 3 };
     arreglo2[ 2 ] = new int[] { 4, 5, 6 };
     salida = "Valores en arreglo1 por fila\n";
     // salida del arreglo1
     for ( int i = 0; i < arreglo1.GetLength( 0 ); i++ ) {
        for ( int j = 0; j < arreglo1.GetLength( 1 ); j++ )
           salida += arreglo1[ i, j ] + "  ";
        salida += "\n";
     }
     salida += "\nValores en arreglo2 por fila\n";
     // salida del arreglo2
     for ( int i = 0; i < arreglo2.Length; i++ ) {
        for ( int j = 0; j < arreglo2[ i ].Length; j++ )
           salida += arreglo2[ i ][ j ] + "  ";
        salida += "\n";
     }
     Console.WriteLine(salida);
  }
}

Salida…

Descargar código fuente

Ejemplo con arreglos bidimensionales

using System;
public class DoubleArray {
  static int[][] calificacion;
  static int estudiantes, examenes;
  static void Main() {
     string salida = "                   ";
     calificacion = new int[ 3 ][];
     calificacion[ 0 ] =  new int[]{ 77, 68, 86, 73 };
     calificacion[ 1 ] =  new int[]{ 96, 87, 89, 81 };
     calificacion[ 2 ] =  new int[]{ 70, 90, 86, 81 };
     estudiantes = calificacion.Length;      // numero de estudiantes
     examenes = calificacion[ 0 ].Length;    // numero de examenes
     // columnas
     for ( int i = 0; i < examenes; i++ )
        salida += "[" + i + "]  ";
     // filas
     for ( int i = 0; i < estudiantes; i++ ) {
        salida += "\ncalificaciones[" + i + "]   ";
        for ( int j = 0; j < examenes; j++ )
           salida += calificacion[ i ][ j ] + "   ";
     }
     salida += "\n\nCal. m&amp;amp;aacute;s baja: " + minimo() +
        "\nCal. m&amp;amp;aacute;s alta: " + maximo() + "\n";

     for ( int i = 0; i < estudiantes; i++ )
        salida += "\nEl promedio por estudiante " + i + " es " +
           promedio( calificacion[ i ] );
     Console.WriteLine(salida);
  }
  // buscar calificacion minima en el arreglo
  static public int minimo() {
     int baja = 100;
     for ( int i = 0; i < estudiantes; i++ )
        for ( int j = 0; j < examenes; j++ )
           if ( calificacion[ i ][ j ] < baja )
              baja = calificacion[ i ][ j ];
       return baja;
  }
  // buscar calificacion maxima en en arreglo
  static public int maximo() {
     int alta = 0;
     for ( int i = 0; i < estudiantes; i++ )
        for ( int j = 0; j < examenes; j++ )
           if ( calificacion[ i ][ j ] > alta )
              alta = calificacion[ i ][ j ];
       return alta;
  }
  // determinar el promedio de la calificacion
  static public double promedio( int[] calificaciones ) {
     int total = 0;
     for ( int i = 0; i < calificaciones.Length; i++ )
        total += calificaciones[ i ];
     return ( double ) total / calificaciones.Length;
  }
}

Salida…

Descargar código fuente

Bonus: sentencia foreach en C#

Cuando de recorrer arreglos se trata, existe una sentencia bastante útil: foreach. Foreach es similar a un for, solo que es un poco más simple. La sintaxis es foreach(VARIABLE in ARREGLO), y cada vez que ocurre una iteración, VARIABLE va tomando los valores del arreglo en orden:

using System;
class Foreach {
   // main entry point for the application
   static void Main(string[] args) {
      int[,] calificaciones = { { 77, 68, 86, 73 },
         { 98, 87, 89, 81 }, { 70, 90, 86, 81 } };
      int baja = 100;
      foreach ( int calificacion in calificaciones ) {
         if ( calificacion < baja )
            baja = calificacion;
      }
      Console.WriteLine( "La calificacion mas baja es: " + baja );
   }
}

Descargar código fuente

Hace unos dí­as y poní­a un ejemplo acerca de búsquedas lineales en arreglos, ésta vez hablaremos acerca de las búsquedas lineales, un método mucho más rápido para buscar elementos.

¿Cómo funciona este método? Para poder aplicar éste método de búsqueda es necesario que el arreglo esté ordenado; posteriormente, se aplica el siguiente algoritmo: se ubica el elemento de la mitad del arreglo, entonces, si el número que se está buscando dentro del arreglo es menor al número de la mitad, se busca el número de la mitad entre el inicio del y la mitad del mismo, y así­ hasta encontrar el elemento deseado.

Por ejemplo, suponiendo que tenemos un arreglo con los siguientes valores:

2, 4, 5 , 6, 8, 9, 10, 12, 24, 34, 46, 56, 60, 67, 78, 89, 90

…y queremos buscar el valor 10; tenemos que, el elemento de la mitad contiene el valor 24. Puesto que 24 > 10, buscamos el valor intermedio entre el principio del arreglo y la mitad del mismo, esto es 8. Puesto que 8 < 10, buscamos el valor intermedio entre 8 y la mitad del arreglo (24), esto es 10. Así­, con tan solo 3 bucles, hemos conseguido el valor buscado.

Vamos con el código del programa, que nos sacará de toda duda:

using System;
using System.Drawing;
using System.Windows.Forms;
public class EjemploBusquedaBinaria : Form
{
  private Label labelSolicitar;
  private TextBox cajaEntrada;
  private Label labelResultado;
  private Label labelMostrar;
  private Label labelSalida;
  private Button botonBuscar;
  int[] a = { 0, 2, 4, 6, 8, 10, 12, 14, 16,
              18, 20, 22, 24, 26, 28 };
  public EjemploBusquedaBinaria(){
     InitializeComponent();
  }
  private void InitializeComponent() {
     this.labelMostrar = new Label();
     this.labelResultado = new Label();
     this.cajaEntrada = new TextBox();
     this.labelSolicitar = new Label();
     this.botonBuscar = new Button();
     this.labelSalida = new Label();
     this.SuspendLayout();
     //
     // labelMostrar
     //
     this.labelMostrar.Location = new System.Drawing.Point(261, 8);
     this.labelMostrar.Name = "labelMostrar";
     this.labelMostrar.Size = new System.Drawing.Size(152, 20);
     this.labelMostrar.TabIndex = 3;
     //
     // labelResultado
     //
     this.labelResultado.Location = new System.Drawing.Point(213, 8);
     this.labelResultado.Name = "labelResultado";
     this.labelResultado.Size = new System.Drawing.Size(50, 16);
     this.labelResultado.TabIndex = 2;
     this.labelResultado.Text = "Resultado:";
     //
     // cajaEntrada
     //
     this.cajaEntrada.Location = new System.Drawing.Point(99, 8);
     this.cajaEntrada.Name = "cajaEntrada";
     this.cajaEntrada.TabIndex = 1;
     this.cajaEntrada.Text = "";
     //
     // labelSolicitar
     //
     this.labelSolicitar.Location = new System.Drawing.Point(27, 8);
     this.labelSolicitar.Name = "labelSolicitar";
     this.labelSolicitar.Size = new System.Drawing.Size(56, 16);
     this.labelSolicitar.TabIndex = 0;
     this.labelSolicitar.Text = "Digite el dato";
     //
     // botonBuscar
     //
     this.botonBuscar.Location = new System.Drawing.Point(152, 40);
     this.botonBuscar.Name = "botonBuscar";
     this.botonBuscar.Size = new System.Drawing.Size(136, 24);
     this.botonBuscar.TabIndex = 5;
     this.botonBuscar.Text = "Buscar dato";
     this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
     //
     // labelSalida
     //
     this.labelSalida.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0)));
     this.labelSalida.Location = new System.Drawing.Point(10, 80);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(420, 72);
     this.labelSalida.TabIndex = 4;
     //
     // EjemploBusquedaBinaria
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(440, 157);
     this.Controls.AddRange(new Control[] {
            this.botonBuscar,
            this.labelSalida,
            this.labelMostrar,
            this.labelResultado,
            this.cajaEntrada,
            this.labelSolicitar});
     this.Name = "EjemploBusquedaBinaria";
     this.Text = "Busqueda Binaria";
     this.ResumeLayout(false);
  }
  static void Main() {
     Application.Run( new EjemploBusquedaBinaria() );
  }
  private void botonBuscar_Click( object sender,
     System.EventArgs e )
  {
     int valorBuscar = Int32.Parse( cajaEntrada.Text );
     // iniciar los datos de salida
     labelSalida.Text = "Portions of array searched\n";
     // realizar busqueda binaria
     int elemento = Buscar( a, valorBuscar );
     if ( elemento != -1 )
        labelMostrar.Text = "Valor encontrado en indice " +
           elemento;
     else
        labelMostrar.Text = "Valor no encontrado";
  } // fin botonBuscar_Click
  // buscar mediante metodo binario
  public int Buscar( int[] array, int dato ) {
     int bajo = 0;
     int alto = array.Length - 1;
     int medio;
     while ( bajo <= alto ) {
        medio = ( bajo + alto ) / 2;
        // el siguiente método nos muestra la porción del
        // arreglo donde se está llevando a cabo la busqueda
        // del dato en cada iteración del bucle
        construirSalida( a, bajo, medio, alto );
        if ( dato == array[ medio ] )   // si se encuentra el valor
           return medio;
        else if ( dato < array[ medio ] )
           alto = medio - 1;   // buscar en la mitad más baja
        else
           bajo = medio + 1;   // buscar en la mitad más alta
     } // fin de la busqueda binaria
     return -1;  // dato no encontrado
  } // fin del metodo Buscar
  public void construirSalida(
     int[] array, int bajo, int mid, int alto ) {
     for ( int i = 0; i < array.Length; i++ ) {
        if ( i < bajo || i > alto )
           labelSalida.Text += "    ";
        // marcar el elemento de la mitad en la salida
        else if ( i == mid )
           labelSalida.Text +=
              array[ i ].ToString( "00" ) + "* ";
        else
           labelSalida.Text +=
              array[ i ].ToString( "00" ) + "  ";
     }
     labelSalida.Text += "\n";
  } // fin de construirSalida
} // fin de la clase EjemploBusquedaBinaria

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar búsquedas dentro de un arreglo de manera lineal.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
namespace BusquedaLineal
{
   public class BusquedaLineal : Form
   {
      private Button botonBuscar;
      private TextBox cajaEntrada;
      private Label labelSalida;
      int[] a = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
                  28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50 };
      public BusquedaLineal()
      {
         InitializeComponent();
      }
      private void InitializeComponent()
      {
         this.botonBuscar = new Button();
         this.cajaEntrada = new TextBox();
         this.labelSalida = new Label();
         this.SuspendLayout();
         //
         // botonBuscar
         //
         this.botonBuscar.Location = new System.Drawing.Point(8, 8);
         this.botonBuscar.Name = "botonBuscar";
         this.botonBuscar.TabIndex = 0;
         this.botonBuscar.Text = "Buscar";
         this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
         //
         // cajaEntrada
         //
         this.cajaEntrada.Location = new System.Drawing.Point(96, 9);
         this.cajaEntrada.Name = "cajaEntrada";
         this.cajaEntrada.Size = new System.Drawing.Size(88, 20);
         this.cajaEntrada.TabIndex = 1;
         this.cajaEntrada.Text = "";
         //
         // labelSalida
         //
         this.labelSalida.Location = new System.Drawing.Point(8, 40);
         this.labelSalida.Name = "labelSalida";
         this.labelSalida.Size = new System.Drawing.Size(184, 23);
         this.labelSalida.TabIndex = 2;
         //
         // BusquedaLineal
         //
         this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
         this.ClientSize = new System.Drawing.Size(200, 69);
         this.Controls.AddRange(new Control[] {
                  this.labelSalida,
                  this.cajaEntrada,
                  this.botonBuscar});
         this.Name = "BusquedaLineal";
         this.Text = "BusquedaLineal";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new BusquedaLineal());
      }
      private void botonBuscar_Click( object sender,
         System.EventArgs e )
      {
         int datoBuscar = Int32.Parse( cajaEntrada.Text );
         int indiceElemento = BuscarLineal( a, datoBuscar );
         if ( indiceElemento != -1 )
            labelSalida.Text =
               "Encontrado en el indice " + indiceElemento;
         else
            labelSalida.Text = "Valor no encontrado";
      } // fin del metodo botonBuscar_Click
      // buscar valor dentro del array
      public int BuscarLineal( int[] array, int dato )
      {
         for ( int n = 0; n < array.Length; n++ )
         {
            if ( array[ n ] == dato )
               return n;
         }
         return -1;
      } // fin del metodo BusquedaLineal
   }
}

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar el ordenamiento de arreglos de enteros, usando el método burbuja en C#.

Ejemplo…

using System;
public class OrdenamientoBurbuja
{
  static void Main()
  {
     int[] a =  { 54, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
     string salida = "Valores de los items originales\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     // ordenar elementos del arreglo
     OrdenarBurbuja( a );
     salida += "\n\nValores de los items en orden descendente\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     Console.WriteLine(salida);
  } // fin del metodo main
  // ordenar elementos de un arreglo con el metodo burbuja
  static public void OrdenarBurbuja( int[] b )
  {
     for ( int pasadas = 1; pasadas < b.Length; pasadas++ ) // pasadas
        for ( int i = 0; i < b.Length - 1; i++ )
           if ( b[ i ] > b[ i + 1 ] )      // comparar
              intercambio( b, i );         // intercambiar
  }
  // intercambio de dos elementos en un arreglo
  static public void intercambio( int[] c, int primero )
  {
     int temp;      // variable temporal para el intercambio
     temp = c[ primero ];
     c[ primero ] = c[ primero + 1 ];
     c[ primero + 1 ] = temp;
  }
}

Resultado…

Descargar código fuente

En el post anterior decíamos que cuando pasamos un arreglo a un método, ‘se pasa la referencia al arreglo por valor’. En este post veremos entonces cual es la diferencia entre pasar la “referencia de un arreglo por valor” y “referencia de un arreglo por referencia”.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class EjemploArregloReferencia : Form
{
  private Label labelSalida;
  private Button botonMostrarSalida;
  public EjemploArregloReferencia()
  {
     InitializeComponent();
  }

  private void InitializeComponent()
  {
     this.labelSalida = new Label();
     this.botonMostrarSalida = new Button();
     this.SuspendLayout();
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(10, 40);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(272, 280);
     this.labelSalida.TabIndex = 0;
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(101, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(91, 23);
     this.botonMostrarSalida.TabIndex = 1;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // EjemploArregloReferencia
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 325);
     this.Controls.AddRange(new Control[] {
                                                                  this.botonMostrarSalida,
                                                                  this.labelSalida});
     this.Name = "EjemploArregloReferencia";
     this.Text = "EjemploArregloReferencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new EjemploArregloReferencia() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     // crear e iniciar primerArreglo
     int[] primerArreglo = { 1, 2, 3 };

     // copiar primerArreglo en otro arreglo
     int[] copiaPrimerArreglo = primerArreglo;

     labelSalida.Text =
        "Ejemplo pasar la referencia de primerArreglo por valor";

     labelSalida.Text += "\n\nContenido de primerArreglo " +
        "antes de llamar el metodo primerDoblar:\n\t";

     // imprimir el contenido del arreglo primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // pasar referencia de primerArreglo por valor a primerDoblar
     primerDoblar( primerArreglo );

     labelSalida.Text += "\n\nContenido de primerArreglo despues " +
        "de llamar el metodo primerDoblar\n\t";

     // imprimir contenido de primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // probar si la copia cambio
     if ( primerArreglo == copiaPrimerArreglo )
        labelSalida.Text +=
           "\n\nLa copia fue modificada tambien (porque tiene la referencia a dicho arreglo)\n";
     else
        labelSalida.Text +=
           "\n\nLa copia no fue modificada\n";

     // crear e inciar segundoArreglo
     int[] segundoArreglo = { 1, 2, 3 };

     // crear una copia de segundoArreglo
     int[] copiaSegundoArreglo = segundoArreglo;

     labelSalida.Text += "\nEjemplo, pasar referencia de segundoArreglo " +
        "por referencia";

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "antes de llamar el metodo segundoDoblar:\n\t";

     // imprime el contenido de segundoArreglo antes de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     segundoDoblar( ref segundoArreglo );

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "despues de llamar el metodo segundoDoblar:\n\t";

     // imprimir el contenido de segundoArreglo despues de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     // verificar si la copia ha cambiado
     if ( segundoArreglo == copiaSegundoArreglo )
        labelSalida.Text +=
           "\n\nLa copia ha cambiado\n";
     else
        labelSalida.Text +=
           "\n\nLa referencia y el arreglo original son distintos (porque el original cambio de referencia)\n";

  } // fin del metodo botonMostrarSalida_Click

  // modifica elementos del arreglo e intentar modificar la referencia
  void primerDoblar( int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }

  // modifica elementos del arreglo e intentar modificar la referencia
  void segundoDoblar( ref int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }
}

Descargar código fuente

Cuando estamos trabajando con arreglos en C#, debemos tener en cuenta algo importante: si pasamos un arreglo entero, éste será pasado por referencia ; mientras que si pasamos uno de los elementos del arreglo, éste es pasado por valor.

¿Qué quiere decir esto exactamente? Pues bien, cuando pasamos un arreglo completo a un método, TODAS las modificaciones que hagamos sobre el arreglo en dicho método se verán reflejadas en el arreglo original. Por otro lado, cuando lo que pasamos es un elemento de un arreglo, las modificaciones que hagamos sobre el elemento serán accesibles únicamente desde dicho método, por lo tanto el valor original del elemento no es modificado.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class PasarArreglo : Form
{
  private Button botonMostrarSalida;
  private Label labelSalida;
  public PasarArreglo()
  {
     InitializeComponent();
  }
  private void InitializeComponent()
  {
     this.botonMostrarSalida = new Button();
     this.labelSalida = new Label();
     this.SuspendLayout();
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(106, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(80, 23);
     this.botonMostrarSalida.TabIndex = 0;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(8, 48);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(280, 184);
     this.labelSalida.TabIndex = 1;
     //
     // PasarArreglo
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 237);
     this.Controls.AddRange(new Control[] {
          this.labelSalida,
          this.botonMostrarSalida});
     this.Name = "PasarArreglo";
     this.Text = "Pasar Arreglo por valor y referencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new PasarArreglo() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     int[] a = { 1, 2, 3, 4, 5 };

     labelSalida.Text = "Resultado de pasar un arreglo " +
        "por referencia...\n\nLos valores del arreglo original son:\n\t";

     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     ModificarArreglo( a );   // el array es pasado por referencia

     labelSalida.Text +=
        "\n\nEl valor de los datos modificados del arreglo son:\n\t";

     // mostrar elementos del array a
     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     labelSalida.Text += "\n\nResultado de pasar un elemento del array por valor..." +
        "\n\nvalor de a[ 3 ] (antes de ser pasado a ModificarElemento()) " + a[ 3 ];

     // elemento del array pasado por valor
     ModificarElemento( a[ 3 ] );

     labelSalida.Text +=
        "\na[ 3 ] (despues de ser pasado a ModificarElemento()): " + a[ 3 ];
  }

  // metodo que modifica el arreglo que recibe
  // (el original será modificado)
  public void ModificarArreglo( int[] b )
  {
     for ( int j = 0; j < b.Length; j++ )
        b[ j ] *= 2;
  }

  // metodo que modifica el entero recibido
  // (el original no será modificado)
  public void ModificarElemento( int e )
  {
     labelSalida.Text +=
        "\nvalor recibido por el metodo: " + e;
     e *= 2;
     labelSalida.Text +=
        "\nvalor modificado dentro del metodo: " + e;
  }
}

Descargar código fuente

Ejemplos básicos de manipulación de arreglos en C#

Sumar elementos de un array

Sinopsis: hacer la sumatoria de los elementos de un arreglo.

using System;
class SumarArreglo
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     int total = 0;
     for ( int i = 0; i < a.Length; i++ )
        total += a[ i ];
     Console.WriteLine( "Suma de todos los elementos del array: " + total);
  } // fin de Main
} // fin de la clase SumarArreglo

Resultado…

Descargar código fuente

Creacion de histogramas

Sinopsis: crear un histograma (barras a base de asteriscos) a partir de unos datos.

using System;
class Histograma
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] n = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
     string salida = "Elemento\tValor\tHistograma\n";
     // construir salida
     for ( int i = 0; i < n.Length; i++ )
     {
        salida += "\n" + i + "\t\t\t" + n[ i ] + "\t\t";
        for ( int j = 1; j <= n[ i ]; j++ ) // imprimir una barra
           salida += "*";
     }
     Console.WriteLine( salida);
  } // fin Main
} // fin de la clase Histograma

Resultado…

Descargar código fuente

Estadisticas de notas de estudiantes

Sinopsis: apartir de un arreglo de notas (puntajes) identificar la frecuencia de cada una de ellas entre todos los estudiantes.

using System;
class EncuestaEstudiantes
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] respuestas = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1,
        6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,
        5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

     int[] frecuencia = new int[ 11 ];
     string salida = "";

     // incrementar la frecuecia de para cada respuesta
     for ( int j = 0; j < respuestas.Length; j++ )
        ++frecuencia[ respuestas[ j ] ];

     salida += "Puntaje\tFrecuencia\n";

     // resultados
     for ( int puntaje = 1; puntaje < frecuencia.Length; puntaje++ )
        salida += puntaje + "\t\t" + frecuencia[ puntaje ] + "\n";

     Console.WriteLine( salida);

  } // fin Main

} // fin de la clase EncuestaEstudiantes

Resultado…

Descargar código fuente

La creación y manipulación de arrays en C# es similar a la de cualquier otro lenguaje de programación, aunque difiere un poco en cuanto a sintaxis (desde la perspectiva de un programador en Java).

Tenemos entoces 2 maneras básicas de iniciar un arreglo:

• Al asignarle un tamaño estamos iniciándolo con los valores por defecto (en el caso de enteros, es cero)
• En el momento de la declaración podemos asignar directamente los valores, poniéndolos dentro de corchetes ({ … }), separados por comas.

Ejemplo…

using System;
class InitArray
{
	// metodo main
	static void Main( string[] args )
	{
	   string salida = "";
	   int[] x;            // declarar el array
	   x = new int[ 10 ];  // y asignarle un tamanio
     // iniciar un arreglo con tamanio y datos especificos
	   int[] y = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
	   const int TAMANIO_ARRAY = 10; // crear una constante
	   int[] z;                   // declarar un array de enteros
	   // asignar el tammanio con la constante
	   z = new int[ TAMANIO_ARRAY ];
	   // asignar valores al array
	   for ( int i = 0; i < z.Length; i++ )
	      z[ i ] = 2 + 2 * i;
	   salida += "Indice\tArray x\tArray y\tArray z\n";
	   // poner los valores del array en el string de salida
	   for ( int i = 0; i < TAMANIO_ARRAY; i++ )
	      salida += i + "\t\t" + x[ i ] + "\t\t" + y[ i ] +
	         "\t\t" + z[ i ] + "\n";
	Console.WriteLine(salida);
	} // fin de Main
} // fin de la clase IniciarArray

Salida del programa…

Descargar código fuente

Descargar código fuente