Regularización unidad 2

Pseudocodigo

1. inicio

total=0 double

peso double

limite double

Print "Introduce el limite de pesca: ", limite

do

{Print"Introduce el peso de la presa: ", peso

total=total+peso

Print "Total de kilos hasta el momento: ", total

}

while (total

Print "Limite excedido"

Fin

Código

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace joe_regu_2

{

class Program

{

static void Main(string[] args)

{

double total=0,peso;

double limite;

Console.Write("Introduce el limite de pesca: ");

limite = double.Parse(Console.ReadLine());

do

{

Console.WriteLine("\nIntroduce el peso cada presa: ");

peso = double.Parse(Console.ReadLine());

total = total + peso;

Console.Write("Total de kilos hasta el momento: {0}",total);

}

while(total

Console.Write("\nLimite excedido!!!");

Console.ReadKey();

}

}

}

practica 12 problema 2

Binary Writer

namespace Practica12problema2consola
{
class Program
{
static void Main(string[] args)
{
BinaryWriter bw = null;

try
{
bw=new BinaryWriter(new FileStream("c:\\PROM.txt",FileMode.Create,FileAccess.Write));
int N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, N11, N12, N13, N14, N15, N16, N17, N18, N19, N20;


Console.WriteLine("Introduce el N1:");
N1=int.Parse(Console.ReadLine());
bw.Write(N1);
Console.WriteLine("Introduce el N2:");
N2 = int.Parse(Console.ReadLine());
bw.Write(N2);
Console.WriteLine("Introduce el N3:");
N3 = int.Parse(Console.ReadLine());
bw.Write(N3);
Console.WriteLine("Introduce el N4:");
N4 = int.Parse(Console.ReadLine());
bw.Write(N4);
Console.WriteLine("Introduce el N5:");
N5 = int.Parse(Console.ReadLine());
bw.Write(N5);
Console.WriteLine("Introduce el N6:");
N6 = int.Parse(Console.ReadLine());
bw.Write(N6);
Console.WriteLine("Introduce el N7:");
N7 = int.Parse(Console.ReadLine());
bw.Write(N7);
Console.WriteLine("Introduce el N8:");
N8 = int.Parse(Console.ReadLine());
bw.Write(N8);
Console.WriteLine("Introduce el N9:");
N9 = int.Parse(Console.ReadLine());
bw.Write(N9);
Console.WriteLine("Introduce el N10:");
N10 = int.Parse(Console.ReadLine());
bw.Write(N10);
Console.WriteLine("Introduce el N11:");
N11 = int.Parse(Console.ReadLine());
bw.Write(N11);
Console.WriteLine("Introduce el N12:");
N12 = int.Parse(Console.ReadLine());
bw.Write(N12);
Console.WriteLine("Introduce el N13:");
N13 = int.Parse(Console.ReadLine());
bw.Write(N13);
Console.WriteLine("Introduce el N14:");
N14 = int.Parse(Console.ReadLine());
bw.Write(N14);
Console.WriteLine("Introduce el N15:");
N15 = int.Parse(Console.ReadLine());
bw.Write(N15);
Console.WriteLine("Introduce el N16:");
N16 = int.Parse(Console.ReadLine());
bw.Write(N16);
Console.WriteLine("Introduce el N17:");
N17 = int.Parse(Console.ReadLine());
bw.Write(N17);
Console.WriteLine("Introduce el N18:");
N18 = int.Parse(Console.ReadLine());
bw.Write(N18);
Console.WriteLine("Introduce el N19:");
N19 = int.Parse(Console.ReadLine());
bw.Write(N19);
Console.WriteLine("Introduce el N20:");
N20 = int.Parse(Console.ReadLine());
bw.Write(N20);



}
catch(IOException e)
{
Console.WriteLine("Error:"+e.Message);
}

finally
{
if(bw !=null) bw.Close();
}
Console.ReadLine();


}
}
}

Binary Reader

namespace Practica12problema2consola
{
class Program
{
static void Main(string[] args)
{
BinaryWriter bw = null;

try
{
bw=new BinaryWriter(new FileStream("c:\\PROM.txt",FileMode.Create,FileAccess.Write));
int N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, N11, N12, N13, N14, N15, N16, N17, N18, N19, N20;


Console.WriteLine("Introduce el N1:");
N1=int.Parse(Console.ReadLine());
bw.Write(N1);
Console.WriteLine("Introduce el N2:");
N2 = int.Parse(Console.ReadLine());
bw.Write(N2);
Console.WriteLine("Introduce el N3:");
N3 = int.Parse(Console.ReadLine());
bw.Write(N3);
Console.WriteLine("Introduce el N4:");
N4 = int.Parse(Console.ReadLine());
bw.Write(N4);
Console.WriteLine("Introduce el N5:");
N5 = int.Parse(Console.ReadLine());
bw.Write(N5);
Console.WriteLine("Introduce el N6:");
N6 = int.Parse(Console.ReadLine());
bw.Write(N6);
Console.WriteLine("Introduce el N7:");
N7 = int.Parse(Console.ReadLine());
bw.Write(N7);
Console.WriteLine("Introduce el N8:");
N8 = int.Parse(Console.ReadLine());
bw.Write(N8);
Console.WriteLine("Introduce el N9:");
N9 = int.Parse(Console.ReadLine());
bw.Write(N9);
Console.WriteLine("Introduce el N10:");
N10 = int.Parse(Console.ReadLine());
bw.Write(N10);
Console.WriteLine("Introduce el N11:");
N11 = int.Parse(Console.ReadLine());
bw.Write(N11);
Console.WriteLine("Introduce el N12:");
N12 = int.Parse(Console.ReadLine());
bw.Write(N12);
Console.WriteLine("Introduce el N13:");
N13 = int.Parse(Console.ReadLine());
bw.Write(N13);
Console.WriteLine("Introduce el N14:");
N14 = int.Parse(Console.ReadLine());
bw.Write(N14);
Console.WriteLine("Introduce el N15:");
N15 = int.Parse(Console.ReadLine());
bw.Write(N15);
Console.WriteLine("Introduce el N16:");
N16 = int.Parse(Console.ReadLine());
bw.Write(N16);
Console.WriteLine("Introduce el N17:");
N17 = int.Parse(Console.ReadLine());
bw.Write(N17);
Console.WriteLine("Introduce el N18:");
N18 = int.Parse(Console.ReadLine());
bw.Write(N18);
Console.WriteLine("Introduce el N19:");
N19 = int.Parse(Console.ReadLine());
bw.Write(N19);
Console.WriteLine("Introduce el N20:");
N20 = int.Parse(Console.ReadLine());
bw.Write(N20);



}
catch(IOException e)
{
Console.WriteLine("Error:"+e.Message);
}

finally
{
if(bw !=null) bw.Close();
}
Console.ReadLine();


}
}
}

practica 12 problema 1

Binary Writer

class Program
{
static void Main(string[] args)
{
double x1,y1,x2,y2,x3,y3,x4,y4,x5,y5,x6,y6;


FileStream f1 = new FileStream("c:\\Puntos.txt", FileMode.Create, FileAccess.Write);
BinaryWriter bw = new BinaryWriter(f1);

Console.WriteLine("Introduce Coordenadas Punto 1");
Console.Write("x1= ");
x1 = double.Parse(Console.ReadLine());

Console.Write("y1= ");
y1 = double.Parse(Console.ReadLine());

Console.WriteLine("Introduce Coordenadas Punto 2");
Console.Write("x2= ");
x2 = double.Parse(Console.ReadLine());

Console.Write("y2= ");
y2 = double.Parse(Console.ReadLine());


bw.Write(x1);
bw.Write(y1);
bw.Write(x2);
bw.Write(y2);

Console.WriteLine("Introduce Coordenadas Punto 3");
Console.Write("x3= ");
x3 = double.Parse(Console.ReadLine());

Console.Write("y3= ");
y3 = double.Parse(Console.ReadLine());

Console.WriteLine("Introduce Coordenadas Punto 4");
Console.Write("x4= ");
x4 = double.Parse(Console.ReadLine());

Console.Write("y4= ");
y4 = double.Parse(Console.ReadLine());

bw.Write(x3);
bw.Write(y3);
bw.Write(x4);
bw.Write(y4);

Console.WriteLine("Introduce Coordenadas Punto 5");
Console.Write("x5= ");
x5 = double.Parse(Console.ReadLine());

Console.Write("y5= ");
y5 = double.Parse(Console.ReadLine());

Console.WriteLine("Introduce Coordenadas Punto 6");
Console.Write("x6= ");
x6 = double.Parse(Console.ReadLine());

Console.Write("y6= ");
y6 = double.Parse(Console.ReadLine());

bw.Write(x5);
bw.Write(y5);
bw.Write(x6);
bw.Write(y6);



Console.ReadKey();


}
}
}


Binary Reader

class Program
{
static void Main(string[] args)
{
BinaryReader br = null;
try
{
if (File.Exists("c:\\puntos.txt"))
{
br = new BinaryReader(new FileStream("c:\\puntos.txt", FileMode.Open, FileAccess.Read));
double x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6;
double pendiente1, pendiente2, pendiente3;
double pmX1, pmX2, pmX3;
double pmY1, pmY2, pmY3;


x1 = br.ReadDouble();
y1 = br.ReadDouble();
x2 = br.ReadDouble();
y2 = br.ReadDouble();
x3 = br.ReadDouble();
y3 = br.ReadDouble();
x4 = br.ReadDouble();
y4 = br.ReadDouble();
x5 = br.ReadDouble();
y5 = br.ReadDouble();
x6 = br.ReadDouble();
y6 = br.ReadDouble();



Console.WriteLine("Coordenadas punto1:{0}\t{1}", x1, y1);
Console.WriteLine("Coordenadas punto2:{0}\t{1}", x2, y2);
Console.WriteLine("Coordenadas punto3:{0}\t{1}", x3, y3);
Console.WriteLine("Coordenadas punto4:{0}\t{1}", x4, y4);
Console.WriteLine("Coordenadas punto5:{0}\t{1}", x5, y5);
Console.WriteLine("Coordenadas punto6:{0}\t{1}", x6, y6);
Console.WriteLine("Puntos 1 y 2");
pendiente1 = (y2 - y1) / (x2 - x1);
pmX1 = (x1 + x2) / 2;
pmY1 = (y1 + y2) / 2;

Console.WriteLine("pendiente1: " +pendiente1);

Console.WriteLine("Punto medio X: " +pmX1);

Console.WriteLine("Punto medio Y: " + pmY1);

Console.WriteLine("Puntos 3 y 4");
pendiente2 = (y4 - y3) / (x4 - x3);
pmX2 = (x3 + x4) / 2;
pmY2 = (y3 + y4) / 2;

Console.WriteLine("pendiente2: " + pendiente2);

Console.WriteLine("Punto medio X: " + pmX2);

Console.WriteLine("Punto medio Y: " + pmY2);

Console.WriteLine("Puntos 5 y 6");
pendiente3 = (y6 - y5) / (x6 - x5);
pmX3 = (x5 + x6) / 2;
pmY3 = (y6 + y5) / 2;

Console.WriteLine("pendiente3: " + pendiente3);

Console.WriteLine("Punto medio X: " + pmX3);

Console.WriteLine("Punto medio Y: " + pmY3);


Console.ReadKey();




}
else
Console.WriteLine("no existe archivo");
}
catch (EndOfStreamException)
{
Console.WriteLine("fin de archivo ");
}
finally
{
if (br != null) br.Close();
}

Console.ReadKey();
}
}
}

Archivos de texto

1.¿Que es un archivo de texto?

Un archivo de texto es una secuencia de
caracteres organizadas en líneas terminadas por un carácter de nueva línea. En estos archivos se pueden
almacenar canciones, fuentes de programas, base de datos simples, etc. Los archivos de texto se caracterizan por
ser planos, es decir, todas las letras tienen el mismo formato y no hay palabras subrayadas, en negrita, o letras de
distinto tamaño o ancho.

2.¿Como se almacenan datos en un archivo texto?

Se logra mediante la clase Stream que representa un flujo de información (Un archivo es considerado un flujo de datos, al igual que los datos transferidos de un dispositivo a otro, o los datos transferidos por la red mediante TCP/IP).
La clase Stream, es una clase abstracta, por lo que no es posible utilizarla directamente ya que no se puede crear instancias. Lo que se debe hacer es utilizar una de sus clases derivadas que se especializan en el tratamiento de streams para diferentes destinos como por ejemplo FileStream (para el manejo de archivos), Memorystream (para el manejo de datos en memoria), etc.
El FileStream actúa como un intermediario entre el sistema de archivos y nuestra aplicación, permitiendo realizar de una manera limpia y sencilla operaciones de escritura y lectura en archivos. Para utilizar el FileStream, lo primero que se debe hacer es crear una instancia que apunte al archivo deseado. Para esto se tiene la opción de utilizar alguno de los constructores ofrecidos.

3. ¿Que tipo de clases utiliza, como se hace la lectura de datos almacenados en un archivo de texto?

Al igual que prácticamente todos los lenguajes de programación, C# ofrece el acceso a leer y escribir
archivos en disco, por medio de estructuras especialmente definidas que consisten en clases de características y métodos particulares, que resuelven la
problemática general de acceso a los archivos, permitiendo desarrollar programas que los utilicen como fuente de información y medio de almacenamiento de información de largo plazo.
Las clases más relacionadas con la escritura y lectura de archivos son:
- FileStream, cuyo propósito es lectura y escritura de datos binarios (no de texto legible), a cualquier
archivo de tipo binario, aunque se puede utilizar para acceder a cualquier tipo de archivo, inclusive los de texto.
- StreamReader y StreamWriter, las cuales están diseñadas para lectura y escritura de archivos de texto. Estas clases se asumen como de un nivel más alto que FileStream.
string rutaarchivo = @”C:\Temp\archivo.txt”;
StreamReader sr = new StreamReader(@”C:\Temp\archivo.txt”);
StreamReader sr = new StreamReader(@”C:\Temp\file.txt”, Encoding.UTF8Encoding);

4.¿Como se especifica una nota para localizar un archivo?

Las clases más relacionadas con la escritura y lectura de archivos (File Input/Output o File I/O) son:
*FileStream, cuyo propósito es lectura y escritura de datos binarios (no de texto legible), a cualquier archivo de tipo binario, aunque se puede utilizar para acceder a cualquier tipo de archivo, inclusive los de texto.
*StreamReader y StreamWriter, las cuales están diseñadas para lectura y escritura de archivos de texto. Estas clases se asumen como de un nivel más alto que FileStream.
Una observación acerca de la declaración de nombres/rutas de archivos en C#. Usualmente, la ruta de un archivo contiene el carácter ‘\’, que en C# se utiliza como caracter de control para símbolos especiales (como el cambio de línea: ‘\n’). Sin embargo, entendiendo que no es el mismo sentido el que se le quiere dar en la interpretación de rutas de archivos (por ej: “C:\Mis documentos\Programas\ejemplo.cs”), se utiliza una sintaxis particular, anteponiendo el símbolo ‘@’ antes del string con la ruta del archivo. Es decir:
string rutaarchivo = @”C:\Temp\archivo.txt”;
Esta declaración evita la interpretación de los dos caracteres ‘\’ como símbolos especiales y el string queda correctamente inicializado

practica11problema2 consola y visual

PSEUDOCODIGO

1.- Experimentos [4,7] double
R=0, C=0 int
Suma=0.0 double
For(R=0 to 3 step R=R+1)
{
Suma=0
Print "Introduce los ensayes del experimento ",(R+1)
For(C=0 to 5 step C=C+1)

{
Print "Ensaye", (C+1)
Read Experimentos [R,C]
Suma=Suma+Experimentos[R,C]

}
Experimentos [R,6]=Suma/6
}
Print "Reporte de Experimentos"
Print"Experimento R1 R2 R3 R4 R5 R6"
For(R=0 to 3 step R=R+1)
{
For(C=0 to 6 step C=C+1)
{Print R, Experimentos [R,C]}
}

CONSOLA

class Program
{
static void Main(string[] args)
{
double[,] experimentos = new double[4, 7];
int r = 0, c = 0;
double Suma;
for (r = 0; r < 4; r++)
{
Suma = 0;
Console.WriteLine("Introduce los ensayes del experimento: {0}", r + 1);
for (c = 0; c < 6; c++)
{
Console.WriteLine("ensaye {0}", c + 1);
experimentos [r,c]=double.Parse(Console.ReadLine());
Suma = Suma + experimentos[r, c];
}
experimentos[r, 6] = Suma / 6;
}
Console.WriteLine("\n EL REPORTE DE EXPERIMENTOS ");
Console.WriteLine("\nNo.Exp\tr1\tr2\tr3\tr4\tr5\tr6\tpromedio");
for (r = 0; r < 4; r++)
{
Console.WriteLine("");
Console.Write("{0}", r + 1);
for (c = 0; c < 7; c++)
{
Console.Write("\t{0}",experimentos[r, c]);
}
}
Console.ReadKey();
}
}
}


VISUAL


public partial class Form1 : Form
{
double[,] Experimentos = new double[4, 7];
int R,C;
double suma;
public Form1()
{
InitializeComponent();
R=0;
C = 0;
suma = 0;

}

private void button1_Click(object sender, EventArgs e)
{


if (R < 4)
{
if (C < 7)
{
Experimentos[R, C] = double.Parse(textBox1.Text);
label2.Text = "Experimentos [" + R.ToString() + "," + C.ToString() + "]:" + Experimentos[R, C].ToString();
suma = suma + Experimentos[R, C];
C ++;
textBox1.Clear();
textBox1.Focus();

}
else
{
R++;
C = 0;
Experimentos[R, 6] = suma / 6;

}

}
else
{
button1.Enabled = false;
textBox1.Enabled = false;
}

}




private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Add("\n EL REPORTE DE EXPERIMENTOS ");
listBox1.Items.Add("\nNo.Exp\tR1\tR2\tR3\tR4\tR5\tR6\tPromedio");





listBox1.Items.Add("\t" + Experimentos[0, 0] + "\t" + Experimentos[0, 1] + "\t" + Experimentos[0, 2] + "\t" + Experimentos[0, 3] + "\t" + Experimentos[0, 4] + "\t" + Experimentos[0, 5] + "\t" + Experimentos[0, 6]);
listBox1.Items.Add("\t" + Experimentos[1, 0] + "\t" + Experimentos[1, 1] + "\t" + Experimentos[1, 2] + "\t" + Experimentos[1, 3] + "\t" + Experimentos[1, 4] + "\t" + Experimentos[1, 5] + "\t" + Experimentos[1, 6]);
listBox1.Items.Add("\t" + Experimentos[2, 0] + "\t" + Experimentos[2, 1] + "\t" + Experimentos[2, 2] + "\t" + Experimentos[2, 3] + "\t" + Experimentos[2, 4] + "\t" + Experimentos[2, 5] + "\t" + Experimentos[2, 6]);
listBox1.Items.Add("\t" + Experimentos[3, 0] + "\t" + Experimentos[3, 1] + "\t" + Experimentos[3, 2] + "\t" + Experimentos[3, 3] + "\t" + Experimentos[3, 4] + "\t" + Experimentos[3, 5] + "\t" + Experimentos[3, 6]);



}

private void button3_Click(object sender, EventArgs e)
{
textBox1.Focus();
textBox1.Clear();
listBox1.Items.Clear();
button1.Enabled = true;
textBox1.Enabled = true;
}

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

private void Form1_Load(object sender, EventArgs e)
{

}
}
}

practica 11 problema 1 consola y visual

PSEUDOCODIGO

REAL[,] voltajes=new double[3,5];
REAL c1 =0,c2=0,c3=0,c4=0,c5=0;
for (r = 0 TO 3 r=r+1)
{
for (c = 0 TO 5; c= c+1)
{
PRINT "Voltajes [{0},{1}] : ", r, c
READ voltajes[r, c]
}
}
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] < 60)
{
c1 = c1 + 1;
}

}
}
PRINT("numero de voltajes<60 {0}", c1);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{

if (voltajes[r, c] >= 60 && voltajes[r, c] < 70)
{
c2 = c2 + 1;
}

}
}
PRINT("numero de voltajes>=60 & <70 {0}", c2);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 70 && voltajes[r, c] < 80)
{
c3 = c3 + 1;
}

}
}
PRINT("numero de voltajes>=70 & <80 {0}", c3);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 80 && voltajes[r, c] < 90)
{
c4 = c4 + 1;
}

}
}
PRINT("numero de voltajes>=80 & <90 {0}", c4);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 90)
{
c5 = c5 + 1;
}

}
}
PRINT("numero de voltajes>=90 {0}", c5);.
FIN

CONSOLA

class Program
{
static void Main(string[] args)
{
double[,] voltajes = new double[3, 5];
int c1 = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0;
int r, c;
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
Console.Write("voltajes[{0},{1}]", r, c);
voltajes[r, c] = double.Parse(Console.ReadLine());
}
}
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] < 60)
{
c1 = c1 + 1;
}

}
}
Console.WriteLine("numero de voltajes<60 {0}", c1);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{

if (voltajes[r, c] >= 60 && voltajes[r, c] < 70)
{
c2 = c2 + 1;
}

}
}
Console.WriteLine("numero de voltajes>=60 & <70 {0}", c2);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 70 && voltajes[r, c] < 80)
{
c3 = c3 + 1;
}

}
}
Console.WriteLine("numero de voltajes>=70 & <80 {0}", c3);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 80 && voltajes[r, c] < 90)
{
c4 = c4 + 1;
}

}
}
Console.WriteLine("numero de voltajes>=80 & <90 {0}", c4);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 90)
{
c5 = c5 + 1;
}

}
}
Console.WriteLine("numero de voltajes>=90 {0}", c5);


Console.ReadKey();

}
}
}


VISUAL


public partial class Form1 : Form
{
double[,] voltajes = new double[3, 5];
int c1, c2, c3, c4, c5;
int r, c;
public Form1()
{
InitializeComponent();
c1 = c2 = c3 = c4 = c5 = 0;
}

private void Form1_Load(object sender, EventArgs e)
{

}

private void button1_Click(object sender, EventArgs e)
{
{
if (r < 3)
{
if (c < 5)
{
voltajes[r, c] = double.Parse(textBox1.Text);
listBox1.Items.Add("Voltaje[" + r.ToString() + "," + c.ToString() + "]:" + voltajes[r, c].ToString());
c++;
textBox1.Clear();
textBox1.Focus();
}
else
{
r++;
c = 0;

}
}


}

}

private void textBox1_TextChanged(object sender, EventArgs e)
{

}

private void button2_Click(object sender, EventArgs e)
{
{
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] < 60)
{
c1 = c1 + 1;
}
}
}
MessageBox.Show("Voltajes < 60 : " + c1);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 60 && voltajes[r, c] < 70)
{
c2 = c2 + 1;
}
}
}
MessageBox.Show("Voltajes >= 60 & < 70 : " + c2);

for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 70 && voltajes[r, c] < 80)
{
c3 = c3 + 1;
}
}
}
MessageBox.Show("Voltajes >= 70 & < 80 : " + c3);

for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 80 && voltajes[r, c] < 90)
{
c4 = c4 + 1;
}
}
}
MessageBox.Show("Voltajes >= 80 & < 90: " + c4);
for (r = 0; r < 3; r++)
{
for (c = 0; c < 5; c++)
{
if (voltajes[r, c] >= 90)
{
c5 = c5 + 1;
}
}
}
MessageBox.Show("Voltajes >= 90 : " + c5);

}
}
private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
textBox1.Clear();

}

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

private void label2_Click(object sender, EventArgs e)
{

}
}
}

RECTANGULO

class RECTANGULO
{
double ancho;
double largo;
public RECTANGULO()
{
ancho = 0;
largo = 0;
}
public RECTANGULO(double w, double h)
{
ancho = w;
largo = h;
}
public double Area()
{
return ancho * largo;
}
public double Perimetro()
{
return 2 * (ancho + largo);
}
public void Asignarlargo(double h)
{
largo = h;
}
public void Asignarancho(double w)
{
ancho = w;
}
public double obtenerlargo()
{
return largo;
}
public double obtenerancho()
{
return ancho;
}


}
}

class Program
{
static void Main(string[] args)
{
RECTANGULO R1 = new RECTANGULO();
double h, w;
Console.Write("Introduce largo de un rectangulo:");
h = double.Parse(Console.ReadLine());
Console.Write("Introduce ancho de un rectangulo:");
w = double.Parse(Console.ReadLine());
R1.Asignarlargo(h);
R1.Asignarancho(w);
Console.WriteLine("area ={0}", R1.Area());
Console.WriteLine("Perimetro={0}", R1.Perimetro());

RECTANGULO R2 = new RECTANGULO(h, w);
Console.Write("Introduce largo de un rectangulo:");
h = double.Parse(Console.ReadLine());
Console.Write("Introduce ancho de un rectangulo:");
w = double.Parse(Console.ReadLine());
R2.Asignarlargo(h);
R2.Asignarancho(w);
Console.WriteLine("area ={0}", R2.Area());
Console.WriteLine("Perimetro={0}", R2.Perimetro());


RECTANGULO R3 = new RECTANGULO(h, w);
Console.Write("Introduce largo de un rectangulo:");
h = double.Parse(Console.ReadLine());
Console.Write("Introduce ancho de un rectangulo:");
w = double.Parse(Console.ReadLine());
R3.Asignarlargo(h);
R3.Asignarancho(w);
Console.WriteLine("area ={0}", R3.Area());
Console.WriteLine("Perimetro={0}", R3.Perimetro());
Console.ReadKey();
}
}
}

Metodos en C #

Los métodos son un bloque de código que contiene una serie de instrucciones. En C#, cada instrucción se ejecuta en el contexto de un método.

Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el valor devuelto, el nombre del método y los parámetros de método. Los parámetros de método se incluyen entre paréntesis y separados por comas. Los paréntesis vacíos indican que el método no requiere ningún parámetro. Esta clase contiene tres métodos:

class Motorcycle
{
public void StartEngine() { }
public void AddGas(int gallons) { }
public int Drive(int miles, int speed) { return 0; }
}


Todo método debe de ser parte de una clase, no existen métodos globales.
De forma predeterminada, los parámetros se pasan por valor.
El modificador ref fuerza a pasar los parámetros por referencia en vez de pasarlos por valor.
El modificador out es similar al modificador "ref" con una excepción: sólo se puede utilizar para pasar un valor fuera de un método. El método debe de asignar un valor al parámetro antes de que el método finalice.
Cuando "ref" y "out" modifican un parámetro de referencia, la propia referencia se pasa por referencia.
Un método debe tener como máximo un único parámetro params y éste debe de ser el último.
Un método puede devolver cualquier tipo de datos, incluyendo tipos de clase.
Ya que en C# las matrices se implementan como objetos, un método también puede devolver una matriz.
C# implementa sobrecarga de métodos, dos o más métodos pueden tener el mismo nombre siempre y cuando se diferencien por sus parámetros.

Valores devueltos

Los métodos pueden devolver un valor al llamador. Si el tipo de valor devuelto no es void, el método puede devolver el valor mediante la palabra clave return. Una instrucción con la palabra clave return, seguida de un valor que coincida con el tipo de valor devuelto, devolverá ese valor al llamador del método. La palabra clave return también detiene la ejecución del método. Si el tipo de valor devuelto es void, una instrucción return sin ningún valor sigue siendo útil para detener la ejecución del método. Sin la palabra clave return, el método detendrá la ejecución cuando llegue al fin del bloque de código. Es necesario que los métodos con un tipo de valor devuelto no nulo utilicen la palabra clave return para devolver un valor. Por ejemplo, estos dos métodos utilizan la palabra clave return para devolver enteros:

class SimpleMath
{
public int AddTwoNumbers(int number1, int number2)
{
return number1 + number2;
}

public int SquareANumber(int number)
{
return number * number;
}
}

EJEMPLO

class Program
{
static void Main(string[] args)
{
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];

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);
Console.ReadKey();
}
static public void OrdenarBurbuja(int[] b)
{
for (int pasadas = 1; pasadas < b.Length; pasadas++)
for (int i = 0; i < b.Length - 1; i++)
if (b[i] > b[i + 1])
intercambio(b, i);
}
static public void intercambio(int[] c, int primero)
{
int temp;
temp = c[primero];
c[primero] = c[primero + 1];
c[primero + 1] = temp;
}
}
}

Arreglos bidimensionales

Un arreglo bidimensional tiene dos dimensiones y es un caso particular de los arreglos multidimensionales. En C#, las dimensiones se manejan por medio de un par de corchetes, dentro de los que se escriben, separados por comas, los valores de las dos dimensiones.

Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:

[ , ] < identificador > ;

Donde:

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.

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.



CONSOLA


namespace practica11problema1
{
class Program
{
static void Main(string[] args)
{
int[,] num = { { 16, 22, 99, 4, 18 }, { -258, 4, 101, 5, 98 }, { 105, 6, 15, 2, 45 }, { 33, 88, 72, 16, 3 } };
int Mayor = num[0, 0];
int posR = 0, posC = 0, R, C;
for (R = 0; R < 4; R++)
{
for (C = 0; C < 5; C++)
{
if (num[R, C] > Mayor)
{
posR = R;
posC = C;
Mayor = num[R, C];
}
}
}
for (R = 0; R < 4; R++)
{
for (C = 0; C < 5; C++)
{
Console.Write("\t{0}", num[R, C]);
}
Console.WriteLine();
}
Console.WriteLine("El dato mayor es: {0}", Mayor);
Console.WriteLine("En el renglon: {0}", posR + 1);
Console.WriteLine("Y la columna: {0}", posC + 1);

Console.ReadKey();
}
}
}



VISUAL

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

private void Form1_Load(object sender, EventArgs e)
{

}

private void button1_Click(object sender, EventArgs e)
{
int[,] num = { { 16, 22, 99, 4, 18 }, { 258, 4, 101, 5, 98 }, { 105, 6, 15, 2, 45 }, { 33, 88, 72, 16, 3 } };
int Mayor = num[0, 0];
int posR = 0, posC = 0, R, C;

for (R = 0; R < 4; R++)
{
for (C = 0; C < 5; C++)
{
if (num[R, C] > Mayor)
{
posR = R;
posC = C;
Mayor = num[R, C];
}
}
}
for (R = 0; R < 4; R++)
{
for (C = 0; C < 5; C++)
{
listBox1.Items.Add(num[R, C]);

}

}
MessageBox.Show("\nEl dato mayor es: " + Mayor +"\n"+ "En el renglon: " + posR + 1 +"\n"+ "Y la columna: " + posC + 1);
}

private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
}

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

}
}

practica 10 problema 2 consola y visual

pseudocodigo:

1.- Inicio
Pendientes [0]={17.24, 25.63, 5.94, 33.92, 3.71, 31.84, 45.90, 35.99, 18.44, 6.92, 12.2, 29.45, 13.89, 5.21, 2.56, 8.77, 23.99, 7.23, 31.56 }
max [0] double
min [0] double
Pmax=0 double
Pmin=0 double
i=0 int

for(i=1 to 18 step i=i+1 )
{
if(Pendientes [i]>max)
{
max=Pendientes[i]>max
Pmax=i
}
else
{
if(Pendientes[i] {
min=Pendientes[i]
Pmin=1
}
}
}
Print "PENDIENTES"
for(i=0 to 18 step i=i+1)
{
Print "\t",Pendientes[i]
}
Print "Pendiente Mayor=",max
Print "En la posicion=",Pmax
Print "Pendiente Menor=",min
Print "En la posicion=",Pmin
fin

CONSOLA

namespace practica10problema2
{
class Program
{
static void Main(string[] args)
{
double[]pendientes= {17.24,25.63,5.94,33.92,3.71,31.84,45.90,35.99,18.44,6.92,12.2,29.45,13.89,5.21,2.56,8.77,23.99,7.23,31.56};
double max = pendientes[0];
double pmax = 0.0;
double min = pendientes[0];
double pmin = 0.0;
int I = 0;
for (I = 1; I < 19; I = I + 1)
{
if (pendientes[I] > max)
{
max = pendientes[I];
pmax = I;
}
else
{
if (pendientes[I] < min)
{
min = pendientes[I];
pmin = I;
}
}
}
Console.WriteLine("pendientes");
for (I = 0; I < 19; I = I + 1)
{
Console.WriteLine("{0}",pendientes[I]);
}
Console.WriteLine("Pendiente mayor={0}", max);
Console.WriteLine("En la posicion={0}", pmax);
Console.WriteLine("Pendiente menor={0}", min);
Console.WriteLine("En la posicion={0}", pmin);
Console.ReadKey();

}
}
}














VISUAL

namespace practica10problema2vis
{
public partial class Form1 : Form
{
double[] pendientes = { 17.24, 25.63, 5.94, 33.92, 3.71, 31.84, 45.90, 35.99, 18.44, 6.92, 12.2, 29.45, 13.89, 5.21, 2.56, 8.77, 23.99, 7.23, 31.56 };
double max;
double pmax = 0.0;
double min;
double pmin = 0.0;
int I = 0;
public Form1()
{
InitializeComponent();
max = pendientes[0];
min = pendientes[0];
}

private void Form1_Load(object sender, EventArgs e)
{

}

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

private void button1_Click(object sender, EventArgs e)
{
for (I = 1; I < 19; I = I + 1)
{
if (pendientes[I] > max)
{
max = pendientes[I];
pmax = I ;
}
else
{
if (pendientes[I] < min)
{
min = pendientes[I];
pmin = I ;
}
}
}
listBox1.Items.Add("pendientes");
for (I = 0; I < 19; I = I + 1)
{
listBox1.Items.Add("" + pendientes[I]);
}
listBox1.Items.Add("Pendiente mayor"+max);
listBox1.Items.Add("En la posicion"+pmax);
listBox1.Items.Add("Pendiente menor"+min);
listBox1.Items.Add("En la posicion" + pmin);
}

private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
}

private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{

}
}
}

Tarea de programacion "INSTRUCCIONES"

Instrucción “if”
La instrucción “if” permite ejecutar ciertas instrucciones sólo si de da una determinada condición. Su sintaxis de uso es la sintaxis:

if (condición)
{
instrucciones ”If”
}
else
{
instrucciones ”Else”
}
El significado de esta instrucción es el siguiente: se evalúa la expresión condición, que ha de devolver un valor lógico. Si es cierta se ejecutan las instrucciones “If”, y si es falsa se ejecutan las instrucciones “Else”. La rama else es opcional, y si se omite y la condición es falsa se seguiría ejecutando a partir de la instrucción siguiente al “if”. En realidad, tanto instrucciones”If” como instrucciones “Else” pueden ser una única instrucción o un bloque de instrucciones.
Ejemplo:

using System;
class HolaMundoIf
{
public static void Main(String[] args)
{
if (args.Length > 0){
Console.WriteLine("Hola {0}!", args[0]);}
else{
Console.WriteLine("Hola mundo!");}
}
}


Instrucción “switch”
La instrucción switch permite ejecutar unos u otros bloques de instrucciones según el valor de una cierta expresión. Su estructura es:

switch (expresión)
{
case valor1: bloque1
siguienteAcción
case valor2: bloque2
siguienteAcción

default: bloqueDefault
siguienteAcción
}


El significado de esta instrucción es el siguiente: se evalúa. Si su valor es se ejecuta el, si es se ejecuta, y así para el resto de valores especificados. Si no es igual a ninguno de esos valores y se incluye la rama default, se ejecuta el; pero si no se incluye se pasa directamente a ejecutar la instrucción siguiente al switch.
Los valores indicados en cada rama del switch han de ser expresiones constantes que produzcan valores de algún tipo básico entero, de una enumeración, de tipo char o de tipo string. Además, no puede haber más de una rama con el mismo valor.
El elemento marcado como “siguienteAcción” colocado tras cada bloque de instrucciones indica qué es lo que ha de hacerse tras ejecutar las instrucciones del bloque que lo preceden. Puede ser uno de estos tres tipos de instrucciones:
goto case valor I;
goto default;
break;

Si es un go to case indica que se ha de seguir ejecutando el bloque de instrucciones asociado en el switch a la rama del valor “I” indicado, si es un go to default indica que se ha de seguir ejecutando el bloque de instrucciones de la rama default, y si es un break indica que se ha de seguir ejecutando la instrucción siguiente al switch.


Ejemplo:

using System;
class HolaMundoSwitch
{
public static void Main(String[] args)
{
if (args.Length > 0)
switch(args[0])
{
case "José":
Console.WriteLine("Hola José. Buenos días");
break;
case "Paco":
Console.WriteLine("Hola Paco. Me alegro de verte");
break;
default:
Console.WriteLine("Hola {0}", args[0]);
break;
}
else
Console.WriteLine("Hola Mundo");
}
}


Instrucción “while”
La instrucción while permite ejecutar un bloque de instrucciones mientras se de una cierta instrucción. Su sintaxis de uso es:

while ()
{

}
Su significado es el siguiente: Se evalúa la condición indicada, que ha de producir un valor lógico. Si es cierta (valor lógico true) se ejecutan las instrucciones y se repite el proceso de evaluación de condición y ejecución de instrucciones hasta que deje de serlo. Cuando sea falsa se pasará a ejecutar la instrucción siguiente al while. En realidad instrucciones puede ser una única instrucción o un bloque de instrucciones.

Ejemplo:

using System;
class HolaMundoWhile
{
public static void Main(String[] args)
{
int actual = 0;
if (args.Length > 0)
while (actual < args.Length)
{
Console.WriteLine("¡Hola {0}!", args[actual]);
actual = actual + 1;
}
else
Console.WriteLine("¡Hola mundo!");
}
}
Por otro lado, dentro de las instrucciones de un while pueden utilizarse las siguientes dos instrucciones especiales:
• break; Indica que se ha de abortar la ejecución del bucle y continuarse ejecutando por la instrucción siguiente al while.
• continue; Indica que se ha de abortar la ejecución de las instrucciones y reevaluarse la condición del bucle, volviéndose a ejecutar las instrucciones si es cierta o pasándose a ejecutar la instrucción siguiente al while si es falsa.




Instrucción “do...while”
La instrucción do...while es una variante del while que se usa así:
do {
instrucciones
}
while(condición);

La única diferencia del significado de do...while respecto al de while es que en vez de evaluar primero la condición y ejecutar instrucciones sólo si es cierta, do...while primero ejecuta las instrucciones y luego mira la condición para ver si se ha de repetir la ejecución de las mismas. Por lo demás ambas instrucciones son iguales, e incluso también puede incluirse break; y continue; entre las instrucciones del do...while.
do ... while está especialmente destinado para los casos en los que haya que ejecutar las instrucciones al menos una vez aún cuando la condición sea falsa desde el principio.

Ejemplo:
using System;
class HolaMundoDoWhile
{
public static void Main()
{
String leído;
do
{
Console.WriteLine("Clave: ");
leído = Console.ReadLine();
}
while (leído != "José");
Console.WriteLine("Hola José");
}
}







Instrucción “for”
La instrucción for es una variante de while que permite reducir el código necesario para escribir los tipos de bucles más comúnmente usados en programación. Su sintaxis es:

for (inicialización; condición; modificación)
{
instrucciones
}
El significado de esta instrucción es el siguiente: se ejecutan las instrucciones de inicialización, que suelen usarse para definir e inicializar variables que luego se usarán en instrucciones. Luego se evalúa condición, y si es falsa se continúa ejecutando por la instrucción siguiente al for; mientras que si es cierta se ejecutan las instrucciones indicadas, luego se ejecutan las instrucciones de modificación que como su nombre indica suelen usarse para modificar los valores de variables que se usen en instrucciones y luego se reevalúa condición repitiéndose el proceso hasta que ésta última deje de ser cierta.
En inicialización puede en realidad incluirse cualquier número de instrucciones que no tienen porqué ser relativas a inicializar variables o modificarlas, aunque lo anterior sea su uso más habitual. En caso de ser varias se han de separar mediante comas (,), ya que el carácter de punto y coma (;) habitualmente usado para estos menesteres se usa en el for para separar los bloques de inicialización, condición y modificación.
Con modificación pasa algo similar, ya que puede incluirse código que nada tenga que ver con modificaciones pero en este caso no se pueden incluir definiciones de variables.


Ejemplo:

using System;
class HolaMundoFor
{
public static void Main(String[] args)
{
if (args.Length > 0)
for (int actual = 0; actual < args.Length; actual++) {
Console.WriteLine("¡Hola {0}!", args[actual]);
}
else
Console.WriteLine("¡Hola mundo!");
}
}
Al igual que con while, dentro de las del for también pueden incluirse instrucciones continue; y break; que puedan alterar el funcionamiento normal del bucle.

practica10problema1 consola y visual

Pseudocodigo

Inicio
resistencia[5]={16,27,39,56,81} int
corriente [5] double
potencia [5] double
I=0 int
suma=0 double
print "Introduce valor de corriente"
for (I=0 to 4 step I=I+1)
{
print "Corriente" I+1
Read corriente[I]
potencia[I]=resistencia[I]*Math.Pow(corriente[I],2)
suma=suma+potencia[I]
}
Print "Resistencia Corriente Potencia"
for (I=0 to 4 step I=I+1)
{
Print "Resistencia[I],"\t",Corriente[I],"\t",Potencia[I]
}
Print "\t\tTotal=", suma
fin


CONSOLA

namespace practica10prob1
{
class Program
{
static void Main(string[] args)
{
int[] resistencia = {16,27,39,56,81};
double[]corriente=new double[5];
double[] Potencia=new double[5];
int I = 0;
double suma=0;

Console.WriteLine("INTRODUCE VALOR DE CORRIENTE");
for (I = 0; I < 5; I++)
{
Console.WriteLine("Corriente{0}", I+1);
corriente[I] = double.Parse(Console.ReadLine());
Potencia[I] = resistencia[I] * (Math.Pow(corriente[I], 2));
suma = suma + Potencia[I];
}
Console.WriteLine("Resistencia\t\tCorriente\t\tPotencia");
for (I = 0; I < 5; I++)
{
Console.WriteLine("{0}\t\t\t{1}\t\t\t{2}", resistencia[I], corriente[I], Potencia[I]);
}
Console.WriteLine("");
Console.WriteLine("\t\t\t\t\t\tTotal:{0}", suma);
Console.ReadKey();
}
}
}

















VISUAL

namespace practica10prob1vis
{
public partial class Form1 : Form
{
int[] resistencia = { 16, 27, 39, 56, 81 };
double[] corriente = new double[5];
double[] potencia = new double[5];
int I = 0;
double suma = 0;

public Form1()
{
InitializeComponent();
}

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

private void Form1_Load(object sender, EventArgs e)
{

}

private void button1_Click(object sender, EventArgs e)
{
if (I < 5)
{
corriente[I] = double.Parse(textBox1.Text);
textBox1.Clear();
textBox1.Focus();
I++;
}
if (I == 5)
{
textBox1.Enabled = false;
button1.Enabled = false;

}
}

private void button2_Click(object sender, EventArgs e)
{

listBox1.Items.Add("Corriente\t\tResistencia\tPotencia");

for (I = 0; I < 5; I++)
{

potencia[I] = resistencia[I] * (Math.Pow(corriente[I], 2));
listBox1.Items.Add("" + corriente[I] + "\t\t" + resistencia[I] + "\t\t" + potencia[I]);
suma = suma + potencia[I];

}
listBox1.Items.Add("");
listBox1.Items.Add("\t\t\t\tTotal" + suma);
}

private void button3_Click(object sender, EventArgs e)
{
textBox1.Clear();
listBox1.Items.Clear();
textBox1.Focus();
textBox1.Enabled = true;
button1.Enabled = true;
button1.Enabled = true;
}
}
}

practica9problema2 consola y visual

pseudocodigo

corriente[10] int
resistencia[10]int
voltios[10] int

I int

print "Introduce los valores de corriente"
for(I=0 to 9 step I=I+1)
{
print "corriente" I
read (corriente[I])
}
print "Introduce los valores de resistencia"
for(I=0 to 9 step I=I+1)
{
print "resistencia"
read (resistencia[I])
}
print("Corriente Resistencia Voltios")
for(I=0 to 9 step I=I+1)
{
voltios[I]=resistencia[I]*corriente[I];
print corriente[I], " ",resistencia[I]," ",voltios[I]
}
fin

namespace practica9problema2
{
class Program
{
static void Main(string[] args)
{
int[] corriente = new int[10];
int[] resistencia = new int[10];
int[] voltios = new int[10];
int I = 0;

Console.WriteLine("Introduce los valores de la corriente:");
for (I = 0; I <= 9; I++)
{
Console.WriteLine("Corriente [{0}]:", I);
corriente[I] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Introduce los valores de la resistencia:");
for (I = 0; I <= 9; I++)
{
Console.WriteLine("Resistenca [{0}]:", I);
resistencia[I] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Corriente\t\tResistencia\t\tVoltios");
for (I = 0; I <= 9; I++)
{
voltios[I] = corriente[I] * resistencia[I];
Console.WriteLine("{0}\t\t\t{1}\t\t\t{2}", corriente[I], resistencia[I], voltios[I]);
}
Console.ReadKey();
}
}
}























namespace practica9problema2vis
{
public partial class Form1 : Form
{
int[] corriente;
int[] resistencia;
int[] voltios;
int I;
public Form1()
{
InitializeComponent();
corriente = new int[10];
resistencia = new int[10];
voltios = new int[10];
I= 0;
}

private void button1_Click(object sender, EventArgs e)
{
if (I < 10)
{
corriente[I] = int.Parse(textBox1.Text);
resistencia[I] = int.Parse(textBox2.Text);
textBox1.Clear();
textBox1.Focus();
textBox2.Clear();
I++;

}
if (I == 10)
{
textBox1.Enabled = false;
button1.Enabled = false;
textBox2.Enabled = false;
button1.Enabled = false;
}

}



private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Add("Corriente\t\tResistencia\tVoltios");
for (I = 0; I <10; I++)
{
voltios[I] = corriente[I] * resistencia[I];
listBox1.Items.Add(""+corriente[I]+"\t\t"+resistencia[I]+"\t\t"+voltios[I]);

}
}

private void button4_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
listBox1.Items.Clear();
textBox1.Focus();
textBox1.Enabled = true;
button1.Enabled = true;
textBox2.Enabled = true;
button1.Enabled = true;



}

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



private void Form1_Load(object sender, EventArgs e)
{

}
}
}

practica 9 problema 1 consola y visual

Pseudocodigo
inicio
temp[10] int
total=0 int
I=0 int
Prom=0 int
Print "Introduce los siguientes elementos"
for (I=0 to 9 step I=I+1)
{
Print "temp", I
Read temp[I]
total=total + temp[I]
}
Prom = total/10
for (I=0 to 9 step I=I+1)
{
print=temp[I]
}
Print "Promedio", Prom
fin


CONSOLA

namespace practica9problema1
{
class Program
{
static void Main(string[] args)
{
int[] temp = new int[10];
int total = 0;
int I=0;
double promedio=0;
Console.WriteLine("Introduce los siguientes elementos:");

for (I = 0; I < 10; I = I + 1)
{
Console.WriteLine("\nTemperatura{0}:", I+1);
temp[I] = int.Parse(Console.ReadLine());
total = total + temp[I];
}
promedio = total / 10;
for (I = 0; I < 10; I = I + 1)
{
Console.WriteLine("\n{0}", temp[I]);
}
Console.WriteLine("\nPromedio es:{0}", promedio);
Console.ReadKey();



}
}
}

VISUAL

namespace practica9problema1vis
{
public partial class Form1 : Form
{
int[] temp;
int I, total, prom;

public Form1()
{
InitializeComponent();
temp=new int[10];
I = 0;
total = 0;
prom = 0;


}

private void button1_Click(object sender, EventArgs e)
{
if (I < 10)
{
temp[I] = int.Parse(textBox1.Text);
total = total + temp[I];
listBox1.Items.Add("Elemento" + I + " : " + temp[I]);
I++;
textBox1.Clear();
textBox1.Focus();
}
if (I == 10)
{
textBox1.Enabled = false;
button1.Enabled = false;
}

}

private void label1_Click(object sender, EventArgs e)
{

}

private void Form1_Load(object sender, EventArgs e)
{

}

private void button2_Click(object sender, EventArgs e)
{
prom = total / 10;
listBox1.Items.Add("Promedio =" + prom);

}

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

private void button4_Click(object sender, EventArgs e)
{
I = 0;
textBox1.Enabled= true;
button1.Enabled= true;
listBox1.Items.Clear();


}
}
}

practica 8 problema 3

namespace Practica8_problema3V
{
public partial class PlantaT : Form
{
public double DP1, DP2, DP3, DP4, DP5, DP6, DP7, DD1, DD2, DD3, DD4, DD5, DD6, DD7, PD1, PD2, PD3, PD4, PD5, PD6, PD7, TP, TD, Tpd;
public PlantaT()
{
InitializeComponent();
DP1 = DP2 = DP3 = DP4 = DP5 = DP6 = DP7 = DD1 = DD2 = DD3 = DD4 = DD5 = DD6 = DD7 = PD1 = PD2 = PD3 = PD4 = PD5 = PD6 = PD7 = TP = TD = Tpd = 0.0;
}

private void btPlantaH_Click(object sender, EventArgs e)
{
DP1 = double.Parse(txtBH1.Text);
DD1 = double.Parse(txtBH2.Text);
DP2 = double.Parse(txtBH4.Text);
DD2 = double.Parse(txtBH5.Text);
DP3 = double.Parse(txtBH7.Text);
DD3 = double.Parse(txtBH8.Text);
DP4 = double.Parse(txtBH10.Text);
DD4 = double.Parse(txtBH11.Text);
DP5 = double.Parse(txtBH13.Text);
DD5 = double.Parse(txtBH14.Text);
DP6 = double.Parse(txtBH16.Text);
DD6 = double.Parse(txtBH17.Text);
DP7 = double.Parse(txtBH19.Text);
DD7 = double.Parse(txtBH20.Text);

PD1 = DD1 / DP1;
PD2 = DD2 / DP2;
PD3 = DD3 / DP3;
PD4 = DD4 / DP4;
PD5 = DD5 / DP5;
PD6 = DD6 / DP6;
PD7 = DD7 / DP7;
TP = DP1 + DP2 + DP3 + DP4 + DP5 + DP6 + DP7;
TD = DD1 + DD2 + DD3 + DD4 + DD5 + DD6 + DD7;
Tpd = TD / TP;

txtBH3.Text = PD1.ToString();
txtBH6.Text = PD2.ToString();
txtBH9.Text = PD3.ToString();
txtBH12.Text = PD4.ToString();
txtBH15.Text = PD5.ToString();
txtBH18.Text = PD6.ToString();
txtBH21.Text = PD7.ToString();
txtBH22.Text = TP.ToString();
txtBH23.Text = TD.ToString();
txtBH24.Text = Tpd.ToString();
}

private void btBorrar_Click(object sender, EventArgs e)
{
txtBH1.Focus();
txtBH1.Clear();
txtBH10.Clear();
txtBH11.Clear();
txtBH12.Clear();
txtBH13.Clear();
txtBH14.Clear();
txtBH15.Clear();
txtBH16.Clear();
txtBH17.Clear();
txtBH18.Clear();
txtBH19.Clear();
txtBH2.Clear();
txtBH20.Clear();
txtBH21.Clear();
txtBH22.Clear();
txtBH23.Clear();
txtBH24.Clear();
txtBH3.Clear();
txtBH4.Clear();
txtBH5.Clear();
txtBH6.Clear();
txtBH7.Clear();
txtBH8.Clear();
txtBH9.Clear();
}

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

private void PlantaT_Load(object sender, EventArgs e)
{

}
}
}

namespace Practica8_problema3V
{
public partial class PlantaM : Form
{
public double DP1, DP2, DP3, DP4, DP5, DP6, DP7, DD1, DD2, DD3, DD4, DD5, DD6, DD7, PD1, PD2, PD3, PD4, PD5, PD6, PD7, TP, TD, Tpd;
public PlantaM()
{
InitializeComponent();
DP1 = DP2 = DP3 = DP4 = DP5 = DP6 = DP7 = DD1 = DD2 = DD3 = DD4 = DD5 = DD6 = DD7 = PD1 = PD2 = PD3 = PD4 = PD5 = PD6 = PD7 = TP = TD = Tpd = 0.0;
}

private void btPlantaH_Click(object sender, EventArgs e)
{
DP1 = double.Parse(txtBH1.Text);
DD1 = double.Parse(txtBH2.Text);
DP2 = double.Parse(txtBH4.Text);
DD2 = double.Parse(txtBH5.Text);
DP3 = double.Parse(txtBH7.Text);
DD3 = double.Parse(txtBH8.Text);
DP4 = double.Parse(txtBH10.Text);
DD4 = double.Parse(txtBH11.Text);
DP5 = double.Parse(txtBH13.Text);
DD5 = double.Parse(txtBH14.Text);
DP6 = double.Parse(txtBH16.Text);
DD6 = double.Parse(txtBH17.Text);
DP7 = double.Parse(txtBH19.Text);
DD7 = double.Parse(txtBH20.Text);

PD1 = DD1 / DP1;
PD2 = DD2 / DP2;
PD3 = DD3 / DP3;
PD4 = DD4 / DP4;
PD5 = DD5 / DP5;
PD6 = DD6 / DP6;
PD7 = DD7 / DP7;
TP = DP1 + DP2 + DP3 + DP4 + DP5 + DP6 + DP7;
TD = DD1 + DD2 + DD3 + DD4 + DD5 + DD6 + DD7;
Tpd = TD / TP;

txtBH3.Text = PD1.ToString();
txtBH6.Text = PD2.ToString();
txtBH9.Text = PD3.ToString();
txtBH12.Text = PD4.ToString();
txtBH15.Text = PD5.ToString();
txtBH18.Text = PD6.ToString();
txtBH21.Text = PD7.ToString();
txtBH22.Text = TP.ToString();
txtBH23.Text = TD.ToString();
txtBH24.Text = Tpd.ToString();
}

private void btBorrar_Click(object sender, EventArgs e)
{
txtBH1.Focus();
txtBH1.Clear();
txtBH10.Clear();
txtBH11.Clear();
txtBH12.Clear();
txtBH13.Clear();
txtBH14.Clear();
txtBH15.Clear();
txtBH16.Clear();
txtBH17.Clear();
txtBH18.Clear();
txtBH19.Clear();
txtBH2.Clear();
txtBH20.Clear();
txtBH21.Clear();
txtBH22.Clear();
txtBH23.Clear();
txtBH24.Clear();
txtBH3.Clear();
txtBH4.Clear();
txtBH5.Clear();
txtBH6.Clear();
txtBH7.Clear();
txtBH8.Clear();
txtBH9.Clear();
}

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

private void PlantaM_Load(object sender, EventArgs e)
{

}
}
}

namespace Practica8_problema3V
{
public partial class PlantaH : Form
{
public double DP1, DP2, DP3, DP4, DP5, DP6, DP7, DD1, DD2, DD3, DD4, DD5, DD6, DD7, PD1, PD2, PD3, PD4, PD5, PD6, PD7, TP, TD, Tpd;
public PlantaH()
{
InitializeComponent();
DP1 = DP2 = DP3 = DP4 = DP5 = DP6 = DP7 = DD1 = DD2 = DD3 = DD4 = DD5 = DD6 = DD7 = PD1 = PD2 = PD3 = PD4 = PD5 = PD6 = PD7 = TP = TD = Tpd = 0.0;
}



private void btBorrar_Click(object sender, EventArgs e)
{
txtBH1.Focus();
txtBH1.Clear();
txtBH10.Clear();
txtBH11.Clear();
txtBH12.Clear();
txtBH13.Clear();
txtBH14.Clear();
txtBH15.Clear();
txtBH16.Clear();
txtBH17.Clear();
txtBH18.Clear();
txtBH19.Clear();
txtBH2.Clear();
txtBH20.Clear();
txtBH21.Clear();
txtBH22.Clear();
txtBH23.Clear();
txtBH24.Clear();
txtBH3.Clear();
txtBH4.Clear();
txtBH5.Clear();
txtBH6.Clear();
txtBH7.Clear();
txtBH8.Clear();
txtBH9.Clear();

}

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

private void btPlantaH_Click(object sender, EventArgs e)
{
DP1 = double.Parse(txtBH1.Text);
DD1 = double.Parse(txtBH2.Text);
DP2 = double.Parse(txtBH4.Text);
DD2 = double.Parse(txtBH5.Text);
DP3 = double.Parse(txtBH7.Text);
DD3 = double.Parse(txtBH8.Text);
DP4 = double.Parse(txtBH10.Text);
DD4 = double.Parse(txtBH11.Text);
DP5 = double.Parse(txtBH13.Text);
DD5 = double.Parse(txtBH14.Text);
DP6 = double.Parse(txtBH16.Text);
DD6 = double.Parse(txtBH17.Text);
DP7 = double.Parse(txtBH19.Text);
DD7 = double.Parse(txtBH20.Text);

PD1 = DD1 / DP1;
PD2 = DD2 / DP2;
PD3 = DD3 / DP3;
PD4 = DD4 / DP4;
PD5 = DD5 / DP5;
PD6 = DD6 / DP6;
PD7 = DD7 / DP7;
TP = DP1 + DP2 + DP3 + DP4 + DP5 + DP6 + DP7;
TD = DD1 + DD2 + DD3 + DD4 + DD5 + DD6 + DD7;
Tpd = TD / TP;

txtBH3.Text = PD1.ToString();
txtBH6.Text = PD2.ToString();
txtBH9.Text = PD3.ToString();
txtBH12.Text = PD4.ToString();
txtBH15.Text = PD5.ToString();
txtBH18.Text = PD6.ToString();
txtBH21.Text = PD7.ToString();
txtBH22.Text = TP.ToString();
txtBH23.Text = TD.ToString();
txtBH24.Text = Tpd.ToString();

}

private void PlantaH_Load(object sender, EventArgs e)
{

}


}
}


namespace Practica8_problema3V
{
public partial class PlantaG : Form
{
public double DP1, DP2, DP3, DP4, DP5, DP6, DP7, DD1, DD2, DD3, DD4, DD5, DD6, DD7, PD1, PD2, PD3, PD4, PD5, PD6, PD7, TP, TD, Tpd;
public PlantaG()
{
InitializeComponent();
DP1 = DP2 = DP3 = DP4 = DP5 = DP6 = DP7 = DD1 = DD2 = DD3 = DD4 = DD5 = DD6 = DD7 = PD1 = PD2 = PD3 = PD4 = PD5 = PD6 = PD7 = TP = TD = Tpd = 0.0;
}

private void btPlantaH_Click(object sender, EventArgs e)
{
DP1 = double.Parse(txtBH1.Text);
DD1 = double.Parse(txtBH2.Text);
DP2 = double.Parse(txtBH4.Text);
DD2 = double.Parse(txtBH5.Text);
DP3 = double.Parse(txtBH7.Text);
DD3 = double.Parse(txtBH8.Text);
DP4 = double.Parse(txtBH10.Text);
DD4 = double.Parse(txtBH11.Text);
DP5 = double.Parse(txtBH13.Text);
DD5 = double.Parse(txtBH14.Text);
DP6 = double.Parse(txtBH16.Text);
DD6 = double.Parse(txtBH17.Text);
DP7 = double.Parse(txtBH19.Text);
DD7 = double.Parse(txtBH20.Text);

PD1 = DD1 / DP1;
PD2 = DD2 / DP2;
PD3 = DD3 / DP3;
PD4 = DD4 / DP4;
PD5 = DD5 / DP5;
PD6 = DD6 / DP6;
PD7 = DD7 / DP7;
TP = DP1 + DP2 + DP3 + DP4 + DP5 + DP6 + DP7;
TD = DD1 + DD2 + DD3 + DD4 + DD5 + DD6 + DD7;
Tpd = TD / TP;

txtBH3.Text = PD1.ToString();
txtBH6.Text = PD2.ToString();
txtBH9.Text = PD3.ToString();
txtBH12.Text = PD4.ToString();
txtBH15.Text = PD5.ToString();
txtBH18.Text = PD6.ToString();
txtBH21.Text = PD7.ToString();
txtBH22.Text = TP.ToString();
txtBH23.Text = TD.ToString();
txtBH24.Text = Tpd.ToString();

}

private void btBorrar_Click(object sender, EventArgs e)
{
txtBH1.Focus();
txtBH1.Clear();
txtBH10.Clear();
txtBH11.Clear();
txtBH12.Clear();
txtBH13.Clear();
txtBH14.Clear();
txtBH15.Clear();
txtBH16.Clear();
txtBH17.Clear();
txtBH18.Clear();
txtBH19.Clear();
txtBH2.Clear();
txtBH20.Clear();
txtBH21.Clear();
txtBH22.Clear();
txtBH23.Clear();
txtBH24.Clear();
txtBH3.Clear();
txtBH4.Clear();
txtBH5.Clear();
txtBH6.Clear();
txtBH7.Clear();
txtBH8.Clear();
txtBH9.Clear();
}

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

private void PlantaG_Load(object sender, EventArgs e)
{

}
}
}

namespace Practica8_problema3V
{
public partial class PlantaC : Form
{
public double DP1, DP2, DP3, DP4, DP5, DP6, DP7, DD1, DD2, DD3, DD4, DD5, DD6, DD7, PD1, PD2, PD3, PD4, PD5, PD6, PD7, TP, TD, Tpd;
public PlantaC()
{
InitializeComponent();
DP1 = DP2 = DP3 = DP4 = DP5 = DP6 = DP7 = DD1 = DD2 = DD3 = DD4 = DD5 = DD6 = DD7 = PD1 = PD2 = PD3 = PD4 = PD5 = PD6 = PD7 = TP = TD = Tpd = 0.0;
}

private void btPlantaH_Click(object sender, EventArgs e)
{
DP1 = double.Parse(txtBH1.Text);
DD1 = double.Parse(txtBH2.Text);
DP2 = double.Parse(txtBH4.Text);
DD2 = double.Parse(txtBH5.Text);
DP3 = double.Parse(txtBH7.Text);
DD3 = double.Parse(txtBH8.Text);
DP4 = double.Parse(txtBH10.Text);
DD4 = double.Parse(txtBH11.Text);
DP5 = double.Parse(txtBH13.Text);
DD5 = double.Parse(txtBH14.Text);
DP6 = double.Parse(txtBH16.Text);
DD6 = double.Parse(txtBH17.Text);
DP7 = double.Parse(txtBH19.Text);
DD7 = double.Parse(txtBH20.Text);

PD1 = DD1 / DP1;
PD2 = DD2 / DP2;
PD3 = DD3 / DP3;
PD4 = DD4 / DP4;
PD5 = DD5 / DP5;
PD6 = DD6 / DP6;
PD7 = DD7 / DP7;
TP = DP1 + DP2 + DP3 + DP4 + DP5 + DP6 + DP7;
TD = DD1 + DD2 + DD3 + DD4 + DD5 + DD6 + DD7;
Tpd = TD / TP;

txtBH3.Text = PD1.ToString();
txtBH6.Text = PD2.ToString();
txtBH9.Text = PD3.ToString();
txtBH12.Text = PD4.ToString();
txtBH15.Text = PD5.ToString();
txtBH18.Text = PD6.ToString();
txtBH21.Text = PD7.ToString();
txtBH22.Text = TP.ToString();
txtBH23.Text = TD.ToString();
txtBH24.Text = Tpd.ToString();
}

private void btBorrar_Click(object sender, EventArgs e)
{
txtBH1.Focus();
txtBH1.Clear();
txtBH10.Clear();
txtBH11.Clear();
txtBH12.Clear();
txtBH13.Clear();
txtBH14.Clear();
txtBH15.Clear();
txtBH16.Clear();
txtBH17.Clear();
txtBH18.Clear();
txtBH19.Clear();
txtBH2.Clear();
txtBH20.Clear();
txtBH21.Clear();
txtBH22.Clear();
txtBH23.Clear();
txtBH24.Clear();
txtBH3.Clear();
txtBH4.Clear();
txtBH5.Clear();
txtBH6.Clear();
txtBH7.Clear();
txtBH8.Clear();
txtBH9.Clear();
}

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

private void PlantaC_Load(object sender, EventArgs e)
{

}
}
}

namespace Practica8_problema3V
{
public partial class Form1 : Form
{
PlantaH ph;
PlantaG pg;
PlantaT pt;
PlantaC pc;
PlantaM pm;
public Form1()
{
ph = new PlantaH();
pg = new PlantaG();
pt = new PlantaT();
pc = new PlantaC();
pm = new PlantaM();
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{

}

private void btHermosillo_Click(object sender, EventArgs e)
{
ph.Show();
}

private void btGuamuchil_Click(object sender, EventArgs e)
{
pg.Show();
}

private void btTijuana_Click(object sender, EventArgs e)
{
pt.Show();
}

private void btCuliacan_Click(object sender, EventArgs e)
{
pc.Show();
}

private void btMexico_Click(object sender, EventArgs e)
{
pm.Show();
}

private void btReporte_Click(object sender, EventArgs e)
{
double TotalProduccion = ph.TP + pg.TP + pt.TP + pc.TP + pm.TP;
double TotalDefectos = ph.TD + pg.TD + pt.TD + pm.TD + pc.TD;
double PocentajeDef = ph.Tpd + pg.Tpd + pt.Tpd + pc.Tpd + pm.Tpd;
listBox1.Items.Add("\t\tReporte de Control de Calidad");
listBox1.Items.Add("Planta \t\tUnidades \t\t Unidades \t%");
listBox1.Items.Add("\t\tproducidas \t\tdefectuosas \tdefectuosas");
listBox1.Items.Add("\nHermosillo\t\t" + ph.TP + "\t\t" + ph.TD + "\t\t" + ph.Tpd);
listBox1.Items.Add("\nGuamuchil \t\t" + pg.TP + "\t\t" + pg.TD + "\t\t" + pg.Tpd);
listBox1.Items.Add("\nTijuana \t\t" + pt.TP + "\t\t" + pt.TD + "\t\t" + pt.Tpd);
listBox1.Items.Add("\nCuliacan \t\t" + pc.TP + "\t\t" + pc.TD + "\t\t" + pc.Tpd);
listBox1.Items.Add("\nMexico \t\t" + pm.TP + "\t\t" + pm.TD + "\t\t" + pm.Tpd);
listBox1.Items.Add("\nTotales \t\t" + TotalProduccion + "\t\t" + TotalDefectos + "\t\t" + PocentajeDef);
}
}
}