1) Hola Mundo .net

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

namespace HolaMundo
{

class Program

{

static void Main(string[] args)

{

Console.WriteLine(“Hola Mundo .net”);

Console.ReadLine();

}

}

}

 

Hola Mundo .net

Hola Mundo .net

Anuncios

41) Hilos

Los hilos o Threads son básicamente procesos, de forma que se puede realizar más de un proceso a la vez de forma simultánea.

package hilos;

public class Hilos {

public static void main(String[] args) {

Thread hilo = new Proceso (“Proceso 1”);
Thread hilo2 = new Proceso (“Proceso 1”);

hilo.start();
hilo2.start();
}

}

hilos

package hilos;

public class Proceso extends Thread {

public Proceso(String msg) {

super(msg);

}

public void run( ) {

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

System.out.println(this.getName());

}

}

}

hilos1

40) Calculadora

import java.util.Scanner;

public class Parser {

public static void main(String[ ] args){

String str = “”;
Scanner in = new Scanner(System.in);
Calculadora C= new Calculadora( );

System.out.print(“Ingrese la expresión regular:”);
str = in.nextLine( );

if(str.substring(0,1).equals(“=”)&& str.length() > 1) {

C.setValor(str);
Double valor = C.getResultado( );
if(valor !=null) {

System.out.println(“El resultado obtenido es: ” + valor.doubleValue());

}
else {

System.out.println(“La expresión: \”” + str + “\” no se puede evaluar !!”);

}

}
else{

System.out.println(“La expresión: \”” + str + “\” no se puede evaluar !!”);

}

}

}

Calculadora Resultado

===============================================================

import java.util.ArrayList;

public class Calculadora {

private ArrayList<String> Numeros;
private ArrayList<String> Operador;
private Double Resultado;

public Calculadora( ){

Numeros = new ArrayList<String>( );
Operador = new ArrayList<String>( );
Resultado = new Double(0);

}

public void setValor(String str) {

String copy = str.substring(1,str.length( ));
int i=0;
do{

char [ ]cadena = copy.toCharArray();

switch(cadena[i]){

case ‘+’: Numeros.add(copy.substring(0,i));

Operador.add(“+”);
copy = copy.substring(i+1);
i = 0;
break;

case ‘-‘: Numeros.add(copy.substring(0,i));

Operador.add(“-“);
copy = copy.substring(i+1);
i = 0;
break;

case ‘/’: Numeros.add(copy.substring(0,i));

Operador.add(“/”);
copy = copy.substring(i+1);
i = 0;
break;

case ‘*’: Numeros.add(copy.substring(0,i));

Operador.add(“*”);
copy = copy.substring(i+1);
i = 0;
break;

default: i++;

if(i == copy.length()){

Numeros.add(copy);
copy = null;

}
break;

}

}while (copy != null);

}

private void getProcesar( ){

double resultado = 0;
int i = 0;
int j = 0;
boolean paso = true;

while(j < Operador.size( )){

double v1 = 0;
double v2 = 0;
if (paso){

String s1 = Numeros.get(i).toString( );
String s2 = Numeros.get(i+1).toString( );

try{

v1 = Double.parseDouble(s1);
v2 = Double.parseDouble(s2);

}
catch(NumberFormatException N){

Resultado = null;
return;

}
catch(Exception E) {

Resultado = null;
return;

}
i+=2;

}
else{

String s2 = Numeros.get(i).toString();
v1 = 0;
try {

v2 = Double.parseDouble(s2);

}
catch(NumberFormatException N) {

Resultado = null;
return;

}
catch(Exception E){
Resultado = null;
return;
}
i++;

}
if(Operador.get(j).toString().equals(“+”)) {

if(paso){
resultado = v1 + v2;
paso = false;

}
else{

resultado += v2;

}

}
else if(Operador.get(j).toString().equals(“-“)) {

if(paso){

resultado = v1 – v2;
paso = false;

}
else{
resultado -= v2;
}

}
else if(Operador.get(j).toString().equals(“*”)) {

if(paso){

resultado = v1 * v2;
paso = false;

}
else {

resultado *= v2;

}

}
else if(Operador.get(j).toString( ).equals(“/”)) {

if(paso) {

resultado = v1 / v2;
paso = false;

}
else {

resultado /= v2;

}

}
j++;

}

Resultado = new Double(resultado);

}

public Double getResultado( ) {

getProcesar();
return Resultado;

}

}

Calculadora

39) Ordenamiento Quicksort

public class Ordenamiento_Quicksort {

public static void main(String[ ] args) {

int[ ] arreglo = {5, 11, 7, 15, 4, 12, 75, 1, 3, 6, 23, 45, 13};
Ordenador o = new Ordenador( );
o.OrdenadorQuicksort(arreglo);

for (int i = 0; i < arreglo.length; i++)

{

System.out.println(arreglo[i]);

}

}

}

Ordenamiento Quicksort

 

===============================================================

 

public class Ordenador {

public void OrdenadorQuicksort(int[ ] array) {
array = quicksort1(array);
}

public int[ ] quicksort1(int numeros[ ]) {

return quicksort2(numeros, 0, numeros.length – 1);

}

public int[ ] quicksort2(int numeros[], int izq, int der) {

if (izq >= der) {

return numeros;

}
int i = izq, d = der;
if (izq != der) {

int pivote;
int aux;
pivote = izq;

while (izq != der) {

while (numeros[der] >= numeros[pivote] && izq < der) {

der–;

}
while (numeros[izq] < numeros[pivote] && izq < der) {

izq++;

}

if (der != izq) {

aux = numeros[der];
numeros[der] = numeros[izq];
numeros[izq] = aux;

}

}

}
if (izq == der) {

quicksort2(numeros, i, izq – 1);
quicksort2(numeros, izq + 1, d);
} else {

return numeros;

}
return numeros;

}

}

Quicksort

38) Ordenamiento por Inserción (Insertion Sort)

public class Ordenamiento_Insercion {

public static void main(String[ ] args) {

int [ ] arreglo = {5,7,11,15,4,12,23,3,2,1,45,13,67,92};
Ordenador o = new Ordenador( );
o.OrdenarInsercion(arreglo);

for(int i=0; i<arreglo.length; i++)
{

System.out.println(arreglo [i]);

}

}

}

Ordenamiento por Insercion

===============================================================

public class Ordenador {

public void OrdenarInsercion(int[ ] array) {

int aux;
int cont1;
int cont2;

for (cont1 = 1; cont1 < array.length; cont1++) {

aux = array[cont1];
for (cont2 = cont1 – 1; cont2 >= 0 && array[cont2] > aux; cont2–) {

array[cont2 + 1] = array[cont2];
array[cont2] = aux;

}

}

}

}

Resultado Insercion

37) Ordenamiento Burbuja (Bubble Sort)

public class Ordenamiento_Burbuja {

/**
* {5,3,4,2}
* {3,4,2,5}
* {3,2,4,5}
* {2,3,4,5}
*/
public static void main(String[ ] args) {

int [ ]arreglo = {5,3,4,2};
Ordenador o = new Ordenador();
o.OrdenadorBurbuja(arreglo);
for(int i=0; i<arreglo.length; i++)
{

System.out.println(arreglo[i]);

}

}

}

Ordenamiento Burbuja

==============================================================

public class Ordenador {

public void OrdenadorBurbuja(int[ ] array) {
int aux;
boolean cambios = false;

while (true) {

cambios = false;
for (int i = 1; i < array.length; i++) {

if (array[i] < array[i – 1]) {

aux = array[i];
array[i] = array[i – 1];
array[i – 1] = aux;
cambios = true;

}

}

if (cambios == false) {

break;

}

}

}

}

Ordenamiento Burbuja Resultado burbuja

36) Colas

Método OFFER:     Añadir un dato

Método POLL:        Obtener un dato

FILO (Firts-in, Firts-out) El primer dato que se ingresa es el que vamos a poder obtener

import java.util.LinkedList;

public class Colas {

public static void main(String[ ] args) {

LinkedList cola = new LinkedList( ); //Crear cola

for(int i=1;  i<11; i++)

cola.offer(i);

while(cola.peek( )!=null)//El método peek NO ELIMINA valores de la cola
{

System.out.println(cola.poll( )); //El método poll SI ELIMINA valores de la cola

}

}

}

Colas