chore: name of first year folder

40 files changed, 2334 insertions, 0 deletions

diff --git a/1_anno/Programmazione_1/ex01.cc b/1_anno/Programmazione_1/ex01.cc
new file mode 100644
index 0000000..9183dec
--- /dev/null
+++ b/1_anno/Programmazione_1/ex01.cc
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#define K 2
+#define N 3
+
+using namespace std;
+
+template<int KK, int NN>
+bool func(int (&a)[KK][NN][NN], int w) {
+	vector<int> list;
+	for(int i = 0; i < KK; ++i) {
+		list.clear();
+		for(int j = 0; j < NN; ++j)
+			list.push_back(a[i][j][j]);
+			
+		auto mm = minmax_element(begin(list), end(list));
+		float media = (static_cast<float>(*mm.first)+static_cast<float>(*mm.second))/2;
+		if(media <= w)
+			return true;
+	}
+	
+	return false;
+}
+
+int main() {
+	int a[K][N][N] = {
+		{
+			{1, 2, 30},
+			{1, 80, 3},
+			{1, 2, 3},
+		},
+		{
+			{1, 2, 30},
+			{1, 20, 3},
+			{1, 2, 3},
+		}};
+		
+	cout << func(a, 5);
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex08.cc b/1_anno/Programmazione_1/ex08.cc
new file mode 100644
index 0000000..fdfea92
--- /dev/null
+++ b/1_anno/Programmazione_1/ex08.cc
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <stdio.h>
+#define N 3 
+#define M 5
+
+using namespace std;
+
+bool func(int A[N][M], short k, short w) { 
+    short counter = 0;
+    for(int i = 0; i < M; ++i) {
+        short t_counter = 0;
+        for(int j = 1; j < N; ++j) {
+            if(A[j][i] < A[j-1][i])
+                break;
+            else 
+                ++t_counter;
+        }
+
+        if(t_counter >= k)
+            ++counter;
+    }
+
+    return counter >= w;
+}
+
+int main() {
+    int array[N][M] = {
+        {5, 7, 9, 10, 5},
+        {10, 2, 3, 4, 10},
+        {16, 34, 21, 23, 1}
+    };
+
+    cout << func(array, 2, 1) << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex10_07_18.cc b/1_anno/Programmazione_1/ex10_07_18.cc
new file mode 100644
index 0000000..092b184
--- /dev/null
+++ b/1_anno/Programmazione_1/ex10_07_18.cc
@@ -0,0 +1,45 @@
+#include<iostream>
+#include<vector>
+
+#define n 3
+
+using namespace std;
+
+bool func(char (*A)[n]) {
+    bool check{false};
+    char str[n];
+
+    for(int i = 0; i < n; ++i) {
+        str[i] = A[i][i];
+    }
+
+    short n_check{0};
+    for(int i = 0; i < n; ++i) {
+        short index{0};
+        for(int j = 0; j < n; ++j) {
+            if(A[j][i] != str[index++]) {
+                break;
+            }
+            ++n_check;
+        }
+        if(n_check == n) {
+            check = true;
+            break;
+        }
+    }
+
+    return check;
+}
+
+
+int main() {
+    char A[3][3] = {
+        {'a', 'b', 'c'},
+        {'b', 'b', 'c'},
+        {'c', 'b', 'c'},
+    };
+
+    cout << func(&A[0]);
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex12.cc b/1_anno/Programmazione_1/ex12.cc
new file mode 100644
index 0000000..ab20cef
--- /dev/null
+++ b/1_anno/Programmazione_1/ex12.cc
@@ -0,0 +1,50 @@
+#include <iostream>
+#include <vector>
+#define N 3
+using namespace std;
+
+string* func(string a[N][N], short k, string s) {
+    string* sn = new string[N];
+    vector<string> l;
+
+    // Diagonale secondaria
+    for(int i = N-1, j = 0; i >= 0; --i, ++j) {
+        l.push_back(a[i][j]);
+    } 
+
+    bool d2 = true;
+    for(auto const& i : l) {
+        if(i.length() < k || i.find(s) != 0) {
+            d2 = false;
+            break;
+        }
+    }
+
+    if(d2) {
+        for(int i = 0; i < N; ++i) {
+            sn[i] = l.at(i);
+        }
+    } else {
+        for(int i = 0; i < N; ++i) {
+            sn[i] = a[i][i];
+        }
+    }
+
+    return sn; 
+}
+
+int main() {
+    string a[N][N] = {
+        {"aab", "bbc", "4de"},
+        {"xyb", "bbc", "yz3"},
+        {"47x", "1y_", "23g"},
+    };
+    string* x = func(a, 1, "4");
+
+    for(int i = 0; i < N; ++i)
+        cout << x[i] << ' ';
+    
+    cout << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex13.cc b/1_anno/Programmazione_1/ex13.cc
new file mode 100644
index 0000000..f9f19fa
--- /dev/null
+++ b/1_anno/Programmazione_1/ex13.cc
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <memory>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+template<int N, int K>
+unique_ptr<double[]> func(int (&A)[K][N], int (&B)[N][K]) {
+    auto arr = unique_ptr<double[]>(new double{K});
+    for(int i = 0; i < K; ++i) {
+        vector<int> t;
+        int sum = 0;
+        for(int j = 0; j < N; ++j) {
+            t.push_back(B[j][i]);
+            sum+=A[i][j];
+        }
+        
+        double media = static_cast<double>(sum)/N;
+        auto min_num = min_element(begin(t), end(t));
+        arr[i] = media - *min_num;
+    }
+
+    return arr;
+}
+
+int main() {
+    const int N2 = 3, K2 = 2;
+    int A[K2][N2] = {
+        {3, 7, 10},
+        {5, 12, 32},
+    };
+    int B[N2][K2] = {
+        {12, 10},
+        {15, 17},
+        {8, 0},
+    };
+    auto x = func(A, B);
+
+    for(int i = 0; i < K2; ++i)
+        cout << x[i] << ' ';
+    
+    cout << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex15.cc b/1_anno/Programmazione_1/ex15.cc
new file mode 100644
index 0000000..525882c
--- /dev/null
+++ b/1_anno/Programmazione_1/ex15.cc
@@ -0,0 +1,41 @@
+#include <iostream>
+using namespace std;
+
+template<int N, int M>
+unique_ptr<string[]> func(string (&A)[N][M], short (&B)[N][M]) {
+    auto arr = unique_ptr<string[]>(new string[N]);
+
+    for(int i = 0; i < N; ++i) {
+        short sum{0};
+        string tmp{""};
+        for(int j = 0; j < M; ++j) {
+            sum+=B[i][j];
+            tmp+=A[i][j];
+        }
+
+        arr[i] = tmp.length() >= sum ? tmp : "";
+    }
+
+    return arr;
+}
+
+int main() {
+    string A[2][3] = {
+        {"aab", "aA", "314"},
+        {"1334", "5715", "__"},
+    };
+
+    short B[2][3] = {
+        {2, 3, 0},
+        {1, 15, 7}
+    };
+    
+    auto x = func(A, B);
+
+    for(int i = 0; i < 2; ++i)
+        cout << x[i] << ' ';
+    
+    cout << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex16.cc b/1_anno/Programmazione_1/ex16.cc
new file mode 100644
index 0000000..4c2b74a
--- /dev/null
+++ b/1_anno/Programmazione_1/ex16.cc
@@ -0,0 +1,41 @@
+#include <iostream>
+
+using namespace std;
+
+template<int N, int M>
+short func(string (&S)[N][M], short (&B)[M]) {
+    short index{0};
+    short ex_count{0};
+    short i{0};
+
+    for(auto const& row : S) {
+        short count{0};
+        if(i > M)
+            break;
+
+        for(auto const& col : row) {
+            if(col.length() <= B[i])
+                ++count;            
+        }
+
+        if(count > ex_count) {
+            index = i;
+            ex_count = count;
+        }
+        ++i;
+    }
+
+    return index;
+}
+
+int main() {
+    string t[2][3]{
+        {"greeeeee", "aaaaaaa", "bbbbbb"},
+        {"abc", "sooca", "icsdi"},
+    };
+    short bb[3]{3, 10};
+    short x = func(t, bb);
+
+    cout << x << endl;
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex17.cc b/1_anno/Programmazione_1/ex17.cc
new file mode 100644
index 0000000..9eee61d
--- /dev/null
+++ b/1_anno/Programmazione_1/ex17.cc
@@ -0,0 +1,43 @@
+#include <iostream>
+
+using namespace std; 
+
+template<int N, int M>
+short* func(string (&S)[N][M], char (&C)[N], char (&D)[N]) {
+    short* a = new short[N];
+
+    for(int i = 0; i < N; ++i) {
+        short counter = 0;
+        for(auto const& rows_string : S[i]) {
+            if(rows_string.length() > 2) {
+                if(rows_string.at(0) == C[i]
+                    && rows_string.at(rows_string.length()-1) == D[i])
+                        ++counter;
+            }
+        }
+
+        a[i] = counter;
+    }    
+
+
+    return a;
+}
+
+int main() {
+    string t[3][3]{
+        {"suca", "we", "soia"},
+        {"omg", "ooohygodg", "onopg"},
+        {"", "mii", ""},
+    };
+
+    char c[3] = {'s', 'o', 'a'};
+    char d[3] = {'a', 'g', 'a'};
+
+    short* n = func(t, c, d);
+
+    for(int i = 0; i < 3; ++i) {
+        cout << n[i] << ' ';
+    }
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_03_12_19.cc b/1_anno/Programmazione_1/ex1_03_12_19.cc
new file mode 100644
index 0000000..8f9bed7
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_03_12_19.cc
@@ -0,0 +1,65 @@
+#include <iostream>
+
+using namespace std;
+/*
+2 3 4 5
+1 2 3 4
+1 2 3 0
+
+3 x 4
+
+5 2 1 0
+*/
+
+template<int N, int M>
+bool* func(unsigned int (&K)[N][M], double (&D)[M]) {
+    bool* A = new bool[M];
+    for(int i = 0; i < M; ++i) 
+        A[i] = false;
+
+    for(int i = 0; i < M; ++i) {
+        int sum = 0;
+        for(int j = 0; j < N; ++j) {
+            sum+=K[j][i];
+        }
+
+        if(static_cast<double>(sum)/static_cast<double>(M) > D[i]) {
+            A[i] = true;
+        }
+    }
+
+    return A;
+}
+
+int main() {
+    // TODO: test
+    unsigned int A[3][4] = {
+        {2, 3, 4, 5},
+        {1, 2, 3, 4},
+        {1, 2, 3, 0}
+    };   
+
+    double D[4] = {5., 2.2, 1.1, 0.50};
+
+    auto a = func(A, D);
+    for(int i = 0; i < 4; ++i) 
+        cout << a[i] << ' ';
+
+    cout << endl;
+    
+    unsigned int A2[3][4] = {
+        {2, 3, 4, 5},
+        {1, 2, 0, 4},
+        {1, 2, 0, 0}
+    };   
+
+    double D2[4] = {5., 2.2, 15.1, 18.50};
+
+    auto a2 = func(A2, D2);
+    for(int i = 0; i < 4; ++i) 
+        cout << a2[i] << ' ';
+
+    cout << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_04_12_19.cc b/1_anno/Programmazione_1/ex1_04_12_19.cc
new file mode 100644
index 0000000..3d352f1
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_04_12_19.cc
@@ -0,0 +1,39 @@
+#include <iostream>
+
+using namespace std;
+
+template<int N, int M>
+short func(int (&A)[N][M], double d1, double d2, short s) {
+    short result{0};
+
+    for(int i = 0; i < M; ++i) {
+        short temp_result{0};
+        for(int j = 0; j < N-1; ++j) {
+            if(temp_result >= s)
+                continue;
+
+            double div = static_cast<double>(A[j][i]) / static_cast<double>(A[j+1][i]);
+            if(div >= d1 && div <= d2)
+                temp_result++;
+        }
+
+        if(temp_result >= s)
+            result++;
+    }
+
+    return result;
+}
+
+int main() {
+    int a1[5][2] = {
+        {15, 100},
+        {15, 100},
+        {10, 100},
+        {10, 10},
+        {10, 30},
+    };  
+
+    cout << func(a1, 0.3, 1.9, 2) << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_06_12_18.cc b/1_anno/Programmazione_1/ex1_06_12_18.cc
new file mode 100644
index 0000000..b16748f
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_06_12_18.cc
@@ -0,0 +1,35 @@
+#include<iostream>
+
+using namespace std;
+
+template<int N>
+bool func(int (&A)[N][N], double w) {
+    int sumDiagonale{};
+    for(int i = 0; i < N; ++i) sumDiagonale+=A[i][i];
+
+    for(int i = 0; i < N; ++i) {
+        int sumCol{};
+        for(int j = 0; j < N; ++j) {
+            sumCol+=A[j][i];
+        }
+
+        if(static_cast<double>(sumCol/sumDiagonale) > w)
+            return true;
+    }
+    
+
+    return false;
+}
+
+int main() {
+    int A[4][4] = {
+        {1, 2, 3, 4},
+        {1, 2, 3, 4},
+        {1, 2, 3, 4},
+        {1, 2, 3, 4},
+    };
+
+    cout << func(A, 4.5);
+    
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_08_03_18.cc b/1_anno/Programmazione_1/ex1_08_03_18.cc
new file mode 100644
index 0000000..9942714
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_08_03_18.cc
@@ -0,0 +1,33 @@
+#include<iostream>
+
+#define n 3
+
+using namespace std;
+
+bool func(int (*A)[n]) {
+    /*
+        0    1   n-2  n-1  
+      0 | x | x | x | x |
+      1 | x | x | x | x |
+    n-2 | x | x | x | x |
+    n-1 | x | x | x | x |
+    */
+
+    int sum{}; // Inizializza sum a 0
+    for(int i = 1, j = n-1; j > 0; ++i, j--) {
+        sum+=A[j][i];
+    }
+
+    return (sum % n == 0);
+}
+
+int main() {
+    int A[n][n] = {
+        {1, 2, 3, },
+        {1, 2, 3, },
+        {1, 3, 0, },
+    };
+
+    cout << func(&A[0]);
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_18_02_19.cc b/1_anno/Programmazione_1/ex1_18_02_19.cc
new file mode 100644
index 0000000..a1bfc91
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_18_02_19.cc
@@ -0,0 +1,33 @@
+#include<iostream>
+
+using namespace std;
+
+template<int N, int M>
+bool func(int (&A)[N][M], double w, double v) {
+    if(w > v) return false;
+
+    for(int i = 0; i < M; ++i) {
+        double sum{};
+        for(int j = 0; j < N; ++j) {
+            sum+=A[j][i];
+        }
+
+        double media = sum / static_cast<double>(N);
+
+        if(media >= w && media <= v) return true;
+    }
+
+    return false;
+}
+
+int main() {
+    int M[3][4] = {
+        {1, 2, 3, 4},
+        {1, 2, 3, 5,},
+        {1, 2, 3, 6},
+    };
+    
+    cout << func(M, 0.1, 0.2);
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_23_04_19.cc b/1_anno/Programmazione_1/ex1_23_04_19.cc
new file mode 100644
index 0000000..c977ece
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_23_04_19.cc
@@ -0,0 +1,35 @@
+#include<iostream>
+#define N 4
+#define M 3
+
+using namespace std;
+
+double func(string (*S)[M], string s1, short k) {
+    if(k < 1 || k > M) return -1;
+
+    short counter{};
+    short c_strings{};
+
+    for(int i = 0; i < N; ++i) {
+        for(int j = 0; j < k; ++j) {
+            ++c_strings;
+            if(S[i][j].length() > s1.length())
+                ++counter;
+        }
+    }
+    
+    return static_cast<double>(counter*100/c_strings);
+}
+
+int main() {
+    string A[N][M] = {
+        {"red", "orange", "green"},
+        {"red", "orange", "green"},
+        {"red", "orange", "green"},
+        {"red", "orange", "green"},
+    };
+
+    cout << func(&A[0], "pink", 2);
+   
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_23_07_19.cc b/1_anno/Programmazione_1/ex1_23_07_19.cc
new file mode 100644
index 0000000..3c6c5f3
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_23_07_19.cc
@@ -0,0 +1,28 @@
+#include<iostream>
+
+using namespace std;
+
+template<int N, int M>
+bool func(double (&D)[N][M], int a) {
+    for(int i = 0; i < M; ++i) {
+        for(int j = 0; j < N-1; ++j) {
+            if(static_cast<int>(D[j][i]+D[j+1][i]) == a) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+int main() {
+    double A[3][4] = {
+        {40.2, 10, 10.2, 1},
+        {40.2, 10, 10.2, 1},
+        {40.2, 10, 10.2, 1},
+    };
+
+    cout << func(A, 20);
+    
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_25_06_19.cc b/1_anno/Programmazione_1/ex1_25_06_19.cc
new file mode 100644
index 0000000..f28a09b
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_25_06_19.cc
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <utility>
+#include <vector>
+
+using namespace std;
+
+template<int N, int M>
+bool func(int (&A)[N][M], short k, double x) {
+    for(int i = 0; i < M; ++i) {
+        vector<pair<int, int> > v;
+
+        for(int j = 0; j < N-1; ++j) {
+            v.push_back({A[j][i], A[j+1][i]});
+        }
+        
+        int check_num = 0;
+
+        for(auto const& i : v) {
+            if(i.second == 0) continue;
+            double elem = static_cast<double>(i.first) / static_cast<double>(i.second);
+
+            if(elem < x)
+                check_num++;
+        }
+
+        if(check_num == k)
+            return true;
+    }
+
+
+    return false;
+}
+
+int main() {
+    int A[4][3] = {
+        {2, 3, 5},
+        {10, 20, 10},
+        {90, 19, 69},
+        {10, 0, 0},
+    };
+
+    cout << func(A, 2, 0.005) << endl; // 0
+    cout << func(A, 2, 1.0) << endl; // 1
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_27_01_20.cc b/1_anno/Programmazione_1/ex1_27_01_20.cc
new file mode 100644
index 0000000..1b0e529
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_27_01_20.cc
@@ -0,0 +1,47 @@
+#include<iostream>
+#define N 3
+#define M 4
+using namespace std;
+
+float* func(int** Q, float a, float b) {
+    float* arr = new float[M];
+
+    int a_i = static_cast<int>(a);
+    int b_i = static_cast<int>(b);
+
+    for(int i = 0; i < M; ++i) {
+        short counter{};
+        float sum{};
+        for(int j = 0; j < N; ++j) {
+            if(Q[j][i]) {
+                if(Q[j][i] >= a_i && Q[j][i] <= b_i) {
+                    ++counter;
+                    sum += Q[j][i];
+                }
+            }
+        }
+
+        arr[i] = (sum / static_cast<float>(counter));
+    }
+
+    return arr;
+}
+
+int main() {
+    int** A = new int*[N];
+    for(int i = 0; i < N; ++i) {
+        A[i] = new int[M];
+        for(int j = 0; j < M; ++j)
+            A[i][j] = 24;
+    }
+
+    float* arr = func(A, 1.0, 33.0);    
+    
+    for(int j = 0; j < M; ++j)
+        cout << arr[j] << ' ';
+
+    delete[] A;
+    delete arr;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_28_01_19.cc b/1_anno/Programmazione_1/ex1_28_01_19.cc
new file mode 100644
index 0000000..a027e82
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_28_01_19.cc
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+template<int N>
+bool func(int (&A)[N][N], double w) {
+    vector<int> l;
+    for(int i = N-1, j = 0; j < N; --i, j++) {
+        l.push_back(A[i][j]);
+    }
+
+    auto min_max = minmax_element(begin(l), end(l));
+
+    return (static_cast<double>(*min_max.first)/static_cast<double>(*min_max.second)) <= w;
+}
+
+int main() {
+    int A[3][3] = {
+        {1, 2, 3,},
+        {67, 10, 56},
+        {10, 0, 1},
+    };
+
+    cout << func(A, 0.2) << endl; // False
+    cout << func(A, 0.4) << endl; // True
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_tutorato_03_12_19.cc b/1_anno/Programmazione_1/ex1_tutorato_03_12_19.cc
new file mode 100644
index 0000000..d8d61b0
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_tutorato_03_12_19.cc
@@ -0,0 +1,33 @@
+#include <iostream>
+#include <cctype>
+
+using namespace std;
+
+template<int N>
+bool* func(string (&A)[N]) {
+    bool* a2 = new bool[N];
+
+    for(int i = 0; i < N; ++i) {
+        bool is_pal = true;
+        for(int j = 0, z = A[i].length()-1; j < z; ++j, --z ) {
+            if(tolower(A[i].at(j)) != tolower(A[i].at(z))) {
+                is_pal = false;
+                break;
+            }
+        }
+        a2[i] = is_pal;
+    }
+
+    return a2;
+}
+
+int main() {
+    string t[] = {"oslo", "yam_a_may", "AnNa"};
+    auto a = func(t);
+    
+    for(int i = 0; i < 3; ++i) {
+        cout << a[i] << ' ';
+    }
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex1_tutorato_14_01_20.cc b/1_anno/Programmazione_1/ex1_tutorato_14_01_20.cc
new file mode 100644
index 0000000..557b0ee
--- /dev/null
+++ b/1_anno/Programmazione_1/ex1_tutorato_14_01_20.cc
@@ -0,0 +1,27 @@
+#include<iostream>
+#include<algorithm>
+#include<vector>
+
+using namespace std;
+
+template<int N>
+bool func(int (&A)[N][N], double w) {
+    vector<int> list;
+    for(int i = 0, j = N-1; i < N; ++i, --j) 
+        list.push_back(A[j][i]);
+
+    auto minmax = minmax_element(begin(list), end(list));
+    return (static_cast<double>(*minmax.first)/static_cast<double>(*minmax.second)) <= w;
+}
+
+int main() {
+    int A[3][3] = {
+        {1, 2, 3},
+        {1, 2, 3},
+        {1, 2, 3},
+    };
+
+    cout << func(A, 0.1);
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_04_12_19.cc b/1_anno/Programmazione_1/ex2_04_12_19.cc
new file mode 100644
index 0000000..66b2895
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_04_12_19.cc
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+template<int N>
+bool func(string (&Q)[N][N], string s) {
+    short n_presents[2] = {0};
+    for(int i = 0; i < N; ++i) {
+        if(Q[i][i].find(s) != std::string::npos)
+            n_presents[0]++;
+    }
+    
+    for(int i = 0, j = N-1; i < N; ++i, --j) {
+        cout << Q[j][i].find(s) << endl;
+        if(Q[j][i].find(s) != std::string::npos)
+            n_presents[1]++;
+    }
+
+    return n_presents[0] > n_presents[1];
+}
+
+int main() {
+    string a1[3][3] = {
+        {"ciaoneXX", "fra", "zio"},
+        {"oh, ma che", "eXXh", "sta cosa?"},
+        {"greg", "no", "foXXrse"}
+    };
+    
+    string a2[3][3] = {
+        {"ciaoneXX", "fra", "ziYYo"},
+        {"oh, ma che", "eXXYYh", "sta cosa?"},
+        {"gregYY", "no", "foXrse"}
+    };
+
+    cout << func(a1, "XX") << ' ' << func(a2, "YY") << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_06_12_18.cc b/1_anno/Programmazione_1/ex2_06_12_18.cc
new file mode 100644
index 0000000..50744ba
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_06_12_18.cc
@@ -0,0 +1,34 @@
+#include<iostream>
+#define N 3
+#define M 4
+
+using namespace std;
+
+bool* func(string (*A)[M], short k, string s) {
+    bool* arr = new bool[N];
+
+    for(int i = 0; i < N; ++i) {
+        short counter{};
+        for(int j = 0; j < M; ++j) {
+            if(A[i][j].find(s) != std::string::npos)
+                ++counter;
+        }
+
+        arr[i] = (counter >= k);
+    }
+    
+    return arr;
+}
+
+int main() {
+    string Arr[N][M] = {
+        {"Ciaone", "Come one va?", "We one", ""},
+        {"Ciaoe", "Come va?", "We one", ""},
+        {"Ciaone", "Come one va?", "We one", ""},
+    };
+
+    bool* v = func(Arr, 2, "one");
+    for(int i = 0; i < N; ++i) cout << v[i] << ' ';
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_08_03_18.cc b/1_anno/Programmazione_1/ex2_08_03_18.cc
new file mode 100644
index 0000000..88d55e1
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_08_03_18.cc
@@ -0,0 +1,49 @@
+#include<iostream>
+using namespace std;
+
+template<int N, int M>
+bool func(string (&A)[N][M], short w) {
+    bool check{false};
+    for(int i = 0; i < N; ++i) {
+        bool counter{false};
+        string str{""};
+        string str2{""};
+        for(int j = 0; j < M; ++j) {
+            if(A[i][j].length() < w) {
+                counter = false;
+                continue;
+            }
+
+            if(!counter) {
+                str = A[i][j].substr(0, w);
+                
+                counter = true;
+                continue;
+            } 
+
+            str2 = A[i][j].substr(A[i][j].length()-w, w);
+
+            if(str == str2) {
+                check = true;
+                break;
+            } else {
+                j--;
+                counter = false;
+            }
+        }
+
+        if(check) break;
+    }
+
+    return check;
+}
+
+int main() {
+    string A[3][3] = {
+        {"parola", "allorapar", "bla",},
+        {"", "red", "red",},
+        {"blue", "", "",},
+    };
+    cout << func(A, 3);
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_18_02_19.cc b/1_anno/Programmazione_1/ex2_18_02_19.cc
new file mode 100644
index 0000000..8195fb9
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_18_02_19.cc
@@ -0,0 +1,43 @@
+#include<iostream>
+#include<cctype>
+
+using namespace std;
+
+short func(string (*M)[4], unsigned short k, unsigned short s) {
+    short counter{};
+
+    for(int i = 0; i < 4; ++i) {
+        short _rowcounter{};
+        for(int j = 0; j < 3; ++j) {
+            short _vocals{};
+            for(char& c : M[j][i]) {
+                switch(tolower(c)) {
+                    case 'a': case 'e': case 'i': case 'o': case 'u':
+                        ++_vocals;
+                        break;
+                    default: break;
+                }
+            }
+
+            if(_vocals < s) ++_rowcounter;
+        }
+
+        if(_rowcounter >= k) ++counter;
+    }
+
+    return counter;
+}
+
+
+int main() {
+    string M[3][4] = {
+        {"HEI", "we", "ciao", "com'è?"},
+        {"HEI", "we", "ciao", "com'è?"},
+        {"HEI", "we", "ciao", "com'è?"},
+    };
+    
+    cout << func(&M[0], 2, 3);
+
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_23_07_19.cc b/1_anno/Programmazione_1/ex2_23_07_19.cc
new file mode 100644
index 0000000..3b0ed37
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_23_07_19.cc
@@ -0,0 +1,44 @@
+#include<iostream>
+
+using namespace std;
+
+template<int N>
+bool func(string (&Q)[N][N]) {
+    string stringaL = Q[0][0];
+    string stringaC = Q[0][0];
+    for(int i = 0; i < N; ++i) {
+        if(Q[i][i].length() > stringaL.length())
+            stringaL = Q[i][i];
+        else if(Q[i][i].length() < stringaC.length())
+            stringaC = Q[i][i];
+    }
+
+    short vocaliL{};
+    short vocaliC{}; 
+
+    for(auto& c : stringaL) {
+        c = tolower(c);
+        if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
+            ++vocaliL;
+    }
+    
+    for(auto& c : stringaC) {
+        c = tolower(c);
+        if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
+            ++vocaliC;
+    }
+    
+    return vocaliL < vocaliC;
+}
+
+int main() {
+    string A[3][3] = {
+        {"lllll", "bb", "cc"},
+        {"AAA", "e", "cc"},
+        {"AAA", "bb", "cc"},
+    };
+
+    cout << func(A);
+    
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_27_01_20.cc b/1_anno/Programmazione_1/ex2_27_01_20.cc
new file mode 100644
index 0000000..25caf5b
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_27_01_20.cc
@@ -0,0 +1,57 @@
+#include<iostream>
+#include<set>
+
+using namespace std;
+
+template<int N, int M>
+double func(string (&A)[N][M], string x, string y, short k, short w) {
+    set<char> s;
+    for(char const&c : x) s.insert(c);
+    x = "";
+    for(char const&c: s) x+=c;
+
+    s.clear();
+    for(char const&c : y) s.insert(c);
+    y = "";
+    for(char const&c: s) y+=c;
+
+    for(int i = 0; i < N; ++i) {
+        for(int j = 0; j < M; ++j) {
+            s.clear();
+            for(char const&c : A[i][j]) s.insert(c);
+            A[i][j] = "";
+            for(char const&c: s) A[i][j]+=c;
+        }
+    }
+
+    short counter{};
+    for(int i = 0; i < M; ++i) {
+        short k_i{};
+        for(int j = 0; j < N; ++j) {
+            if(A[j][i].length() < w) continue;
+            short char_counter{};
+            for(char const& c: A[j][i]) {
+                if(x.find(c) != std::string::npos && y.find(c) != std::string::npos)
+                    ++char_counter;
+            }
+            if(char_counter >= w)
+                ++k_i;
+        }
+        if(k_i >= k)
+            ++counter;
+    }
+
+    return static_cast<double>(counter*100)/static_cast<double>(M);
+}
+
+int main() {
+    string A[3][4] = {
+        {"we,", "heila", "ciaone", ""},
+        {"we,", "heila", "ciaone", ""},
+        {"we,", "heila", "ciaone", ""},
+    };
+
+    cout << func(A, "we", "we", 2, 2);    
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_28_01_19.cc b/1_anno/Programmazione_1/ex2_28_01_19.cc
new file mode 100644
index 0000000..7ad8398
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_28_01_19.cc
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <cctype>
+
+using namespace std;
+
+template<int N, int M>
+bool func(string (&A)[N][M], unsigned short k, unsigned short s) {
+    for(int i = 0; i < N; ++i) {
+        short string_num = 0;
+        for(int j = 0; j < M; ++j) {
+            short upper_chars = 0;
+            for(auto const& c : A[i][j]) {
+                if(isupper(c))
+                    ++upper_chars;
+            }
+
+            if(upper_chars >= s)
+                ++string_num;
+        }
+
+        if(string_num >= k) 
+            return false;
+    }   
+
+    return true;
+}
+
+int main() {
+    string A[2][3] = {
+       {"suce", "oHh", "b"},
+       {"111", "HAAa", "B"}
+    };
+
+    cout << func(A, 2, 1) << endl;
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/ex2_tutorato_14_01_20.cc b/1_anno/Programmazione_1/ex2_tutorato_14_01_20.cc
new file mode 100644
index 0000000..b54860e
--- /dev/null
+++ b/1_anno/Programmazione_1/ex2_tutorato_14_01_20.cc
@@ -0,0 +1,38 @@
+#include<iostream>
+
+using namespace std;
+
+template<int N, int M>
+bool func(string (&A)[N][M], unsigned short k, unsigned short s) {
+    for(int i = 0; i < N; ++i) {
+        short count_s{};
+        for(int j = 0; j < M; ++j) {
+            short upper_cs{};
+            for(auto const& c : A[i][j]) {
+                if(isupper(c))
+                    ++upper_cs;
+            }
+        
+            if(upper_cs < s)
+                ++count_s;
+        }
+
+        if(count_s >= k)
+            return true;
+    }
+    
+    return false;
+}
+
+int main() {
+    string A[3][4] = {
+        {"ProVA", "CiAone", "RAed"},
+        {"IVVA", "CiAOO", "BLUE"},
+        {"AA", "AA", "AA3#"},
+    };
+
+    cout << func(A, 3, 1);
+        
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_1.cc b/1_anno/Programmazione_1/h9_1.cc
new file mode 100644
index 0000000..12c629d
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_1.cc
@@ -0,0 +1,27 @@
+#include <iostream>
+
+// Array NxM. Trovare media dei valori differenza tra gli elementi della diagonale principale e secondaria
+
+int main() {
+    const short N = 4, M = 3;
+    int A[N][M] = {
+        {3, 1, 5},
+        {5, 3, 1},
+        {8, 7, 4},
+        {4, 7, 4},
+    };
+
+    int diff1 = A[0][0], diff2 = A[N-1][0];
+
+    // Condizione necessaria per matrici in cui M != N
+    short cond = (N < M) ? N : M;
+    
+    for(int i = 1, j = N-1, j2 = 1; i < cond; ++i, --j, ++j2) {
+        diff1 -= A[i][i];
+        diff2 -= A[j][j2];
+    }
+
+    std::cout << static_cast<float>((diff1+diff2)/2) << std::endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_2.cc b/1_anno/Programmazione_1/h9_2.cc
new file mode 100644
index 0000000..0e9c853
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_2.cc
@@ -0,0 +1,32 @@
+#include <iostream>
+
+// Array NxM e numero p. Stampare le medie per ogni colonna dispari dei valori x <= p
+
+int main() {
+    const short N = 4, M = 4;
+    int p = 9;
+    int A[N][M] = {
+        {3, 1, 5, 5},
+        {5, 3, 1, 5},
+        {8, 7, 4, 5},
+        {4, 7, 4, 5},
+    };
+    // Condizione necessaria per matrici in cui M != N
+    short cond = (N < M) ? N : M;
+
+    for(int i = 1; i < cond; i+=2) {
+        int sum = 0, c = 0;
+        for(int j = 0; j < M; ++j) {
+            if(A[j][i] <= p) {
+                sum += A[j][i];
+                c++;
+            }
+        }
+
+        if(c > 0) {
+            std::cout << static_cast<float>(sum)/c << '\n';
+        }
+    }
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_3.cc b/1_anno/Programmazione_1/h9_3.cc
new file mode 100644
index 0000000..c9ef418
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_3.cc
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <algorithm>
+
+// Dato array V=NxM e uno grande W, trovare il numero di elementi presenti in W che sono compresi in ogni riga di V
+
+int main() {
+    std::cout << __cplusplus;
+    const auto N = 4, M = 4, L = 3;
+    int V[N][M] = {
+        {3, 1, 5, 50},
+        {5, 3, 1, 5},
+        {8, 7, 4, 5},
+        {4, 7, 4, 5},
+    };
+
+    int W[L] = {4, 50, 2};
+
+    for(auto i = 0; i < N; ++i) {
+        const auto range = std::minmax_element(std::begin(V[i]), std::end(V[i]));
+        int count{0};
+        for(auto const& j : W) {
+            if(j >= *range.first && j <= *range.second)
+                count++;
+        }
+
+        std::cout << count << std::endl;
+    }
+
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_4.cc b/1_anno/Programmazione_1/h9_4.cc
new file mode 100644
index 0000000..cd534b3
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_4.cc
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <algorithm>
+
+// Data matrice V di NxM, array A e numero w<M, trovare se c'è almeno una riga di V con almeno w elementi maggiori di ogni elemento di A
+
+const auto N{4}, M{4}, k{3}, w{2};
+
+bool row_alg(int V[N][M], int* A, int w) {
+    // È ovvio che sia presente almeno 0 elementi, quindi non ha senso continuare
+    if(w <= 0) return true;
+    auto max_element_of_A = std::max_element(A,A+k);
+    
+    for(auto i = 0; i < N; ++i) {
+        int counts = 0;
+        for(auto j = 0; j < M; ++j) {
+            if(V[i][j] > *max_element_of_A)
+                counts++;
+
+            if(counts == w)
+                return true;
+        }
+    } 
+
+    return false;
+}
+
+int main() {
+    int V[N][M] = {
+        {3, 59, 5, 54},
+        {5, 3, 1, 5},
+        {8, 7, 4, 5},
+        {4, 7, 4, 5},
+    };
+
+    int A[k] = {4, 50, 2};
+
+    std::cout << row_alg(V, A, w) << std::endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_5.cc b/1_anno/Programmazione_1/h9_5.cc
new file mode 100644
index 0000000..a2e3f8b
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_5.cc
@@ -0,0 +1,51 @@
+#include <iostream>
+#include <algorithm>
+#include <map>
+
+// Date due matrici e un numero p, stampare i valori che compaiono p volte dalla prima alla seconda matrice
+
+int main() {
+    const auto N{4}, M{4}, L{4}, Q{4}, p{4};
+    int V[N][M] = {
+        {3, 1, 5, 50},
+        {5, 3, 1, 5},
+        {8, 7, 4, 5},
+        {4, 7, 4, 5},
+    };
+
+    int W[L][Q] = {
+        {30, 3, 5, 50},
+        {51, 25, 12, 5},
+        {90, 12, 4, 5},
+        {4, 6, 4, -3},
+    };
+
+    std::map<int, int> values;
+
+    for(auto i = 0; i < N; ++i) {
+        for(auto j = 0; j < M; ++j) {
+            if(values.find(V[i][j]) == values.end())
+                values.insert({V[i][j], 1});
+            else
+                values[V[i][j]] += 1;
+        }
+    }
+
+    for(auto i = 0; i < L; ++i) {
+        for(auto j = 0; j < Q; ++j) {
+            auto elem = values.find(W[i][j]);
+            if(elem != values.end()) {
+                if(elem->second >= p) {
+                    std::cout << W[i][j] << ' ';
+                } else {
+                    std::cout << "x ";
+                }
+            } else {
+                std::cout << "x ";
+            }
+        }
+        std::cout << '\n';
+    }
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/h9_6.cc b/1_anno/Programmazione_1/h9_6.cc
new file mode 100644
index 0000000..d889c43
--- /dev/null
+++ b/1_anno/Programmazione_1/h9_6.cc
@@ -0,0 +1,35 @@
+#include <iostream>
+#include <algorithm>
+
+int main() {
+    const auto N{4}, M{4}, s{50}, z{2};
+    int V[N][M] = {
+        {3, 1, 5, 50},
+        {5, 3, 1, 5},
+        {8, 7, 4, 5},
+        {4, 7, 4, 5},
+    };
+
+    int W[M] = {0};
+
+    for(auto i = 0; i < N; ++i) {
+        bool finish{false};
+        for(auto j = 0, index = 0; j < M-1; ++j, ++index) {
+            int sum{0};
+            for(auto zz = index; zz < index+z; ++zz) {
+                sum+=V[i][zz];
+                if(sum >= s) {
+                    W[i] = 1;
+                    finish = true;
+                    break;
+                }
+            }
+            if(finish) break;
+        }
+    }
+
+    for(auto i = 0; i < N; ++i)
+        std::cout << W[i] << ' ';
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_14_12_18.cc b/1_anno/Programmazione_1/lab_14_12_18.cc
new file mode 100644
index 0000000..02bbd69
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_14_12_18.cc
@@ -0,0 +1,149 @@
+#include<iostream>
+#include<cmath>
+#define DIM 30
+
+using namespace std;
+
+class A {
+protected:
+	double* ptr;
+	short len;
+
+	void getPtr(ostream& os) {
+		os << "ptr=[";
+		for(int i = 0; i < len; ++i) { 
+			os << ptr[i] << ' ';
+		}
+
+		os << "]";
+	}
+public:
+	A(short n) : len{n} {
+		srand(time(NULL));
+		ptr = new double[n];
+		for(int i = 0; i < n; ++i) {
+			ptr[i] = (double) rand() / RAND_MAX;
+		}
+	}
+
+	~A() {
+		delete ptr;
+	}
+	virtual double foo(short a) const = 0;
+	virtual void print(ostream& os) = 0;
+
+	double operator[](int i) {
+		return ptr[i];
+	}
+};
+
+class B : public A {
+public:
+	B(short m, double s) : A{m}, alpha{s} {}
+	double foo(short b) const {
+		return static_cast<double>(log(1+extract(b)));
+	}
+	void print(ostream& os) {
+		os << "B, ";
+		getPtr(os);
+		os << ", alpha=" << alpha;
+	}
+
+private:
+	double alpha;
+	double extract(short s) const {
+		return (ptr[s%len]+alpha)/2;
+	}
+
+};
+
+template<typename T>
+class C;
+
+template<>
+class C<double> : public A {
+public:
+	C(short n) : A{n} {
+		x = static_cast<double>(log(1+n));
+	}
+
+	double foo(short r) const {
+		return g(r*x);
+	}
+
+	double g(double k) const {
+		return 3*k;
+	}
+
+	void print(ostream& os) {
+		os << "C<double> ";
+		getPtr(os);
+		os << ", x=" << x;
+	}
+private:
+	short x;
+};
+
+template<>
+class C<int> : public A {
+public:
+	C(short n) : A{n} {
+		x = g(n);
+	}
+
+	double foo(short r) const {
+		return g(r*x);
+	}
+
+	short g(short k) const {
+		return 3*k;
+	}
+
+	void print(ostream& os) {
+		os << "C<short> ";
+		getPtr(os);
+		os << ", x=" << x;
+	}
+private:
+	short x;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+	a.print(os);
+
+	return os;
+}
+
+int main() {
+	srand(328832748);
+	A* vett[DIM];
+	double maxfoo{-11111111.0};
+	double g_sum{};
+	for(int i=0; i<DIM; i++) {
+		short n=1+rand()%5;
+		switch(rand()%3) {
+			case 0: vett[i]= new B(n, n/100.0); break;
+			case 1: {
+				vett[i]= new C<double>(n);
+				auto refC = dynamic_cast<C<double>*>(vett[i]);
+				g_sum+=refC->g(5);
+				break;
+			}
+			case 2: vett[i]= new C<int>(n);
+
+		}
+
+		double foo5 = vett[i]->foo(5);
+		if(foo5 > maxfoo)
+			maxfoo = foo5;
+	}
+
+	for(int i = 0; i < DIM; ++i) {
+		cout << i+1 << ")" << *(vett[i]) << ", foo(5)=" << vett[i]->foo(5) << endl;
+	}
+
+	cout << "max(foo(5))=" << maxfoo << " sum(g(5))=" << g_sum << endl;
+	cout << (*vett[2])[0] << endl;
+
+	return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_15_02_19_D.cc b/1_anno/Programmazione_1/lab_15_02_19_D.cc
new file mode 100644
index 0000000..b050e72
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_15_02_19_D.cc
@@ -0,0 +1,159 @@
+#include<iostream>
+#include<stdexcept>
+#define DIM 50
+
+using namespace std;
+
+class A {
+public:
+	A(short m, short k) : len{m} {
+		ptr = new int[len];
+		srand(time(NULL));
+		
+		for(int i = 0; i < len; ++i) {
+			ptr[i] = rand()%k + 1;
+		}
+	}
+
+	~A() {
+		delete ptr;
+	}
+
+	virtual double const f() = 0;
+	void print(ostream& os) {
+		os << typeid(*this).name() << ", ptr=[ ";
+		for(int i = 0; i < len; ++i)
+			os << ptr[i] << ' ';
+
+		os << "]";
+	}
+
+	int get(short i) {
+		if(i >= len)
+			throw out_of_range{"out of range"};
+
+	 	return ptr[i];
+	}
+
+	short getLen() {
+		return len;
+	}
+
+	int& operator[](int x){ 
+		return ptr[x];
+	}
+
+	const int& operator[](int x) const { 
+		return ptr[x];
+	}
+	
+private:
+	int* ptr;
+	short len;
+
+};
+
+class B : public A {
+public:
+	B(short m, short k, double y) : A{m, k}, p{y} {}
+	double const f() {
+		int sum{};
+		for(int i = 0; i < getLen(); ++i) {
+			int t = get(i);
+
+			if((t%2) == 0) {
+				sum+=t;
+			}
+		}
+
+		if(sum == 0)
+			return 0;
+
+		return static_cast<double>(sum/p);
+	}
+
+	void print(ostream& os) {
+		A::print(os);
+		os << ", p=" << p;
+	}
+private:
+	double p;
+};
+
+class C : public A {
+public:
+	C(short n, short k, char c) : A{n, k}, x{c} {}
+
+	double const f() {
+		int sum{};
+		short c{};
+		for(int i = 0; i < getLen(); ++i) {
+			int t = get(i);
+
+			if((t%2) == 1) {
+				sum+=t;
+				++c;
+			}
+		}
+
+		if(c == 0)
+			return 0;
+
+		return static_cast<double>(sum/c);
+	}
+
+	string const g(char c) {
+		string t{""};
+		t+=x;
+		t+=c;
+
+		return t;
+	}
+
+	void print(ostream& os) {
+		A::print(os);
+		os << ", x=" << x;
+	}
+private:
+	char x;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+	a.print(os);
+
+	return os;
+}
+
+int main() {
+	srand(111222333);
+    A *vett[DIM];
+
+	string conc{""};
+    for(int i=0; i<DIM; i++){
+		short n=1+rand()%10;
+		short m = 1+rand()%15;
+		if(rand()%2==0)
+	 	 	vett[i]= new B(n, m, rand()/(double) RAND_MAX+0.05);
+		else {
+	  		vett[i]= new C(n, m, (char) (rand()%('z' - 'a' + 1) + 'a'));
+			auto cpnt = dynamic_cast<C*>(vett[i]);
+			conc+=cpnt->g('h');
+		}
+	}
+
+	double sum{};
+    for(int i = 0; i < DIM; i++) {
+		auto fval = vett[i]->f();
+		cout << i << ") " << *(vett[i]) << ", f()=" << fval << endl; 
+		sum+=fval;
+	}
+	
+	cout << "PUNTO 2:\n\tavg(f())=" << sum/DIM << ", g('h')=" << conc << endl;
+	cout << "PUNTO 3:\n";
+	cout << (*(vett[0])).get(0) << endl;
+	(*(vett[0]))[0] = 24;
+	cout << (*(vett[0])).get(0) << endl;
+
+	
+	return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_26_07_19.cc b/1_anno/Programmazione_1/lab_26_07_19.cc
new file mode 100644
index 0000000..91822d9
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_26_07_19.cc
@@ -0,0 +1,164 @@
+#include<iostream>
+#include<cmath>
+#include<typeinfo>
+
+#define DIM 30
+
+using namespace std;
+
+class A {
+public:
+    A(short m, int a, int b) : len(m) {
+        srand(time(NULL));
+        vec = new int[m];
+        
+        for(int i = 0; i < m; ++i) {
+            vec[i] = rand()%b + a;
+        }
+    }
+
+    ~A() {
+        delete vec;
+    }
+
+    virtual double foo(short a) = 0;
+    short getLen() {
+        return len;
+    }
+
+    virtual void print(ostream& o) = 0;
+
+    int operator()(int i1, int i2) {
+        if(i1 < 0) i1 = 0;
+        if(i2 > len) i2 = len;
+
+        int sum = 0;
+        
+        for(int i = i1; i < i2; ++i) {
+            sum+=vec[i];
+        }
+
+        return sum;
+    }
+    
+protected:
+    int get(short i) {
+        return vec[i];
+    }
+private:
+    int* vec;
+    short len;
+};
+
+class B : public A {
+public:
+    B(short m, int x, int y) : A(m, x, y) {
+        srand(time(NULL));
+        short rand_num = rand()%m;
+        p = get(rand_num);
+    }
+    
+    double foo(short a) {
+        return static_cast<double>(prod(a)) / static_cast<double>(p);
+    }
+
+    void print(ostream& os) {
+        os << "vec=[";
+        for(int i = 0; i < getLen(); ++i) {
+            os << get(i) << ' ';
+        }
+        os << "], p=" << p;
+    }
+protected:
+    int prod(short s) {
+        int index = s%getLen();
+        int _prod = 1;
+        for(int i = index; i < getLen(); ++i) {
+            _prod *= get(i);
+        }
+
+        return _prod;
+    }
+private:
+    int p;
+};
+
+
+template<class T> class C : public A {
+public:
+    C(short n, int a, int b) : A(n, a, b) {
+        if(typeid(T) == typeid(short)) {
+            x = n;
+        } else {
+            x = log(1+pow(sin(n), 2));
+        }
+
+    }
+    
+    double foo(short r) {
+        return g(r);
+    }
+
+    T g(T k) {
+        return 2*x*(k+1);
+    }
+
+    void print(ostream& os) {
+        os << "vec=[";
+        for(int i = 0; i < getLen(); ++i) {
+            os << get(i) << ' ';
+        }
+        os << "], x=" << x;
+    }
+private:
+    T x;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+    os << typeid(a).name() << ", ";
+    a.print(os);
+    return os;
+}
+
+int main() {
+    srand (time(0)); 
+    A* vett[DIM];
+    double sum_cd = 0;
+    short num_cd = 0;
+    for(int i=0; i < DIM; ++i) {
+        short n = 1+rand()%10;
+        switch ( rand ()%3) {
+        case 0:
+            vett[i]= new B(n, rand()%5 + 1, rand()%10 + 5);
+            break ;
+        case 1: {
+            vett[i]= new C<double>(n, rand()%5 + 1, rand()%10 + 5); 
+            ++num_cd;
+            C<double>& cc = dynamic_cast<C<double>& >(*(vett[i]));
+            sum_cd += cc.g(5);
+            
+            break ;
+        }
+        case 2:
+            vett[i]= new C<short>(n, rand()%5 + 1, rand()%10 + 5);
+        }
+    }
+
+    double max_foo = -100000;
+
+    for(int i = 0; i < DIM; ++i) {
+        auto foo3 = vett[i]->foo(3);
+
+        if(foo3 > max_foo) {
+            max_foo = foo3;
+        }
+        cout << (*(vett[i])) << ", foo(3)=" << foo3 <<endl;
+    }
+    
+    // max_foo => Valore maggiore calcolato per foo(3)
+    // sum_cd / num_cd => media valori g(5) per C<Double> 
+    
+    cout << (*vett[0])(0, 2) << endl;
+
+    return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_28_02_19_A.cc b/1_anno/Programmazione_1/lab_28_02_19_A.cc
new file mode 100644
index 0000000..ff2eaae
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_28_02_19_A.cc
@@ -0,0 +1,166 @@
+#include<iostream>
+#include<stdexcept>
+#include<cstdlib>
+#include<cmath>
+#define DIM 50
+
+using namespace std;
+
+class A {
+public:
+	A(short m) : len{m} {
+		arr = new short[m];
+		srand(time(NULL));
+		for(int i = 0; i < m; ++i) {
+			arr[i] = rand()%10+1;
+		}
+	}
+
+	~A() {
+		delete[] arr;
+	}
+
+	virtual double f(short a) = 0;	
+	virtual void print(ostream& os) = 0;
+
+	short getLen() {
+		return len;
+	}
+
+protected:
+	short get(short i) {
+		if(i < 0 || i >= getLen())
+			throw out_of_range{"out of arr' range"};
+
+		return arr[i];
+	}
+
+private:
+	short* arr;
+	short len;
+};
+
+template<typename T>
+class B : public A {
+public:
+	B(short m, char c) : A{m} {
+		if(typeid(T) == typeid(char)) {
+			x = c;
+		} else if(typeid(T) == typeid(string)) {
+			for(int i = 0; i < m; ++i) 
+				x+=c;
+
+		} else {
+			// tipo non gestito
+			throw bad_typeid{}; 
+		}
+	}
+	
+	double f(short a) override {
+		double n = static_cast<double>(getLen() - a);
+		double sum{};
+		for(int i = a; i < getLen(); ++i) 
+			sum+=get(i);
+		
+		return sum/n;
+	}
+
+	void print(ostream& os) override {
+		os << "B<" << (typeid(T) == typeid(char) ? "char" : "string") << "> arr=[";
+		for(int i = 0; i < getLen(); ++i)
+			os << get(i) << ' ';
+		os << "], x=" << x;
+	}
+
+	double foo(short s) {
+		return log(s) + sin(f(s));
+	}
+private:
+	T x;
+};
+
+class C : public A {
+public:
+	C(short n, int k) : A{n}, y{k} {}
+
+	double f(short a) override {
+		srand(time(NULL));
+		short rand_elem = get(rand()%getLen());
+		
+		return static_cast<double>(a+y)/static_cast<double>(rand_elem);
+	}
+
+	double g(short w) {
+		// sicuri che non debba convertire a double? qui sarà sempre 0, forse 1
+		return static_cast<double>(sin(w+y));
+	}
+
+	void print(ostream& os) override {
+		os << "C arr=[";
+		for(int i = 0; i < getLen(); ++i)
+			os << get(i) << ' ';
+		os << "], y=" << y;
+	}
+
+	C& operator++() {
+		++y;
+		return *this;
+	}
+private:
+	int y;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+	a.print(os);
+
+	return os;
+} 
+
+int main() {
+	srand(111222333);
+
+	A *vett[DIM];
+
+	double max_f3{-100000000.0};
+	short c_count{};
+	double gsum{};
+	short i_to_p{-1};
+	
+	for(int i=0; i<DIM; i++) {
+		short n=1+rand()%10;
+		switch(rand()%3) {
+		case 0: 
+		{
+			vett[i]= new C(n, rand()%10 + 1);
+			i_to_p = i;
+			auto cref = dynamic_cast<C&>(*(vett[i]));
+			gsum+=cref.g(5);
+			++c_count;
+	    	break;
+	  	}
+		case 1:
+	    	vett[i]= new B<string>(n, rand()%('z' - 'a' + 1) + 'a');
+	    	break;
+	  	case 2: 
+	    	vett[i]= new B<char>(n, rand()%('z' - 'a' + 1) + 'a');
+		}
+
+		auto f3 = vett[i]->f(3);
+		if(f3 > max_f3)
+			max_f3 = f3;
+    }
+
+	for(int i = 0; i < DIM; ++i)
+		cout << i+1 << ')' << *(vett[i]) << ", f(3)=" << vett[i]->f(3) << endl;
+
+	cout << "max f(3)=" << max_f3;
+	cout << " avg g(5)=" << (static_cast<double>(gsum/c_count)) << endl;
+	if(i_to_p >= 0) {
+		cout << *(vett[i_to_p]) << endl;
+		auto cref = dynamic_cast<C*>(vett[i_to_p]);
+		++(*cref);
+		cout << *(vett[i_to_p]) << endl;
+	}
+	
+	return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_28_02_19_B.cc b/1_anno/Programmazione_1/lab_28_02_19_B.cc
new file mode 100644
index 0000000..4639f66
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_28_02_19_B.cc
@@ -0,0 +1,162 @@
+#include<iostream>
+#include<cstdlib>
+#include<cmath>
+#define DIM 50
+using namespace std;
+
+class A {
+public:
+	A(short m, char c) : len{m} {
+		ptr = new char[len];
+		srand(time(NULL));
+		for(int i = 0; i < m; ++i) {
+			ptr[i] = static_cast<char>(rand()%(c-'a'+1) + 'a');
+		}
+	}
+	A(const A& a) = default;
+	~A() {
+		delete ptr;
+	}
+
+	virtual string elab(short a, char c) = 0;
+	virtual void print(ostream& o) = 0;
+	short getLen() {
+		return len;
+	}
+
+	char& operator[](int i) {
+		return ptr[i];
+	}
+
+protected:
+	char get(short i) {
+		if(i > len)
+			return ptr[0];
+
+		return ptr[i];
+	}
+
+private:
+	char* ptr;
+	short len;
+};
+
+class B : public A {
+public:
+	B(short m, double y, char c) : A{m, c}, x{y} {}
+	double foo(short s) {
+		return sin(x+s)/log(x+s);
+	}
+
+	string elab(short a, char c) {
+		string st{};
+		for(int i = 0; i < getLen(); ++i) {
+			auto ch = get(i);
+			if(abs(ch-c) <= a) {
+				st+=ch;
+			}
+		}
+
+		return st;
+	}
+
+	void print(ostream& os) {
+		os << "B ptr=[";
+		for(int i = 0; i < getLen(); ++i) 
+			os << get(i) << ' ';
+
+		os << "], x=" << x << ", elab(5, z)=" << elab(5, 'z');
+	}
+
+private:
+	double x;
+};
+
+template<typename T>
+class C : public A {
+public:
+	C(short n, double k, char c) : A{n, c} {
+		if(typeid(T) == typeid(short))
+			y = static_cast<int>(100*k);
+		else
+			y = k;
+	}
+
+	string elab(short a, char c) {
+		string st{};
+		if(getLen() >= a) {
+			if(a >= 1) {
+				for(int i = 0; i < getLen(); st+=c, ++i);
+			}
+		} else {
+			for(int i = 0; i < getLen(); st += get(i++));
+		}
+
+		return st;
+	}
+
+	double g(short w) {
+		return sin(w+y);
+	}
+	
+	void print(ostream& os) {
+		os << "C<" << typeid(T).name() << "> ptr=[";
+		for(int i = 0; i < getLen(); ++i) 
+			os << get(i) << ' ';
+
+		os << "], y=" << y << ", elab(5, z)=" << elab(5, 'z');
+	}
+private:
+	T y;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+	a.print(os);
+
+	return os;
+}
+
+int main() {
+	srand(time(NULL));
+
+	A *vett[DIM];
+	short cb{}, cc{};
+	double sumb{}, sumc{};
+
+	for(int i=0; i<DIM; i++) {
+  		short n=1+rand()%10;
+    	switch(rand()%3) {
+      	case 0: 
+		{
+        	vett[i]= new B(n, (double) rand()/RAND_MAX, rand()%('z' - 'a' + 1) + 'a');
+			auto temp = dynamic_cast<B&>(*(vett[i]));
+			sumb+=temp.foo(5);
+			++cb;
+			break;
+      	}
+		case 1:
+			vett[i]= new C<double>(n, (double) rand()/RAND_MAX, rand()%('z' - 'a' + 1) + 'a');
+			break;
+      	case 2:
+		{
+			vett[i]= new C<short>(n, (double) rand()/RAND_MAX, rand()%('z' - 'a' + 1) + 'a');
+			auto temp = dynamic_cast<C<short>&>(*(vett[i]));
+			sumc+=temp.g(5);
+			++cc;
+		}
+      	}
+	}
+
+	for(int i=0; i<DIM; i++) {
+		cout << *vett[i] << endl;
+	}
+
+	cout << "avg(foo(5))=" << sumb/cb << " "; 
+	cout << "avg(g(5))=" << sumc/cc << endl; 
+
+	cout << endl;
+	cout << *vett[0] << endl;
+	(*vett[0])[0] = '$';
+	cout << *vett[0] << endl;
+	return 0;
+}
diff --git a/1_anno/Programmazione_1/lab_28_02_19_C.cc b/1_anno/Programmazione_1/lab_28_02_19_C.cc
new file mode 100644
index 0000000..ac53815
--- /dev/null
+++ b/1_anno/Programmazione_1/lab_28_02_19_C.cc
@@ -0,0 +1,185 @@
+#include<iostream>
+#include<cmath>
+#include<set>
+#define DIM 10
+
+using namespace std;
+
+class A {
+public:
+	A(short m) : len{m} {
+		srand(time(NULL));
+		base = new char[len];
+		for(int i = 0; i < len; ++i) {
+			base[i] = rand()%('z'-'a'+1)+'a';
+		}
+	}
+
+	~A() {
+		delete base;
+	}
+
+	short getLen() {
+		return len;
+	}
+
+	virtual string extract(short x) = 0;
+	virtual void print(ostream& os) = 0;
+
+protected:
+	char get(short i) {
+		return base[i];
+	}
+
+private:
+	char* base;
+	short len;
+};
+
+class B : public A {
+public:
+	B(short m, double p) : A{m} {
+		for(int i = 0; i < m; ++i) {
+			switch(get(i)) {
+			case 'a':
+			case 'e':
+			case 'i':
+			case 'o':
+			case 'u':
+				str+=get(i);
+			}
+		}
+	}
+
+	double foo(short s) {
+		return sin(k+s)/log(s+1);
+	}
+
+	string extract(short x) override {
+		string x2{""};
+		short inserted{};
+		set<char> chars_a;
+		for(int i = 0; i < getLen(); ++i)
+			chars_a.insert(get(i));
+
+		while(inserted < x) {
+			char r_char = rand()%('z'-'a'+1)+'a';
+			if(chars_a.find(r_char) != chars_a.end()) {
+				x2+=r_char;
+				++inserted;
+			}			
+		}
+
+		return x2;
+	}
+
+	void print(ostream& os) override {
+		os << "B: base=[";
+		for(int i = 0; i < getLen(); ++i) {
+			os << get(i) << ' ';
+		}
+		os << "], str=" << str << ", k=" << k;
+	}
+	
+private:
+	string str;
+	double k;
+};
+
+class C : public A {
+public:
+	C(short n, int k) : A{n}, y{k} {}
+
+	double g(short w) {
+		return sin(w+y);
+	}
+
+	string extract(short x) override {
+		string x2{""};
+		char* narr = new char[x];
+		short counter_narr{};
+
+		for(int i = 0; i < getLen(); ++i) {
+			switch(get(i)) {
+			case 'a':
+			case 'e':
+			case 'i':
+			case 'o':
+			case 'u':
+				break;
+			default:
+				narr[counter_narr++] = get(i);
+			}
+		}
+		for(int i = 0; i < x; ++i)
+			x2+=narr[i];
+
+		delete[] narr;
+
+		return x2;
+	}	
+
+	void print(ostream& os) override {
+		os << "C: base=[";
+		for(int i = 0; i < getLen(); ++i) {
+			os << get(i) << ' ';
+		}
+		os << "], y=" << y;
+	}
+
+	C operator++(int) {
+		C temp{*this};
+		
+		y++;
+
+		return temp;
+	}
+private:
+	int y;
+};
+
+ostream& operator<<(ostream& os, A& a) {
+	a.print(os);
+
+	return os;
+}
+
+int main() {
+	A *vett[DIM];
+
+	double sum{};
+	short i_c{-1};
+	for(int i=0; i<DIM; i++) {
+		short n=10+rand()%10;
+		switch(rand()%2){
+	  	case 0: {
+	    	vett[i]= new C(n, rand()%20 + 1);
+			auto cref = dynamic_cast<C*>(vett[i]);
+			sum+=cref->g(5);
+			i_c = i;
+	    	break;
+	  	}
+		case 1: {
+	   	 	vett[i]= new B(n, rand()/(double) RAND_MAX);
+			auto bref = dynamic_cast<B*>(vett[i]);
+			sum+=bref->foo(5);
+	    	break;
+		}
+		}
+    }
+
+	for(int i=0; i<DIM; i++) 
+		cout << *(vett[i]) << ", extract(3)=" << vett[i]->extract(3) <<  endl;
+
+	cout << sum/DIM << endl;
+
+	if(i_c >= 0) {
+		cout << *vett[i_c] << endl;
+		auto cref = dynamic_cast<C*>(vett[i_c]);
+		(*cref)++;
+		cout << *vett[i_c] << endl;
+		
+
+	}
+	return 0;
+}