martes, 3 de febrero de 2015

Ejercicios resueltos en C#

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”)

namespace ejercicio1
{
    class Program
    {
        public void cargarvalores()
        {
            Console.ForegroundColor = ConsoleColor.DarkBlue;
            Console.BackgroundColor = ConsoleColor.DarkGray;
            Console.Clear();

            Console.WriteLine("\n\t\t\t\tBienvenidos");

            Console.WriteLine("\nIngrese una frase");
            string a = Console.ReadLine();

            Invierte(a);
            Console.WriteLine(Invierte(a));
            Console.ReadKey();

        }
        static void Main(string[] args)
        {
            Program inv = new Program();
            inv.cargarvalores();

        }

        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”.)

namespace ejercicio2
{
    class Program
    {
        public void cargarvalores()
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.BackgroundColor = ConsoleColor.DarkGray;
            Console.Clear();

            Console.WriteLine("\n\t\t\t\tBienvenidos");

            Console.WriteLine("\n Ingrese una palabra:");
            string a = Console.ReadLine();

            Console.WriteLine("\nIngrese la posicion de frase:");
            int pos = int.Parse(Console.ReadLine());

            Console.WriteLine("\nIngrese la cantidad:");
            int cant = int.Parse(Console.ReadLine());

            SubString(a, pos, cant);
            string algo;

            algo = SubString(a, pos, cant);

            Console.WriteLine("La frase corta es: " + algo);
            Console.ReadLine();
        }

        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;
   }
        }

        static void Main(string[] args)
        {
            Program inv = new Program();
            inv.cargarvalores();
        }
    }
}


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”)

namespace ejercicio3
{
    class Program
    {
        public void cambiarletras()
        {
            Console.ForegroundColor = ConsoleColor.DarkGreen;
            Console.BackgroundColor = ConsoleColor.White;
            Console.Clear();

            Console.WriteLine("\n\t\t\t\tBienvenidos");

            Console.WriteLine("\nIngrese la palabra");
            string a = Console.ReadLine();

            Console.WriteLine("\nIngrese la letra que va a cambiar");
            char b = char.Parse(Console.ReadLine());

            Console.WriteLine("\nIngrese la letra nueva");
            char c = char.Parse(Console.ReadLine());

            Replace (a, b, c);
            string r = Replace(a, b, c);

            Console.WriteLine("\nLa frase nueva es:" + r);
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            Program inv = new Program();
            inv.cambiarletras();
        }

        public string Replace (string a, char old, char nuevo)
{
   string result = "";
   for (int i = 0; i < a.Length ; i++)
   {
      if(a[i] == old)
         result += nuevo;
      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”)

namespace ejercicio4
{
    class Program
    {
        public void cargar()
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.BackgroundColor = ConsoleColor.DarkGray;
            Console.Clear();

            Console.WriteLine("\n\t\t\t\tBienvenidos");

            Console.WriteLine("\n Ingrese una palabra:");
            string a = Console.ReadLine();

            Combina(a);

            Console.WriteLine("\nLas combinaciones posibles son:" + a);
            Console.ReadLine();
        }
        static void Main(string[] args)
        {
            Program inv = new Program();
            inv.cargar();
        }

        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;
      }
   }
}

    }
}

jueves, 29 de enero de 2015

Arrays bidimensional

5 ejemplos de arrays bidimensionales:

Para declarar arreglos de dimensiones se declaran de acuerdo al siguiente esquema:

<Tipo de variable><nombre_matriz>[Filas][Columnas];  

Ejemplo 1:
String nombredelconjunto[2][5];

Ejemplo 2:
Int alumnos[1][3];

Ejemplo 3:
Int participantes[4][2];

Ejemplo 4:
String nombres[1][3];

Ejemplo 5:
Int estudiantes[5][4];

Explicación:
El ejemplo 5 en la declaración de ese Arrays dice que los elementos son de tipo enteros que constan de 5 filas y 4 columnas.       


 Gráficar Ideas sobre los punteros de los arrays bidimensionales.






martes, 27 de enero de 2015

Mentefacto sobre matrices


Cinco deficiones sobre matrices

Definición 1:
Las matrices nos van a permitir hacer referencia a un conjunto de variables por el mismo nombre y utilizar un índice para diferenciarlas. Una matriz puede tener una o varias dimensiones (más allá de tres cuesta representar el contenido). El índice más grande de la matriz es, por lo tanto igual al tamaño de esta menos uno.

Bibliografía:
Thierry Groussard, Los fundamentos del lenguaje - Desarrollar con Visual Studio 2010, Ediciones ENI, 2011

Definición 2:
Una matriz es una estructura de datos interna que almacena un conjunto de datos del mismo tipo bajo un nombre de variable común. La posición de un elemento dentro de la matriz viene identificada por uno o varios índices, de tal modo que a cada elemento se accede mediante el nombre de la matriz y sus índices.

Bibliografía:
Steven L. Heston, El Modelo Heston y sus extensiones en Matlab y C # , John Wiley & Sons, 2013

Definición 3:
Un arreglo es una estructura de datos, o más técnicamente, un espacio de memoria que permite almacenar una colección de elementos, todos del mismo tipo. Conviene imaginar un arreglo como una secuencia contigua de celdas (espacios de memoria), o casillas, en cada una de las cuales se puede guardar un elemento de la colección.

Bibliografía:
Yolanda Cerezo López, Olga Peñalba Rodríguez, Rafael Caballero Roldán, Iniciación a la programación en C#: un enfoque práctico, Delta Publicaciones, 2006

Definición 4:
Desde el punto de vista del programa, una matriz (array ó vector) es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico podemos considerarlas como un conjunto de elementos ordenados en fila. Así pues, en principio todas las matrices son de una dimensión, la dimensión principal, pero veremos que los elementos de esta fila pueden ser a su vez matrices (un proceso que puede ser recursivo), lo que nos permite hablar de la existencia de matrices multi-dimensionales, aunque las más fáciles de "ver" o imaginar son las de dos y tres dimensiones.

Bibliografía:
Vinny Cahill, Aprender a programar el Camino orientada a objetos con C #, Springer Science & Business Media, 2002

Definición 5:
Puede afirmarse que las matrices son un recurso de programación simple y socorrido; en realidad pueden considerarse como las "estructuras" de datos más simples que cabe imaginar (todos los elementos del mismo tipo). Presentan la ventaja de que sus elementos son rápidamente accesibles, en especial si utiliza punteros en vez de subíndices, pero presentan una notable limitación: son de tamaño fijo; es preciso definir su tamaño desde el principio y no pueden ser fácilmente incrementadas o disminuidas sino mediante complejos procesos de copia.

Bibliografía:
Rajeev A. Parida,  El poder de C #, Laxmi Publications, 2009

martes, 6 de enero de 2015

TAREA EN CLASE 06/01/2015



Cadenas dinámicas y estáticas

Existen dos tipos de cadenas:
Cadenas dinámicas: Las cadenas pueden ser de naturaleza dinámica (pueden alterar su longitud durante el tiempo de ejecución).
Mediante un carácter de fin de cadena ("\0" en C) para las cadenas de tipo dinámico.
Sintaxis

charmi_cadena [5] = {‘M’,’u’,‘n’,’d’,’o’,’\0’};

Cadenas estáticas: De naturaleza estática (su longitud es fija a lo largo del tiempo de ejecución).

Mediante una propiedad de la cadena que delimite su longitud (Count en C#) para las de tipo estático.

Usos de las cadenas
§  Usados para describir las características de las personas y cosas.

  • Copia de una cadena
  • Cálculo de la longitud,
  • Comparación,
  • Concatenación,
  • Extracción de subcadenas,
  • Búsqueda de información dentro de las cadenas,
  • Conversiones. 
Operaciones con cadenas

Asignación: asignarle una cadena a otra
char *strcpy(char [], const char[]); # en C
cadena1=cadena2;                     # en C++
cadena1 := cadena2                   # en Smalltalk

Concatenación: unir dos cadenas de caracteres.
$pareja = "Joshua"." y "."Marina"     # en Perl y PHP;
pareja = "Luisa" & " y " & "Carmen"  # en Visual Basic;
pareja = "Luisa" + " y " + "Carmen"; # en C++ y Java con la clase String.
pareja := 'Luisa' , ' y ' , 'Carmen'.  # en Smalltalk
strcat(cadena1,cadena2); strcat(cadena1, cadena3); # en C (Debe haber suficiente espacio en la primera)

Nº de caracteres de una cadena
int strlen(const char[]); # en C Devuelve el nº de caracteres sin contar el '\0'
cadena.length();          # en C++
cadena size.              # en Smalltalk

Comparación: Compara dos cadenas en orden lexicográfico
int strcmp(const char[], const char[]); # en C Devuelvee <0 si la 1ª es menor, >0 si es mayor y 0 si son iguales
cadena1==cadena2; cadena1>cadena2; etc. # en C++ Devuelve un valor de verdad
cadena1 = cadena2                       # en Smalltalk Devuelve true o false.
Multiplicar una cadena: repetir una cadena un número de veces
$puntos ="." x 5 # pone 5 puntos en Perl
puntos := Generator generateJoin: '.' repeat: 5.   # Genera una cadena de 5 puntos en Smalltalk


Acceder a las letras que forman una cadena
Podemos leer (o modificar) una de las letras de una cadena de igual forma que leemos los elementos de cualquier array: si la cadena se llama "texto", el primer elemento será texto [0], el segundo será texto [1] y así sucesivamente.
Eso sí, las cadenas en C# no se pueden modificar letra a letra: no podemos hacer texto [0]=’a’. Para eso habrá que usar una construcción auxiliar, que veremos más adelante.

Longitud de la cadena.
Podemos saber cuántas letras forman una cadena con "cadena.Length". Esto permite que podamos recorrer la cadena letra por letra, usando construcciones como "for".
Ejercicio propuesto: Un programa te pida tu nombre y lo muestre en pantalla separando cada letra de la siguiente con un espacio. Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla "J u a n".

Extraer una subcadena
Podemos extraer parte del contenido de una cadena con "Substring", que recibe dos parámetros: la posición a partir de la que queremos empezar y la cantidad de caracteres que queremos obtener. El resultado será otra cadena:
saludo = frase.Substring(0,4);
Podemos omitir el segundo número, y entonces se extraerá desde la posición indicada hasta el final de la cadena.

Buscar en una cadena
Para ver si una cadena contiene un cierto texto, podemos usar IndexOf ("posición de"), que nos dice en qué posición se encuentra (o devuelve el valor -1 si no aparece):
if (nombre.IndexOf("Juan") >= 0) Console.Write("Bienvenido, Juan");
Podemos añadir un segundo parámetro opcional, que es la posición a partir de la que queremos buscar:
if (nombre.IndexOf("Juan", 5) >= 0) ...
La búsqueda termina al final de la cadena, salvo que indiquemos que termine antes con un tercer parámetro opcional:
if (nombre.IndexOf("Juan", 5, 15) >= 0) ...
De forma similar, LastIndexOf ("última posición de") indica la última aparición (es decir, busca de derecha a izquierda).


Sintaxis
public static void Main()
  {
    tipoFicha[] fichas  = new tipoFicha[1000];
}  



Referencias:

martes, 2 de diciembre de 2014

Tareas Autónoma 02/12/2014

Ejercicios propuestos.

1) Escribir un programa que pida 10 números enteros por teclado y que imprima por pantalla:
I. Cuántos de esos números son pares.
II.Cuál es el valor del número máximo.
III.Cuál es el valor del número mínimo.

namespace Ejercicio1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.BackgroundColor = ConsoleColor.Blue;
            Console.Clear();
            int[] arreglo = new int[10]; 
            int i=0,conteo=0,esclavo=0,mayor=0,menor=0;
               Console.WriteLine("\t \t*** Cantidad de números pares, mayor y menor *** \n");

             for (i=0; i<10; i++)

             {
                 Console.Write("\tIntroduzca el " + (i + 1) + " valor: ");
                arreglo[i] = int.Parse(Console.ReadLine());
              }
            for (i=0; i<10; i++)
            {
                if (arreglo[i] % 2 == 0)
                {
                    conteo=conteo + 1;
                }
            }
            for (i=0; i<10; i++)
            {
                if (arreglo[i] > mayor)
                {
                    mayor = arreglo[i];
                    esclavo = arreglo[i];
                }
            }
            for (i=0; i<10; i++)
            {
                if (arreglo[i] <= esclavo)    
                {
                    menor = arreglo[i];
                    esclavo = arreglo[i];
                }
               }
        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("\n\t**** Resultados ****");
        Console.WriteLine("\tNúmero de pares : " + conteo);
        Console.WriteLine("\tNúmero mayor    : " + mayor);
        Console.WriteLine("\tNúmero menor    : " + menor);
        Console.ReadKey();
        }
    }
}



2) Escribir un programa que lea un vector de 10 elementos. Deberá imprimir el mismo vector por pantalla pero invertido. Ejemplo: dado el vector 1 2 3 4 5 6 7 8 9 10 el programa debería imprimir 10 9 8 7 6 5 4 3 2 1.

namespace Ejercicio2
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.BackgroundColor = ConsoleColor.Blue;
            Console.Clear();
            int[] arreglo = new int[10];
            int i = 0;

            Console.WriteLine("\t \t*** Números invertidos*** \n");
            for (i = 0; i < 10; i++)
            {
                Console.Write("\tIngrese el " + (i+1) + " número: ");
                arreglo[i] = int.Parse(Console.ReadLine());
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write("\n\tOrden original   : ");
            for (i = 0; i < 10; i++)
            {
                Console.Write(arreglo[i] + ",");
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write("\n\tOrden invertido  : ");
            for (i = 9; i >= 0; i--)
            {
                Console.Write(arreglo[i] + ",");

            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.ReadKey();
        }
    }
}


3) Escribir un programa que lea 10 números por teclado. Luego lea dos más e indique si éstos están entre los anteriores.

namespace ejercicio3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.BackgroundColor = ConsoleColor.Blue;
            Console.Clear();
            int[] arreglo = new int[10];
            int i=0,contav1=0,contav2=0;
            Console.WriteLine("\t \t*** Comparación de números *** \n");
            for (i=0; i<10; i++)
            {
                Console.Write("\tIngrese el " + (i+1) + " número: ");
                arreglo[i] = int.Parse(Console.ReadLine());
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("\n\n\t \t*** Ingrese dos valores para comparar ****");
            Console.Write("\tIngrese el 1 valor: ");
            int valor1 = int.Parse(Console.ReadLine());
            Console.Write("\tIngrese el 2 valor: ");
            int valor2 = int.Parse(Console.ReadLine());

            for ( i=0; i<10; i++)
            {
                if (arreglo[i]==valor1)
                {
                    contav1++;
                }
                else if(arreglo[i]==valor2)
                {
                    contav2++;
                }
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write("\n\tEl número "+ valor1 + " se repite " + contav1 + " veces.");
            Console.Write("\n\tEl número " + valor2 + " se repite " + contav2 + " veces.");
            Console.ReadKey();
            }
        }
    }



4) Escribir un programa que lea una matriz de números enteros y que devuelva la suma de los elementos positivos de la matriz y la suma de los elementos negativos. 

namespace Ejercicio4
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.BackgroundColor = ConsoleColor.Blue;
            Console.Clear();
            int[,] matriz = new int[10,10]; 
            int i=0,c=0,negativos=0,positivos=0;
            Console.WriteLine("\t \t*** Matriz de números positivos y negativos ");
            Console.Write("\n\t Ingrese los valores de la matriz: ");
            for (i = 1; i <= matriz.GetLength(0); i++)
            {
                for (c = 1; c <= matriz.GetLength(1); c++)
                {
                    matriz[i,c] = int.Parse(Console.ReadLine()); ;
                }
            }
            for (i = 1; i <= matriz.GetLength(1); i++)
            {
                for (c = 1; c <= matriz.GetLength(0); c++)
                {
                    if (matriz[i,c] > 0)
                    {
                        positivos = positivos + matriz[i,c];
                    }
                    else
                    {
                        negativos = negativos + matriz[i,c];  
                    }
                }
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("\n\tSuma de los numeros positivos: " + positivos);
            Console.WriteLine("\tSuma de los numeros negativos: " + negativos);
            Console.ReadKey();
        }
    }
}

Realizar un mentefacto de cadenas:


Valores de cadenas constantes

Recordando la presentación de arreglos hecha, en donde las cadenas están definidas como un arreglo de caracteres o un apuntador a una porción de memoria conteniendo caracteres ASCII. Una cadena en C es una secuencia de cero o más caracteres seguidas por un caracter NULL o \0:
Es importante preservar el caracter de terminación NULL, ya que con éste es como C define y maneja las longitudes de las cadenas. Todas las funciones de la biblioteca estándar de C lo requieren para una operación satisfactoria.
En general, aparte de algunas funciones restringidas en longitud (strncat(), strncmp() y strncpy()), al menos que se creen cadenas a mano, no se deberán encontrar problemas. Se deberán usar las funciones para manejo de cadenas y no tratar de manipular las cadenas en forma manual desmantelando y ensamblando cadenas.
Funciones necesarias para el manejo de cadenas adecuadas para  el desarrollo de la aplicación informática.

Las funciones más comunes son descritas a continuación:

• char *strcpy(const char *dest, const char *orig) -- Copia la cadena de caracteres apuntada por origen (incluyendo el carácter terminador '\0') al vector apuntado por dest. Las cadenas no deben solaparse, y la de destino, debe ser suficientemente grande como para alojar la copia.
• int strcmp(const char *s1, const char *s2) -- Compara las dos cadenas de caracteres s1 y s2. Devuelve un entero menor, igual o mayor que cero si se encuentra que s1 es, respectivamente, menor que, igual a, o mayor que s2.
• char *strerror(int errnum) -- Devuelve un mensaje de error que corresponde a un número de error.
• int strlen(const char *s) -- Calcula la longitud de la cadena de caracteres.
• char *strncat(char *s1, const char *s2, size_t n) -- Agrega n caracteres de s2 a s1.
• int strncmp(const char *s1, char *s2, size_t n) -- Compara los primeros n caracteres de dos cadenas.
• char *strncpy(const char *s1, const char *s2, size_t n) -- Copia los primeros n caracteres de s2 a s1.
• strcasecmp(const char *s1, const char *s2) -- versión que ignora si son mayúsculas o minúsculas de strcmp().
• strncasecmp(const char *s1, const char *s2, size_t n) -- versión insensible a mayúsculas o minúsculas de strncmp() que compara los primeros n caracteres de s1.

Fuentes:
Harvey M. Deitel y Paul J. Deitel , Cómo programar en C#, 2da Edición