Autor: Juan Pablo Fuentes

Formador de programación y bases de datos

Soluciones fechas

package com.trifulcas.fechas;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;

public class EjerciciosFechas {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LocalDate cumple = LocalDate.of(2024, 8, 13);
		System.out.println(cumple.format(DateTimeFormatter.ofPattern("MM/d/yyyy")));
		System.out.println(cuantoFalta(cumple));
		System.out.println(Arrays.toString(primerosDeMes(2025)));
		System.out.println(esFinDeSemanaAnglo("06/01/2024"));
		System.out.println(esFinDeSemanaEsp("04/06/2024"));
	}

	// Crear una función cuantoFalta(fecha) a la que le pasamos una fecha
	// y nos devuelve cuantos días faltan hasta esa fecha
	static long cuantoFalta(LocalDate fecha) {
		return ChronoUnit.DAYS.between(LocalDate.now(), fecha);

	}

	// Crear una función primerosDeMes(anyo) que nos devuelva una array con las
	// fechas
	// de los primeros de mes de ese año (1 de enero, 1 de febrero, 1 de marzo...)

	// Devuelvo un array de fechas, le paso un int con el año
	static LocalDate[] primerosDeMes(int anyo) {
		// La sintaxis de un array es tipo nombre_variable= new tipo[tamaño]
		LocalDate[] fechas = new LocalDate[12]; // ¿Por qué 12? Porque son 12 meses

		// ¿Cómo creo yo un array con los primeros de mes?
		// (0) 1-1-2024, (1) 1-2-2024, (2) 1-3-2024...
		for (int i = 1; i <= 12; i++) {
			fechas[i - 1] = LocalDate.of(anyo, i, 1);
		}
		return fechas;
	}

	// Crear una función a la que le pasamos una cadena con una fecha en formato
	// "año-mes-dia" y nos devuelve true si es fin de semana y false en caso
	// contrario
	// esFinDeSemana(cadena)

	static boolean esFinDeSemanaEsp(String cadena) {
		// Convertir la cadena a fecha
		LocalDate fechaConvertida = LocalDate.parse(cadena, DateTimeFormatter.ofPattern("dd/MM/yyyy"));
		// Saber el día de la semana
		int diaSemana = fechaConvertida.getDayOfWeek().ordinal();
		// Si es sábado o domingo devolver true y si no false
		return diaSemana >= 5;

	}

	static boolean esFinDeSemanaAnglo(String cadena) {
		// Convertir la cadena a fecha
		LocalDate fechaConvertida = LocalDate.parse(cadena, DateTimeFormatter.ofPattern("MM/dd/yyyy"));
		// Saber el día de la semana
		int diaSemana = fechaConvertida.getDayOfWeek().ordinal();
		// Si es sábado o domingo devolver true y si no false
		return diaSemana >= 5;

	}

}

Ejercicios If

# Cread una función a la que le pasamos una cantidad y nos devuelve el PVP
# siguiendo las siguientes reglas
# Si el precio es <1000 No hay descuento
# Está entre 1000 y <3000 5% de descuento
# Es 3000 o más 10% de descuento
# devuelvo el importe, no el descuento

# Cread una función obtenerIRPF(departamento, sueldo) que nos devuelva el % de irpf acorde a:
# Si el departamento es 'marketing' 12%
# Si el departamento es 'administracion' y el sueldo es <2500 12%, si es mayor 15%
# Si el departamento es 'contabilidad' tiene los siguientes tramos:
# hasta 3000 10% de 3000 a 5000 12% mas de 5000 15%

Ejemplo función recursiva para buscar un archivo

Probad a crear una carpeta meted un archivo dentro y mirad a ver si lo encuentra

import os


def buscar_archivo(ruta, nombre_archivo):
    """
    Busca un archivo con un nombre específico en una carpeta y sus subcarpetas.

    :param ruta: La ruta de la carpeta en la que iniciar la búsqueda.
    :param nombre_archivo: El nombre del archivo a buscar.
    :return: La ruta completa del archivo si se encuentra, de lo contrario None.
    """
    # Recorremos todos los elementos dentro de la carpeta actual
    for elemento in os.listdir(ruta):
        # Construimos la ruta completa del elemento
        ruta_completa = os.path.join(ruta, elemento)

        # Si el elemento es un archivo y su nombre coincide con el que buscamos
        if os.path.isfile(ruta_completa) and elemento == nombre_archivo:
            return ruta_completa

        # Si el elemento es una carpeta, llamamos recursivamente a la función
        elif os.path.isdir(ruta_completa):
            resultado = buscar_archivo(ruta_completa, nombre_archivo)
            if resultado:
                return resultado

    # Si no encontramos el archivo, devolvemos None
    return None


# Ejemplo de uso
ruta_busqueda = 'c:\\xampp'
nombre_archivo = 'index.html'
resultado = buscar_archivo(ruta_busqueda, nombre_archivo)

if resultado:
    print(f'Archivo encontrado en: {resultado}')
else:
    print('Archivo no encontrado')

Ejemplos modulo os

import os

# La carpeta en la que estoy
directorio_actual = os.getcwd()
print(directorio_actual)

# Me devuelve una lista de todos los archivos en una carpeta determinada
archivos_en_directorio = os.listdir(directorio_actual)
print(archivos_en_directorio)
# Lista que se puede recorrer
for archivo in archivos_en_directorio:
    print(archivo)
    if os.path.isfile(archivo):
        print('Es un archivo.')
    elif os.path.isdir(archivo):
        print('Es un directorio.')
    elif os.path.islink(archivo):
        print('Es un enlace simbólico.')

archivos_en_directorio = os.listdir("c:\\xampp")
print(archivos_en_directorio)

# Si un archivo existe. Muy útil si yo quiero abrir un archivo
print(os.path.exists("c:\\xampp\\pepe.txt"))  # False
print(os.path.exists("c:\\xampp\\uninstall.dat"))  # True porque en mi ordenador sí que existe

# Compruebo antes de crear que la carpeta no exista
if not os.path.exists("nueva_carpeta"):
    # Creo la carpeta
    os.mkdir("nueva_carpeta")
# Compruebo que no existe la ruta de carpetas que quiero crear
if not os.path.exists("carpeta\\con\\subcarpetas"):
    # Creo la carpeta con sus subcarpetas
    os.makedirs("carpeta\\con\\subcarpetas")
#Compruebo que existe el archivo
if os.path.exists("pais.txt"):
    # Si existe, lo elimino. OJO CUIDADO no se puede deshacer
    os.remove("pais.txt")

#os.rename("numeros01.txt","numeros1.text")

ruta_absoluta = os.path.abspath('prueba.txt')
print(ruta_absoluta)

Soluciones fechas

import datetime


# crear una función cuantoFalta(fecha) a la que le pasamos una fecha
# y nos devuelve cuantos días faltan hasta esa fecha

def cuantoFalta(fecha):
    # Calcular cuantos días faltan hasta la fecha que me pasan
    # que día es hoy
    hoy = datetime.datetime.now()
    # Hago la resta, en python es tan sencillo como restar
    faltan = fecha - hoy  # timedelta que es un periodo de tiempo
    # De ese periodo de tiempo me interesan los días
    return faltan.days


# La fecha de mi cumpleaños
miFecha = datetime.datetime(2024, 8, 13)
# ¿Cuanto falta hasta mi cumpleaños?
print(cuantoFalta(miFecha))  # 75


# crear una función primerosDeMes(anyo) que nos devuelva una lista con las fechas
# de los primeros de mes de ese año (1 de enero, 1 de febrero, 1 de marzo...)

def primerosDeMes(anyo):
    # Crear una lista de fechas
    res = []
    # creo una fecha datetime.date(año,mes,dia)
    # ¿Cuantas fechas tengo que crear? 12
    for i in range(12):
        res.append(datetime.datetime(anyo, i + 1, 1))
        # res.append("01/"+str(i+1)+"/"+str(anyo))
    return res


print(primerosDeMes(2024))  # [2024-1-1,2024-2-1,....,2024-12-1]
print(primerosDeMes(2556))  # [2024-1-1,2024-2-1,....,2024-12-1]
fechas = primerosDeMes(2024)
for fecha in fechas:
    print(fecha.strftime("%d/%m/%Y"), cuantoFalta(fecha))


# crear una función a la que le pasamos una cadena con una fecha en formato dia/mes/año
# y nos devuelve true si es fin de semana y false en caso contrario
# esFinDeSemana(cadena)

def esFinDeSemana(cadena):
    res = False
    # Pasar de cadena a fecha
    fecha = datetime.datetime.strptime(cadena, "%d/%m/%Y")
    if fecha.weekday() >= 5:
        res = True
    return res


print(esFinDeSemana(("01/06/2024")))  # true
print(esFinDeSemana(("04/06/2024")))  # false


# crear una función a la que le pasamos un año, un mes y un día y nos devuelve una lista
# con todas las horas exactas de ese día
# crearAgendaDia(2024,5,1)->[2024-5-1 00:00,2024-5-1 01:00,2024-5-1 02:00,2024-5-1 03:00,...2024-5-1 23:00]

def crearAgendaDia(anyo, mes, dia):
    res = []
    # crear una lista con unas horas que van de donde a donde? de 0 a 23
    for i in range(24):
        res.append(datetime.datetime(anyo, mes, dia, i))
    return res


print(crearAgendaDia(2024, 5, 1))  # [2024-5-1 00:00,2024-5-1 01:00,2024-5-1 02:00,2024-5-1 03:00,...2024-5-1 23:00]

Ejemplos Fechas y Horas, Period y Duration

LocalDateTime now=LocalDateTime.now();
		
		System.out.println(now);
		
		System.out.println(now.format(DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm")));
		
		now=now.plusDays(2);
		now=now.plusHours(3);
		System.out.println(now.format(DateTimeFormatter.ofPattern("dd/M/yyyy HH:mm")));
			
		now=now.plus(2,ChronoUnit.MILLENNIA);
		System.out.println(now.format(DateTimeFormatter.ofPattern("dd/M/yyyy HH:mm")));
		
		// Periodos: espacio temporal entre fechas
		
		LocalDateTime ahora=LocalDateTime.now();
		// between nos devuelve el periodo entre dos fechas
		System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()));
		// Podemos obtener los días, los meses, los años...
		System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()).getDays());
		System.out.println(Period.between(now.toLocalDate(), ahora.toLocalDate()).getYears());
		// También sirve para añadir a fechas
		ahora=ahora.plus(Period.ofMonths(3));
		
		// Duration: espacio temporal entre horas
		
		// Nos devuelve la duración entre dos horas
		System.out.println(Duration.between(now.toLocalTime(), ahora.toLocalTime()));
		// Obtenemos los segundos
		System.out.println(Duration.between(now.toLocalTime(), ahora.toLocalTime()).getSeconds());
		// También sirve para añadir a horas
		ahora=ahora.plus(Duration.ofMinutes(40));

Ejemplos horas

LocalTime now = LocalTime.now();

		LocalTime miHora = LocalTime.of(10, 30);

		LocalTime otraHora = LocalTime.parse("10:34");
		System.out.println(now);
		System.out.println(miHora);
		System.out.println(otraHora);

		// Obtener información de las horas

		System.out.println(now.getHour());
		System.out.println(now.getMinute());
		System.out.println(now.getSecond());
		System.out.println(now.getNano());

		// Formatear horas

		System.out.println(now.format(DateTimeFormatter.ofPattern("HH:mm:ss")));

		// Modificar horas

		now = now.plusHours(1);
		now = now.plusMinutes(2);
		now = now.plusSeconds(40);
		now = now.plus(1, ChronoUnit.MINUTES);
		System.out.println(now);

Ejemplos fechas

// Son para crear fechas
		// La fecha de hoy
		LocalDate localDate = LocalDate.now();
		System.out.println(localDate); // 2024-05-29
		// Creo una fecha poniendo a mano los valores
		LocalDate miFecha=LocalDate.of(2024, 6, 1);
		System.out.println(miFecha);
		// Creo una fecha intentando convertir una cadena
		LocalDate otraFecha=LocalDate.parse("2024-06-17");
		System.out.println(otraFecha);
		// Puedo obtener información de mi fecha
		// El mes en nombre o en número
		System.out.println(miFecha.getMonth());
		System.out.println(miFecha.getMonthValue());
		// El año
		System.out.println(miFecha.getYear());
		// El día del mes
		System.out.println(miFecha.getDayOfMonth());
		// El día del año
		System.out.println(miFecha.getDayOfYear());
		// El día de la semana
		System.out.println(miFecha.getDayOfWeek());
		// El número del día de la semana (0 lunes 6 domingo)
		System.out.println(miFecha.getDayOfWeek().ordinal());
		// Si es año bisiesto
		System.out.println(miFecha.isLeapYear());
		// Días del mes
		System.out.println(miFecha.lengthOfMonth());
		// Días del año
		System.out.println(miFecha.lengthOfYear());


		// Formatear fechas
		// Con el patrón que nosotros queramos
		System.out.println(miFecha.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")));
		// Formato del sistema operativo
		// Largo, nombre del día y del mes
		System.out.println(miFecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL)));
		// Corto, solo números
		System.out.println(miFecha.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)));
		
		// Operar con fechas
		// Sumar un día
		LocalDate manyana=LocalDate.now().plusDays(1);
		System.out.println(manyana);
		// SUmar meses
		manyana=manyana.plusMonths(1);
		// SUmar Años
		manyana=manyana.plusYears(1);
		// el 30 de junio del año que viene
		System.out.println(manyana);
		
		// Sumar una duración cualquiera
		manyana=manyana.plus(1,ChronoUnit.WEEKS);
		System.out.println(manyana);
		manyana=manyana.plusYears(-1);
		System.out.println(manyana);
		manyana=manyana.minusYears(1);
		System.out.println(manyana);

Ejemplos stream

package com.trifulcas.arrays;

import java.util.Arrays;
import java.util.stream.IntStream;

public class EjemplosStreams {

	public static void main(String[] args) {
		int[] numeros = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		// Creo un stream a partir de un array
		IntStream miStream = Arrays.stream(numeros);
		// Puedo utilizar los métodos que tiene stream. Vemos ejemplos
		// foreach nos permite iterar sobre cada elemento
		// Utilizo una función lambda (en JS eran flechas, se parecen mucho)
		// Sintaxis del lambda:  parametro->valor que retorno o código
		miStream.forEach(x -> System.out.println(x));
		
		// Otra manera
		miStream = Arrays.stream(numeros);
		// Indico directamente cual es la función que se va a aplicar a los elementos del array
		miStream.forEach(System.out::println);
		miStream = Arrays.stream(numeros);
		// Puedo filtrar los elementos. En el filter se pide un predicado
		IntStream pares = miStream.filter(x -> x % 2 == 0);
		pares.forEach(x -> System.out.println(x));

		// Si combino filter con count lo que tengo es una manera muy sencilla
		// De averiguar cuantos elementos en un array cumplen una condición
		// Por ejemplo, cuantos pares tengo en un array
		long nPares = Arrays.stream(numeros).filter(x -> x % 2 == 0).count();
		System.out.println(nPares);

		// Tenemos map que nos aplica una transformación a los elementos del stream
		String[] words = { "Java", "Python", "C++", "JavaScript" };
		// Puedo llamar directamente ala función que quiero aplicar
		Arrays.stream(words).map(String::toUpperCase).forEach(System.out::println);
		// Puedo utilizar una función lambda
		Arrays.stream(words).map(s -> s.toUpperCase()).forEach(System.out::println);
		// Usar una lambda
		Arrays.stream(numeros).map(x -> doble(x)).forEach(System.out::println);
		// Usar la función que tengo definida en mi propia clase
		Arrays.stream(numeros).map(EjemplosStreams::doble).forEach(System.out::println);

		// reduce para hacer operaciones sobre los elementos del stream
		// El ejemplo más común es la suma. Inicializo a cero y después sumo
		int sum = Arrays.stream(numeros).reduce(0, (x, y) -> x + y);
		System.out.println(sum);
		
		// La opción de máximo y mínimo. Uso getAsInt porque el tipo que devuelve
		// es un OptionalInt
		int max = Arrays.stream(numeros).max().getAsInt();
		int min = Arrays.stream(numeros).min().getAsInt();
		System.out.println("Máximo: " + max + ", Mínimo: " + min);
	}

	static int doble(int n) {
		return n * 2;
	}

	static int parityNumber(int[] nums) {
		long even = Arrays.stream(nums).filter(x -> x % 2 == 0).count();
		long odd = nums.length - even;
		if (even == odd) {
			return 0;
		} else if (even > odd) {
			return 2;
		} else {
			return 1;
		}

	}
}

Soluciones ejercicios arrays

package exercise;

import java.util.Arrays;

public class Exercise {
	
	static int sumArray(int[] nums) {
		int res = 0;
		
		for (int num : nums) {
			res += num;
		}
		
		return res;
	}
	
	static double sumArray(double[] nums) {
		double res = 0;
		
		for (double num : nums) {
			res += num;
		}
		
		return res;
	}
	
	static int[] rotateNumber(int[] nums) {
		int[] res = nums.clone();		
		res[0] = nums[nums.length - 1];
		
		for (int i = 1, j = 0; j < nums.length - 1; i++, j++) {
			res[i] = nums[j];
		}
		
		return res;
	}
	
	static int parityNumber(int[] nums) {
		int odd = 0;
		int even = 0;
		
		for (int num : nums) {
			if (num % 2 == 0) {
				even++;
			} else {
				odd++;
			}
		}		
		
		if (even == odd) {
			return 0;
		} else if (even > odd) {
			return 2;
		} else {
			return 1;
		}
	}
	
    static boolean duplicate(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] == nums[j]) {
                    return true; 
                }
            }
        }
        return false; 
    }
	
    static boolean duplicate(String[] strings) {
        for (int i = 0; i < strings.length; i++) {
            for (int j = i + 1; j < strings.length; j++) {
                if (strings[i].equals(strings[j])) {
                    return true;
                }
            }
        }
        return false;
    }    
    
	public static void main(String[] args) {
		int[] nums1 = { 1, 2, 3, 4, 5, 2 };
		System.out.format("Donat una array: '%s' de números mostra la suma d'ells: " + sumArray(nums1) + "\n", Arrays.toString(nums1));
		double[] nums2 = { 1.5, 2, 3.5, 4.1, 5 };
		System.out.format("Donat una array: '%s' de números mostra la suma d'ells: " + sumArray(nums2) + "\n", Arrays.toString(nums2));
		nums1 = new int[]{ 1, 2, 3, 4 };
		System.out.format("Donat una array: '%s' de números l'últim número pasara al 1er: " + Arrays.toString(rotateNumber(nums1)) + "\n", Arrays.toString(nums1));
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		nums1 = new int[]{ 1, 2, 3, 5 };
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		nums1 = new int[]{ 4, 2, 8, 1 };
		System.out.format("Danat una array: '%s' de números, retorna: 1 si hi ha més impars que parells, 2 si hi ha més parells i 0 si hi ha la la mateixa quantitat: %d\n", Arrays.toString(nums1), parityNumber(nums1));
		System.out.format("Donat una array: '%s' de números retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(nums1) + "\n", Arrays.toString(nums1));
		nums1 = new int[]{ 4, 2, 8, 2 };
		System.out.format("Donat una array: '%s' de números retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(nums1) + "\n", Arrays.toString(nums1));
		String[] string1 = {"jaume", "pere", "anna", "jaume"};
		System.out.format("Donat una array: '%s' de cadenes retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(string1) + "\n", Arrays.toString(string1));
		string1 = new String[]{"jaume", "pere", "anna", "maria"};
		System.out.format("Donat una array: '%s' de cadenes retorna 'true' si hi ha duplicats i en cas contrari 'false': " + duplicate(string1) + "\n", Arrays.toString(string1));
	}

}