viernes, 28 de febrero de 2014

Programame: Divisores del factorial

El factorial de un número n es el resultado de multiplicar todos los números entre 1 y el propio n:
fact(n) = 1 · 2 · … · (n − 1) · n
Además, fact(0) = 1.
La pregunta que hoy nos hacemos no es cuál es el factorial de un número; ni siquiera cuál es el último dígito del factorial. La pregunta que nos hacemos es: si dividimos n! por un número p, ¿el resto es cero?

lunes, 24 de febrero de 2014

Unidad 3 Ejercicio 24: matriz latina

Hacer un programa que genere e imprima un cuadrado latino de orden 10 (matriz 10x10). Un cuadradado latino de orden n es aquel en el que la primera fila tiene los nº naturales del 1 a n,  y cada una de las filas restantes de la matriz es igual a su fila superior desplazada una posicion hacia la derecha, entrando por la izquierda el número que se pierde en el desplazamiento. Por ejemplo, un cuadrado latino de orden 5 es:

 1  2  3  4  5
 5  1  2  3  4
 4  5  1  2  3
 3  4  5  1  2
 2  3  4  5  1


Unidad 3 Ejercicio 20: Comprobar si una matriz es simétrica

Hacer un programa que averigüe si una matriz cuadrada de orden 4 es simétrica. Una matriz es simétrica cuando a[f][c]=a[c][f] para cualquier elemento de la matriz. /*


* 20. Hacer un programa que averigüe si una matriz cuadrada de orden 4 es simétrica.
* Una matriz es simétrica cuando a[f][c]=a[c][f] para cualquier elemento de la matriz.
*/
package unidad3ejercicio20;
import java.util.Random;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio20 {

    public static void main(String[] args) {
        int [][] matriz = new int[4][4];
        Random ale = new Random();
   

Unidad 3 Ejercicio 19: Matriz de orden 10 con la diagonal a 1.....

Hacer un programa que genere y escriba una matriz unitaria de orden 10. Una matriz unitaria de orden 10 es una matriz de 10x10 en la que todos los elementos valen 0, excepto los de la diagonal principal que valen 1. La diagonal principal es la que va de la esquina superior izquierda a la inferior derecha.


/*
* 19. Hacer un programa que genere y escriba una matriz unitaria de orden 10.
* Una matriz unitaria de orden 10 es una matriz de 10x10 en la que todos los
* elementos valen 0, excepto los de la diagonal principal que valen 1.
* La diagonal principal es la que va de la esquina superior izquierda a la inferior derecha.
*/
package unidad3ejercicio19;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio19 {

 

Unidad 3 Ejercicios 21 y 22

21.Hacer un programa que asigne números a una matriz de orden 4x5 comprendidos entre 1 y 10. El programa tiene que escribir la suma de los elementos de cada fila y la suma de los números que son pares de cada columna con el formato siguiente:

suma de los elementos de la fila 0 --> XX
suma de los elementos de la fila 1 --> XX
.................................................................
suma de los elementos de la fila 3 --> XX
-----------------------------------------
suma de los elementos pares de la columna 0 --> XX
suma de los elementos pares de la columna 1 --> XX
.....................................................................................
suma de los elementos pares de la columna 4 --> XX



Repetir el programa anterior, pero la suma de los elementos de cada fila tiene que almacenarse en un vector de 4 posiciones y la suma de los elementos pares de cada columna tiene que almacenarse en un vector de 5 posiciones.

viernes, 21 de febrero de 2014

Unidad 3 Ejercicio 18: Calcular menor y mayor y mostrar la matriz

Hacer un programa en el que se declare una matriz de dimensiones 5 x 8 (5 filas y 8 columnas) de datos de tipo entero. Asignarle a  los elementos de la matriz valores generados al azar y comprendidos entre 20 y 40. Calcular cuál es el elemento mas pequeño y mayor de la tabla. Escribir también la tabla para comprobar los resultados. La salida tiene que tener el formato:

Elemento menor: XX Fila: XX Columna: XX
Elemento mayor: XX Fila: XX Columna: XX

/*
* 18. Hacer un programa en el que se declare una matriz de dimensiones 5 x 8
* (5 filas y 8 columnas) de datos de tipo entero.
* Asignarle a  los elementos de la matriz valores generados al azar y
* comprendidos entre 20 y 40.
* Calcular cuál es el elemento mas pequeño y mayor de la tabla.
* Escribir también la tabla para comprobar los resultados.
* La salida tiene que tener el formato:

Elemento menor: XX Fila: XX Columna: XX
Elemento mayor: XX Fila: XX Columna: XX

*/
package unidad3ejercicio18;

import java.util.Random;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio18 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int [][] matriz;
 

Unidad 3 Ejercicio 17: Arrays bidimensionales (tablas o matrices) leer y asignar valores aleatorios

Hacer un programa en el que se declare una matriz de dimensiones 5 x 8 (5 filas y 8 columnas) de datos de tipo entero . Asignarle a  los elementos de la matriz valores generados al azar y comprendidos entre 20 y 40. Recorrer a continuación la matriz y escribir  en pantalla el valor de sus elementos.


/*
*17. Hacer un programa en el que se declare una matriz de dimensiones 5 x 8
* (5 filas y 8 columnas) de datos de tipo entero . Asignarle a  los elementos
* de la matriz valores generados al azar y comprendidos entre
* 20 y 40. Recorrer a continuación la matriz y escribir  en pantalla el valor
* de sus elementos
*/
package unidad3ejercicio17;
import java.util.Random;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio17 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int [][] matriz;
        Random aleatorio = new Random();
  

Unidad 3: Ejercicio 15 Uso de binarySearch en arrays

Asignarle a un vector 100 valores de tipo entero comprendidos entre 1 y 200. Leer por teclado un número y comprobar si coincide con alguno de los elementos del vector. Utilizar el método binarySearch.


/*
* 15. Asignarle a un vector 100 valores de tipo entero comprendidos entre 1 y
* 200.
* Leer por teclado un número y comprobar si coincide con alguno de los elementos
* del vector. Utilizar el método binarySearch.
*/
package unidad3ejercicio15;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Random;
/**
*
* @author Juan
*/
public class Unidad3Ejercicio15 {

 

lunes, 17 de febrero de 2014

Unidad 3: Ejercicio 14 el array anterior ordenado

 Visualizar el contenido del vector del ejercicio anterior ordenado alfabéticamente. 


package unidad3ejercicio14;

import java.util.Random;
import java.util.Arrays;

/**
*
* @author juan
*/
public class Unidad3Ejercicio14 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

Unidad 3: Ejercicio 13 Vector de nombres y apellidos

Hacer un programa en el que se declaren 3 vectores de nombres: nombre, apellido1 y apellido2, que tengan cada uno de ellos 10 nombres y 10 apellidos, dándole valores al declararlos sin que haya valores repetidos.

Declarar otro vector de nombre nombresApellidos de longitud 30, que contenga el contenido de los 3 vectores anteriores. Primero irán los nombres y después los apellidos. Asignarle valores a este vector utilizando el método arrayCopy.

a)      Escribir a continuación el nombre y apellidos de 5 personas, eligiendo aleatoriamente los valores de los vectores nombre,  apellido1 y apellido2. Estos 5 valores tienen que almacenarse previamente en un vector de 5 Strings de nombre nombresCompletos. Escribir los nombres ordenados alfabéticamente
a)      Repetir el apartado a) eligiendo los valores del vector nombresApellidos.

b)      (opcional)  Los nombres y apellidos no pueden estar repetidos.



import java.util.Arrays;
package unidad3ejercicio13;
import java.util.Arrays;
import java.util.Random;

/**
*
* @author juan
*/
public class Unidad3Ejercicio13 {

    /**
     * @param args the command line arguments
 

Unidad 3: Ejercicio 11 array de 25 datos enteros aleatorios entre 25 y 50

Declarar un vector de nombre lista que estará formado por 25 datos de 
 * tipo entero generados al azar comprendidos entre 25 y 50.

 Declarar otro vector de nombre auxi formado por 4 datos de tipo real. 
 * Almacenar en este vector  lo siguiente:

Posición 0: número de elementos pares en lista
Posición 1: número de elementos impares de lista
Posición 2: media de los términos impares de lista
Posición 3: suma de los números enteros comprendidos entre 1 y el valor par más 
pequeño del vector lista

Escribir a continuación el contenido del vector lista, así como los resultados
* obtenidos y almacenados en auxi.


package unidad3ejercicio11;
import java.util.Random;
/**
*
* @author Juan
*/
public class Unidad3Ejercicio11 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int lista [] = new int [25];

viernes, 14 de febrero de 2014

Unidad 3: Ejercicio 10

Hacemos uso de la clase Test definida previamente para realizar un examen:

Hacer un programa en el que se declare un vector de 10 datos de tipo Test, asignándole valores al declararlo. Plantear a continuación un examen con las 5 preguntas almacenadas en el vector seleccionándolas de manera aleatoria y sin que haya preguntas repetidas. Se visualizará el número de preguntas acertadas y falladas.

package unidad3ejercicio9;

   import java.util.Random;
import java.util.Scanner;

public class unidad3ejercicio10 {

public static void main(String[] args) {

Explicación Arrays 2

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package explicaciónarrays2;
import java.util.Scanner;
/**
*
* @author Juan
*/
public class ExplicaciónArrays2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner leo = new Scanner(System.in);
        int array1 [];
        int [] array2;
 

miércoles, 12 de febrero de 2014

Unidad 3: Ejercicio 9, Clase Test

/*
* 9. Diseñar una clase de nombre Test que nos permita representar una pregunta tipo test, la cual estará compuesta de un enunciado, cuatro posibles respuestas y la respuesta correcta. Estas tres propiedades privadas de la clase tendrán los nombres:

- Número de pregunta (int)
- enunciado.
- opciones. Array de 4 strings.
- valida. De tipo carácter. Guarda cual es la respuesta correcta

La clase tiene que implementar los métodos siguientes:

- setNumero, setEnunciado,  setOpciones,  setValida que asignarán cada uno de ellos lo valores de cada una de las propiedades.
- getNumero, getEnunciado, getValida, getOpciones que devuelven de manera respectiva cada una de las tres propiedades de la clase.
- Método de nombre presenta, que escribe de manera adecuada en pantalla la pregunta, y las cuatro posibles respuestas, precedidas de las letras a, b, c, d.

Comprobar el funcionamiento de la clase Test declarando dos objetos de dicha clase, y evaluar el funcionamiento de los métodos definidos.

*/
package unidad3ejercicio9;

/**
*
* @author juan
*/
public class Unidad3Ejercicio9 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String opcion1 [] = {"Estrella","Planeta","Planeta enano","Supernova"};
        String enunciado1= "El planeta tierra es:";
        Test pregunta1 = new Test(1,enunciado1,opcion1,'b');
       
       
        String opcion2[] = {"12","4","512","8"};
        Test pregunta2 = new Test();
        pregunta2.setEnunciado("¿Cuántos bits tiene un byte?");
        pregunta2.setNumero(2);
        pregunta2.setOpciones(opcion2);
        pregunta2.setValida('d');
       
        pregunta1.presenta();
        System.out.println("=====================");
        pregunta2.presenta();
   
    }
}


/**
*
* @author juan
*/
public class Test {
    private int numero;
    private String enunciado;
    private String [] opciones;
    private char valida;

    public Test(int numero, String enunciado, String[] opciones, char valida) {
        this.opciones = new String[5];
       
        this.numero = numero;
        this.enunciado = enunciado;
     
        System.arraycopy(opciones, 0, this.opciones, 0, opciones.length);
        /*
        for (int i = 0; i < opciones.length; i++) {
            this.opciones[i] = opciones[i];
           
        }
        */
        this.valida = valida;
    }

    public Test() {
        numero=0;
        enunciado="";
        opciones = new String[5];
       
    }

    public String getEnunciado() {
        return enunciado;
    }

    public void setEnunciado(String enunciado) {
        this.enunciado = enunciado;
    }

    public int getNumero() {
        return numero;
    }

    public void setNumero(int numero) {
        this.numero = numero;
    }

    public String[] getOpciones() {
        return opciones;
    }

    public void setOpciones(String[] opciones) {
           System.arraycopy(opciones, 0, this.opciones, 0, opciones.length);
    }

    public char getValida() {
        return valida;
    }

    public void setValida(char valida) {
        this.valida = valida;
    }
   
    public void presenta(){
        System.out.print(numero + ".- ");
        System.out.println(enunciado);
        System.out.printf("\t a.- %s%n",opciones[0]);
        System.out.printf("\t b.- %s%n",opciones[1]);
        System.out.printf("\t c.- %s%n",opciones[2]);
        System.out.printf("\t d.- %s%n",opciones[3]);
    }
   
   
   
}

Unidad 3: Ejercicio 8, ecuación segundo grado

/*
* 8. Hacer un programa en el que se declare un vector de 5 datos de tipo
* EcuacionSegundoGrado. A continuación, de manera aleatoria,
* a.- asignar al vector 5 ecuaciones que tengan solución.   Escribir los valores de
* las cinco ecuaciones, así como de sus soluciones.
* b.- Escribir también cuántas ecuaciones se generaron hasta dar con una válida
* para cada elemento del vector.
*/
package unidad2ejercicio8;
import java.util.Random;

/**
*
* @author juan
*/
public class Unidad2Ejercicio8 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        double a,b,c;
        Random aleatorio = new Random();
        int novalida=0;
        int i=0;
        EcuacionSegundoGrado vector [] = new EcuacionSegundoGrado[5];
       
   

lunes, 10 de febrero de 2014

Unidad 3: Ejercicio 7

/*
*
* 7. Dada la clase Fecha, hacer un programa en el que se declare un vector de
*
* 10 objetos de tipo Fecha (este vector almacenaría 10 fechas). 
* A la hora de crear el vector, todos sus elementos tienen que tener la fecha
* (1 de Abril de 2011).
* Asignarle a continuación a todas las fechas,
* valores generados de manera aleatoria. Por simplificar, todos los meses son
* de 30 días, y el año tiene que estar comprendido entre 2000 y 2008, ambos incluidos.
* Imprimir el contenido del vector, una vez generado, y una vez asignadas las nuevas fechas.
* Incrementar a continuación todas las fechas en 3 días, y volver a escribir el contenido del vector
* para comprobar que se hizo de manera correcta.

public class Fecha {
private int dia;
private int mes;
private int anyo;

public Fecha(int dia, int mes, int anyo) {
this.dia = dia;
this.mes = mes;
this.anyo = anyo;
}

Unidad 3: Ejercicio 6

/*
6. Verificar si una cadena de texto leída por teclado es un NIF correcto o no.
* Suponer que los NIFs tienen 8 dígitos y  a continuación una letra
* (no importa que sea mayúscula o minúscula).
PISTAS: dos condiciones que debe cumplir el NIF:
* tener 9 caracteres y que el último sea una letra.
* Comprobado esto, verificar que el resto de caracteres son dígitos.
Usar el método length() de java.lang.String para conocer el número de caracteres de una cadena de texto.
Usar el método estático isLetter(char c) de java.lang.Character para comprobar que un carácter es una letra.
Usar el método estático isDigit(char c) de java.lang.Character para comprobar que un carácter es un dígito.
Usar el método substring(int inicio, int fin) de java.lang.String para obtener la parte numérica del nif

*/
package unidad3ejercicio6;

import java.util.Scanner;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio6 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        char [] letraDni= {'T','R','W','A','G','M','Y','F','P','D','X','B','N','J','Z','S','Q','V','H','L','C','K','E'};
        String numDni;
        Scanner leo = new Scanner(System.in);
        boolean dniCorrecto = true;
        int cont =0;
 

Unidad 3: Ejercicio 5

public static void main(String[] args) {
        char [] letraDni= {'T','R','W','A','G','M','Y','F','P','D','X','B','N','J','Z','S','Q','V','H','L','C','K','E'};
        int numDni;
        Scanner leo = new Scanner(System.in);
       
        System.out.println("Introduzca el número de su DNI: ");
        numDni= leo.nextInt();
       
        System.out.println("La letra correspondiente es "+ letraDni[(numDni%23)]);
       
               
                }

Unidad 3: Viendo métodos carácter y cadena

     */
    public static void main(String[] args) {
        char a= 'a';
        char a9= '9';
        String cadena = "hola mundo";
      
        System.out.println("la variable 'a9' es un número? "+ Character.isDigit(a9));
        System.out.println("la variable 'a9' es un caracter? "+ Character.isLetter(a9));
        System.out.println("la longitud de cadena es"+cadena.length());
        System.out.println("Subcadena de la cadena"+ cadena.substring(3, 8));
   
    }
}

Unidad 3: Ejercicio 4 (de dos maneras distintas)

/*
4. Hacer un programa que almacene en un vector de 100 elementos números
* generados al azar comprendidos entre 20 y 50.
*
* Escribir los números generados, * visualizando 20 números por línea. 
*
* Escribir a continuación cuántos números fueron generados entre 21 y 30.
* La salida tiene que tener el formato:

El 21 apareció XX veces
El 22 apareció XX veces
.......................................
El 30 apareció XX veces
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package unidad2ejercicio4;
import java.util.Random;
/**
*
* @author Juan
*/
public class Unidad2Ejercicio4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int [] vector;
        Random aleatorio = new Random();
        int cont=0;
        int [] repeticiones = {0,0,0,0,0,0,0,0,0,0};
        vector= new int[100];
       
   

Unidad 3 Ejercicio 3 ( 2 formas distintas)

*
3. Hacer un programa que simule el lanzamiento de un dado 10.000 veces.
* Almacenar en un vector de 6 posiciones el número de veces que salió cada
* tirada, escribiendo a continuación el número de veces
* que salió cada cara del dado.

Calcular el tiempo que tarda en asignar al vector los 10.000 valores. Utilizar el método currentTimeMillis() de la clase System.

t0 = System.currentTimeMillis();
t1 = System.currentTimeMillis();
long tv = t1-t0;

*/
package unidad2ejercicio3;
import java.util.Random;
/**
*
* @author Juan
*/
public class Unidad2Ejercicio3 {

    /**
 

viernes, 7 de febrero de 2014

Unidad 3 Ejercicio2

/*
2. Almacenar en un vector 5 numeros enteros leidos por teclado.
* Leer a continuación otro número y comprobar si está en el vector o no.
* En el caso de que esté visualizar que posición ocupa;
* sino indicarlo mediante un mensaje.
* Visualizar tambien el elemento más pequeño, el más grande y la
* posición de ambos.
*/
package unidad3ejercicio2;
import java.util.Scanner;
import java.util.Arrays;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int numeros [] = new int [5];
  

Unidad 3 Ejercicio 1

/*
1. Hacer un programa que almacene en
* un vector de 5 elementos las ventas anuales de cada una de las 5 tiendas de una
* cadena de supermercados (asignárselos al vector al declararlo).
* A continuación calcular cuál fue la tienda que menos vendió,
* cuál fue la que más vendió y el importe total de ventas de las 5 tiendas. */
package unidad3ejercicio1;

import java.util.Arrays;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int ventas [] = {100,250,25,68,40};
        int mayor, menor, total=0;
        int posMayor, posMenor;
       
        mayor=menor=ventas[0];
        posMayor=posMenor=0;
       
  

Explicación Arrays

Declaración y recorrido de arrays 

public class Arrays1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int [] vector;
        String vector2[];
        String[]  vector3 = {"Enero","Febrero","Marzo","Abril"};
       
        vector = new int[10];
        vector2 = new String [15];
       
        for (int i = 0; i < 10; i++) {
            vector[i]=i;
            vector2 [i]=Integer.toString(i*i);
        }
   

miércoles, 5 de febrero de 2014

Ejercicio 3

Pedir números por teclado hasta leer diez impares y mostrar:
- números introducidos
- números impares
- números pares
- media de todos los números     


public static void main(String[] args) {
        Scanner leo= new Scanner(System.in);
        int numero,cont=0,contPares=0,contImpares=0,suma=0;
  
        do
        {
          
            System.out.println("Introduzca un número: ");
            numero=leo.nextInt();
          
            if (numero%2==0) ++contPares;
            else ++contImpares;
            ++cont;
            suma+=numero;
      
        }while(contImpares<10);
      
        System.out.println("Pares: "+ contPares);
        System.out.println("Impares: "+ contImpares);
        System.out.println("Total de números: "+ (contPares+contImpares));
        System.out.println("Media: "+ (((double)suma)/cont));
    }

Calcular primos entre 1 y n

public static void main(String[] args) {

     Scanner leo = new Scanner (System.in);
        int j,suma,numero=0;
        boolean incorrecto,primo;
       
        do
            try{
                System.out.println("Introduzca un número");
                numero= leo.nextInt();
                incorrecto=false;
            }
            catch(Exception e){incorrecto=true;}
        while(incorrecto);
     

Calcular los números defectivos hasta el leído

public static void main(String[] args) {
        Scanner leo = new Scanner (System.in);
        int suma,numero=0;
        boolean incorrecto;
       
        do
            try{
                System.out.println("Introduzca un número");
                numero= leo.nextInt();
                incorrecto=false;
            }
            catch(Exception e){incorrecto=true;}
        while(incorrecto);