EL FUTURO DEL CEREBRO (PROGRAMATE TODO)

viernes, 27 de noviembre de 2015

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("");
}
}

jueves, 26 de noviembre de 2015

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

}
}