/*
* 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();
/*
* 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 {
/*
* 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;
/*
*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();
/*
* 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 {
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) {
package unidad3ejercicio13;
import java.util.Arrays;
import java.util.Random;
/**
*
* @author juan
*/
public class Unidad3Ejercicio13 {
/**
* @param args the command line arguments
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];
package unidad3ejercicio9;
import java.util.Random;
import java.util.Scanner;
public class unidad3ejercicio10 {
public static void main(String[] args) {
/*
* 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;
/*
* 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]);
}
}
/*
* 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];
/*
*
* 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;
}
/*
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;
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)]);
}
*/
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));
}
}
/*
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];
*
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 {
/**
/*
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];
/*
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;
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);
}
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));
}
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);
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);