1
  1 2 1
 1 3 3 1
1 4 6 4 1

src
└── main
    └── java
       └── com
            └── concurso
                └── basico
                    └── reto11
                        ├── AppTriangulo.java
                        └── TrianguloPascal.java

(0,0)→(0,1)→(1,1)→(1,2)→(1,3)→(2,3)→(3,3)→(3,4)→(4,4)

              ┌     ┐
Laberinto 2x2 | 0 0 |, sin solución
              | 1 0 |
              └     ┘

Salida esperada: {}

              ┌         ┐
              | 0 0 0 0 |
Laberinto 4x4 | 1 0 1 0 |
              | 0 0 0 0 |
              | 0 1 1 0 |
              └         ┘

Salida esperada:
{
    {(0,0),(0,1),(0,2),(0,3),(1,3),(2,3),(3,3)},
    {(0,0),(0,1),(1,1),(2,1),(2,2),(2,3),(3,3)}
}

              ┌           ┐
              | 0 0 1 0 0 |
Laberinto 5x5 | 1 0 0 0 1 |
              | 0 0 1 0 0 |
              | 0 1 0 0 1 |
              | 1 0 0 0 0 |
              └           ┘

Salida esperada:
{
    {(0,0),(0,1),(1,1),(1,2),(1,3),(2,3),(3,3),(3,4),(4,4)}
}

src
└── main
    └── java
       └── com
            └── concurso
                └── basico
                    └── reto12
                        ├── Coordenada.java
                        ├── Laberinto.java
                        └── LaberintoMain.java

package com.concurso.basico.reto12;

public class Coordenada {
    private int fila;
    private int columna;

    public Coordenada(int fila, int columna) {
        this.fila = fila;
        this.columna = columna;
    }

    @Override
    public String toString() {
        return "(" + fila + "," + columna + ")";
    }
}

package com.concurso.basico.reto12;

import java.util.ArrayList;
import java.util.List;

public class Laberinto {
    int[][] laberinto;
    boolean[][] visitado;

    public Laberinto(int[][] laberinto) {
        this.laberinto = laberinto;
        visitado = new boolean[laberinto.length][laberinto[0].length];
    }

    public List<List<Coordenada>> encontrarRutas() {
        List<List<Coordenada>> rutas = new ArrayList<>();
        List<Coordenada> rutaActual = new ArrayList<>();

        buscarRutas(0, 0, rutaActual, rutas);

        return rutas;
    }

    private void buscarRutas(int fila, int col,
                             List<Coordenada> rutaActual,
                             List<List<Coordenada>> rutas) {
        int n = laberinto.length;

        // Caso base: llegar a la salida
        if (fila == n - 1 && col == n - 1) {
            rutaActual.add(new Coordenada(fila, col));
            rutas.add(new ArrayList<>(rutaActual));
            rutaActual.removeLast(); //JDK 21
            return;
        }

        // Verificar límites y si es camino transitable
        if (fila < 0 || fila >= n || col < 0 || col >= n ||
                laberinto[fila][col] == 1 || visitado[fila][col]) {
            return;
        }

        // Marcar celda como visitada
        visitado[fila][col] = true;
        rutaActual.add(new Coordenada(fila, col));

        // Moverse a derecha y abajo (recursión)
        buscarRutas(fila, col + 1, rutaActual, rutas); // Derecha
        buscarRutas(fila + 1, col, rutaActual, rutas); // Abajo

        // Backtracking: desmarcar y retroceder
        visitado[fila][col] = false;
        rutaActual.removeLast();
    }
}

package com.concurso.basico.reto12;

import java.util.List;

public class LaberintoMain {

    public static void main(String[] args) {
        int[][] laberinto1 = {
                {0, 0, 1},
                {1, 0, 0},
                {0, 1, 0}
        };

        int[][] laberinto2 = {
                {0,0,0,0},
                {1,0,1,0},
                {0,0,0,0},
                {0,1,1,0}
        };

        Laberinto laberintoMain = new Laberinto(laberinto2);

        List<List<Coordenada>> rutas = laberintoMain.encontrarRutas();

        System.out.println("Rutas encontradas: " + rutas);
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── basico
                    └── reto21
                        ├── AppAdivina.java
                        └── PalabraAdiv.java

package com.concurso.basico.reto21;

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

public class PalabraAdiv {

    private String[] palabra = {
            "martillo",
            "murcielago",
            "mandarina",
            "acelerometro",
            "camiseta",
            "pinguino"
    };

    private StringBuilder adiv;
    private String pal;
    private int op[];

    public void palAdivina() {
        Random r = new Random();
        pal = palabra[r.nextInt(palabra.length)];
        adiv = new StringBuilder(pal);
        op = new int[pal.length() / 2 + 1];
        int num;
        for (int i = 0; i < op.length; i++) {
            num = r.nextInt(pal.length() - 1);
            if (i > 0) {
                if (num != op[i - 1]) {
                    op[i] = num;
                } else {
                    num = r.nextInt(pal.length() - 1);
                    op[i] = num;
                }
            } else {
                op[i] = num;
            }
        }

        for (int i = 0; i < op.length; i++) {
            adiv.replace(op[i], op[i] + 1, "-");
        }
        //return adiv.toString();
        System.out.println(adiv);
    }

    public void adivina() {
        Scanner sc = new Scanner(System.in);
        int cont = adiv.length() / 2 + 3;
        boolean estado = false;
        String let;
        do {
            cont--;
            System.out.println("Ingrese una letra: ");
            let = sc.next();
            Character c;
            for (int i = 0; i < op.length; i++) {
                if (pal.charAt(op[i]) == let.charAt(0)) {
                    c = let.charAt(0);
                    adiv.replace(op[i], op[i] + 1, c.toString());
                    System.out.println(adiv);
                    estado = true;
                    break;
                } else {
                    estado = false;
                }
            }
            if (!estado) {
                System.out.println("Fallaste intenta de nuevo, " +
                        "tienes : " + cont + " intentos");
            }

        } while (cont > 0 && !(pal.equals(adiv.toString())));

        if (pal.equals(adiv.toString())) {
            System.out.println("ganaste el juego");
        } else {
            System.out.println("Te quedaste sin intentos, " +
                    "vuelve a jugar ");
        }
    }
}

package com.concurso.basico.reto21;

public class AppAdivina {
  public static void main(String[] args) {
    PalabraAdiv pal = new PalabraAdiv();

    pal.palAdivina();

    pal.adivina();
  }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── basico
                    └── reto31
                        ├── App.java
                        ├── Baraja.java
                        ├── Cartas.java
                        ├── Jugador.java
                        ├── Jugadores.java
                        └── Palo.java

package com.concurso.basico.reto31;

public record Cartas(Palo palo, int valor) {

}

package com.concurso.basico.reto31;

public enum Jugadores {
    Ana, juan, Carlos
}

package com.concurso.basico.reto31;

public enum Palo {
  PICA, TREBOL, CORAZONES, DIAMANTE
}

package com.concurso.basico.reto31;

import java.util.Random;

public class Baraja {
    public static final int TOTAL_CARTAS = 52;

    private Cartas[] cartas = new Cartas[TOTAL_CARTAS];
    public Cartas[] barajadas = new Cartas[TOTAL_CARTAS];
    private boolean[] marcada = new boolean[TOTAL_CARTAS];
    private Random r = new Random();

    public Baraja() {
        crearCartas();
    }

    public void crearCartas() {
        int count = 1;
        int pal = 0;
        for (int i = 0; i < cartas.length; i++) {
            if (count <= 13)
                cartas[i] = new Cartas(Palo.values()[pal], count++);
            else {
                count = 1;
                pal = pal + 1;
                cartas[i] = new Cartas(Palo.values()[pal], count++);
            }
        }
    }

    public void barajar() {
        int num = 0;
        boolean estado = false;
        for (int i = 0; i < cartas.length; i++) {
            do {
                num = r.nextInt(TOTAL_CARTAS);
                if (barajadas[num] == null) {
                    barajadas[num] = cartas[i];
                    estado = true;
                } else {
                    estado = false;
                }
            } while (!estado);
        }
    }

    public void imrpimir() {
        System.out.println("Las Cartas han sido barajadas");
        for (int i = 0; i < barajadas.length; i++) {
            System.out.print(barajadas[i].palo().name()
                    + barajadas[i].valor() + " ");
        }
        System.out.println();
    }
}

package com.concurso.basico.reto31;

public class Jugador {
  private static int count;
  public int num;
  private Baraja baraja;
  private Jugadores jugador;
  private Cartas[] cartas;
  private int tot;

  public Jugador(Jugadores jugador, Baraja baraja) {
    this.jugador = jugador;
    this.baraja = baraja;
    this.cartas = new Cartas[10];
  }

  public void tomarCarta() {
    cartas[num++] = baraja.barajadas[count++];
  }

  public void imprimirMano() {
    for (int i = 0; i < 10; i++) {
      System.out.print(" " + cartas[i].palo()
          + cartas[i].valor() + " ");
    }
    System.out.println();
  }

  public Jugadores getJugador() {
    return jugador;
  }

  public int total() {
    for (int i = 0; i < 10; i++) {
      tot += cartas[i].valor();
    }
    return tot;
  }
}

package com.concurso.basico.reto31;

public class App {
    public static void main(String[] args) {
        Baraja b = new Baraja();

        b.barajar();
        b.imrpimir();

        Jugador jugadorUno = new Jugador(Jugadores.Ana, b);
        Jugador jugadorDos = new Jugador(Jugadores.Carlos, b);

        for (int i = 0; i < 10; i++) {
            jugadorUno.tomarCarta();
            jugadorDos.tomarCarta();
        }

        System.out.println(" cartas de " + jugadorUno.getJugador() +
                " con un puntaje final de: " + jugadorUno.total());
        jugadorUno.imprimirMano();

        System.out.println(" cartas de " + jugadorDos.getJugador() +
                " con un puntaje final de: " + jugadorDos.total());
        jugadorDos.imprimirMano();

        System.out.println(jugadorUno.total() > jugadorDos.total() ?
                "Ha ganado: " + jugadorUno.getJugador() :
                "Ha ganado: " + jugadorDos.getJugador());
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── basico
                    └── reto32
                        ├── Carta.java
                        ├── Baraja.java
                        ├── Jugador.java
                        └── Test.java

package com.concurso.basico.reto32;

import java.util.Collections;
import java.util.Stack;

public class Baraja {
    private final Stack<Carta> cartas;

    public Baraja() {
        String[] palos = {
                "Corazones",
                "Diamantes",
                "Tréboles",
                "Picas"
        };

        String[] valores = {"2", "3", "4", "5", "6", "7", "8", "9",
                "10", "J", "Q", "K", "A"};

        int[] puntajes = {2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 20};

        this.cartas = new Stack<>();
        for (String palo : palos) {
            int i = 0;
            for (String valor : valores) {
                cartas.push(new Carta(palo, valor, puntajes[i++]));
            }
        }
    }

    public void revolver() {
        Collections.shuffle(cartas);
    }

    public Carta sacarCarta() {
        return cartas.pop();
    }

    public void colocarCarta(Carta carta) {
        cartas.push(carta);
    }

    public boolean estaVacio() {
        return cartas.isEmpty();
    }
}

package com.concurso.basico.reto32;

public record Carta(String palo, String valor, int puntaje) {
    @Override
    public String toString() {
        return valor + " de " + palo;
    }
}

package com.concurso.basico.reto32;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;

public class Jugador {
    private final String nombre;
    private final List<Carta> mano;

    public Jugador(String nombre) {
        this.nombre = nombre;
        this.mano = new ArrayList<>();
    }

    public String getNombre() {
        return nombre;
    }

    public void robarCarta(Baraja baraja) {
        if (baraja.estaVacio()) return;

        Carta carta = baraja.sacarCarta();
        mano.add(carta);

        if ("A".equals(carta.valor())) {
            IntStream.range(0, 2)
                    .forEach(i -> {
                        if (!baraja.estaVacio())
                            mano.add(baraja.sacarCarta());
                    });
        } else if ("K".equals(carta.valor())) {
            Random r = new Random();
            if (!mano.isEmpty()) {
                Carta laCarta = mano.remove(r.nextInt(mano.size()));
                baraja.colocarCarta(laCarta);
            }
        }
    }

    public int puntuar() {
        return this.mano.stream()
                .map(Carta::puntaje)
                .reduce(0, Integer::sum);
    }

    public List<Carta> mostrarMano() {
        return mano;
    }
}

package com.concurso.basico.reto32;

public class MainReto32 {
    public static void main(String[] args) {
        // Crear baraja → Barajar cartas → Crear
        //   2 jugadores que roban por turnos
        // hasta que la baraja se vacíe →Mostrar y
        // Puntuar las manos de los jugadores y decidir quién gano.

        Baraja myBaraja = new Baraja();
        myBaraja.revolver();

        Jugador j1 = new Jugador("Angel");
        Jugador j2 = new Jugador("Ximena");

        boolean turno = true;

        while (!myBaraja.estaVacio()) {
            if (turno) j1.robarCarta(myBaraja);
            else j2.robarCarta(myBaraja);

            turno = !turno;
        }

        if (j1.puntuar() > j2.puntuar())
            System.out.println("GANO !! " + j1.getNombre());
        else if (j1.puntuar() < j2.puntuar())
            System.out.println("GANO !! " + j2.getNombre());
        else
            System.out.println("EMPATE !! ");
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── medio
                    └── reto1
                        ├── AppClasificador.java
                        ├── ClasificadorEtiquetas.java
                        ├── Departamento.java
                        ├── Administrador.java
                        ├── Desarrollador.java
                        ├── Empleado.java
                        └── Usuario.java

package com.concurso.medio.reto1;

public abstract class Empleado {
    public static final String USUARIO = "Usuario";
    public static final String ADMINISTRADOR = "Administrador";
    public static final String DESARROLLADOR = "Desarrollador";

    private final String nombre;
    private final String etiqueta;

    public Empleado(String nombre, String etiqueta) {
        this.nombre = nombre;
        this.etiqueta = etiqueta;
    }

    public String getNombre() {
        return nombre;
    }

    public String getEtiqueta() {
        return etiqueta;
    }

    public abstract String getTipo();
}

package com.concurso.medio.reto1;

public class Usuario extends Empleado {
    public Usuario(String nombre, String etiqueta) {
        super(nombre, etiqueta);
    }

    @Override
    public String getTipo() {
        return "Usuario";
    }
}

package com.concurso.medio.reto1;

public class Desarrollador extends Empleado {
    public Desarrollador(String nombre, String etiqueta) {
        super(nombre, etiqueta);
    }

    @Override
    public String getTipo() {
        return "Desarrollador";
    }
}

package com.concurso.medio.reto1;

public class Administrador extends Empleado {
    public Administrador(String nombre, String etiqueta) {
        super(nombre, etiqueta);
    }

    @Override
    public String getTipo() {
        return "Administrador";
    }
}

package com.concurso.medio.reto1;

import java.util.ArrayList;
import java.util.List;

public class Departamento {
    private final int id;
    private final String nombre;
    private final List<Empleado> empleados = new ArrayList<>();

    public Departamento(int id, String nombre) {
        this.id = id;
        this.nombre = nombre;
    }

    public void agregarEmpleado(Empleado e) {
        empleados.add(e);
    }

    public List<Empleado> getEmpleados() {
        return empleados;
    }

    public String getNombre() {
        return nombre;
    }

    public void listarEmpleados() {
        System.out.println("Departamento: " + nombre);
        for (Empleado e : empleados) {
            System.out.println("- " + e.getNombre()
                    + " [" + e.getEtiqueta() + "]");
        }
    }
}

package com.concurso.medio.reto1;

import java.util.Optional;
import java.util.regex.Pattern;

public class ClasificadorEtiquetas {
    private static final Pattern usuarioPattern =
            Pattern.compile("^@.*u$");

    private static final Pattern adminPattern =
            Pattern.compile("^#.*\\d$");

    private static final Pattern devPattern =
            Pattern.compile("^%d.*\\.(info|des|tec|sop)$");

    public static Optional<Empleado> clasificar(String nombre,
                                                String etiqueta) {
        Empleado emp = null;
        if (usuarioPattern.matcher(etiqueta).matches()) {
            emp = new Usuario(nombre, etiqueta);
        } else if (adminPattern.matcher(etiqueta).matches()) {
            emp =  new Administrador(nombre, etiqueta);
        } else if (devPattern.matcher(etiqueta).matches()) {
            emp =  new Desarrollador(nombre, etiqueta);
        }
        // o lanzar excepción si se prefiere
        return Optional.ofNullable(emp);
    }
}

package com.concurso.medio.reto1;

import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

public class AppClasificador {

    public static void main(String[] args) {
        List<String[]> datos = List.of(
                new String[]{"Ana", "@clientu"},
                new String[]{"Luis", "#admin1"},
                new String[]{"Carlos", "%dcode.des"},
                new String[]{"Diana", "@betauseru"},
                new String[]{"Pedro", "#super5"},
                new String[]{"Laura", "%dapp.tec"}
        );

        Departamento testing = new Departamento(1, "Testing");
        Departamento admin = new Departamento(2, "Admin");
        Departamento programming = new Departamento(3, "Programming");

// alternativa con streams
//   datos.stream()
//           .map(row -> ClasificadorEtiquetas.clasificar(row[0], row[1]))
//           .filter(Optional::isPresent)
//           .flatMap(Optional::stream)
//           .forEach(emp -> {
//               var depto = switch (emp.getTipo()) {
//                   case Empleado.USUARIO -> testing;
//                   case Empleado.ADMINISTRADOR -> admin;
//                   case Empleado.DESARROLLADOR -> programming;
//                   default -> null;
//               };
//               if (depto != null)
//                   depto.agregarEmpleado(emp);
//           });

        for (String[] d : datos) {
            ClasificadorEtiquetas.clasificar(d[0], d[1])
                    .ifPresent(emp -> {
                var depto = switch (emp.getTipo()) {
                    case Empleado.USUARIO -> testing;
                    case Empleado.ADMINISTRADOR -> admin;
                    case Empleado.DESARROLLADOR -> programming;
                    default -> null;
                };
                if (depto != null)
                    depto.agregarEmpleado(emp);
            });
        }

        // Mostrar resultados
        testing.listarEmpleados();
        admin.listarEmpleados();
        programming.listarEmpleados();
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── medio
                    └── reto2
                        ├── Main.java
                        ├── ProxyRecurso.java
                        ├── RecursoReal.java
                        ├── Recursos.java
                        └── Sesion.java

package com.concurso.medio.reto2;

public interface Recursos {
    void acceder(Sesion s);
}

package com.concurso.medio.reto2;

public class RecursoReal implements Recursos {
    public void acceder(Sesion s) {
        System.out.println("Accediendo al recurso protegido.");
    }
}

package com.concurso.medio.reto2;

public class ProxyRecurso implements Recursos {
    // private boolean autenticado;
    private RecursoReal recursoReal = new RecursoReal();

    public ProxyRecurso() {

    }

    public void acceder(Sesion s) {
        if (s.getUsuario().autentica()) recursoReal.acceder(s);
        else System.out.println("Acceso denegado.");
    }
}

package com.concurso.medio.reto2;

public class Sesion {
    private static Sesion instancia;
    private Usuario usuario;

    private Sesion(Usuario usuario) {
        this.usuario = usuario;
    }

    public static Sesion crearSesion(Usuario usuario) {
        if (instancia == null) {
            instancia = new Sesion(usuario);
            System.out.println(" Se creo instancia");
        } else System.out.println(" solo existe una instancia " +
                "de sesión para los usuarios");
        return instancia;
    }

    public Usuario getUsuario() {
        return usuario;
    }

    record Usuario(String name, boolean autentica) {

    }
}

package com.concurso.medio.reto2;

import com.concurso.medio.reto2.Sesion.Usuario;

public class Main {
    public static void main(String[] args) {
        Sesion sesion = Sesion.crearSesion(
                new Usuario("Mary", true)
        );

        Sesion sesion2 = Sesion.crearSesion(
                new Usuario("Juan", false)
        );

        ProxyRecurso r = new ProxyRecurso();
        r.acceder(sesion);
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── medio
                    └── reto3
                        ├── builder
                        |   ├── ReporteBuilder.java
                        |   ├── ReporteConcretoBuilder.java
                        |   └── ReporteDirector.java
                        ├── db
                        |   ├── ConexionBD.java
                        |   ├── CreacionBase.java
                        |   └── PersonaDAO.java
                        ├── model
                        |   └── Persona.java
                        └── ReportesApp.java

implementation("org.xerial:sqlite-jdbc:3.46.1.3")
implementation("commons-beanutils:commons-beanutils:1.11.0")

package com.concurso.medio.reto3.db;

import java.sql.Connection;
import java.sql.DriverManager;

public class ConexionBD {
    public static final String URL = "jdbc:sqlite:reporte.db";

    public static Connection conectar() {
        try {
            return DriverManager.getConnection(URL);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package com.concurso.medio.reto3.model;

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class Persona {
    private int id;
    private String nombre;
    private int edad;
    private String correo;
    private String direccion;
    private String telefono;
}

package com.concurso.medio.reto3.db;

import com.concurso.medio.reto3.model.Persona;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class PersonaDAO {
    public static List<Persona> obtenerPersonas() {
        List<Persona> personas = new ArrayList<>();
        String sql = "SELECT * FROM personas";

        try (Connection conn = ConexionBD.conectar();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {

            while (rs.next()) {
                personas.add(Persona.builder()
                        .id(rs.getInt("id"))
                        .nombre(rs.getString("nombre"))
                        .edad(rs.getInt("edad"))
                        .correo(rs.getString("correo"))
                        .direccion(rs.getString("direccion"))
                        .telefono(rs.getString("telefono"))
                        .build());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return personas;
    }
}

package com.concurso.medio.reto3.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CreacionBase {
    private Connection conn;

    public void connect() throws SQLException {
        conn = DriverManager.getConnection(ConexionBD.URL);
    }

    public void close() throws SQLException {
        if (conn != null) conn.close();
    }

    public void createTable() throws SQLException {
        String sql = """
                CREATE TABLE IF NOT EXISTS Personas (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    nombre TEXT NOT NULL,
                    edad INTEGER,
                    correo TEXT,
                    direccion TEXT,
                    telefono TEXT
                );
                """;

        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql);
        }
    }

    // Insertamos datos para probar (solo si no hay)
    public void insertSampleData() throws SQLException {
        String checkSql = "SELECT COUNT(*) FROM Personas";
        try (Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(checkSql)) {
            if (rs.next()) {
                int count = rs.getInt(1);
                if (count > 0) return; // ya hay datos
            }
        }

        String insertSql = """
            INSERT INTO Personas 
            (nombre, edad, correo, direccion, telefono) 
            VALUES
            ('Ana', 28, 'ana@mail.com', 'Cumbaya','2456789'),
            ('Luis', 34, 'luis@mail.com', 'Conocto', '0987654321'),
            ('Marta', 40, 'marta@mail.com', 'Quito', '045666777');
            """;

        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate(insertSql);
        }
    }
}

package com.concurso.medio.reto3.builder;

import java.util.List;

public interface ReporteBuilder<T> {
    ReporteBuilder<T> setDatos(List<T> personas);
    ReporteBuilder<T> setCampos(List<String> campos);
    String buildReporte();
}

package com.concurso.medio.reto3.builder;

import org.apache.commons.beanutils.PropertyUtils;

import java.util.List;

public class ReporteConcretoBuilder<T> implements ReporteBuilder<T> {
    private List<T> datos;
    private List<String> campos;

    private Object getValue(Object obj, String fieldName) {
        try {
            if (PropertyUtils.isReadable(obj, fieldName)) {
                return PropertyUtils.getProperty(obj, fieldName);
            } else {
                return null;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public ReporteBuilder<T> setDatos(List<T> datos) {
        this.datos = datos;
        return this;
    }

    @Override
    public ReporteBuilder<T> setCampos(List<String> campos) {
        this.campos = campos;
        return this;
    }

    private void buildHeader(StringBuilder report) {
        for (String f : campos) {
            report.append(String.format("%-15s", f.toUpperCase()));
        }
        report.append("\n");
        for (int i = 0; i < campos.size() * 15; i++) {
            report.append("-");
        }
        report.append("\n");
    }

    @Override
    public String buildReporte() {
        StringBuilder sb = new StringBuilder();
        sb.append("=== Reporte Dinamico ===\n");

        if (datos.isEmpty() || campos.isEmpty()) {
            return sb.toString();
        }

        buildHeader(sb);

        for (T it : datos) {
            for (String campo : campos) {
                Object val = getValue(it, campo);

                sb.append(
                        String.format("%-15s", val != null
                                ? val
                                : "?"
                        )
                );
            }
            sb.append("\n");
        }

        return sb.toString();
    }
}

package com.concurso.medio.reto3.builder;

import java.util.List;

public class ReporteDirector<T> {
    private final ReporteBuilder<T> builder;

    public ReporteDirector(ReporteBuilder<T> builder) {
        this.builder = builder;
    }

    public String construirReporte(List<T> datos,
                                   List<String> campos) {
        return builder.setDatos(datos)
                .setCampos(campos)
                .buildReporte();
    }
}

package com.concurso.medio.reto3;

import com.concurso.medio.reto3.builder.ReporteConcretoBuilder;
import com.concurso.medio.reto3.builder.ReporteDirector;
import com.concurso.medio.reto3.db.PersonaDAO;
import com.concurso.medio.reto3.model.Persona;

import java.util.Arrays;
import java.util.List;

public class ReportesApp {

    public static void main(String[] args) throws Exception {
        // se ejecuta una sola vez para crear la base,
        //   la tabla e insertar los datos

        //CreacionBase db = new CreacionBase();
        //db.connect();
        //db.createTable();
        //db.insertSampleData();

        List<Persona> personas = PersonaDAO.obtenerPersonas();

        // Reporte 1: Solo nombre y correo
        var builder1 = new ReporteConcretoBuilder<Persona>();
        var director1 = new ReporteDirector<Persona>(builder1);
        String reporte1 = director1.construirReporte(personas,
                Arrays.asList("nombre", "correo")
        );
        System.out.println(reporte1);

        // Reporte 2: nombre, edad, dirección, teléfono
        var builder2 = new ReporteConcretoBuilder<Persona>();
        var director2 = new ReporteDirector<Persona>(builder2);
        String reporte2 = director2.construirReporte(personas,
                Arrays.asList(
                        "nombre",
                        "edad",
                        "direccion",
                        "telefono"
                )
        );
        System.out.println(reporte2);
    }
}

Se selecciona el pivot: 4
Se generan las dos sub-listas:
menores a 4: [1,3]
mayores a 4: [10,11,9,8]
Se ordenan las dos sub-listas
menores a 4: quicksort([1,4]) = [1,4]
mayores a 4: quicksort([10,11,9,8])=[8,9,10,11]
Se ubica el elemento pivot: [1,3] + 4 + [8,9,10,11]

Se selecciona el pivot: 10
Se generan las dos sub-listas:
menores a 4: [9,8]
mayores a 4: [11]
Se ordenan las dos sub-listas
menores a 4: quicksort([9,8]) = [8,9]
mayores a 4: quicksort([11])=[11]
Se ubica el elemento pivot: [8,9] + 10 + [11]

src
└── main
    └── java
       └── com
            └── concurso
                └── avanzada
                    └── reto1
                        ├── Cons.java
                        ├── Empty.java
                        ├── Lista.java
                        └── QuickSort.java

package com.concurso.avanzado.reto1;

public sealed interface Lista<T> permits Cons, Empty {
    Lista Empty = new Empty();

    T head();

    Lista<T> tail();

    boolean isEmpty();

    static <T> Lista<T> of(T elem, Lista<T> tail) {
        return new Cons<>(elem, tail);
    }

    static <T> Lista<T> of(T... elems) {
        var tmp = Lista.Empty;
        for (int i = elems.length - 1; i >= 0; i--) {
            tmp = Lista.of(elems[i], tmp);
        }

        return tmp;
    }

    default Lista<T> prepend(T elem) {
        return Lista.of(elem, this);
    }

    default Lista<T> concat(Lista<T> ls) {
        if (isEmpty()) {
            return ls;
        } else {
            return Lista.of(this.head(), tail().concat(ls));
        }
    }
}

package com.concurso.avanzado.reto1;

record Cons<T>(T head, Lista<T> tail) implements Lista<T> {
    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public String toString() {
        return String.format("[%s,%s]", head, tail);
    }
}

package com.concurso.avanzado.reto1;

final class Empty<T> implements Lista<T> {
    Empty() {

    }

    @Override
    public T head() {
        throw new RuntimeException("Lista vacía");
    }

    @Override
    public Lista<T> tail() {
        throw new RuntimeException("Lista vacía");
    }

    @Override
    public boolean isEmpty() {
        return true;
    }

    @Override
    public String toString() {
        return "Empty";
    }
}

package com.concurso.avanzada;

import java.util.Comparator;

public class QuickSort {
    record Pair<T>(Lista<T> ls1, Lista<T> ls2) {
    }

    static <T> Pair<T> partition(T pivot, Lista<T> ls,
        Comparator<T> cmp) {
        //TODO: completar
    }

    public static <T> Lista<T> sort(Lista<T> ls, Comparator<T> cmp) {
        //TODO: completar
    }

    public static <T extends Comparable> Lista<T> sort(Lista<T> ls) {
        return QuickSort.sort(ls, Comparable::compareTo);
    }

    public static void main(String[] args) {
        //var ls = Lista.of(12,10,1,11,9,7,8);
        var ls = Lista.of(4,10,1,11,9,3,8);

        var sortedList = QuickSort.sort(ls);

        System.out.println(sortedList);
    }
}

package com.concurso.avanzado.reto1;

import java.util.Comparator;

public class QuickSort {
    record Pair<T>(Lista<T> ls1, Lista<T> ls2) {
    }

    static <T> Pair<T> partition(T pivot, Lista<T> ls,
                                          Comparator<T> cmp) {
        // se toma la cabecera de la lista
        //   si la cabecera es menor que el PIVOT,
        //     se agrega a la lista de la izquierda
        //   si la cabecera es mayor que el PIVOT,
        //     se agrega a la lista de la derecha
        // se repite el procedimiento para la cola
        // el procedimiento termina si la lista está vacía
        if (ls.isEmpty()) {
            return new Pair<>(Lista.Empty, Lista.Empty);
        } else {
            var h = ls.head();

            var tmp = partition(pivot, ls.tail(), cmp);

            if (cmp.compare(h, pivot) < 0) { //h<elem
                return new Pair<>(tmp.ls1.prepend(h), tmp.ls2);
            } else { //h>=elem
                return new Pair<>(tmp.ls1, tmp.ls2.prepend(h));
            }
        }
    }

    public static <T> Lista<T> sort(Lista<T> ls, Comparator<T> cmp) {
        if (ls.isEmpty()) {
            return Lista.Empty;
        } else {
            var mid = ls.head();

            var tmp = partition(mid, ls.tail(), cmp);

            var smallerSorted = QuickSort.sort(tmp.ls1, cmp);
            var largerSorted = QuickSort.sort(tmp.ls2, cmp);

            return smallerSorted.concat(Lista.of(mid, largerSorted));
        }
    }

    public static <T extends Comparable<T>> Lista<T> sort(Lista<T> ls) {
        return QuickSort.sort(ls, Comparable::compareTo);
    }

    public static void main(String[] args) {
        //var ls = Lista.of(12,10,1,11,9,7,8);
        var ls = Lista.of(4, 10, 1, 11, 9, 3, 8);

        var sortedList = QuickSort.sort(ls);

        System.out.println(sortedList);
    }
}

src
└── main
    └── java
       └── com
            └── concurso
                └── avanzada
                    └── reto2
                        ├── db
                        │   └── Persona.java
                        ├── dtos
                        │   └── CountDto.java
                        ├── repository
                        │   └── PersonaRepository.java
                        ├── rest
                        │   └── PersonasRest.java
                        └── servicios
                            ├── ImportarDatos.java
                            └── ImportarDatosImpl.java

plugins {
    id("java")
    id("io.freefair.lombok") version "8.13.1"
    id("io.quarkus") version "3.22.2"
}

group = "com.concurso.avanzada"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

val quarkusVersion = "3.22.2"

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

dependencies {
    implementation(enforcedPlatform("io.quarkus.platform:quarkus-bom:${quarkusVersion}"))

    //CDI
    implementation("io.quarkus:quarkus-arc")

    //REST
    implementation("io.quarkus:quarkus-rest")
    implementation("io.quarkus:quarkus-rest-jsonb")

    //JPA
    implementation("io.quarkus:quarkus-hibernate-orm-panache")
    implementation("io.quarkus:quarkus-jdbc-postgresql")
}

tasks.withType<JavaCompile> {
    options.encoding = "UTF-8"
    options.compilerArgs.add("-parameters")
}

quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=postgres
quarkus.datasource.password=postgres
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/concurso
#quarkus.hibernate-orm.database.generation=drop-and-create
#quarkus.hibernate-orm.log.sql=true
#quarkus.hibernate-orm.log.format-sql=true
quarkus.http.port=8080
app.file-name=c:/datos/Pichincha_CSV_Poblacion.csv

package com.concurso.avanzado.reto2.db;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Getter @Setter
@Entity
public class Persona {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column
    private String provincia;

    @Column
    private String canton;

    @Column
    private Integer sexo;

    @Column
    private Integer edad;

    @Column(name = "anio_nacimiento")
    private Integer anioNacim;

    @Column(name = "mes_nacimiento")
    private Integer mesNacim;
}

package com.concurso.avanzado.reto2.repository;

import com.concurso.avanzado.reto2.db.Persona;
import com.concurso.avanzado.reto2.dtos.CountDto;
import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.transaction.Transactional;

import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;

@ApplicationScoped
@Transactional
public class PersonaRepository implements
        PanacheRepositoryBase<Persona, Integer> {

    @PersistenceContext
    EntityManager entityManager;

    public List<CountDto> findByCanton(String canton) {

        String sql = "select o.sexo, count(o) " +
                " from Persona o " +
                " where o.canton=?1 group by o.sexo";

        return entityManager.createQuery(sql, Object[].class)
                .setParameter(1, canton)
                .getResultList()
                .stream()
                .map(o -> new CountDto(
                        ((Integer) o[0]) == 1 ? "Hombres" : "Mujeres",
                        (Long) (o)[1]))
                .collect(Collectors.toList());
    }

    public List<CountDto> findByAnio(Integer anio) {
        var map = this.find("anioNacimiento", anio)
                .stream()
                .collect(Collectors.groupingBy(
                        Persona::getSexo, Collectors.counting()
                        ));

        if(map.isEmpty()) {
            return List.of();
        }

        return List.of(
                new CountDto("Hombres", map.getOrDefault(1, 0L)),
                new CountDto("Mujeres", map.getOrDefault(2, 0L))
        );
    }
}

package com.concurso.avanzado.reto2.dtos;

public record CountDto(String key, Long count) {
}

package com.concurso.avanzado.reto2.rest;

import com.concurso.avanzado.reto2.repository.PersonaRepository;
import com.concurso.avanzado.reto2.servicios.ImportarDatos;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.PathParam;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

@Path("/personas")
public class PersonasRest {

    @Inject
    ImportarDatos importarDatos;

    @Inject
    PersonaRepository personaRepository;

    @GET
    @Path("/importar/{count}")
    public Response importar(@PathParam("count") Integer count) {
        importarDatos.importar(count);

        return Response.ok("Personas importadas correctamente")
                .build();
    }

    @GET
    @Path("/{canton}")
    @Produces(MediaType.APPLICATION_JSON)
    public Response personasPorCanton(
            @PathParam("canton") String canton) {

        var data = personaRepository.findByCanton(canton);

        if (data.isEmpty()) {
            return Response.status(Response.Status.NOT_FOUND)
                    .entity("No se encontraron personas: " + canton)
                    .build();
        }

        return Response.ok(data).build();
    }

    @GET
    @Path("/anio/{anio}")
    @Produces(MediaType.APPLICATION_JSON)
    public Response personasPorAnio(@PathParam("anio") Integer anio) {

        var data = personaRepository.findByAnio(anio);

        if (data.isEmpty()) {
            return Response.status(Response.Status.NOT_FOUND)
                    .entity("No se encontraron personas: " + anio)
                    .build();
        }

        return Response.ok(data).build();
    }
}

package com.concurso.avanzado.reto2.servicios;

public interface ImportarDatos {
    void importar(Integer count);
}

package com.concurso.avanzado.reto2.servicios;

import com.concurso.avanzado.reto2.db.Persona;
import com.concurso.avanzado.reto2.repository.PersonaRepository;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.config.inject.ConfigProperty;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.atomic.AtomicInteger;

@ApplicationScoped
public class ImportarDatosImpl implements ImportarDatos {

    @Inject
    PersonaRepository repo;

    @Inject
    @ConfigProperty(name = "app.file-name",
            defaultValue = "c:/cc/Pichincha_CSV_Poblacion.csv")
    String csvFileName;

    public void importar(Integer count) {

        try {
            AtomicInteger cc = new AtomicInteger(0);;

            Files.lines(Path.of(csvFileName))
                    .skip(1) // 1=header
                    .takeWhile(it->cc.getAndIncrement()<count)
                    .map(it -> it.split(","))
                    .map(values -> {
                        Persona per = new Persona();

                        //sexo: P01->10
                        //edad: P03->12
                        //anioNacimiento: P04A->14
                        //mesNacimiento: P04M->13
                        var sexo = Integer.parseInt(values[10]);
                        var edad = Integer.parseInt(values[12]);
                        var anio = Integer.parseInt(values[14]);
                        var mes = Integer.parseInt(values[13]);

                        per.setProvincia(values[0]);
                        per.setCanton(values[1]);
                        per.setSexo(sexo);
                        per.setEdad(edad);
                        per.setAnioNacim(anio);
                        per.setMesNacim(mes);

                        return per;
                    })
                    .forEach(repo::persist);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}