Crear y cargar dos matrices de tamaño 3x3, sumarlas y mostrar su suma

package bol05ej03;
public class Main {
public static void main(String[] args) {
int a[][], b[][], suma[][];
int i,j;
a = new int[3][3];
b = new int[3][3];
// Leemos los datos
System.out.println ("Matriz A:");
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
System.out.print("A["+i+"]["+j+"]: ");
a[i][j]=Entrada.entero();
}
}
System.out.println ("Matriz B:");
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
System.out.print("B["+i+"]["+j+"]: ");
b[i][j]=Entrada.entero();
}
}
// hacemos la suma
suma = new int[3][3];
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
suma[i][j] = a[i][j] + b[i][j];
}
}
// mostramos los resultado
System.out.println ("Matriz Suma:");
for (i=0;i<3;i++)
{
for (j=0;j<3;j++)
{
System.out.print (suma[i][j] + " ");
}
System.out.println ();
}
}
}

Leer dos series de 10 enteros, que estarán ordenados crecientemente. Copiar (fusionar) las dos tablas en una tercera, de forma que sigan ordenados

package bol04ej14;
public class Main {
public static void main(String[] args) {
int a[], b[], c[];
int i,j,k;
a =new int[10];
b =new int[10];
// leemos a
System.out.println("Datos para a:");
for (i=0;i<10;i++){
System.out.print("Introduzca numero (orden creciente): ");
a[i]=Entrada.entero();
}
// leemos b
System.out.println("\nDatos para b:");
for (i=0;i<10;i++){
System.out.print("Introduzca numero (orden creciente): ");
b[i]=Entrada.entero();
}
System.out.println();
// creamos
c = new int [20];
// comenzamos a fusionar a y b en c
i=0; // utilizaremos i como índice de a;
j=0; // utilizaremos j como índice de b;
k=0; // utilizaremos k como índice de c
while(i<10 && j<10)
{
if (a[i] < b[j]) // nos interesa el elemento de a
{
c[k] = a[i];
i++; // incrementamos i para tomar el siguiente elemento de a
}
else
{
c[k] = b[j];
j++; // incrementamos j para tomar el siguiente elemento de b
}
k++; // como hemos copiado a c[k], incrementamos k, para
// en la siguiente vuelta, utilizar el siguiente hueco de la tabla
}
// cuando salimos de while es por que alguna de las tablas (a o b) ha llegado al final
if(i==10) // hemos copiado toda la tabla a en c, queda por copiar un resto de b
while (j<10)
{
c[k] = b[j];
j++;
k++;
}
else // hay que copiar el resto de a en c
while (i<10)

{
c[k] = a[i];
i++;
k++;
}
System.out.println("Mostramos la tabla c:");
for (k=0;k<20;k++)
System.out.print(c[k] + " ");
System.out.println("");
}
}

Leer 10 números enteros. Debemos mostrarlos en el siguiente orden: el primero, el último, el segundo, el penúltimo, el tercero, etc.

package bol04ej04;
public class Main {
public static void main(String[] args) {
int i, t[];
t = new int[10];
for (i=0;i<10;i++){
System.out.print("Introduzca numero: ");
t[i]=Entrada.entero();
}
System.out.println("El resultado es:");
for (i=0;i<=4;i++){
System.out.println (t[i]); // mostramos el i-ésimo número por el principio
System.out.println(t[9-i]); // y el i-ésimo por el final
}
// como en cada vuelta de for se muestran dos números
// para mostrarlos todos, solo necesitaremos la mitad de vueltas.
}
}

Leer 5 números por teclado y a continuación realizar la media de los números positivos, la media de los negativos y contar el número de ceros.

package bol04ej03;
public class Main {
public static void main(String[] args) {
int t[]=new int [5];
int suma_pos,cont_pos,suma_neg,cont_neg,cont_cero;
suma_pos=0;
cont_pos=0;
suma_neg=0;
cont_neg=0;
cont_cero=0;
// utilizamos un bucle para leer los datos y otro para procesarlos
// se podrían hacer ambas operaciones, leer y procesar, en un solo bucle
for (int i=0;i<5;i++){
System.out.print("Introduzca un número: ");
t[i]=Entrada.entero();
}
for (int i=0;i<5;i++){
if(t[i]==0)
cont_cero++;
else{
if(t[i]>0){
suma_pos=suma_pos+t[i];
cont_pos++;
}
else{
suma_neg=suma_neg+t[i];
cont_neg++;
}
}
}
if(cont_pos==0)
System.out.println("No se puede realizar la media de números positivos");
else
System.out.println("La media de los positivos: "+(float)suma_pos/cont_pos);
if(cont_neg==0)
System.out.println("No se puede realizar la media de números negativos");
else

System.out.println("La media de los negativos: " + (float)suma_neg/cont_neg);
System.out.println("La cantidad de cero es de: " + cont_cero);
}
}

Leer 5 números y mostrarlos en el mismo orden introducido

package bol04ej01;
public class Main {
public static void main(String[] args) {
int t[];
t = new int[5];
for (int i=0;i<5;i++)
{
System.out.print("Introduzca un número: ");
t[i]=Entrada.entero();
}
System.out.println("Los números son:");
for (int i=0;i<5;i++)
System.out.println(t[i]);
}
}

Realizar un programa que nos pida un número n, y nos diga cuantos números hay entre 1 y n que son primos.

package bol03ej06;
public class Main {
public static void main(String[] args) {
int j,num,cont_pri;
boolean primo;
cont_pri=0;
System.out.print("Introduce numero: ");
num=Entrada.entero();
// vamos procesando todos los números entre 1..num
for(int i=1;i<=num;i++){

// para cada número i, calcularemos si es primo
// veremos si el número i es divisible en el rango 2..i-1
// El bucle while se puede hacer con menos vuelta... consultar algoritmos para primos
primo=true;
j=2;
while (j<=i-1 && primo==true)
{
if (i%j==0)
primo=false;
j++;
}
if (primo==true){
cont_pri++; // si es primo incrementamos el contador de primos
System.out.println(i+(" es primo"));
}
}
System.out.println("En el rango 1.." + num + ", hay "+ cont_pri + " números primos");
}
}

Leer los datos correspondiente a dos tablas de 12 elementos numéricos, y mezclarlos en una tercera de la forma: 3 de la tabla A, 3 de la B, otros 3 de A, otros 3 de la B, etc

public class Main {
public static void main(String[] args) {
int a[], b[], c[];
int i,j;
a=new int[12];
b=new int[12];
// la tabla c tendrá que tener el doble de tamaño que a y b.
c = new int [24];
// leemos la tabla a
System.out.println("Leyendo la tabla a");
for (i=0;i<12;i++){
System.out.print("número: ");
a[i]=Entrada.entero();
}
// leemos la tabla b
System.out.println("Leyendo la tabla b");
for (i=0;i<12;i++){
System.out.print("número: ");
b[i]=Entrada.entero();
}
// asignaremos los elementos de la tabla c
// para las tablas a y b utilizaremos como índice i
// y para la tabla c utilizaremos como índice j.
j=0;
i=0;
Ejercicios de Programación en
while (i<12)
{
// copiamos 3 de a
for (int k=0;k<3; k++)
{
c[j]=a[i+k];
j++;
}
// copiamos 3 de b
for (int k=0;k<3;k++)
{
c[j]=b[i+k];
j++;
}
// como hemos copiado 3 de a y b, incrementamos la i en 3.
i+=3;
// la j se incrementa cada vez que se añade un elemento a la tabla c.
}
System.out.println("La tabla c queda: ");
for (j=0;j<24;j++) // seguimos utilizando j, para la tabla c. Aunque se podría utilizar i.
System.out.print(c[j]+" ");
System.out.println("");
}
}

Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A, el 1º de B, el 2º de A, el 2º de B, etc.

package bol04ej05;
public class Main {
public static void main(String[] args) {
int a[], b[], c[];
int i,j;
a=new int[10];
b=new int[10];
// la tabla c tendrá que tener el doble de tamaño que a y b.
c = new int [20];
// leemos la tabla a
System.out.println("Leyendo la tabla a");
for (i=0;i<10;i++){
System.out.print("número: ");
a[i]=Entrada.entero();
}
// leemos la tabla b
System.out.println("Leyendo la tabla b");
for (i=0;i<10;i++){
System.out.print("número: ");
b[i]=Entrada.entero();
}
// asignaremos los elementos de la tabla c
// para las tablas a y b utilizaremos como índice i
// y para la tabla c utilizaremos como índice j.
j=0;
for (i=0;i<10;i++){
c[j]=a[i];
j++;
c[j]=b[i];
j++;
}
System.out.println("La tabla c queda: ");
for (j=0;j<20;j++) // seguimos utilizando j, para la tabla c. Aunque se podría utilizar i.
System.out.print(c[j]+" ");
System.out.println("");
}
}

Leer 10 números enteros. Debemos mostrarlos en el siguiente orden: el primero, el último, el segundo, el penúltimo, el tercero, etc.

package bol04ej04;
public class Main {
public static void main(String[] args) {
int i, t[];
t = new int[10];
for (i=0;i<10;i++){
System.out.print("Introduzca numero: ");
t[i]=Entrada.entero();
}
System.out.println("El resultado es:");
for (i=0;i<=4;i++){
System.out.println (t[i]); // mostramos el i-ésimo número por el principio
System.out.println(t[9-i]); // y el i-ésimo por el final
}

// como en cada vuelta de for se muestran dos números
// para mostrarlos todos, solo necesitaremos la mitad de vueltas.
}
}

Leer 5 números por teclado y a continuación realizar la media de los números positivos, la media de los negativos y contar el número de ceros.

package bol04ej03;
public class Main {
public static void main(String[] args) {
int t[]=new int [5];
int suma_pos,cont_pos,suma_neg,cont_neg,cont_cero;

suma_pos=0;
cont_pos=0;
suma_neg=0;
cont_neg=0;
cont_cero=0;
// utilizamos un bucle para leer los datos y otro para procesarlos
// se podrían hacer ambas operaciones, leer y procesar, en un solo bucle
for (int i=0;i<5;i++){
System.out.print("Introduzca un número: ");
t[i]=Entrada.entero();
}
for (int i=0;i<5;i++){
if(t[i]==0)
cont_cero++;
else{
if(t[i]>0){
suma_pos=suma_pos+t[i];
cont_pos++;
}
else{
suma_neg=suma_neg+t[i];
cont_neg++;
}
}
}
if(cont_pos==0)
System.out.println("No se puede realizar la media de números positivos");
else
System.out.println("La media de los positivos: "+(float)suma_pos/cont_pos);
if(cont_neg==0)


System.out.println("No se puede realizar la media de números negativos");
else

Leer 5 números y mostrarlos en orden inverso al introducido.

package bol04ej02;
public class Main {
public static void main(String[] args) {
int t[]=new int[5];
for (int i=0;i<5;i++)
{
System.out.print("Introduzca un número: ");
t[i]=Entrada.entero();
}
System.out.println("Los números (en orden inverso):");
for (int i=4;i>=0;i--)
System.out.println(t[i]);
}
}

Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A, el 1º de B, el 2º de A, el 2º de B, etc

package bol04ej05;
public class Main {
public static void main(String[] args) {
int a[], b[], c[];
int i,j;
a=new int[10];
b=new int[10];
// la tabla c tendrá que tener el doble de tamaño que a y b.
c = new int [20];
// leemos la tabla a
System.out.println("Leyendo la tabla a");
for (i=0;i<10;i++){
System.out.print("número: ");
a[i]=Entrada.entero();
}
// leemos la tabla b

System.out.println("Leyendo la tabla b");
for (i=0;i<10;i++){
System.out.print("número: ");
b[i]=Entrada.entero();
}
// asignaremos los elementos de la tabla c
// para las tablas a y b utilizaremos como índice i
// y para la tabla c utilizaremos como índice j.
j=0;
for (i=0;i<10;i++){
c[j]=a[i];
j++;
c[j]=b[i];
j++;
}
System.out.println("La tabla c queda: ");
for (j=0;j<20;j++) // seguimos utilizando j, para la tabla c. Aunque se podría utilizar i.
System.out.print(c[j]+" ");
System.out.println("");
}
}

Punteros y esrtructura de datos C#

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

namespace Lista
{
    unsafe class PunterosEstructuras
    {

        static void Main(string[] args)
        {


            //********************************
            //** Utilización de estructuras **
            //********************************

            //Crea el objeto vacio
            Persona p1 = new Persona();


            //Crea el objeto con valores
            Persona p2 = new Persona("Angel", "Lopez", 30, 1.70);


            //Crea el objeto
            Persona p3;

            //Asigna valores
            p3.Nombre = "Susan";
            p3.Apellido = "Ochoa";
            p3.Edad = 27;
            p3.Estatura = 1.67;

            Console.Write("Nombre: {0} \n Apellido: {1} \n Edad: {2} Estatura: {3} \n", p3.Nombre, p3.Apellido, p3.Edad, p3.Estatura);
           


            //********************************
            //**         Punteros           **
            //********************************

 
                int ejemploEdad = 30;
                int* ejemploPuntero;
                Console.WriteLine("Edad [ejemploEdad]= {0} \n", ejemploEdad);


                //Declara variable Edad y le asigna 30
                int Edad = 30;

                //Declara puntero pEdad
                //pEdad apunta a una variable entera
                int* pEdad;
               
                //Obtiene la dirección de memoria
                //de la variable Edad y la asigna al puntero (&)
                pEdad = &Edad;

                //Imprime contenido de la variable Edad: 30
                Console.WriteLine("Edad= {0}\n", Edad);
                               
                //Realiza el direccionamiento indirecto del puntero,
                //imprime desde el puntero pEdad el contenido de Edad: 30 (*)
                Console.WriteLine("Edad [pEdad]= {0}\n", *pEdad);

                //Realiza el direccionamiento indirecto del puntero,
                //suma 3 desde el puntero pEdad y lo asigna al contenido de Edad: 33 (*)
                *pEdad += 3;
                Console.WriteLine("Edad= {0}\n", Edad);
             
                //Asignación de puntero a puntero
                ejemploPuntero = pEdad;
               
                //Realiza el direccionamiento indirecto del puntero,
                //suma 3 desde el puntero ejemploPuntero y lo
                //asigna al contenido de Edad: 35 (*)

                *ejemploPuntero += 2;
                Console.WriteLine("Edad= {0}", Edad);


                //********************************
                //**  Punteros  y  estructuras  **
                //********************************


                    //Crea el objeto loc
                    Location loc;

                    //Asigna valores a sus variables internas
                    loc.X = 90;
                    loc.Y = 10;


                    //Declara puntero pStruct
                    //pStruct apunta a una estructura
                    Location* pStruct;

                    //Obtiene la dirección de memoria
                    //de la estructura loc y la asigna al puntero (&)
                    pStruct = &loc;

                    //Para tener acceso a un miembro de una
                    //estructura a través de un puntero.  
                    Console.WriteLine("X = {0}", pStruct->X);

                    //Para tener acceso a un miembro de una
                    //estructura a través de un puntero.
                    //Modifica su valor
                    pStruct->X = 200;

                    Console.WriteLine("X = {0}", pStruct->X);

      }


        //**********************************
        //***Declaración de una estructura**
        //**********************************

        public struct Location
        {
            public int X;
            public int Y;          
        }

        public struct Persona
        {
            public string Nombre;
            public string Apellido;
            public int Edad;
            public double Estatura;

            public Persona(string _nombre, string _apellido, int _edad, double _estatura)
            {
                Nombre = _nombre;
                Apellido = _apellido;
                Edad = _edad;
                Estatura = _estatura;
            }
           
        }

    }
}

Listas enlazadas C#

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

namespace ListasEnlazadas
{
    class Program
    {
        static void Main(string[] args)
        {
            ListaEnlazable lista = new ListaEnlazable();

            for (int i = 0; i < 10; i++)
            {
                 lista.Add(i+"angel");
            }

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] +"\n");
            }


            Console.Write("\n");

            lista.Insert(3, "lopez");

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] + "\n");
            }

            string a = lista[3].ToString();
       


        }



        public class Nodo
        {

 
            public object  valor;//valor del nodo
            public Nodo proximo;//Enlace con otro nodo

            //Al constructor le pasamos un valor y un nodo próximo
            public Nodo(object valor, Nodo proximo)
            {
                this.valor = valor;
                this.proximo = proximo;
            }

            //O le pasamos un valor y por defecto el nodo próximo es null
            public Nodo(object valor): this(valor,null) {}

           
        }


        public class ListaEnlazable:IList
        {
            Nodo primero, ultimo;
            int contador;


            public ListaEnlazable()
            {
                //Inicializamos primero y último vacios
                primero = ultimo = new Nodo(null);
                contador = 0;
            }

       

            #region IList Members


            public int Add(object x)
            {
                //Nodo auxiliar con valor x
                Nodo elem = new Nodo(x);

                if (contador == 0)
                {
                    //Si la lista está vacia
                    primero = elem;
                }
                else
                {
                    //Enlazo el nuevo nodo desde el último
                    ultimo.proximo = elem;
                }

                contador++;
                //actualizo último
                ultimo = elem;

                return 0;
            }

            public void Insert(int index, object x)
            {
                //El índice está fuera de del array
                if (index < 0 || index > contador)
                    throw new IndexOutOfRangeException();

                //Creamos un nodo para recorrer la lista
                Nodo temp = primero;

                //Recorremos los nodos hasta la posición index-1

                for (int i = 0; i < index - 1; i++)
                    temp = temp.proximo;

                //Creamos un nuevo nodo con el valor x y lo enlazamos
                //con el nodo de la posición index

                Nodo nuevo = new Nodo(x, temp.proximo);
                temp.proximo = nuevo;
                contador++;

            }

            public int IndexOf(object x)
            {
               //Recorremos los nodos como vimos en el método anterior
                Nodo temp = primero;

                for (int i = 0; i < contador; i++)
                {
                    //si encontramos x
                    if (temp.valor.Equals(x))
                        //se retorna la posición
                        return i;
                    temp = temp.proximo;
                }

                //Si no está, retornamos -1
                return -1;
            }

            public bool Contains(object x)
            {
                //Retornamos true si el método devuelve un índice positivo
                return (IndexOf(x) >= 0);
             
            }

            public void Remove(object x)
            {
                Nodo temp = primero;

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

                    if (temp.valor.Equals(x))
                        temp = temp.proximo;
                }

            }

            public int Count
            {
                get { return contador; }
            }

            public object this[int index]
            {
                //aquí programamos como acceder al elemento
                get
                {
                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;

                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //se retorna el valor que está en index
                        return cursor.valor;
                   
                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");
                }
                //Aquí programamos como darle un valor al elemento
                //que está en la posición index
                set
                {

                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;
                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //cambiamos el valor del elemento que está en el index
                        cursor.valor = value;

                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");

                }

            }


           
            public void Clear()
            {
                throw new NotImplementedException();
            }
                 
            public bool IsFixedSize
            {
                get { throw new NotImplementedException(); }
            }

            public bool IsReadOnly
            {
                get { throw new NotImplementedException(); }
            }
         
            public void RemoveAt(int index)
            {
                throw new NotImplementedException();
            }
           

            #endregion

            #region ICollection Members
           
            public void CopyTo(Array array, int index)
            {
                throw new NotImplementedException();
            }

            public bool IsSynchronized
            {
                get { throw new NotImplementedException(); }
            }

            public object SyncRoot
            {
                get { throw new NotImplementedException(); }
            }
           
            #endregion

            #region IEnumerable Members
           
            public IEnumerator GetEnumerator()
            {
                throw new NotImplementedException();
            }
           
            #endregion
        }



    }
}

C#, calcular promedio anual

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

namespace TONELADAS
{
    class Program
    {
        static void Main(string[] args)
        {
           
           
            Console.Title = "JOSUE SANTANA !!!!!!!!!!!!!!^_^";
            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.BackgroundColor = ConsoleColor.Cyan;
            Console.Clear();
            double[] toneladas=new double[12];
            double prom;
            int c=0;
            int w = 0;
            double suma=0;
            int i;
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine(@"PROBLEMA: EN UN ARREGLO UNIDIMENSIONAL
SE HAN ALMACENADO EL NUMERO TOTAL DE TONELADAS DE CEREALES CONSECHADOS
DURANTE CADA MES DEL AÑO ANTERIOR");
            Console.WriteLine();
            Console.WriteLine();
            for (i = 0; i < 12; i++)
            {
                Console.Write("Toneladas cosechadas por mes: ");
                toneladas[i]=double.Parse(Console.ReadLine());
                suma += toneladas[i];

            }

            prom = suma / 12;

            for (i = 0; i < 12; i++)
            {
                if (toneladas[i] >= prom)
                {
                    c++;
                }
            }

            for (i = 0; i < 12; i++)
            {
                if (toneladas[i] < prom)
                {
                    w++;
                }
            }

   

            Console.WriteLine("El promedio anual de toneladas cosechadas: "+prom);

            Console.WriteLine("Meses cosecha superior al promedio anual : "+prom+" total: "+c);

            Console.WriteLine("Meses cosecha inferior al promedio anual  : " + prom + " total: " + w);
         


            Console.ReadLine();
        }
    }
}

Recursividad Fibonacci

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

namespace tarea
{
    class Program
    {
        static int Fibonaci(int n)
        {
            if ((n == 1 || n == 2))
            {
                return 1;
            }

            else
            {
                return Fibonaci(n - 1) + Fibonaci(n - 2);
            }



        }



        static void Main(string[] args)
        {
            int n;
            Console.WriteLine("Introduce un numero fibonacci: ");
            n = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("Serie fibonacci:"+n+"es"+Fibonaci(n));
            Console.Read();
        }
     
    }
}

Calcular el factorial recursivo

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

namespace Tarea
{
    class Factorial
    {
        public static int factorial(int n)
        {
            return n == 0 ? 1 : factorial(n - 1) * n;
        }

        public static void Main(string[] args)

        {
            Console.Write("Numero: ");
            int n = int.Parse(Console.ReadLine());

            Console.WriteLine("Factorial: {0}", factorial(n));
        }
    }
}
       

Trabajar con arrelgos, numero mayor,menor

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

namespace MayorMenor
{
    class Program
    {
        static void Main(string[] args)
        {
            int mayor = 0;
            //int mayor = -99;
            int menor = 99;
            int i, n, numero;

            Console.Write("Ingrese la cantidad de numeros a comparar: ");
            n = Int32.Parse(Console.ReadLine());

            for (i = 0; i < n; i++)
            {
                //Console.Write((i + 1) + " numero: ");
                Console.WriteLine("Numero: ");

                numero = Int32.Parse(Console.ReadLine());

                if (mayor < numero)
                {
                    mayor = numero;
                }

                if (menor > numero)
                {
                    menor = numero;
                }
            }

            Console.WriteLine("El numero mayor es: " + mayor);
           Console.WriteLine("El numero menor es: " + menor);

            Console.ReadKey();
        }
    }
}

/////////////////////////////////////////////////////////

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int mayor=0;
            int n, numero;
            int i;

            Console.WriteLine("Introduce la cantidad: ");
            n = Convert.ToInt32(Console.ReadLine());

            for (i =0; i < n;i++)
            {
                Console.WriteLine("numero: ");
                numero = Convert.ToInt32(Console.ReadLine());

                if (numero >mayor)
                {
                    mayor=numero;
                 
                }
   
            }

            Console.WriteLine("El mayor es: " + mayor);


            Console.Read();


        }
    }
}