Practica 12

namespace Pr ctica_12__Consola_
{
class Racional
{
// Declaraci¢n de variables
public int numerador;
public int denominador;
static int i, mayor, num, den;
// Constructor sin par metros no utilizado
public Racional()
{
numerador = 1;
denominador = 2;
}
// Constructor con par metros
public Racional(int numerador, int denominador)
{
this.numerador = numerador;
this.denominador = denominador;
}
public void asignarNumerador(int numerador)
{
this.numerador = numerador;
}
public int obtenerNumerador()
{
return numerador;
}
public void asignarDenominador(int denominador)
{
this.denominador = denominador;
}
public int obtenerDenominador()
{
return denominador;
}
// Propiedad para el Numerador
public int Numerador
{
get
{
return numerador;
}
set
{
numerador = value;
}
}
// Propiedad para el Denominador
public int Denominador
{
get
{
return denominador;
}
set
{
denominador = value;
}
}
// M‚todo para saber si el n£merador es mayor o el denominador
static int Mayor(int num, int den)
{
if (num > den)
{
return num;
}
else
{
return den;
}
}
// Operador suma sobrecargado
public static Racional operator +(Racional Q1, Racional Q2)
{
den = Q1.denominador * Q2.denominador;
num = Q2.denominador * Q1.numerador + Q1.denominador * Q2.numerador;
mayor = Mayor(num, den);
for (i = 2; i < mayor; i++)
{
while (num % i == 0 && den % i == 0)
{
num = num / i;
den = den / i;
}
}
Racional newQ = new Racional(num, den);
return newQ;
}
// Operador resta sobrecargado
public static Racional operator -(Racional Q1, Racional Q2)
{
den = Q1.denominador * Q2.denominador;
num = Q2.denominador * Q1.numerador - Q1.denominador * Q2.numerador;
mayor = Mayor(num, den);
for (i = 2; i < mayor; i++)
{
while (num % i == 0 && den % i == 0)
{
num = num / i;
den = den / i;
}
}
Racional newQ = new Racional(num, den);
return newQ;
}
// Operador multiplicaci¢n sobrecargado
public static Racional operator *(Racional Q1, Racional Q2)
{
den = Q1.denominador * Q2.denominador;
num = Q1.numerador * Q2.numerador;
mayor = Mayor(num, den);
for (i = 2; i < mayor; i++)
{
while (num % i == 0 && den % i == 0)
{
num = num / i;
den = den / i;
}
}
Racional newQ = new Racional(num, den);
return newQ;
}
// Operador divisi¢n sobrecargado
public static Racional operator /(Racional Q1, Racional Q2)
{
den = Q1.denominador * Q2.numerador;
num = Q1.numerador * Q2.denominador;
mayor = Mayor(num, den);
for (i = 2; i < mayor; i++)
{
while (num % i == 0 && den % i == 0)
{
num = num / i;
den = den / i;
}
}
Racional newQ = new Racional(num, den);
return newQ;
}
}
}

Practica 13

namespace ConsoleApplication1
{
class Subclase : ClaseMadre
{
public int c;
public void imprimir_c()
{
Console.WriteLine("c = {0}",c);
}
public void imprimirsuma()
{
Console.WriteLine("Suma= {0}",(a+b+c));
}
public void producto()
{
Console.WriteLine("Producto= {0}",(a*b*c));
}
public int calcularmayor()
{
int mayor=0;
if (a > b && a > c)
{
Console.WriteLine("Mayor es a: {0}", a); mayor= a;
}
if (b > a && b > c)
{
Console.WriteLine("Mayor es b: {0}", b); mayor= b;
}
if (c > a && c > b)
{
Console.WriteLine("Mayor es c: {0}", c); mayor= c;
}
if (a == b && a == c)
{
Console.WriteLine("Todos Iguales"); mayor= a;
}
if (a == b && a > c)
{
Console.WriteLine("Mayor a:{0} y b:{1}", a, b); mayor= a;
}
if (c == b && c > a)
{
Console.WriteLine("Mayor c:{0} y b:{1}", c, b); mayor= c;
}
if (a == c && a > b)
{
Console.WriteLine("Mayor a:{0} y c:{1}", a, c); mayor= a;
}
return mayor;
}
public int calcularmenor()
{
int menor=0;
if (a < b && a < c)
{
Console.WriteLine("Menor es a: {0}", a); menor= a;
}
if (b < a && b < c)
{
Console.WriteLine("Menor es b: {0}", b); menor= b;
}
if (c < a && c < b)
{
Console.WriteLine("Menor es c: {0}", c); menor= c;
}
if (a == b && a == c)
{
Console.WriteLine("Todos Iguales"); menor= a;
}
if (a == b && a < c)
{
Console.WriteLine("Menor a:{0} y b:{1}", a, b); menor= a;
}
if (c == b && c < a)
{
Console.WriteLine("Menor c:{0} y b:{1}", c, b); menor= c;
}
if (a == c && a < b)
{
Console.WriteLine("Menor a:{0} y c:{1}", a, c); menor= a;
}
return menor;
}
public void intervalo(int may,int men)
{
int mayor, menor, diferencia=0;
mayor = may; menor = men;
diferencia = mayor - menor;
Console.WriteLine("Intervalo= {0}",diferencia );
}
}
}

practica 2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class VentasTotalesMiniSuper
{
//Declaracion
double[] VentasTotales;
int i, mayIndice, menIndice;
double mayorVenta, menorVenta;
public VentasTotalesMiniSuper()
{
VentasTotales = new double[7];
}
public void asignarDato(int j, double dato)
{
VentasTotales[j]= dato;
}
public double obtenerDato(int j)
{
return VentasTotales[j];
}
public int ventaMayor()
{
mayorVenta = VentasTotales[0];
mayIndice = 0;
for (i = 1; i < 7; i = i + 1)
{
if (VentasTotales[i] > mayorVenta)
{
mayorVenta = VentasTotales[i];
mayIndice = i;
}
}
return mayIndice;
}
public int ventaMenor()
{
menorVenta = VentasTotales[0];
menIndice = 0;
for (i = 1; i < 7; i++)
{
if (VentasTotales[i] < menorVenta)
{
menorVenta = VentasTotales[i];
menIndice = i;
}
}
return menIndice;
}
public double intervalo()
{
return mayorVenta - menorVenta;
}

}
}

Practica 2

using System;
using System.Collections.Generic;
using System.Text;
namespace Aplicacion_de_Ventas_Semanal
{
class VentasTotalesMiniSuper
{
double[] VentasTotales;
int i, mayIndice, menIndice;
double mayorVenta, menorVenta;
public VentasTotalesMiniSuper()
{
VentasTotales = new double[7];
}
public void asignarDato(int j, double dato)
{
VentasTotales[j] = dato;
}
public double obtenerDato(int j)
{
return VentasTotales[j];
}
public int ventaMayor()
{
mayorVenta = VentasTotales[0];
mayIndice = 0;
for (i = 1; i < 7; i = i + 1)
{
if (VentasTotales[i] > mayorVenta)
{
mayorVenta = VentasTotales[i];
mayIndice = i;
}
}
return mayIndice;
}
public int ventaMenor()
{
menorVenta = VentasTotales[0];
menIndice = 0;
for (i = 1; i < 7; i++)
{
if (VentasTotales[i] < menorVenta)
{
menorVenta = VentasTotales[i];
menIndice = i;
}
}
return menIndice;
}
public double intervalo()
{
return mayorVenta - menorVenta;
}

}
}

practica3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Venta_de_15_productos
{
class VentasProductos
{
double[] pedidos;
int[] inventario;
int[] codigo;
string[] nombreProd;
double[] preciosProd;
int[] ventaTotalProd;
int[] ventaTotalProd1;
int i, NoPedidos;
double promedio;
public VentasProductos()
{
inventario = new int[15] { 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
codigo = new int[15] { 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, 13, 14 };
nombreProd = new string[15] { "xbox", "xbox 360", "play Station 3", "Pay Station 2", "Nintendo Wii", "Nintendo 64", "Mario Kart 64", "LapTopHp", "WOW III", "LapTopDell", "Super Smash Bros.", "super Smash Bros. Brawl", "Lap Top Hp", "Lap Top Dell", "God of War" };
preciosProd = new double[15] { 1500.00, 3250.70, 8899.95, 1750.64, 4950.45, 789.99, 320.00, 220.99, 320.50, 1199.99, 459.99, 789.98, 1499.90, 1789.95, 1200.43 };
ventaTotalProd = new int[15];
ventaTotalProd1 = new int[15];
pedidos = new double[15];
i = NoPedidos = 0;
}
public double mostrarpreciopedidos(int k)
{
return pedidos[k];
}
public void asignarpedidodinero(int k, double l)
{
pedidos[k] = pedidos[k] + l;
}
public string obtenerNombreProd(int j)
{
return nombreProd[j];
}
public int obtenerCodigo(int j)
{
return codigo[j];
}
public double obtenerPreciosProd(int j)
{
return preciosProd[j];
}
public void asignarVentaTotalProd(int j, int dato)
{
ventaTotalProd[j] = ventaTotalProd[j] + dato;
ventaTotalProd1[j] = ventaTotalProd1[j] + dato;
}
public void incrementaPedido()
{
NoPedidos++;
}
public int obtenerPedido()
{
return NoPedidos;
}
public double precioTotal(int k)
{
double precio;
precio = ventaTotalProd1[k] * preciosProd[k];
return precio;
}
public void cero(int k)
{
ventaTotalProd1[k] = 0;
}
public double ventaTotalPedidos()
{
double suma = 0.0;
for (i = 0; i < suma =" suma" total =" inventario[j];" suma =" 0.0;" i =" 0;" suma =" suma" promedio =" (suma" mayproduct =" ventaTotalProd[0];" mayindice =" 0;" i =" 1;"> mayproduct)
{
mayproduct = ventaTotalProd[i];
mayIndice = i;
}
}
nombre = nombreProd[mayIndice];
return nombre;
}
public string productoMenosVendido()
{
string nombre;
double mayproduct;
int mayIndice;
mayproduct = ventaTotalProd[0];
mayIndice = 0;
for (i = 1; i < mayproduct =" ventaTotalProd[i];" mayindice =" i;" nombre =" nombreProd[mayIndice];" desviacion =" ventaTotalProd[k]" mayproduct =" pedidos[0];" mayindice =" 0;" i =" 1;"> mayproduct)
{
mayproduct = pedidos[i];
mayIndice = i;
}
}
return mayIndice + 1;
}
}
}

Practica11

using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication2
{
class empleado
{
string nombre;
double horas;
int no_empleado;
float tasa;
public empleado(string name,int no, double hrs, float tas)
{
nombre = name;
horas = hrs;
no_empleado = no;
tasa = tas;
}
public empleado()
{
nombre = "";
horas = 0.0;
no_empleado = 0;
tasa = 0.0f;
}

public string obtenernombre()
{
return nombre;
}
public double obtenerhoras()
{
return horas;
}
public int obtenernumero()
{
return no_empleado;
}
public float obtenertasa()
{
return tasa;
}
public void eliminarempleado()
{
nombre = "";
horas = 0.0;
no_empleado = 0;
tasa = 0.0f;
}
}
}

Practica 10

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
class cuenta_ahorros
{
static double tasainteresanual = 0.03;
double saldoahorro;

public void ultimointeresmensual()
{
double interesmensual = saldoahorro * tasainteresanual / 12;
saldoahorro = saldoahorro + interesmensual;
}

public static void modificatasainteres(double nuevovalor)
{
tasainteresanual=nuevovalor;

}


public void asignarsaldo(double saldo)
{
saldoahorro=saldo;
}

public double obtenersaldo()

{
return saldoahorro;
}
public double ssaldoahorro
{
get { return saldoahorro; }
set { saldoahorro = value; }
}
}
}

Practica 8

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PracticaEstudiante
{
class Estudiante
{
int idEstudiante;
double[] Calificaciones;
int numCalificaciones;
public Estudiante()
{
idEstudiante = 0;
Calificaciones = new double[5];
numCalificaciones = 0;
}
public void introduceID(int id)
{
idEstudiante = id;
}
public void introduceCalificacion(double calif, int j)
{
Calificaciones[j] = calif;
if (Calificaciones[j] > 0)
{
numCalificaciones++;
}
}
public int obtenerID()
{
return idEstudiante;
}
public double desplegarPromedio()
{
double sumacalif = 0.00;
for (int i = 0; i < 5; i++)
{
sumacalif = sumacalif + Calificaciones[i];
}
return (sumacalif / numCalificaciones);
}

}
}

Practica 7

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Empleado
{
int[] Num_Empleado;
string[] Nom_Empleado;
int[] Ciudad;
string[] Ciudades;
int i;
public void Empleados(int j)
{
Num_Empleado = new int[j];
Nom_Empleado = new string[j];
Ciudad = new int[j];
Ciudades = new string[5] { "Cancun", "Distrito Federeal", "Puebla", "Oaxaca", "Michoacan" };
}
public void AsignarDato(int j, int cd, int NumE, string nom)
{
Num_Empleado[j] = NumE;
Ciudad[j] = cd;
Nom_Empleado[j] = nom;
}
public string ObtenerNombre(int j)
{
return Nom_Empleado[j];
}
public int ObtenerCiudad(int j)
{
return Ciudad[j];
}
public int ObtenerNumEmpleado(int j)
{
return Num_Empleado[j];
}
public string ObtenerNomCiudad(int j)
{
return Ciudades[j];
}
}
}

practica 5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Varianza
{
class Program
{
static void Main(string[] args)
{
int i, Num;
float N, Ac1 = 0;
double Prom, Ac2 = 0.0, Varianza, Y;
Console.Write("\n\n Numeros para La Varianza ");
Num = int.Parse(Console.ReadLine());
Console.WriteLine("\n ");
Arreglo X1 = new Arreglo();
X1.CrearVector(Num);
for (i = 0; i < Num; i++)
{
Console.Write("\n El Valor " + (i + 1) + " ");
N = Single.Parse(Console.ReadLine());
X1.AsignarDato(i, N);
Ac1 = Ac1 + N;
}
Prom = Ac1 / Num;
for (i = 0; i < Num; i++)
{
Y = X1.ObtenerDato(i) - Prom;
Ac2 = Ac2 + (Math.Pow(Y, 2));
}
Varianza = Ac2 / (Num - 1);
Console.WriteLine("\n\n La Varianza de " + Num + " Numeros es igual a : " + Varianza);
Console.ReadLine();
}
}
}

Practica 4

class Program
{
static void Main(string[] args)
{
arreglo corriente = new arreglo();
arreglo resistencia = new arreglo();
arreglo voltios = new arreglo();
int i;
double nuevodato, dato;
Console.WriteLine("Introduzca Los Siguientes Datos: ");
for (i = 0; i < 10; i++)
{
Console.Clear();
Console.WriteLine("Corriente [{0}]:",i+1);
nuevodato = double.Parse(Console.ReadLine());
corriente.asignardato(i,nuevodato);
}
for (i = 0; i < 10; i++)
{
Console.Clear();
Console.WriteLine("Resistencia [{0}]:", i + 1);
resistencia.asignardato(i, double.Parse(Console.ReadLine()));
}
Console.WriteLine(" CORRIENTE RESISTENCIA VOLTS");
for (i = 0; i < 10; i++)
{
nuevodato = corriente.obtenerdato(i);
dato = resistencia.obtenerdato(i);
voltios.asignardato(i, nuevodato * dato);

Console.WriteLine(" ( {0} ) ( {1} ) ( {2} )", corriente.obtenerdato(i), resistencia.obtenerdato(i), voltios.obtenerdato(i));
}
Console.ReadLine();

}
}
}

Practica 6

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ventas_anuales
{
class Program
{
static void Main(string[] args)
{
Arreglo va = new Arreglo(12);
int mes;
double mon;
char resp;
do
{
Console.WriteLine("Introduzca el numero del mes");
mes = int.Parse(Console.ReadLine());
Console.WriteLine("Introduzca el monto de venta");
mon = double.Parse(Console.ReadLine());

va.suma(mes, mon);
Console.WriteLine("Desea introducir otra cantidad?");
resp = char.Parse(Console.ReadLine());
}
while (resp == 's' || resp == 'S');
Console.WriteLine("Ventas del año");
for (int i = 0; i < 12; i++)
{
Console.WriteLine("Mes {0}-----Venta de {1}", i + 1, va.obtener(i));
}
Console.WriteLine("La venta total del año fue de {0}", va.sumatotal());
Console.ReadLine();
}
}
}

ventas semanales

Ventas Totales mini super

Practica 1 en visual

















using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace WindowsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void cmdcaptura_Click(object sender, EventArgs e)
{
float[] calif = new float[10];
float P, Suma = 0;
int R = 0;

frmSegunda FormaCaptura = new frmSegunda();
cmdcaptura.Enabled = false;

for (R = 0; R < 10; R++)
{
if (FormaCaptura.ShowDialog() == DialogResult.OK)
{

calif[R] = System.Single.Parse(FormaCaptura.txtcalif.Text);
}

Suma = Suma + calif[R];
}
P = Suma / 10;

txtPg.Text = P.ToString();

for (R = 0; R < 10; R++)
{

if (P <= calif[R])
{
txtcalifi.Text = txtcalifi.Text + calif[R] + "\r\n".ToString();
}
}
}

private void cmdOtro_Click(object sender, EventArgs e)
{
txtcalifi.Clear();
txtPg.Clear();
cmdcaptura.Enabled = true;
}

private void cmdsalida_Click(object sender, EventArgs e)
{
Close();
}
}
}

Practica 1

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
double[] elemento;
int I;
int N;
Console.Write("Introdusca numero de datos:");
N = int.Parse(Console.ReadLine());
elemento = new double[N];
for(I=0;I promedio)
{
Console.WriteLine(elemento[I]);
}
}
Console.ReadLine();


}
}
}

Arreglos Unidimensionales y Multidimensionales

Un arreglo unidimensional es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.

Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.

REPRESENTACION EN MEMORIA

Los arreglos se representan en memoria de la forma siguiente:

Los arreglos multidimensionales tienen más de una dimensión. En C#, las dimensiones se manejan por medio de un par de corchetes, dentro de los que se escriben los valores de cada dimensión, separados por comas.

---

Operaciones.

Para manejar un arreglo, las operaciones a efectuarse son:

• Declaración del arreglo,
• Creación del arreglo,
• Inicialización de de los elementos del arreglo, y
• Acceso a los elementos del arreglo.

A continuación describiremos cada una de estas operaciones, en C#.

Declaración.

La sintaxis para declarar un arreglo multidimensional es la siguiente:

<tipo> [ , ...] < identificador > ;

Donde:

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

el par de corchetes, la coma y las diéresis, [ , ...], representan las dimensiones del arreglo. Los corchetes encierran todas las comas necesarias para separar las dimensiones del arreglo.

Ejemplos:

double [ , ] bidim; // Dos dimensiones.

int [ , , ] tridim ; // Tres dimensiones.

char [ , , , ] enciclopedia; // Cuatro dimensiones.

Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.

Creación.

La creación de un arreglo multidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ... dimN ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

dim1 , dim2 , dimN son valores enteros que representan las dimensiones del arreglo.

El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.

Ejemplos:

bidim = new double [2, 3] ;

tridim = new int[ 2, 3, 4] ;

enciclopedia = new char[30, 80, 500, 10] ;

Las operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:

double [ , ] bidim = new double [2,3] ;

int [ , , ] tridim = new int[2, 3, 4] ;

char [ , , , ] enciclopedia = new char[ 30, 80, 500, 10 ] ;

Inicialización.

Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:

• Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
• Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
• Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
• Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:

int [ , , ] tridim={{{12, 59, 70, 45} , {20, 16, 29, 48} , {93, 75, 43, 10}},

{{44, 72, 30, 24} , {60, 89, 39, 61} , {99, 52, 34, 47}}};

Acceso.

Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.

---

Aplicaciones.

Se necesita manejar, en un arreglo, la posición todos los caracteres escritos en una enciclopedia. El arreglo deberá tener las siguientes dimensiones:

• Una para manejar el renglón en la página,
• otra para la columna en la página,
• otra para la hoja en el volumen y
• otra para el volumen en la enciclopedia.

Cada página tiene 30 renglones y 80 columnas.
Cada volumen tiene 500 páginas.
La enciclopedia tiene 18 volúmenes.

El siguiente fragmento de programa implementa la solución a este problema.

char car;

// Declara y crea el arreglo.

char[ , , , ] enciclopedia = new char [18,500,30,80] ;

// Lee, desde el teclado, cada carácter para la enciclopedia.

for(int v = 0 ; v < class="Estilo32">// Volumen

for(int p = 0 ; p < class="Estilo32">// Página

for(int r = 0 ; r < class="Estilo32">// Renglón

for(int c = 0 ; c < class="Estilo32">// Columna

{

car = (char)Console.Read( ) ;
enciclopedia[v,p,r,c] = car ;

}