2° ejemplo

como vimos anterirormente el ejemplo anteriro es muy didactico pero es hora de ver algo mas de level entonces:::.............

//NOTA "NUNCA USAR BURBUJA"
public class arreglo{

    public static void main(String[] args) {
        int n, m, i, j;
        int empresa;
        n = 2;
        m = 12;

        empresa = (int) (Math.random() * 10 + 1);
        int arreglo[][] = new int[n + 1][m + 1];
        int temporal1[] = new int[m + 1];
        int temporal2[] = new int[m + 1];
        for (int h = 0; h < empresa; h++) {
            for (i = 0; i < n; i++) {
                for (j = 0; j < m; j++) {
                    arreglo[i][j] = (int) (Math.random() * 2000 + 1001);

                    System.out.println(arreglo[i][j]);
                }
                System.out.println("FIN DE AñO");
            }
            System.out.println("Fin de empresa ");

            for (int t = 0; t < m; t++)//Transfiere a un temporal empresa 1
            {
                temporal1[t] = arreglo[0][t];
            }
            for (int w = 0; w < m; w++)//Transfiere a un temporal empresa 2
            {
                temporal2[w] = arreglo[1][w];
            }
            quick_sort(temporal1, 0, temporal1.length - 1);
            quick_sort(temporal2, 0, temporal2.length - 1);
            System.out.println("la mayor venta en el 1° año es " + temporal1[m]);
            System.out.println("la menor venta en el 1° año " + temporal1[1]);
            System.out.println("la mayor venta en el 2° año " + temporal2[m]);
            System.out.println("la menor venta en el 2° año " + temporal2[1]);
            System.out.println();
        }
    }

//Aca esta el quick sort lo llame como metodo veran como se transfieren los datos
    public static void quick_sort(int array[], int low, int n) {
        int bajo = low;
        int alto = n;
        if (bajo >= n) {
            return;
        }
        int pivote = array[(bajo + alto) / 2];
        while (bajo < alto) {
            while (bajo < alto && array[bajo] < pivote) {
                bajo++;
            }
            while (bajo < alto && array[alto] > pivote) {
                alto--;
            }
            if (bajo < alto) {
                int T = array[bajo];
                array[bajo] = array[alto];
                array[alto] = T;
            }
        }
        if (alto < bajo) {
            int T = alto;
            alto = bajo;
            bajo = T;
        }
        quick_sort(array, low, bajo);
        quick_sort(array, bajo == low ? bajo + 1 : bajo, n);
    }
}

Personalmente yo prefiero usar este metodo que el de burbuja unos de mis motivos es la fiabilidad.
Ami me paso que a veces la burbuja me fallaba aunque este bien la logica y ademas con el tiempo y practica asumes formas mas elaboradas de programar

Share:

Read More

Primos en un arreglo

Ahora buscaremos numeos primos en un arreglo es sencillo ya rapido solo refrescaremos que primo es aquel divisible sobre si y el 1.

/*
 * Realizar el programa que asigne a un arreglo lineal n numeros enteros
 * se pide calcular e imprimir cuantos numeros primos existen en el arreglo.
 */
package arreglos;

/**
 *
 * @author Jonathan
 */
public class arreglos1{

    public static void main(String[] args) {
        int n, i, cnp = 0, res;
        n = (int) (Math.random() * 100);
        int num[] = new int[n + 1];
        for (i = 0; i < n; i++) {
            num[i] = (int) (Math.random() * 100);
            res = 0;
            for (int j = 1; j <= num[i]; j++) {
                if (num[i] % j == 0) {
                    res++;
                }
            }
            if (res == 2) {
                cnp++;
                System.out.println("numero primo =" + num[i]);
            }

        }
        System.out.println("La cantidad de numeros primos es :" + cnp);
    }
}

Ya vimos un unidimensional tenemos la idea apliquemos al bidimensional.

/* 
* Realizar el programa que asigne aleatoriamente a un arreglo bidimensional 
* de mxn elementos datos de tipo entero, se pide calcular e imprimir cuantos 
* nùmeros primos existen en cada fila y en cada columna del arreglo. 
*/ 
package arreglos;

public class arreglos2{

    public static void main(String[] args) {
        int m, n, i, j, cnp, res;
        m = (int) (Math.random() * 10 + 2);
        n = (int) (Math.random() * 10 + 2);
        int beta[][] = new int[m + 1][n + 1];
        cnp = 0;
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                beta[i][j] = (int) (Math.random() * 100);
                res = 0;
                for (int k = 1; k <= beta[i][j]; k++) {
                    if (beta[i][j] % k == 0) {
                        res++;
                    }
                }
                if (res == 2) {
                    cnp++;
                    System.out.println("numero primo =" + beta[i][j]);
                }

            }
        }//Fin de la generacion de filas
        System.out.println("La cantidad de numeros primos en la fila " + i + " son:" + cnp);
        for (j = 0; j < n; j++) {
            for (i = 0; i < m; i++) {
                beta[i][j] = (int) (Math.random() * 100);
                res = 0;
                for (int k = 1; k <= beta[i][j]; k++) {
                    if (beta[i][j] % k == 0) {
                        res++;
                    }
                }
                if (res == 2) {
                    cnp++;
                    System.out.println("numero primo =" + beta[i][j]);
                }

            }
        } //Fin de la generacion de columnas

        System.out.println("La cantidad de numeros primos en la columna " + j + " son:" + cnp);
    }
}

http://www.mediafire.com/?mgtybdwnjmb

Share:

Read More

Java programa 4 Ordenar un arreglo

Bueno llegamos al capitulo en el cual tengamos que ordenar un arreglo a la hora de mostrar o ordenarlo fisicamente pero como lo hacemos ya que hay muchos elementos para eso esta la forma mas simple el metodo de burbuja.
Aclaro una cosa es el metodo mas simple de ordenamiento pero no es el mas eficaz con esto digo que hay veces que te pueda fallar ya que sirve mas para entender como es el ordenamiento.
Para ordenar un arreglo de forma mas eficaz esta el quick short que por asi decirlo es demasiado mas complicado. Es por ello que primero veamos esta forma para entender luego el otro.

Usamos Frame para mostrar pero si ven el metodo ordenamBurbuja( arreglo ) que es que lo hace lo podran adaptar a consola.

import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author JONATHAN PALOMINO VILCA
 */
public class Burbuja1 extends JFrame{

    public Burbuja1() {
        setSize(400, 300);
        setLocation(300, 300);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        JTextArea areaSalida = new JTextArea();
        Container contenedor = getContentPane();
        contenedor.add(areaSalida);

        int arreglo[] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37};

        String salida = "Elementos de datos en su orden original\n";

// anexar los valores originales al String salida
        for (int contador = 0; contador < arreglo.length; contador++) {
            salida += " " + arreglo[ contador];
        }

        ordenamBurbuja(arreglo); // ordenar arreglo

        salida += "\n\nElementos de datos en orden ascendente\n";

// anexar los valores ordenados del arreglo al String salida
        for (int contador = 0; contador < arreglo.length; contador++) {
            salida += " " + arreglo[ contador];
        }

        areaSalida.setText(salida);

    }
// ordenar elementos del arreglo con el método burbuja
    public void ordenamBurbuja(int arreglo2[]) {
// ciclo para controlar número de pasadas
        for (int pasada = 1; pasada < arreglo2.length; pasada++) {

// ciclo para controlar número de comparaciones
            for (int elemento = 0;
                    elemento < arreglo2.length - 1;
                    elemento++) {

// comparar elementos uno a uno e intercambiarlos si
// el primer elemento es mayor que el segundo
                if (arreglo2[ elemento] > arreglo2[ elemento + 1]) {
                    intercambiar(arreglo2, elemento, elemento + 1);
                }

            } // fin del ciclo para controlar las comparaciones

        } // fin del ciclo para controlar las pasadas

    } // fin del método ordenamBurbuja

// intercambiar dos elementos de un arreglo
    public void intercambiar(int arreglo3[], int primero, int segundo) {
        int almacen; // área temporal de almacenamiento para intercambiar

        almacen = arreglo3[ primero];
        arreglo3[ primero] = arreglo3[ segundo];
        arreglo3[ segundo] = almacen;
    }

    public static void main(String[] args) {
        Burbuja1 obj = new Burbuja1();
        obj.show();
    }
} // fin de la clase OrdenamBurbuja

Link del proyecto = http://www.mediafire.com/?yhzdmzuyymz

Share:

Read More