Mcd,Mcm java

Ahora veamos la forma en que hallamos el mcm y mcd dando un ejemplo sencillo podran modificarlo y aplicarlo.
En este caso vemos que asigno numeros uds. le pueden poner un Math.ramdom() para que sean variable o cualquier cosa que imaginen.

/*
* Dado 2 numeros enteros calcular su maximo comun divisor
* y su minimo comun divisor.
*/

package problemasunfv;

/**
*
* @author JONATHAN
*/
public class mcmymcd {

public static void main(String[] args) {
int a,b,t,t1,x;
a=10;
b=20;
t=1; //constante inicializada para evitar la multiplicidad x cero
x=2; //constante inicial

while (x<=a && x<=b)
{
while (a%x==0 && b%x==0)
{
a=a/x;
b=b/x;
t=t*x;
}
x++;
}
t1=t;
t=t*a*b;
System.out.println("El mcm es :" +t);
System.out.println("El mcd es :" +t1);
}

}

Ahora veamos como hacer imprimir numeros que comiensan y termionan con la misma cifra.
El codigo esta aqui:

/*
* Realizar el programa que asigen aleatoriamente n numeros enteros se pide
* calcular e imprimir cuantos numeros empiesan y terminan en la misma cifra.
*/

package problemasunfv;

public class numeros {
public static void main(String[] args) {
int n,i,d,d1=0,contador = 0;

n=(int)(Math.random()*20);
if (n==0)
n=1;
i=1;
while (i<=n)
{
d=(int)(Math.random()*1000);
System.out.println(d);
int r=1,k=0;
k=d;
d1=k%10;
while (d!=0)
{
r=d%10;
d=d/10;
}
//System.out.println(r+" y "+d1);
if (r==d1)
{
//System.out.println("Si cumple la condicion");
contador++;
}
else
{
//System.out.println("No cumple la condicion");
}
i++;
}
System.out.println("Son en total "+contador+" los que cumplen con la condicion");
}
}

Ahora hay formas graficas de aplicarlos pero eso esta en el archivo que adjunto lo descargan y veran que es sencillo.

Link = http://www.mediafire.com/?jy4dxznikn3

Share:

Read More

Funciones trigonometricas en una tabla

Hagamos una tabla de funciones trigonometricas es muy sencillo asi q manos a la obra.

/**
*
* @author JONATHAN
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
double sen,cos,tan,cotg,sec,csc,d;
int i=0;

System.out.println("***********************************************************************************************************************************************************************************");
System.out.println("*\t\t\t\t\t\t\t\tRazones trigonometricas\t\t\t\t\t\t\t\t\t\t\t *");
System.out.println("***********************************************************************************************************************************************************************************");
System.out.println("Angulo \tSeno\t\t\tCoseno\t\t\ttangente\t\t\tcotangente\t \tsecante\t\t cosecante");
System.out.println("***********************************************************************************************************************************************************************************");
System.out.println(0+" \t"+Math.sin(0)+" \t\t\t"+Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
while (i<30) {
i=i+15;

d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}
for(i=37;i<=53;i=i+8){

d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}

for(i=60;i<90;i=i+15){
d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}

System.out.println(90+" \t"+(Math.sin(0)+1)+"\t\t\t "+(Math.cos(0)-1)+"\t\t\tinfinito"+ "\t\t\t"+0.0+"\t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
System.out.println(180+" \t"+Math.sin(0)+" \t\t\t"+-Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(-1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
for(i=210;i<270;i=i+30){
d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
System.out.println(270+" \t"+-(Math.sin(0)+1)+" \t\t"+(Math.cos(0)-1)+"\t\t\tinfinito"+ "\t\t\t"+0.0+"\t\t\t"+-(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
System.out.println(360+" \t"+Math.sin(0)+" \t\t\t"+Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
}
}
}


Link = http://www.mediafire.com/?drro1xmgm3y

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

Share:

Read More

Funciones trigonometricas en una tabla

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

Maximos y minimo en un arreglo

Como dice el nombre del paquete este fue una pregunta de examen del profe huapaya es encillo usamos la burbuja para buscar.

package examen;
public class Main {
public static void main(String[] args) {
int m,n,i,j,j1=0,max = 0,min = 0;
m=(int)(Math.random()*10);
n=24;
int emp[][] =new int [m+2][n+2];

for(i=0;i{
for(j=0;j {
emp[i][j]=(int)(Math.random()*2001+1000);
System.out.println(emp[i][j]+" "+i+" "+j);
j1=j;

while(emp[i][j1]>emp[i][j1+1] && j1!=25)
{

max=emp[i][j1];

j1=j1+1;
}

}
System.out.println("El maximo sera "+max);
System.out.println("El minimo sera "+min);
}
}
}

link = http://www.mediafire.com/?zmurf3jiliy

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

Java programa 3 -- Arreglos Bidimensionales

Bueno este ejemplo es para un arreglo bidimensional esta es la sumilla.
Como veran es un ejemplo sencillo donde veran como asignar numeros a un arreglo bidimensional teniendo esta idea podran hacerlo para multiples dimensiones-

/*
* Realizar un programa que asigne aleatoriamente a un arreglo de m x n (entero)
* se pide calcular e imprimir la cantidad de números
* que empiezan y terminan con las misma cifra en las dos diagonales
* principales del arreglo cuando m = n ..
*/
package arreglodiagonal;

public class arreglodiagonal {

public static void main(String[] args) {
int m,i,j,n=0,t=0,k=0,q=0,x = 0,c=0;
m=3;
int delta[][] = new int[m+1][m+1];
for (i=0;i0)
{
x=n%10; //resto
y=n/10; //cociente;
n=y;
}
System.out.println("es "+x+ " y "+t);
}
//Fin de condicional de diagonal
k=x*10+t;


}

}


System.out.println("es la cantidad de numeros que comiensan y terminan " +
"con la misma cifra en la 1° diagonal son "+c);
}
}

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

Share:

Read More