public static void main(String[] args) {
int[] numeros= {1,2,3,4,5};
System.out.println(Arrays.toString(rotarDerecha(numeros,2)));
System.out.println(Arrays.toString(numeros));
}
/*
* Crear una función rotarDerecha a la que la pasamos un
* array de enteros y nos devuelve el array con los elementos
* desplazados a la derecha (el último va al principio)
rotarDerecha([1,2,3,4]) -> [4,1,2,3]
*/
public static int[] rotarDerecha(int[] array, int pos) {
int longitud=array.length;
int[] nuevo=new int[longitud];
// En el primero pongo el último
// En los siguientes del nuevo pongo el que está en
// la posición anterior del que me pasan
//nuevo[0]=array[array.length-1];
for(int i=0;i<longitud;i++) {
nuevo[i]=array[(i-pos+longitud) % longitud];
}
return nuevo;
}
public static int paridadArray(int[] numeros) {
// Dos contadores: pares e impares
int pares = 0;
int impares = 0;
for (int numero : numeros) {
if (numero % 2 == 0) {
pares++;
} else {
impares++;
}
}
switch (Integer.compare(pares, impares)) {
case -1:
return 1;
case 1:
return 2;
default:
return 0;
}
}
public static boolean hayDuplicados(int[] numeros) {
int[] ordenado=numeros.clone();
Arrays.sort(ordenado);
// { 1, 2, 3, 4, 6,5,1 }->{1,1,2,3,4,5,6}
for(int i=0;i<ordenado.length-1;i++) {
if (ordenado[i]==ordenado[i+1]) {
return true;
}
}
return false;
}
// Sin ordenar la receta es lo que haría yo
public static boolean hayDuplicadosSin(int[] numeros) {
for(int i=0;i<numeros.length;i++) {
int numero=numeros[i];
for(int j=i+1;j<numeros.length;j++) {
if(numeros[j]==numero) {
return true;
}
}
}
return false;
}
Categoría: Java
Dos maneras de encontrar el menor y probar cual tarda más
public static void main(String[] args) {
// Vamos a crear un array con 10000 números aleatorios
// Y vamos a comprobar cronómetro en mano cuanta diferencia hay
// Entre usar un método y otro
int[] numeros=new int[10000];
for (int i=0;i<numeros.length;i++) {
numeros[i]=(int) (Math.random()*100+1);
}
//System.out.println(Arrays.toString(numeros));
LocalTime ahora=LocalTime.now();
System.out.println(menorElemento(numeros));
LocalTime despues=LocalTime.now();
Duration tiempo=Duration.between(ahora, despues);
System.out.println(tiempo);
ahora=LocalTime.now();
System.out.println(menorElementoOrden(numeros));
despues=LocalTime.now();
tiempo=Duration.between(ahora, despues);
System.out.println(tiempo);
}
// Devolver el menor elemento de un array
public static int menorElemento(int[] numeros) {
// Almacenar el elemento menor
int menor=numeros[0];
// Recorrer el array
for(int numero:numeros) {
// Comparo cada valor con el que ya tengo
if(numero<menor) {
menor=numero;
}
}
return menor;
}
// Los arrays se pueden modificar en las funciones
// pero no SE DEBEN MODIFICAR por defecto
public static int menorElementoOrden(int[] numeros) {
int[] copia=numeros.clone();
Arrays.sort(copia);
return copia[0];
}
Resolución ejercicios fechas java
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.TextStyle;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;
public class FechasHoras {
public static void main(String[] args) {
// La función esViernes me devuelve...
for (LocalDate fecha : diasLaborablesArray(1, 11, 2023)) {
System.out.println(fecha);
}
System.out.println(Arrays.toString(diasLaborablesArray(1, 11, 2023)));
}
public static boolean esViernes() {
// Fecha de hoy
LocalDate hoy = LocalDate.now();
// Si hoy es viernes
return hoy.getDayOfWeek() == DayOfWeek.FRIDAY;
}
public static int hastaelFinde() {
// Fecha de hoy
LocalDate hoy = LocalDate.now();
// Cogemos el día numérico de la sema 1-lunes...7 domingo
int dia = hoy.getDayOfWeek().getValue();
// Si es sábado o domingo devolvemos 0
if (dia >= 6) {
return 0;
} else {
// Devolvemos 6 menos el valor
return 6 - dia;
}
}
public static int hastaelFindeNinja() {
// Obtenemos el día numérico de la semana
int dia = LocalDate.now().getDayOfWeek().getValue();
// Operador ternario para devolver 0 o la resta de días como
// En el ejemplo anterior
// Operador ternario if comprimido
// condicion ? valor si cierto : valor si falso
return dia >= 6 ? 0 : 6 - dia;
}
public static LocalDate vencimiento(LocalDate fecha, int dias) {
// Añado los días a la fecha
return fecha.plusDays(dias);
}
public static String diaCumple(int mes, int dia) {
// Creo la fecha de cumpleaños de este año
LocalDate cumple = LocalDate.of(LocalDate.now().getYear(), mes, dia);
// Obtengo el día de la semana en formato string
return cumple.getDayOfWeek().getDisplayName(TextStyle.FULL, Locale.of("es", "es"));
}
public static String diaCumpleOtro(int mes, int dia) {
LocalDate cumple = LocalDate.of(LocalDate.now().getYear(), mes, dia);
// Lo mismo pero usando un formateador
return cumple.format(DateTimeFormatter.ofPattern("EEEE"));
}
public static int numFestivos(int anyo, int mes) {
// Pongo la fecha del dia uno de mes
LocalDate fecha = LocalDate.of(anyo, mes, 1);
// Defino un contador
int festivos = 0;
// Mientras sigamos en este mes
while (fecha.getMonthValue() == mes) {
// Comparo con sábado y domingo
if (fecha.getDayOfWeek() == DayOfWeek.SATURDAY || fecha.getDayOfWeek() == DayOfWeek.SUNDAY) {
festivos++;
}
// Sumo uno al día para recorrer todos los días del mes
fecha = fecha.plusDays(1);
}
return festivos;
}
public static String diasLaborables(int dia, int mes, int anyo) {
// Creo la fecha que me han pasado
LocalDate fecha = LocalDate.of(anyo, mes, dia);
// Aquí acumularé las fechas
String resultado = "";
// Contador días laborables
int cont = 0;
while (cont < 15) {
// Si el día es laborable
if (fecha.getDayOfWeek().getValue() < 6) {
// Lo añado a la cadena
resultado += fecha.toString() + " - ";
// Sumo uno al contador
cont++;
}
// Siempre sumo uno a la fecha
fecha = fecha.plusDays(1);
}
return resultado;
}
public static LocalDate[] diasLaborablesArray(int dia, int mes, int anyo) {
return diasLaborablesArray(dia,mes,anyo,15);
}
public static LocalDate[] diasLaborablesArray(int dia, int mes, int anyo, int numDias) {
// Creo la fecha que me han pasado
LocalDate fecha = LocalDate.of(anyo, mes, dia);
// Aquí acumularé las fechas
LocalDate[] resultado = new LocalDate[15];
// Contador días laborables
int cont = 0;
while (cont < numDias) {
// Si el día es laborable
if (fecha.getDayOfWeek().getValue() < 6) {
// Lo añado a la cadena
resultado[cont] = fecha;
// Sumo uno al contador
cont++;
}
// Siempre sumo uno a la fecha
fecha = fecha.plusDays(1);
}
return resultado;
}
}
Ejemplos fechas en Java
LocalDate fecha = LocalDate.now();
System.out.println(fecha);
System.out.println(fecha.getDayOfMonth());
System.out.println(fecha.getDayOfYear());
System.out.println(fecha.getYear());
// Crear una fecha específica
LocalDate specificDate = LocalDate.of(2023, 5, 14);
System.out.println(specificDate.getDayOfWeek().getValue());
LocalDate juevesproximo=fecha.plusWeeks(1);
System.out.println(juevesproximo);
// En temp cojo la fecha de hoy
LocalDate temp=LocalDate.now();
temp=LocalDate.of(2023, 1, 1);
// Miro el mes en el que estamos
int mes=temp.getMonthValue();
// Mientras la fecha siga siendo del mismo mes
while(temp.getMonthValue()==mes) {
// Si es sábado, imprimo la fecha
if (temp.getDayOfWeek()==DayOfWeek.SATURDAY) {
System.out.println("Este día es sábado:"+temp);
temp=temp.plusDays(7);
}else {
temp=temp.plusDays(1);
}
// Sumo un día a la fecha
}
temp=LocalDate.of(2023, 8, 15);
// Formatear
System.out.println(temp.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
// Parsear
LocalDate fechaParseada = LocalDate.parse("2022-12-03");
System.out.println("Fecha parseada: " + fechaParseada);
// Parsear con un formato determinado
LocalDate fechaParseada2 = LocalDate.parse("03/12/2023",DateTimeFormatter.ofPattern("dd/MM/yyyy"));
System.out.println("Fecha parseada: " + fechaParseada2);
// Crear una hora específica
LocalTime specificTime = LocalTime.of(14, 30,50);
System.out.println(specificTime);
// Momento actual
LocalTime ahora=LocalTime.now();
System.out.println(ahora);
// Obtener partes de la hora
System.out.println(ahora.getHour());
System.out.println(ahora.getMinute());
System.out.println(ahora.getNano());
// Añadir o restar partes de tiempo
LocalTime momento=ahora.plusHours(2);
System.out.println(momento);
// Podemos parsear una cadena de caracteres
LocalTime cita=LocalTime.parse("10:00:00");
System.out.println(cita);
// Crear una fecha y hora específica
LocalDateTime specificDateTime = LocalDateTime.of(2023, 5, 15, 14, 30);
System.out.println(specificDateTime);
// Obtener partes de la fecha/hora
LocalDateTime esteMomento=LocalDateTime.now();
System.out.println(esteMomento);
System.out.println(esteMomento.getMonthValue());
System.out.println(esteMomento.getHour());
System.out.println(esteMomento.getSecond());
System.out.println(esteMomento.getDayOfYear());
// Sumar y restar partes de tiempo
esteMomento=esteMomento.plusDays(1);
esteMomento=esteMomento.plusHours(1);
System.out.println(esteMomento);
// Parsear una fecha y una hora
LocalDateTime fechahora=LocalDateTime.parse("2023-11-17T21:12:10");
System.out.println(fechahora);
Más ejemplos arrays
public static void main(String[] args) {
// Resolver el problema de rellenar un array de string
// Con puntos que se incrementan
String[] puntos = new String[10];
String cadena = ".";
for (int i = 0; i < puntos.length; i++) {
puntos[i] = ".".repeat(i + 1);
cadena += ".";
}
System.out.println(Arrays.toString(puntos));
int[] a = { 1, 20, 200, 3, 40, 50 };
int[] b = { 1, 2, 3 };
int[] c = a;
// Nos comprueba si dos arrays diferentes tienen
// los mismos valores
System.out.println(Arrays.equals(a, b));
//Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(c));
// Rellena un array con un valor repetido
// Arrays.fill(c, 9);
System.out.println(Arrays.toString(a));
// Copia los n primeros elementos de un array
int[] j = Arrays.copyOf(a, 2);
System.out.println(Arrays.toString(j));
// Esto copia un rango de un array en otro
int[] k = Arrays.copyOfRange(a, 1, 2);
System.out.println(Arrays.toString(k));
// Compara los valores de un array y devuelve
// 1 si el primero es mayor, 0 si son iguales y -1
// Si el segundo es mayor
System.out.println(Arrays.compare(a, b));
// Hace una búsqueda binaria pero el arraytiene
// que estar ordenado previamente
int pos = Arrays.binarySearch(a, 10);
System.out.println(pos);
System.out.println(mayorArray(a));
System.out.println(Arrays.toString(a));
}
// Devuelvo el elemento mayor de un array
static int mayorArray(int[] numeros) {
// Copio (clono) el array para que no se modifique en el main
int[] temp=numeros.clone();
// Lo ordeno
Arrays.sort(temp);
// Devuelvo el ultimo
return temp[temp.length - 1];
}
Ejemplos split
String frase="En un lugar de la mancha de cuyo nombre";
// Dividimos la cadena por espacio
// Los espacios no se incluyen
// Obtenemos un array con los elementos resultantes
String[] palabras=frase.split(" ");
System.out.println(Arrays.toString(palabras)); //[En, un, lugar, de, la, mancha, de, cuyo, nombre]
frase="1,2,3,4,5,6";
palabras=frase.split(",");
System.out.println(Arrays.toString(palabras)); //[1, 2, 3, 4, 5, 6]
frase="En un lugar de la mancha de cuyo nombre";
palabras=frase.split(" ");
String masLarga="";
// Recorro el array con foreach
for(String palabra:palabras) {
// Si la palabra en la que estoy es más larga
// Que la que ya tenía la sustituyo
if (palabra.length()>masLarga.length()) {
masLarga=palabra;
}
}
System.out.println("La palabra más larga es "+masLarga);
Más ejemplos Arrays
public static void main(String[] args) {
// tipo[] nombredelarray=new tipo[tamaño] o {valores,...}
// Con tamaño
int[] cuadrados = new int[10];
// Con valores
int[] notas = { 6, 3, 8, 9, 7 };
// Un tipo string
String[] alumnos = { "Ana", "Eva", "Pep", "Juan" };
// recorro el array usando un for normal
for (int i = 0; i < alumnos.length; i++) {
System.out.println(alumnos[i]);
}
// recorro el array usando el foreach (solo valoes)
for (String alumno : alumnos) {
System.out.println(alumno);
}
// Recorro el array y lo modifico porque tengo el índice
for (int i = 1; i <= cuadrados.length; i++) {
cuadrados[i - 1] = i * i;
}
System.out.println(Arrays.toString(cuadrados)); // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
// Modifico la posición 1 del array
alumnos[1] = "Federica";
System.out.println(Arrays.toString(alumnos)); // [Ana, Federica, Pep, Juan]
// Suma de los cuadrados que hemos generado antes
int suma = 0;
// Utilizo foreach porque solo quiero los valores
for (int cuadrado : cuadrados) {
suma += cuadrado;
}
System.out.println(suma);
// Creo un array de un tamaño fijo
Scanner sc = new Scanner(System.in);
System.out.println("¿De qué tamaño quieres la lista");
int tamanyo = sc.nextInt();
// EL tamaño puede venir de una variable
int[] lista = new int[tamanyo];
// Relleno el array pidiendo valores al usuario
for (int i = 0; i < lista.length; i++) {
System.out.println("Dime el número " + (i + 1) + ":");
lista[i] = sc.nextInt();
}
sc.close();
System.out.println(Arrays.toString(lista));
int total = sumaArray(lista);
System.out.println(total); // Imprimirá la suma de los número del usuario
}
// Creo una función que me suma todos los números
// Del array que le pasemos
static int sumaArray(int[] numeros) {
int total = 0;
// Uso el foreach nunca se modifica el array
for (int numero : numeros) {
total += numero;
}
return total;
}
Arrays ejemplos
public static void main(String[] args) {
// Defino una variable como entero
// almacena 1 valor entero
int edad = 5;
// Para almacenar más de un valor del mismo tipo
// se usan los arrays
int[] edades = new int[5];
edades[0] = 20;
edades[1] = 70;
edades[2] = 8;
edades[3] = 90;
edades[4] = 65;
for (int i = 0; i < edades.length; i++) {
System.out.println(edades[i]);
}
int[] precios = { 20, 30, 50, 18 };
System.out.println(precios[2]);
precios = new int[5];
int[] fibonacci = new int[10];
fibonacci[0] = 1;
fibonacci[1] = 1;
for (int i = 2; i < fibonacci.length; i++) {
fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
}
System.out.println(Arrays.toString(fibonacci));
// foreach
for (int numero : fibonacci) {
System.out.println(numero);
}
System.out.println(fibonacci);
printArray(fibonacci);
int[] inverso=reverseArray(fibonacci);
System.out.println(Arrays.toString(inverso));
int[] otro=printArrayDuplicado(fibonacci);
System.out.println(Arrays.toString(fibonacci));
int a=90;
int b=a;
a=25;
int[] pepe=fibonacci.clone();
int[] nuevo=Arrays.copyOf(fibonacci,fibonacci.length);
System.out.println(doble(a));
System.out.println(a);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static int[] reverseArray(int[] arr) {
int[] result = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
result[i] = arr[arr.length - i - 1];
}
return result;
}
public static int[] printArrayDuplicado(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i]*=2; // NO HACER NUNCA
}
return arr;
}
public static int doble(int numero) {
numero*=2;
return numero;
}
Más ejercicios cadenas resueltos
static int contarLetra(String cadena, char letra) {
int total = 0;
for (int i = 0; i < cadena.length(); i++) {
if (cadena.charAt(i) == letra) {
total++;
}
}
return total;
}
static int contarVocales(String cadena) {
cadena = quitarAcentos(cadena.toLowerCase());
String vocales = "aeiou";
int total = 0;
for (int i = 0; i < vocales.length(); i++) {
total += contarLetra(cadena, vocales.charAt(i));
}
return total;
}
static String sinEspacios(String cadena) {
cadena = cadena.trim();
while (cadena.indexOf(" ") != -1) {
cadena = cadena.replace(" ", " ");
}
return cadena;
}
static int contarChar(String cadena, char letra) {
int total = 0;
for (int i = 0; i < cadena.length(); i++) {
if (cadena.charAt(i) == letra) {
total++;
}
}
return total;
}
static String eliminar(String cadena, String cadenaEliminar) {
return cadena.replace(cadenaEliminar, "");
}
static String cambiar(String cadena, char antiguo, char nuevo) {
return cadena.replace(antiguo, nuevo);
}
Ejercicios cadenas resueltos
public static void main(String[] args) {
// Escribir una función que invierta el orden de los caracteres
// de una cadena dada. invertir("hola")–>"aloh"
String alreves=invertirCadena("cacahuete");
System.out.println(alreves);
if (esPalindromo("Isaac no ronca así")) {
System.out.println("Es palindromo");
}
System.out.println(quitarAcentos("áéíóúàèìòùäëïöü"));
// Saber si una cadena es un palíndromo
// Se lee lo mismo al derecho que al revés
// dabalearrozalazorraelabad
// dabalearrozalazorraelabad
// Sé dar la vuelta: Lo acabo de hacer
// Sé quitar espacios: replace(" ", "")
// quitar acentos que nos sustituya vocales acentuadas
// por vocales sin acento
// puedo reemplazar cada vocal acentuada por la sin acentuar
// Tengo un problema: hay que encontrar el algoritmo
// ¿Cómo lo hago yo?
// Divide y vencerás: El problema grande se convierte
// En problemas más pequeños
}
public static String quitarAcentos(String cadena) {
String acentos="áéíóúàèìòùäëïöü";
String sinacentos="aeiou";
for(int i=0;i<acentos.length();i++) {
cadena=cadena.replace(acentos.charAt(i),
sinacentos.charAt(i%5)); // Aritmética modular
}
return cadena;
}
public static boolean esPalindromo(String cadena) {
cadena=cadena.replace(" ","");
cadena=quitarAcentos(cadena);
return cadena.equalsIgnoreCase(invertirCadena(cadena));
}
public static String invertirCadena(String cadena) {
// cacahuete -> eteuhacac
// empiezo por el final, voy letra a letra y escribo cada letra
// ¿Se empezar e ir letra a letra? Sí con un for
// Se añadir esas letras a un resultado: sí, concatenando
String res="";
for(int i=cadena.length()-1;i>=0;i--) {
res+=cadena.charAt(i);
}
return res;
}