calcular el promedio de los números a ingresar y saber cuales son mayores al promedio y menores al promedio

//Hacer una aplicación que forme un vector del que no se sabe el número
 //de elementos (el tamaño lo indica el usuario). Calcule el promedio
 //de todos los elementos y forme dos nuevos arreglos, uno con los
 //elementos menores o iguales al promedio y otro con los superiores.
 //Imprima los dos nuevos arreglos.

using System;

namespace Prog_Promedios
{
class Program
{
public static int lim;

public static void Main(string[] args)
{

Console.WriteLine("Determine el tamaño del Arreglo ");
lim=Convert.ToInt16(Console.ReadLine());

Console.Clear();
double[] num = new double [lim];

Console.WriteLine("Ingrese los valores ");
for(int t=0; t<lim; t++)
num[t]=Convert.ToDouble(Console.ReadLine());

Procesamiento(num);


Console.ReadKey(true);
}

public static void Procesamiento (double[] pv)
{
double p=0, pf=0;

for(int j=0; j<lim; j++)
p+=pv[j];
pf=p/lim;

Console.WriteLine("Promedio ==> {0}" , pf);

double[] m = new double [lim];
double[] n = new double [lim];


Console.WriteLine("Valores menores al promedio ");
for(int l=0; l<lim; l++){
if(pv[l]<=pf)
m[l]=pv[l];
Console.WriteLine("[{0}]" , m[l]);
}

Console.WriteLine("Valores mayores al promedio ");
for(int e=0; e<lim; e++){
if(pv[e]>=pf)
n[e]=pv[e];
Console.WriteLine("[{0}]" , n[e]);
}


}

}
}

producto de vectores inversamente

*
 * Creado por SharpDevelop.
 * Usuario: Administrador
 * Fecha: 30/07/2011
 * Hora: 6:14
 *
 * Para cambiar esta plantilla use Herramientas | Opciones | Codificación | Editar Encabezados Estándar
 */

//Elaborar una aplicación que lea dos arreglos unidimensionales de igual tamaño
//y forme un tercer arreglo mediante el producto de los elementos de los dos
//arreglos, tomados en orden inverso, es decir, productos del primer elemento
//del primer arreglo, con el último del segundo; del segundo del primer arreglo
//con el penúltimo del segundo arreglo; hasta llegara al último del primer
//arreglo, con el primero del segundo arreglo. Imprimir el arreglo formado.

using System;

namespace Produc_Arreglos_Inversos
{
class Program
{
public static void Main(string[] args)
{
int [] arreg1 = new int [5];
int [] arreg2 = new int [5];

Console.WriteLine("Llenando los arreglos . . ");
Console.WriteLine("Escriba 5 valores del primer arreglo ");
for(int m=0; m<5; m++)
arreg1[m]=Convert.ToInt16(Console.ReadLine());

Console.Clear();
Console.WriteLine("Llenando los arreglos . . ");
Console.WriteLine("Escriba 5 valores del segundo arreglo ");
for(int n=0; n<5; n++)
arreg2[n]=Convert.ToInt16(Console.ReadLine());

MetodoProceso(arreg1,arreg2);
Console.ReadKey(true);

}

public static void MetodoProceso (int[] a1, int[] a2)
{
int e=0;
int[] product = new int [5];

Console.SetCursorPosition(0,8);
Console.WriteLine("Elementos Vector 1");
for(int r=0; r<5; r++){
Console.Write("[{0}]",a1[r]);
}
Console.SetCursorPosition(0,11);
Console.WriteLine("Elementos Vector 2");
for(int t=0; t<5; t++){
Console.Write("[{0}]",a2[t]);
}

Console.SetCursorPosition(0,14);
Console.WriteLine("Producto de Vectores Inversamente ");
while(e<5){
for(int j=4; j>=0; j--){
product[e]=a1[e]*a2[j];
Console.Write("[{0}]",product[e]);
e++;
}
}
}

}
}

Implementar un algoritmo que me permita leer 10 valores numéricos desde el teclado. A estos valores se aplicara el siguiente menu de opciones

using System;
using System.Collections.Generic;

namespace Medidas_Estadisticas
{
class MainClass
{
public static int[] valores = new int [10];

public static void Main(string[] args)
{


Console.WriteLine("MEDIDAS ESTADISTICAS");
Console.WriteLine("Ingrese 10 valores ");
for(int p=0; p<valores.Length; p++)
valores[p]=Convert.ToInt16(Console.ReadLine());

Menu(valores);


}

public static void Menu(int[] pv)
{

int op;
bool vuelta = true;

while(vuelta==true){

Console.Clear();
Console.WriteLine("MEDIDAS ESTADISTICAS");
Console.WriteLine("[1]. Mediana ");
Console.WriteLine("[2]. Varianza ");
Console.WriteLine("[3]. Desviacion Estandar ");
Console.WriteLine("[4]. Todas ");
Console.WriteLine("[5]. Salir ");
Console.WriteLine("Eliga una opcion . . ");
op=Convert.ToInt16(Console.ReadLine());



switch (op){

case 1:
{
  Console.Clear();
  Mediana(valores);
  Console.ReadKey(true);
  break;

}
case 2:
{
  Console.Clear();
  Varianza(valores);
  Console.ReadKey(true);
  break;

}
case 3:
{
  Console.Clear();
  DesviacionE(valores);
  Console.ReadKey(true);
  break;

}
case 4:
{
  Console.Clear();
  Todas(valores);
  Console.ReadKey(true);
  break;

}
case 5:
{
  Console.Clear();
  vuelta=false;
  Console.ReadKey(true);
  break;

}

default:
{
Console.Clear();
Console.WriteLine("Elige bien . . ");
Console.ReadKey(true);
break;
}

}
}
}

public static void Mediana(int[] p1)
{
double r=0, t=0;

for(int i=0; i<10; i++)
r+=p1[i];
t=r/10;

Console.WriteLine("La mediana de los valores es {0}",t);

}

public static void Varianza(int[] p2)
{
double r=0, t=0;

for(int i=0; i<10; i++)
r+=Math.Pow(p2[i],2);
t=((r/10)-1);

Console.WriteLine("La Varianza de los valores es {0}",t);


}

public static void DesviacionE(int[] p3)
{

double r=0, t=0, h=0;

for(int i=0; i<10; i++)
r+=Math.Pow(p3[i],2);
t=((r/10)-1);
h=Math.Sqrt(t);

Console.WriteLine("La Desviacion Estandar de los valores es {0}",h);


}

public static void Todas(int[] p4)
{
double r=0, t=0, h=0, o=0, m=0, n=0, z=0;

for(int i=0; i<10; i++)
r+=p4[i];
t=r/10;

Console.WriteLine("La mediana de los valores es {0}",t);

for(int p=0; p<10; p++)
h+=Math.Pow(p4[p],2);
o=((r/10)-1);

Console.WriteLine("La Varianza de los valores es {0}",o);

for(int j=0; j<10; j++)
m+=Math.Pow(p4[j],2);
n=((m/10)-1);
z=Math.Sqrt(n);

Console.WriteLine("La Desviacion Estandar de los valores es {0}",z);


}
  }
}

ALMACENAMIENTO DE NUMEROS ALEATORIOS A UN ARREGLO UNIDIMENSIONAL SIN DUPLICADOS.

using System;

namespace AppRandomicosSinDuplicar
{
    class Program
    {
        public static void Main(string[ ] args)
        {

            //Definimos una constante de tipo entero.
            const int limite=10;

            //Implementamos el arreglo de tipo entero
            int[ ] lista = new int[limite];
             

            LlenarArregloUnidimensional(lista);
            VisualizarArregloUnidimensional(lista);

            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    
        public static void LlenarArregloUnidimensional(int[] pLista)
        {
            Random rnd = new Random();
            int i=0,valor=0;
            bool sw=true;
        
            while(i '<' pLista.Length)
            {
                valor=rnd.Next(1,50);
            
                for(int pasada=0; pasada'<'=i;pasada++)
                {
                    if(valor == pLista[pasada]){
                        sw=false;
                        break;
                    }
                }
            
                if (sw){
                      pLista[i]=valor;
                      i++;
                      sw=true;
                }
            
            }
        }
    
        public static void VisualizarArregloUnidimensional(int[] pLista)
        {
            Random rnd = new Random();
            for(int p=0; p'<'pLista.Length;p++)
            {
                Console.WriteLine("{0}",pLista[p]);
            }
        }
    }
}

BUSCAR VECTOR

//Elaborar una aplicación que forme un vector B de M elementos
//(el tamaño del vector lo define el usuario), luego entre el valor de la variable
//CLAVE y la búsquelo secuencialmente dentro del arreglo, suspendiendo la búsqueda
//cuando lo encuentre. Imprima un mensaje para el usuario, indicando si encontró
//dicho valor o no, en caso afirmativo, indique la posición en la que estaba el dato.

using System;

namespace Prog_busqueda_vector
{
class Program
{
public static void Main(string[] args)
{
int tv;

Console.WriteLine("Define tamaño del vector ");
tv=Convert.ToInt16(Console.ReadLine());

Vector(tv);
Console.ReadKey(true);
}

public static void Vector (int p)
{
Console.Clear();
int i=0;
int[] b = new int [p];
Console.WriteLine("Ingresa los valores al vector ");
do{
b[i]=Convert.ToInt16(Console.ReadLine());
i++;
}while(i<p);
Verificacion(b,p);

}

public static void Verificacion (int[] ver, int r)
{
int vc;
Console.WriteLine("Ingrese variable clave ");
vc=Convert.ToInt16(Console.ReadLine());

for(int j=0; j<r; j++){
if(vc==ver[j])
Console.WriteLine("Dato encontrado ==> Pocision {0}",j);
}
}

}

}

Elaborar una aplicación que forme dos arreglos

             Elaborar una aplicación que forme dos arreglos. El primero contiene los M códigos de los estudiantes que perdieron LÓGICA DE PROGRAMACION y el segundo los N códigos de     los estudiantes que perdieron ESTRUCTURA DE DATOS. Partiendo de los dos arreglos formar un nuevo arreglo con los códigos de los estudiantes que perdieron ambas materias.

/*

 * 

     using System;

     

     namespace Estudiantes

{

     class Program

{  

    public static void Main(string[] args)

   {

   string [] logic_prog = {"A5","A14","A21","A23","A25","A29","A33","A39","A41","A42"};

   string [] estruc_datos = {"B1","B4","B15","B16","B18","B22","B26","B28","B30","B39"};

   Info(logic_prog,estruc_datos);

   Console.ReadKey(true);

   }

 

    public static void Info(string[] lo_po, string[] es_da)

    {

   Console.WriteLine("Codigos de alumnos que perdieron ");

   Console.WriteLine(    "LOGICA DE PROGRAMACION ");

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

    Console.WriteLine(lo_po[i]);

     

   Console.WriteLine("Codigos de alumnos que perdieron ");

   Console.WriteLine(     "ESTRUCTURA DE DATOS ");

   for(int j=0; j<10; j++)

   Console.WriteLine(es_da[j]);

   NuevoVector(lo_po,es_da);

    }

    public static void NuevoVector (string[] a, string[] b)

    {

  string [] uni = new string [10];

  Console.WriteLine("Codigos de alumnos que perdieron ");

  Console.WriteLine("ESTRUCTURA DE DATOS Y LOGICA DE PROGRAMACION ");

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

  uni[i]=a[i];

   Console.WriteLine(uni[i]);

   }

  for(int m=0; m<10; m++){

  uni[m]=b[m];

  Console.WriteLine(uni[m]);

  }

  

   }

}

}

INGRESAR VECTORES EN UN SEGUNDO ARREGLO

           Ingresar 5 valores numéricos desde el teclado a un arreglo unidimensional, invertir los valores en un segundo arreglo, visualizar el contenido de los dos arreglos.

/*

 * 

    using System; 

   

     namespace Prog_arrays_invert

    {

     class Program

{

    public static int[] arreglo = new int [5];

   public static void Main(string[] args)

  {

 Datos(arreglo);

 Ejecucion(arreglo);

 Console.ReadKey(true);

  }

  public static void Datos (int[] a)

   {

  Console.WriteLine("Ingrese 5 valores ");

 for(int i=0;i<5;i++)

  a[i]=Convert.ToInt16(Console.ReadLine());

   }

   public static void Ejecucion (int[] b)

  {

 Console.SetCursorPosition(0,7);

 for(int j=0;j<5;j++){

 Console.Write("[{0}]" , b[j]);

 }

 Console.SetCursorPosition(0,9);

 for(int p=4;p>=0;p--){

 Console.Write("[{0}]" , b[p]);

 }

  }

}

}

Método de ordenamiento de Burbuja

using System;


namespace OrdenamientoBurbuja
{
class Program
{
public static void Main(string[] args)
{
const int limite=10;
            int[ ] lista = new int[limite];
            IngresarDatos(lista);
            OrderDatos(lista);
            VisualizarDatos(lista);
            
Console.ReadKey(true);
}

public static void IngresarDatos(int[ ] param)
        {
        for(int i=0;i<param.Length;i++)
        {
        Console.Write("Ingrese valor [{0}]: ",i);
        param[i]=Convert.ToInt16(Console.ReadLine());
         }
        }
        
        public static void OrderDatos(int[ ] param)
        {
            int aux;
            for(int pasada=0;pasada<param.Length;pasada++)
            {
             for(int b=0;b<param.Length-1;b++)
             {
             if(param[b]<param[b+1])
             {
             aux=param[b];
             param[b]=param[b+1];
             param[b+1]=aux;
              }
             }
            }
        }
        
        public static void VisualizarDatos(int[ ] param)
        {
            Console.WriteLine("Vector Ordenado...");
            for(int i=0;i<param.Length;i++)
            {
            Console.Write("{0}",param[i] + "  ");
            }
        }
        
    }
}

VECTOR QUE SUME LOS NÚMEROS PARES E IMPARES

  HHacer una aplicación que entre una serie de valores numéricos desde el teclado, los almacene en un vector y sume los elementos de las posiciones pares, lo mismo que las posiciones impares por separado.

/*

 * Creado por SharpDevelop.

 * Usuario: Anais

 * Fecha: 30/07/2011

 * Hora: 2:00

 * 

 * Para cambiar esta plantilla use Herramientas | Opciones | Codificación | Editar Encabezados Estándar

 */

using System;

namespace Sum_Pars_e_Impars

{

class Program

{

public static int[] valores = new int [10];

public static void Main(string[] args)

{

LecturaDatos(valores);

ProcesoDatos(valores);

Console.ReadKey(true);

}

public static void LecturaDatos(int[] par)

{

int i=0;

Console.WriteLine("Ingresa 10 valores numericos ");

while(i<10){

valores[i]=Convert.ToInt16(Console.ReadLine());

i++;

}

}

public static void ProcesoDatos(int[] parm)

{

int par=0, impar=0;

for(int j=0; j<10; j++){

if(j%2==0)

par+=parm[j];

}

for(int m=0; m<10; m++){

if(!(m%2==0))

impar+=parm[m];

}

Console.WriteLine("Suma de las pocisiones pares es:   ====> {0}",par);

Console.WriteLine("Suma de las pocisiones impares es: ====>    {0}",impar);

}

}

}

calcular la suma y el promedio de los números aleatorios de una matriz

using System;
using System.Collections.Generic;

namespace arreglo_tabla
{
class MainClass
{
public static void Main(string[] args)
{
int [,]tabla=new int [5,4];
int sum=0, promedio=0;
Random rnd=new Random();

for(int c=0; c<=4;c++)
{
for(int f=0; f<=3;f++)
{
tabla[c,f]=rnd.Next(1,30);
Console.WriteLine("{0}",tabla[c,f]);
sum=sum+tabla[c,f];

}
}
promedio=sum/20;
Console.WriteLine("Sumatoria={0}",sum);
Console.WriteLine("Promedio={0}",promedio);

Console.ReadKey();

}
}
}

Ingresar números aleatorios

using System;

namespace Num_Aleatorios
{

class Program
{

public static void Main(string[] args)
{
Random rnd = new Random( );

int[] num = new int[10];

for(int i=0;i<10;i++){
num[i]=rnd.Next(1,30);
}

for(int i=0;i<10;i++){
Console.WriteLine("Vector [{0}] = {1}",i,num[i]);
}
Console.ReadKey(true);
}
}
}

calcular el perímetro de una matriz

using System;
using System.Collections.Generic;

namespace perimetro_matriz
{
class MainClass
{
public static void Main(string[] args)
{
int[,] matriz = new int [5,5];

LlenandoMatriz(matriz);
Console.SetCursorPosition(15,20);
int diag = Perimetro(matriz);
Console.WriteLine("El Perimetro es => {0}",diag);


Console.ReadKey(true);
}

public static void LlenandoMatriz (int[,] pmatriz)
{
Random rnd = new Random();

int fil=0, col=15;
for(int i=0; i<5; i++){
fil=5;
for(int j=0; j<5; j++){
Console.SetCursorPosition(col,fil);
pmatriz[i,j]=rnd.Next(1,20);
Console.WriteLine("{0}",pmatriz[i,j]);
fil=fil+3;
}
col=col+6;
}
}

public static int Perimetro (int[,] pmatriz)
{
int p=0;
int sum1=0, sum2=0, sum3=0, sum4=0, sumatotal;

do{
for(int i=0; i<5; i++)
sum1+=pmatriz[p,i];
}while(p!=0);

int o=4;
for(int i=0; i<5; i++)
sum2+=pmatriz[o,i];

int f=0;
for(int i=0; i<5; i++)
sum3+=pmatriz[i,f];

int y=4;
for(int i=0; i<5; i++)
sum4+=pmatriz[i,y];


sumatotal=sum1+sum2+sum3+sum4;

return sumatotal;
}

}
}

sumatoria de la diagonal principal de una matriz

using System;
using System.Collections.Generic;

namespace matriz
{
class MainClass
{
public static void Main(string[] args)
{
int[,] tabla = new int [5,5];

LlenandoMatriz(tabla);
Console.SetCursorPosition(5,3);
int diag = Diagonal(tabla);
Console.WriteLine("Sumatoria de la Diagonal => {0}",diag);
Console.ReadKey(true);

}

public static void LlenandoMatriz (int[,] param)
{
Random rnd = new Random();

int fil=15, col=15;
for(int i=0; i<5; i++){
fil=5;
for(int j=0; j<5; j++){
Console.SetCursorPosition(col,fil);
param[i,j]=rnd.Next(1,15);
Console.WriteLine("{0}",param[i,j]);
fil=fil+2;
}
col=col+3;
}
}

public static int Diagonal (int [,] param2)
{
int a=0, i=0;
while(i<5){
a=a+param2[i,i];
i++;
}
return a;
}
}
public static int perimetro(int [,] pmatriz)
{
int p=0;
int sum1=0, suma2=0, suma3=0;

do{
for(int i=0;i<5;i++){
sum1+=pmatriz[p,i]
}
}
}


}

calcular la suma de la diagonal secundaria de la matriz

using System;

namespace programa_ab

{

class Program

{

public static void Main(string[] args)

{

int[,] matriz = new int [4,4];

LlenandoMatriz(matriz);

Console.SetCursorPosition(15,18);

int diag = DiagonalSecundaria(matriz);

Console.WriteLine("Sumatoria de la D. Secundaria => {0}",diag);

Console.ReadKey(true);

}

public static void LlenandoMatriz (int[,] pmatriz)

{

Random rnd = new Random();

int fil=0, col=15;

for(int i=0; i<4; i++){

fil=5;

for(int j=0; j<4; j++){

Console.SetCursorPosition(col,fil);

pmatriz[i,j]=rnd.Next(1,20);

Console.WriteLine("{0}",pmatriz[i,j]);

fil=fil+3;

}

col=col+6;

}

}

public static int DiagonalSecundaria (int[,] pmatriz)

{

int i=3, a=0;

while(i>=0){

for(int j=0; j<=3; j++){

a+=pmatriz[i,j];

i--;

}

}

return a;

}

}

}