Level1

level1/pom.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>level1</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

level1/src/main/java/org/com/level/agency/Agency.java

@@ -0,0 +1,67 @@
+package org.com.level.agency;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+public class Agency {
+    static Scanner scanner = new Scanner(System.in);
+    static Map<Integer, String> options = Map.of(100, "Winter", 200, "Summer", 500,
+                                                 "Spring", 1000, "Autumn");
+    static List<Integer> priceTravels = options.keySet().stream().sorted().toList();
+
+    public static void main(String[] args) {
+        System.out.println("write your budget..");
+        var budget = scanner.nextInt();
+        System.out.println("Possible Travel for budget: ");
+        findPossiblesCombinations(new HashSet<>(), priceTravels, budget)
+                .stream()
+                .map(Agency :: getMapPriceAndRepetitions)
+                .forEach(Print :: printMapTravelRepetition);
+    }
+
+    private static Map<Integer, Long> getMapPriceAndRepetitions(List<Integer> integers) {
+        return integers.stream()
+                       .distinct()
+                       .collect(Collectors.toMap(
+                               integer -> integer,
+                               integer -> integers.stream()
+                                                  .filter(integer1 -> integer1.equals(integer))
+                                                  .count()
+                       ));
+    }
+
+    public static HashSet<List<Integer>> findPossiblesCombinations(HashSet<List<Integer>> results,
+                                                                   List<Integer> optionsCopy,
+                                                                   Integer budget) {
+        if (optionsCopy.isEmpty()) {return results;}
+        results.add(getOptionsFor(budget, optionsCopy, new ArrayList<>()));
+        return findPossiblesCombinations(results,
+                                         optionsCopy.subList(0, optionsCopy.size() - 1),
+                                         budget);
+
+    }
+
+    public static List<Integer> getOptionsFor(Integer budget,
+                                              List<Integer> optionsPrices,
+                                              List<Integer> possibleTravels) {
+        Integer lastTravelPrice = optionsPrices.getLast();
+        if (budget >= 0 && budget < optionsPrices.getFirst()) {
+            return possibleTravels;
+        } else if (budget - lastTravelPrice >= 0) {
+            possibleTravels.add(lastTravelPrice);
+            return getOptionsFor(budget - lastTravelPrice,
+                                 optionsPrices,
+                                 possibleTravels);
+        } else {
+            return getOptionsFor(budget,
+                                 optionsPrices.stream()
+                                              .filter(integer -> ! integer.equals(lastTravelPrice))
+                                              .toList(),
+                                 possibleTravels);
+        }
+    }
+}

level1/src/main/java/org/com/level/agency/Print.java

@@ -0,0 +1,15 @@
+package org.com.level.agency;
+
+import java.util.Map;
+
+public class Print {
+    static void printMapTravelRepetition(Map<Integer, Long> integerLongMap) {
+        System.out.println(
+                "::::Option::::");
+        integerLongMap.forEach(
+                (integer, aLong) ->
+                        System.out.println(
+                                "You would got tickets: " + aLong + " for: " + Agency.options.get(integer))
+        );
+    }
+}

level1/src/main/java/org/com/level/hospital/Authenticator.java

@@ -0,0 +1,56 @@
+
+package org.com.level.hospital;
+
+import java.util.Scanner;
+import java.util.function.BiPredicate;
+
+
+public class Authenticator {
+    private Scanner scanner = new Scanner(System.in);
+    public Boolean isLogged = false;
+
+    void shouldLogOut() {
+        System.out.println("Do you want to continue? ");
+        String next = scanner.next();
+        if (next.equalsIgnoreCase("no")) {
+            Main.authenticator.isLogged = false;
+        }
+    }
+
+    private void printMessage(String x) {
+        System.out.println(x);
+    }
+
+    public void authProcessFor(int tries,
+                               User user) {
+        var isLoged = false;
+        while (! isLoged && tries > 0) {
+            isLoged = authLogic().test(user.password(), user.name());
+            if(!isLoged){
+                printMessage("you still have " + (tries - 1) + " tries left");
+                tries--;
+            }
+        }
+        isLogged = isLoged;
+        authMessage();
+    }
+
+
+    private BiPredicate<String, String> authLogic() {
+        return (passwordP, userNameP) -> {
+            printMessage("Enter User Name");
+            var userName = scanner.next();
+            printMessage("Enter Password");
+            var password = scanner.next();
+            return userName.equals(userNameP) && password.equals(passwordP);
+        };
+    }
+
+    private void authMessage() {
+        if (! isLogged) {
+            printMessage("Sorry, max try possible");
+        } else {
+            printMessage("Welcome ");
+        }
+    }
+}

level1/src/main/java/org/com/level/hospital/Doctor.java

@@ -0,0 +1,17 @@
+package org.com.level.hospital;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public record Doctor(String speciality, String name, List<Slot> slotList) {
+     Stream<Slot> getFreeSlotStream(User user) {
+        return this.slotList().stream().filter(user :: isFreeForUser)
+                   .filter(Slot :: free);
+    }
+
+    Doctor registerAppointment(List<Slot> updatedSlotList) {
+        return new Doctor(this.speciality(),
+                          this.name(),
+                          updatedSlotList);
+    }
+}

level1/src/main/java/org/com/level/hospital/Main.java

@@ -0,0 +1,81 @@
+package org.com.level.hospital;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+
+import static org.com.level.hospital.Printer.printOptions;
+
+public class Main {
+    static Authenticator authenticator = new Authenticator();
+    static Scanner scanner = new Scanner(System.in);
+    static User user;
+
+    public static void main(String[] args) {
+        user = new User("lol", "pass", Map.of());
+        authenticator.authProcessFor(3, user);
+        while (authenticator.isLogged && ! user.userHave3Appointments()) {
+            searchAppointment();
+            authenticator.shouldLogOut();
+        }
+    }
+
+
+    private static void searchAppointment() {
+
+        System.out.println("Select the speciality");
+        var selectedSpeciality = printOptions(Utils.specialities);
+        var possibleDoctors    = filterDoctorsBySpeciality(selectedSpeciality);
+
+        System.out.println("Possible Doctors for this Speciality");
+        var numberSelectedDoctor = printOptions(possibleDoctors.stream()
+                                                               .map(Doctor :: name)
+                                                               .toList());
+
+        var selectedDoctorByUser = possibleDoctors.get(numberSelectedDoctor);
+        var possibleSlots = filterSlotsByDoctorAndUser(selectedDoctorByUser);
+
+        System.out.println("Select a free slot");
+        var numberOfSelectedSlot = printOptions(possibleSlots);
+
+        var appointment = possibleSlots.get(numberOfSelectedSlot).registerAppointment();
+
+        user = user.registerAppointment(selectedDoctorByUser, appointment);
+
+        Doctor updatedDoctor = updateDoctorWithNewAppointment(appointment, selectedDoctorByUser);
+
+        updateDoctorsList(updatedDoctor);
+
+    }
+
+    private static Doctor updateDoctorWithNewAppointment(Slot appointment,
+                                                         Doctor selectedDoctorByUser) {
+        var updatedSlotList = selectedDoctorByUser.getFreeSlotStream(user)
+                                                  .map(slot -> slot.id().equals(appointment.id()) ? appointment : slot)
+                                                  .toList();
+        return selectedDoctorByUser.registerAppointment(updatedSlotList);
+    }
+
+    private static List<Slot> filterSlotsByDoctorAndUser(Doctor selectedDoctorByUser) {
+        return selectedDoctorByUser.getFreeSlotStream(user).toList();
+    }
+
+    private static void updateDoctorsList(Doctor selectedDoctor)
+    {
+        Utils.doctors = Utils.doctors.stream().map(doctor ->
+                                                           doctor.name()
+                                                                 .equals(selectedDoctor.name())?
+                                                                   selectedDoctor: doctor).toList();
+    }
+
+
+    private static List<Doctor> filterDoctorsBySpeciality(int selectedSpeciality) {
+        return Utils.doctors.stream()
+                            .filter(doctor -> (doctor.speciality()
+                                                     .equals(Utils.specialities.get(selectedSpeciality)) &&
+                                               (! user.doctorAndAppointment()
+                                                      .containsKey(doctor.name()))
+                            )).toList();
+    }
+
+}

level1/src/main/java/org/com/level/hospital/Printer.java

@@ -0,0 +1,21 @@
+package org.com.level.hospital;
+
+import java.util.List;
+
+public class Printer {
+    static <T> int printOptions(List<T> options) {
+        var repeat = true;
+        var optionNumber = - 1;
+        while (repeat) {
+            for (int i = 0; i < options.size(); i++) {
+                System.out.println(i + ") para " + options.get(i));
+            }
+            optionNumber = Main.scanner.nextInt();
+            repeat = ! (optionNumber >= 0 && optionNumber <= options.size());
+            if (repeat) {
+                System.out.println("Elegiste una option invalida intentalo de nuevo");
+            }
+        }
+        return optionNumber;
+    }
+}

level1/src/main/java/org/com/level/hospital/Slot.java

@@ -0,0 +1,9 @@
+package org.com.level.hospital;
+
+public record Slot(Integer id, String timeStamp, boolean free) {
+    Slot registerAppointment() {
+        return new Slot(this.id(),
+                        this.timeStamp(),
+                        false);
+    }
+}

level1/src/main/java/org/com/level/hospital/User.java

@@ -0,0 +1,38 @@
+package org.com.level.hospital;
+
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public record User(String name,
+                   String password,
+                   Map<String, Slot> doctorAndAppointment) {
+    Stream<Slot> getUserSlotsStream() {
+        return this.doctorAndAppointment()
+                .values()
+                .stream();
+    }
+
+    User registerAppointment(Doctor selectedDoctor,
+                             Slot newSlot) {
+        var newMapSlot =
+                Stream.concat(this.doctorAndAppointment().entrySet().stream(),
+                              Stream.of(Map.entry(selectedDoctor.name(), newSlot)))
+                      .collect(Collectors.toMap(Map.Entry :: getKey,
+                                                Map.Entry :: getValue));
+        return new User(this.name(), this.password(), newMapSlot);
+    }
+
+    boolean userHave3Appointments() {
+        if (this.doctorAndAppointment().size() >= 3) {
+            System.out.println("Maximal Number Appointments gotten");
+            return true;
+        }
+        return false;
+    }
+
+    boolean isFreeForUser(Slot slot) {
+        return getUserSlotsStream()
+                   .noneMatch(slotFromUser -> slotFromUser.timeStamp().equals(slot.timeStamp()));
+    }
+}