Add 2023-2 L03 solution

1 files changed, 408 insertions, 0 deletions

diff --git a/2023-2/L03/mitsuo/fun.cpp b/2023-2/L03/mitsuo/fun.cpp
new file mode 100644
index 0000000..6f5fe0e
--- /dev/null
+++ b/2023-2/L03/mitsuo/fun.cpp
@@ -0,0 +1,408 @@
+#include <iomanip>
+#include <cstring>
+#include <algorithm>    // find
+#include "fun.hpp"
+
+using namespace std;
+
+void lecturaDeProductos(const char *archivo, char ***&productos, int *&stocks, double *&precios) {
+    ifstream in(archivo);
+    if (!in) {
+        cerr << "Error: no se pudo abrir el archivo.\n";
+        exit(1);
+    }
+
+    // read (stack memory)
+    char code[MAXLEN];
+    char description[MAXLEN];
+    double price;
+    int qty;
+
+    productos = NULL;
+    stocks = NULL;
+    precios = NULL;
+    size_t size = 0;       // size of the parallel arrays
+
+    int i;
+    for (i = 0; true; i++) {
+        in.getline(code, MAXLEN, ',');
+        in.getline(description, MAXLEN, ',');
+        in >> price; in.get();
+        in >> qty; in.get();
+        if (!in) {
+            break;
+        }
+
+        // memory allocation "por incrementos"
+        if (i == size) {
+            increase_size_productos(productos, stocks, precios, size);
+        }
+        productos[i] = crea_producto(code, description);    // "code" is the "Primary Key" of the parallel arrays
+        stocks[i] = qty;
+        precios[i] = price;
+    }
+}
+
+void increase_size_productos(char ***& productos, int *& stocks, double *& precios, size_t &size) {
+    if (!productos) {
+        // init
+        size = INCREMENTO;
+        productos = new char ** [size];
+        stocks = new int [size];
+        precios = new double [size];
+        
+        productos[0] = NULL;
+        return;
+    }
+    /* In LP1 increments are 5 by 5.  This has time complexity N^2 and space 
+       complexity N.  On the other hand, exponential increase of array size
+       has time complexity n*log(n), with space complexity of N.  Much better. */
+    size *= 2;
+    char *** productos_tmp = new char ** [size];
+    int * stocks_tmp = new int [size];
+    double * precios_tmp = new double [size];
+
+    int i;    
+    for (i = 0; i < size && productos[i]; i++) {
+        productos_tmp[i] = productos[i];
+        stocks_tmp[i] = stocks[i];
+        precios_tmp[i] = precios[i];
+    }
+    productos_tmp[i] = NULL;
+
+    delete [] productos;
+    delete [] stocks;
+    delete [] precios;
+    productos = productos_tmp;
+    stocks = stocks_tmp;
+    precios = precios_tmp;
+}
+
+char **crea_producto(char * code, char * description) {
+    char * field1 = new char [strlen(code) + 1];
+    char * field2 = new char [strlen(description) + 1];
+
+    strcpy(field1, code);
+    strcpy(field2, description);
+
+    return new char * [2] {field1, field2};
+}
+
+void pruebaDeLecturaDeProductos(const char *archivo, char ***productos, int *stock, double *precios) {
+    ofstream out(archivo);
+    if (!out) {
+        cerr << "Error: no se pudo abrir archivo.\n";
+        exit(1);
+    }
+
+    char ** producto;
+    int i;
+    for (i = 0; i < MAX && (producto = productos[i]); i++) {
+        out << left;
+        out << setw(12) << producto[0];
+        out << setw(72) << producto[1];
+        out << right << setprecision(2) << fixed;
+        out << setw(8) << stock[i];
+        out << setw(12) << precios[i];
+        out << '\n';
+    }
+}
+
+void lecturaDePedidos(const char *archivo, int *& fechas, char ***& grouped_producto, int ***& grouped_dniqty) {
+    ifstream in(archivo);
+    if (!in) {
+        cerr << "Error: no se pudo abrir el archivo.\n";
+        exit(1);
+    }
+
+    int date, dd, mm, yy;
+    char code[MAXLEN];
+    int dni;
+    int qty;
+
+    fechas = NULL;
+    grouped_producto = NULL;
+    grouped_dniqty = NULL;
+    size_t size = 0;            // size of the parallel arrays
+    size_t size2[MAX] = {};     // size of internal parallel arrays (level 2)
+
+    int n, i = 0;
+    while (true) {
+        in.getline(code, MAXLEN, ',');
+        in >> dni; in.get();
+        in >> qty; in.get();
+        in >> dd; in.get(); in >> mm; in.get(); in >> yy; in.get();
+        date = yy*10000 + mm*100 + dd;
+        if (!in) {
+            break;
+        }
+
+        // memory allocation "por incrementos"
+        if (i == size) {
+            increase_size_pedidos(fechas, grouped_producto, grouped_dniqty, size);
+        }
+
+        int * dniqty = new int [2] {dni, qty};
+        char * code_mem = new char [strlen(code) + 1]; strcpy(code_mem, code);
+
+        insert_pedido(i, date, code_mem, dniqty, fechas, grouped_producto, grouped_dniqty, size2);
+    }
+    qsort_pedidos(fechas, grouped_producto, grouped_dniqty, 0, i - 1);
+}
+
+void increase_size_pedidos(int *& fechas, char ***& grouped_producto, int ***& grouped_dniqty, size_t &size) {
+    if (!fechas) {
+        // init
+        size = INCREMENTO;
+        fechas = new int [size];
+        grouped_producto = new char ** [size];
+        grouped_dniqty = new int ** [size];
+        
+        fechas[0] = 0;
+        return;
+    }
+    /* In LP1 increments are 5 by 5.  This has time complexity N^2 and space 
+       complexity N.  On the other hand, exponential increase of array size
+       has time complexity n*log(n), with space complexity of N.  Much better. */
+    size *= 2;
+    int * f = new int [size];
+    char *** gp = new char ** [size];
+    int *** gd = new int ** [size];
+
+    int i;    
+    for (i = 0; i < size && fechas[i]; i++) {
+        f[i] = fechas[i];
+        gp[i] = grouped_producto[i];
+        gd[i] = grouped_dniqty[i];
+    }
+    f[i] = 0;
+
+    delete [] fechas;
+    delete [] grouped_producto;
+    delete [] grouped_dniqty;
+    fechas = f;
+    grouped_producto = gp;
+    grouped_dniqty = gd;
+}
+
+void insert_pedido (
+        int & n,
+        int date, char * code_mem, int * dniqty, 
+        int * fechas, char *** grouped_producto, int *** grouped_dniqty,
+        size_t * size2
+) {
+    // find if date is already in the list
+    int i;
+    for (i = 0; i < n; i++) {
+        if (fechas[i] == date) {
+            break;
+        }
+    }
+    if (i == n) {
+        // new date
+        fechas[i] = date;
+        grouped_producto[i] = NULL;
+        grouped_dniqty[i] = NULL;
+        size2[i] = 0;
+        fechas[++n] = 0;        // update reference (n) and list terminator (0)
+    } 
+
+    // make sure there is space for the product (in the nested list (#2)) before adding it to the date (at `fechas[i]`)
+    int i2;
+    for (i2 = 0; grouped_producto[i] && grouped_producto[i][i2]; i2++)
+        ;
+    if (i2 == size2[i]) {
+        increase_size_pedidos_fecha(grouped_producto[i], grouped_dniqty[i], size2[i]);
+    }
+    grouped_producto[i][i2] = code_mem;
+    grouped_dniqty[i][i2] = dniqty;
+    i2 += 1;
+    grouped_producto[i][i2] = NULL;
+}
+
+/* qsort: sort v[left]...v[right] into increasing order 
+
+   Quicksort.
+   Ref.:
+   * The C Programming Language (ANSI C) - pg. 87)
+   * https://en.wikipedia.org/wiki/Quicksort
+*/
+void qsort_pedidos(int * v1, char *** v2, int *** v3, int left, int right) {
+    int i, last;
+
+    /* do nothing if array has less than 2 elements */
+    if (left >= right)
+        return;
+
+    swap_pedidos(v1, v2, v3, left, (left + right) / 2); 
+    last = left;
+
+    /* partition */
+    for (i = left + 1; i <= right; i++) {
+        if (v1[i] < v1[left]) {
+            swap_pedidos(v1, v2, v3, ++last, i);
+        }
+    }
+
+    swap_pedidos(v1, v2, v3, left, last);        /* reset partition element */
+    qsort_pedidos(v1, v2, v3, left, last - 1);
+    qsort_pedidos(v1, v2, v3, last + 1, right);
+}
+
+void swap_pedidos(int * v1, char *** v2, int *** v3, int left, int right) {
+    int     t1 = v1[left];
+    char ** t2 = v2[left];
+    int **  t3 = v3[left];
+
+    v1[left] = v1[right];
+    v2[left] = v2[right];
+    v3[left] = v3[right];
+
+    v1[right] = t1;
+    v2[right] = t2;
+    v3[right] = t3;
+}
+
+void increase_size_pedidos_fecha(char **& productos, int **& dniqtys, size_t &size) {
+    if (!productos) {
+        // init
+        size = INCREMENTO;
+        productos = new char * [size];
+        dniqtys = new int * [size];
+
+        productos[0] = NULL;
+        return;
+    }
+    /* In LP1 increments are 5 by 5.  This has time complexity N^2 and space 
+       complexity N.  On the other hand, exponential increase of array size
+       has time complexity n*log(n), with space complexity of N.  Much better. */
+    size *= 2;
+    char ** p = new char * [size];
+    int ** d = new int * [size];
+
+    int i;    
+    for (i = 0; i < size && productos[i]; i++) {
+        p[i] = productos[i];
+        d[i] = dniqtys[i];
+    }
+    p[i] = NULL;
+
+    delete [] productos;
+    delete [] dniqtys;
+    productos = p;
+    dniqtys = d;
+}
+
+void pruebaDeLecturaDePedidos(const char *archivo, int *fechaPedidos, char ***codigoPedidos, int ***dniCantPedidos) {
+    ofstream out(archivo);
+    if (!out) {
+        cerr << "Error: no se pudo abrir archivo.\n";
+        exit(1);
+    }
+
+    int fecha;
+    int i, j;
+    for (i = 0; i < MAX && (fecha = fechaPedidos[i]); i++) {
+        out << "FECHA: " << fecha << '\n';
+        char ** productos = codigoPedidos[i];
+        int ** dniqtys = dniCantPedidos[i];
+        for (j = 0; j < MAX && productos[j]; j++) {
+            int dni = dniqtys[j][0];
+            int qty = dniqtys[j][1];
+            char * code = productos[j];
+
+            out << right << setprecision(2) << fixed;
+            out << setw(2) << j + 1 << ") ";
+            out << left;
+            out << setw(12) << dni;
+            out << setw(12) << code;
+            out << setw(12) << qty;
+            out << '\n';
+        }
+    }
+}
+
+void reporteDeEnvioDePedidos(const char *archivo, 
+        char ***productos, int *stocks, double *precios,                     // productos parallel arrays
+        int *fechaPedidos, char ***codigoPedidos, int ***dniCantPedidos     // pedidos parallel arrays
+) {
+    ofstream out(archivo);
+    if (!out) {
+        cerr << "Error: no se pudo abrir archivo.\n";
+        exit(1);
+    }
+
+    int fecha;
+    int i, j;
+    for (i = 0; i < MAX && (fecha = fechaPedidos[i]); i++) {
+        int dd = fecha % 100;
+        int mm = fecha / 100 % 100;
+        int yy = fecha / 10000;
+        out << "                                                               REPORTE DE ENTREGA DE PEDIDOS\n"
+               "=====================================================================================================================================\n"
+        ;
+        out << "FECHA: " << dd << "/" << mm << "/" << yy << '\n';
+        out << "=====================================================================================================================================\n"
+               "No. DNI             Producto                                                                    Cantidad    Precio  Total de ingresos\n"
+               "-------------------------------------------------------------------------------------------------------------------------------------\n"
+        ;
+
+        char ** pedido_productos = codigoPedidos[i];
+        int ** dniqtys = dniCantPedidos[i];
+
+        double served_income = 0;
+        double not_served_income = 0;
+        for (j = 0; j < MAX && pedido_productos[j]; j++) {
+            int dni = dniqtys[j][0];
+            int qty = dniqtys[j][1];
+            char * code = pedido_productos[j];
+
+            int i_product = busca_producto(productos, code);
+            char * name = productos[i_product][1];
+            int * stock = &stocks[i_product];
+            double price = precios[i_product];
+
+            int qty_served;
+            if (*stock >= qty) {
+                qty_served = qty;
+                *stock -= qty;
+            } else {
+                qty_served = *stock;
+                *stock = 0;
+            }
+            served_income += qty_served * price;
+            not_served_income += (qty - qty_served) * price;
+
+            out << right << setprecision(2) << fixed;
+            out << setw(2) << j + 1 << ") ";
+            out << left;
+            out << setw(12) << dni;
+            out << setw(12) << code;
+            out << setw(64) << name;
+            out << right << setprecision(2) << fixed;
+            out << setw(12) << qty_served;
+            out << setw(12) << price;
+            if (qty_served == 0) {
+                out << left;
+                out << setw(12) << "  SIN STOCK";
+            } else {
+                out << setw(12) << price * qty_served;
+            }
+            out << '\n';
+        }
+        out << right << setprecision(2) << fixed;
+        out << "-------------------------------------------------------------------------------------------------------------------------------------\n";
+        out << "Total ingresado: " << served_income << '\n';
+        out << "Total perdido por falta de stock: " << not_served_income << '\n';
+    }
+}
+
+int busca_producto(char *** productos, char * producto) {
+    for (int i = 0; productos[i]; i++) {
+        if (strcmp(productos[i][0], producto) == 0) {
+            return i;
+        }
+    }
+    return -1;
+
+}
\ No newline at end of file