diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json new file mode 100644 index 0000000..a1feb4f --- /dev/null +++ b/.vscode/c_cpp_properties.json @@ -0,0 +1,18 @@ +{ + "configurations": [ + { + "name": "linux-gcc-x64", + "includePath": [ + "${workspaceFolder}/**" + ], + "compilerPath": "/usr/lib64/ccache/gcc", + "cStandard": "${default}", + "cppStandard": "${default}", + "intelliSenseMode": "linux-gcc-x64", + "compilerArgs": [ + "" + ] + } + ], + "version": 4 +} \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..cc00405 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,24 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "C/C++ Runner: Debug Session", + "type": "cppdbg", + "request": "launch", + "args": [], + "stopAtEntry": false, + "externalConsole": false, + "cwd": ".", + "program": "build/Debug/outDebug", + "MIMode": "gdb", + "miDebuggerPath": "gdb", + "setupCommands": [ + { + "description": "Enable pretty-printing for gdb", + "text": "-enable-pretty-printing", + "ignoreFailures": true + } + ] + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..3e5eb95 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,59 @@ +{ + "C_Cpp_Runner.cCompilerPath": "gcc", + "C_Cpp_Runner.cppCompilerPath": "g++", + "C_Cpp_Runner.debuggerPath": "gdb", + "C_Cpp_Runner.cStandard": "", + "C_Cpp_Runner.cppStandard": "", + "C_Cpp_Runner.msvcBatchPath": "", + "C_Cpp_Runner.useMsvc": false, + "C_Cpp_Runner.warnings": [ + "-Wall", + "-Wextra", + "-Wpedantic", + "-Wshadow", + "-Wformat=2", + "-Wcast-align", + "-Wconversion", + "-Wsign-conversion", + "-Wnull-dereference" + ], + "C_Cpp_Runner.msvcWarnings": [ + "/W4", + "/permissive-", + "/w14242", + "/w14287", + "/w14296", + "/w14311", + "/w14826", + "/w44062", + "/w44242", + "/w14905", + "/w14906", + "/w14263", + "/w44265", + "/w14928" + ], + "C_Cpp_Runner.enableWarnings": true, + "C_Cpp_Runner.warningsAsError": false, + "C_Cpp_Runner.compilerArgs": [], + "C_Cpp_Runner.linkerArgs": [], + "C_Cpp_Runner.includePaths": [], + "C_Cpp_Runner.includeSearch": [ + "*", + "**/*" + ], + "C_Cpp_Runner.excludeSearch": [ + "**/build", + "**/build/**", + "**/.*", + "**/.*/**", + "**/.vscode", + "**/.vscode/**" + ], + "C_Cpp_Runner.useAddressSanitizer": false, + "C_Cpp_Runner.useUndefinedSanitizer": false, + "C_Cpp_Runner.useLeakSanitizer": false, + "C_Cpp_Runner.showCompilationTime": false, + "C_Cpp_Runner.useLinkTimeOptimization": false, + "C_Cpp_Runner.msvcSecureNoWarnings": false +} \ No newline at end of file diff --git a/Corsi a Scelta/Algorithm Design/Note Benerecetti [2020-2021].pdf b/Corsi a Scelta/Algorithm Design/Note Benerecetti [2020-2021].pdf new file mode 100644 index 0000000..2156450 Binary files /dev/null and b/Corsi a Scelta/Algorithm Design/Note Benerecetti [2020-2021].pdf differ diff --git a/Corsi a Scelta/Algorithm Design/Note [Benerecetti].pdf b/Corsi a Scelta/Algorithm Design/Note [Benerecetti].pdf new file mode 100644 index 0000000..7a51601 Binary files /dev/null and b/Corsi a Scelta/Algorithm Design/Note [Benerecetti].pdf differ diff --git a/Corsi a Scelta/Computer Forensics/Slides [Laurato].pdf b/Corsi a Scelta/Computer Forensics/Slides [Laurato].pdf new file mode 100644 index 0000000..1dd451b Binary files /dev/null and b/Corsi a Scelta/Computer Forensics/Slides [Laurato].pdf differ diff --git a/Corsi a Scelta/Economia ed Organizzazione Aziendale/Slides [Laterza].pdf b/Corsi a Scelta/Economia ed Organizzazione Aziendale/Slides [Laterza].pdf new file mode 100644 index 0000000..e102b56 Binary files /dev/null and b/Corsi a Scelta/Economia ed Organizzazione Aziendale/Slides [Laterza].pdf differ diff --git a/Corsi a Scelta/Esercizi/Algorithm Design/Esercizi.pdf b/Corsi a Scelta/Esercizi/Algorithm Design/Esercizi.pdf new file mode 100644 index 0000000..62415db Binary files /dev/null and b/Corsi a Scelta/Esercizi/Algorithm Design/Esercizi.pdf differ diff --git a/Corsi a Scelta/Esercizi/Analisi II/Tracce [2023].pdf b/Corsi a Scelta/Esercizi/Analisi II/Tracce [2023].pdf new file mode 100644 index 0000000..4394d67 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Analisi II/Tracce [2023].pdf differ diff --git a/Corsi a Scelta/Esercizi/Computer Forensic/Domande e Soluzioni [2021-2022].pdf b/Corsi a Scelta/Esercizi/Computer Forensic/Domande e Soluzioni [2021-2022].pdf new file mode 100644 index 0000000..ef55e73 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Computer Forensic/Domande e Soluzioni [2021-2022].pdf differ diff --git a/Corsi a Scelta/Esercizi/Computer Forensic/Tracce [2021-2022].pdf b/Corsi a Scelta/Esercizi/Computer Forensic/Tracce [2021-2022].pdf new file mode 100644 index 0000000..e2af29b Binary files /dev/null and b/Corsi a Scelta/Esercizi/Computer Forensic/Tracce [2021-2022].pdf differ diff --git a/Corsi a Scelta/Esercizi/Economia ed Organizzazione Aziendale/Domande e Risposte [2022].pdf b/Corsi a Scelta/Esercizi/Economia ed Organizzazione Aziendale/Domande e Risposte [2022].pdf new file mode 100644 index 0000000..c8a3291 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Economia ed Organizzazione Aziendale/Domande e Risposte [2022].pdf differ diff --git a/Corsi a Scelta/Esercizi/LP2/Tracce Faella [2022-2023].pdf b/Corsi a Scelta/Esercizi/LP2/Tracce Faella [2022-2023].pdf new file mode 100644 index 0000000..0f67970 Binary files /dev/null and b/Corsi a Scelta/Esercizi/LP2/Tracce Faella [2022-2023].pdf differ diff --git a/Corsi a Scelta/Esercizi/Operation Research/Tracce [2022].pdf b/Corsi a Scelta/Esercizi/Operation Research/Tracce [2022].pdf new file mode 100644 index 0000000..006e680 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Operation Research/Tracce [2022].pdf differ diff --git a/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Autovalutazione [2011-2021].pdf b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Autovalutazione [2011-2021].pdf new file mode 100644 index 0000000..7d1c642 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Autovalutazione [2011-2021].pdf differ diff --git a/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Solution 1.pdf b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Solution 1.pdf new file mode 100644 index 0000000..33f2a8d Binary files /dev/null and b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Solution 1.pdf differ diff --git a/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Tracce [2011-2019].pdf b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Tracce [2011-2019].pdf new file mode 100644 index 0000000..6e1c762 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Parallel and Distributing Computing/Tracce [2011-2019].pdf differ diff --git a/Corsi a Scelta/Esercizi/SIM/Domande Frequenti.pdf b/Corsi a Scelta/Esercizi/SIM/Domande Frequenti.pdf new file mode 100644 index 0000000..f60efa9 Binary files /dev/null and b/Corsi a Scelta/Esercizi/SIM/Domande Frequenti.pdf differ diff --git a/Corsi a Scelta/Esercizi/SIM/Solutioni.pdf b/Corsi a Scelta/Esercizi/SIM/Solutioni.pdf new file mode 100644 index 0000000..2f479f9 Binary files /dev/null and b/Corsi a Scelta/Esercizi/SIM/Solutioni.pdf differ diff --git a/Corsi a Scelta/Esercizi/SIM/Tracce [2023].pdf b/Corsi a Scelta/Esercizi/SIM/Tracce [2023].pdf new file mode 100644 index 0000000..133dc14 Binary files /dev/null and b/Corsi a Scelta/Esercizi/SIM/Tracce [2023].pdf differ diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage.m new file mode 100644 index 0000000..c7c6680 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage.m @@ -0,0 +1,37 @@ +function f = myLagrage(xdata,ydata,z) +% MYLAGRANGE +% La funzione utilizza il metodo di interpolazione di Lagrange +% per identificare una funzione che approssimi la serie di punti in input e +% restituisca in output la stessa. +% +% INPUT: +% 'xdata' = vettore delle ascisse dei punti +% 'ydata' = vettore delle ordinate dei punti +% 'z' = vettore di ascisse su cui costruire la funzione +% +% OUTPUT +% 'f' = vettore di numeri che stanno alla relazione interpolante +% +% + size_x = length(xdata); + size_z = length(z); + f = zeros(size_z); + + + for i=1:size_x + pos = ones(size_z); + for j=[1:i-1 i+1:size_x] + pos = pos .*(z - xdata(j))./(xdata(i)-xdata(j)); + end + f = f + pos * ydata(i); + end + f = f(1, :); + +end + +% Esmpio di utilizzo +% xdata = [1 2 3 4 5]; +% ydata = [1 4 9 16 25]; +% z = 1:0.1:5; +% f = myLagrage(xdata,ydata,z); +% plot(xdata,ydata,'o',z,f,'-') diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage_BAR.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage_BAR.m new file mode 100644 index 0000000..66b2f92 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myLagrage_BAR.m @@ -0,0 +1,43 @@ +function f = myLagrage_BAR(xdata,ydata,z) +% MYLAGRANGE_BAR +% Metodo di interpolazione di Lagrange +% xdata = vettore delle ascisse dei punti di interpolazione +% ydata = vettore delle ordinate dei punti di interpolazione +% z = vettore delle ascisse dei punti di valutazione +% f = vettore delle ordinate dei punti di valutazione + + size_x = length(xdata); + size_z = length(z); + f = zeros(size_z); + + + for k=1:size_x + w_k(k) = 1; + for j=1:size_x + if k~=j + w_k(k) = w_k(k) .* (xdata(k)-xdata(j)); + end + end + end + + w_w = 1; + s = 0; + disp(w_k) + + for i =1:size_x + for j= 1:size_z + if z(j) ~= xdata(i) + %w_w = w_w .* 1; + %s = s +(ydata(i) ./ w_k).*1; + w_w = w_w .* (z(j)-xdata(i)); + s = s +(ydata(i) ./ w_k).*(1./(z(j)-xdata(i))); + end + end + f = s.*w_w; + end +end +% Esempio +% xdata = [1 2 3 4 5]; +% ydata = [1 4 9 16 25]; +% z = [1.5 2.5 3.5 4.5]; +% f = myLagrange_BAR(xdata,ydata,z) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/mySpline.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/mySpline.m new file mode 100644 index 0000000..ac09283 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/mySpline.m @@ -0,0 +1,68 @@ +function spval = mySpline(xdata, ydata, zval) + +% MYSPLINE +% La funzione di spline cubica utilizza un successione di +% polinomi di grado tre per approssimare una serie di punti. +% +% INPUT +% xdata = array di nodi su cui collegare i polinomi +% ydata = ordinate di interpolazione +% zval = valori delle ascisse su cui costruire il polinomio +% interpolante +% OUTPUT +% spval = ordinate da combinare con l'array zval per la +% costruzione del polinomio interpolante +% + n = length(xdata); + h = zeros(n-1, 1); + A = zeros(n, n); + delta = zeros(n, 1); + + b = zeros(n, 1); + d = zeros(n, 1); + + spval = zeros(length(zval), 1); + + % Distanze tra i nodi + for j=1 : n-1 + h(j) = xdata(j+1) - xdata(j); + end + + % Matrice dei coefficienti + A(1, 1) = 1; A(n, n) = 1; + for i=2 : n-1 + A(i, i) = 2*(h(i-1) + h(i)); % Diagonali + A(i, i-1) = h(i-1); + A(i, i+1) = h(i); + end + + % Vettore delle soluzioni + for i=2 : n-1 + delta(i) = (3/h(i))*(ydata(i+1) - ydata(i)) - (3/h(i-1))*(ydata(i) - ydata(i-1)); + end + + % Calcolo le incognite + x = A\delta; + + % Ottengo i valori per i coefficienti + for i=1 : n-1 + b(i) = (ydata(i+1) - ydata(i))/h(i) - (h(i)/3)*(x(i+1) + 2*x(i)); + d(i) = (x(i+1) - x(i))/(3*h(i)); + end + + % Calcolo la spline nei punti + for i=1 : length(zval) + for j=1 : n-1 + if(zval(i) >= xdata(j) && zval(i) <= xdata(j+1)) + spval(i) = ydata(j) + b(j)*(zval(i) - xdata(j)) + x(j)*(zval(i) - xdata(j))^2 + d(j)*(zval(i) - xdata(j))^3; + end + end + end +end +% ESEMPIO +% xdata = [0 1 2 3 4 5 6 7 8 9 10]; +% ydata = [0 1 2 3 4 5 6 7 8 9 10]; +% zval = 0:0.1:10; +% spval = mySpline(xdata, ydata, zval); +% plot(xdata, ydata, 'o', zval, spval, 'r-') +% grid on diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myls.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myls.m new file mode 100644 index 0000000..f076d64 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Interpolation/myls.m @@ -0,0 +1,47 @@ +function coeff = myls(xdata, ydata, m) +% MYLS +% coeff = myls(xdata, ydata, m) +% E' una funzione che prende in INPUT due vettori di dimensione n +% ed il numero di coefficienti che vogliamo in output +% Restituisce in OUTPUT m coefficienti di un polinomio +% +% Questa funzione usa il metodo dei minimi quadrati per trovare dei +% coefficienti di un polinomio che approssima i nodi +% +% Nello specifico, viene costruita una matrice dei coefficienti B che +% contiene le potenze dei nodi x da x^0 a x^m. Viene costruito un +% vettore di termini noti b che contiene la somma degli y_i +% moltiplicati per le potenze di x_i. Viene risolto questo sistema, ed +% il risultato è proprio il vettore dei coefficienti del polinomio. +% +% xdata : vettore riga : sono le ascisse dei punti dati +% ydata : vettore riga : sono le ordinate dei punti dati +% m : intero : è il numero di coefficienti del polinomio +% Questa funzione restituisce in ordine i coefficienti a_0, ..., a_m; +% Non c'è alcun controllo sull'input; + + if length(xdata) ~= length(ydata) + disp('La dimensione dei dati deve essere uguale!') + return + end + + m = m-1; + n = length(xdata) - 1; + B = ones(n+1, m+1); + b = zeros(n+1, 1); + A = zeros(m+1, m+1); + + for i=2 : m+1 + B(:, i) = (xdata').^(i-1); + end + + A = B'* B; + b = B' * ydata'; + coeff = (A\b)'; +end + +% Esempio di utilizzo +% xdata = [0 1 2 3 4 5 6 7 8 9 10]; +% ydata = [0 1 2 3 4 5 6 7 8 9 10]; +% m = 3; +% coeff = myls(xdata, ydata, m) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/SolveLinearSystem.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/SolveLinearSystem.m new file mode 100644 index 0000000..a5b9d63 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/SolveLinearSystem.m @@ -0,0 +1,53 @@ +function x = SolveLinearSystem(A, b) +% SOLVELINEARSYSTEM +% Risolve un sistema lineare Ax = b +% Input: +% A: matrice dei coefficienti +% b: vettore dei termini noti +% Output: +% x: vettore soluzione del sistema lineare Ax = b + + + n = length(b); + x = zeros(n, 1); + y = zeros(n, 1); + % Decomposizione della matrice per mezzo del metodo Doolittle + for i = 1:1:n + for j = 1:1:(i - 1) + alpha = A(i,j); + for k = 1:1:(j - 1) + alpha = alpha - A(i,k)*A(k,j); + end + A(i,j) = alpha/A(j,j); + end + for j = i:1:n + alpha = A(i,j); + for k = 1:1:(i - 1) + alpha = alpha - A(i,k)*A(k,j); + end + A(i,j) = alpha; + end + end + % A = L+U-I + % calcolo delle soluzioni di Ly = b + for i = 1:1:n + alpha = 0; + for k = 1:1:i + alpha = alpha + A(i,k)*y(k); + end + y(i) = b(i) - alpha; + end + % calcolo delle soluzioni di Ux = y + for i = n:(-1):1 + alpha = 0; + for k = (i + 1):1:n + alpha = alpha + A(i,k)*x(k); + end + x(i) = (y(i) - alpha)/A(i, i); + end +end + +% Esempio +% A = [1 2 3; 4 5 6; 7 8 10]; +% b = [3; 3; 4]; +% x = SolveLinearSystem(A, b) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myBackSubs.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myBackSubs.m new file mode 100644 index 0000000..1a4dfbb --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myBackSubs.m @@ -0,0 +1,31 @@ +function x = myBackSubs(U, b) + % MYBACSUBS + % Questa funzione implementa l'algoritmo di backward substitution per + % la risoluzione di sistemi triangolari superiori + % INPUT + % U : Una matrice triangolare superiore + % b : Il vettore dei termini noti + % OUTPUT + % x : Il vettore delle soluzioni + % COMPLESSITA O(n^2) + + n = length(b); + x = zeros(n, 1); + check = size(U); + + % Controllo che la dimensione di U sia coerente con quella di b + if check(1) ~= check(2) || check(1) ~= n + disp('Errore dimensione della matrice') + return + end + + for k = n:-1:1 + j = k+1:n; + x(k) = (x(k) - U(k,j)*x(j))/U(k,k); + end +end + +% Esempio +% A = [1 2 3; 0 4 5; 0 0 6]; +% b = [1; 2; 3]; +% x = myBackSubs(A, b) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myFarwardSubs.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myFarwardSubs.m new file mode 100644 index 0000000..e7f12eb --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myFarwardSubs.m @@ -0,0 +1,38 @@ +function y = myFarwardSubs(L, b) + % MYFARWARDSUBS + % Questo funzione implementa l'algoritmo di foreward substitution per + % la risoluzione di sistemi lineari con matrici triangolari inferiori + % + % INPUT + % L : Una matrice triangolare inferiore + % b : Il vettore dei termini noti + % OUTPUT + % x : Il vettore delle soluzioni + % COMPLESSITA O(n^2) + + n = length(b); + y = zeros(n, 1); + check = size(L); + + % Controllo che la dimensione della matrice sia coerente con la + % dimensione di b + if check(1) ~= check(2) || check(1) ~= n + disp('Errore dimensione del sistema') + return + end + + y(1) = b(1) / L(1, 1); + for k=2 : n + y(k) = b(k); + for j=1 : k-1 + y(k) = y(k) - L(k, j) * y(j); + end + + %y(k) = y(k) / L(k, k); % Eliminare per una funz. più generale + end +end + +% Esempio di utilizzo +% A = [1 0 0; 2 3 0; 4 5 6]; +% b = [1; 2; 3]; +% x = myFarwardSubs(A, b) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myGS.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myGS.m new file mode 100644 index 0000000..74417e6 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myGS.m @@ -0,0 +1,40 @@ +function [xv,iter]=myGS(A,b,x0,nmax,toll) +% MYGS +% Calcola la soluzione del sistema lineare Ax=b utilizzando il metodo iterativo di +% Gauss-Seidel. +% [xv,iter]=myGS(A,b,x0,nmax,toll) calcola la soluzione del sistema lineare Ax=b con tolleranza +% toll partendo dal vettore x0 e con un numero di iterazioni inferiore o uguale a nmax. +% La funzione restituisce il vettore xv, approssimazione della soluzione ed il numero di iterazioni +% effettuate. + +[m,n] = size(A); +if (m ~= n) + error('La matrice deve essere quadrata.'); +end +if (size(b,2) ~= 1)||(size(x0,2) ~= 1) %controlla che b e x0 siano vettori colonna + error('Il termine noto e il vettore iniziale devono essere vettori colonna.'); +end +iter=0; +err=1; +xk=x0; +xk1=zeros(size(xk)); +while err>toll + if (iter == nmax) + error('Attenzione il metodo non converge o nmax è piccolo per la tolleranza richiesta') + end + iter=iter+1; + for i=1:n + xk1(i)=(b(i)-A(i,1:i-1)*xk1(1:i-1)-A(i,i+1:n)*xk(i+1:n))/A(i,i); + end + err=norm(xk1-xk); + xk=xk1; +end +iter=iter-1; +xv=xk1; + +% Esempio +% A=diag(ones(8,1)*8)+diag(ones(7,1)*2,1)+diag(ones(7,1),-1); +% b=[10,11,11,11,11,11,11,9]'; +% [xv,iter]=myGS(A,b,zeros(8,1),30,1e-12) +% calcola la soluzione del sistema lineare Ax=b con tolleranza 1e-12 partendo dal vettore colonna +% di componenti nulle utilizzando il metodo iterativo di Gauss-Seidel. \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myJacobi.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myJacobi.m new file mode 100644 index 0000000..5e96c23 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myJacobi.m @@ -0,0 +1,40 @@ +function [xv,iter]=myJacobi(A,b,x0,nmax,toll) + % MYJACOBI + % Calcola la soluzione del sistema lineare Ax=b utilizzando il metodo iterativo di Jacobi. + % [xv,iter]=myJacobi(A,b,x0,nmax,toll) calcola la soluzione del sistema lineare Ax=b con tolleranza toll + % partendo dal vettore x0 e con un numero di iterazioni inferiore o uguale a nmax. + % La funzione restituisce il vettore xv, approssimazione della soluzione ed il numero di iterazioni + % effettuate. + + [m,n] = size(A); + if (m ~= n) + error('La matrice deve essere quadrata.'); + end + if (size(b,2) ~= 1)||(size(x0,2) ~= 1) %controlla che b e x0 siano vettori colonna + error('Il termine noto e il vettore iniziale devono essere vettori colonna'); + end + iter=0; + err=1; + xk=x0; + xk1=zeros(size(xk)); + while err>toll + if (iter == nmax) + error('Attenzione il metodo non converge o nmax è piccolo per la tolleranza richiesta') + end + iter=iter+1; + for i=1:n + xk1(i)=(b(i)-A(i,1:i-1)*xk(1:i-1)-A(i,i+1:n)*xk(i+1:n))/A(i,i); + end + err=norm(xk1-xk); + xk=xk1; + end + iter=iter-1; + xv=xk1; + + % + % Esempio + % A=diag(ones(8,1)*8)+diag(ones(7,1)*2,1)+diag(ones(7,1),-1); + % b=[10,11,11,11,11,11,11,9]; + % [xv,iter]=myJacobi(A,b,zeros(8,1),30,1e-12) + % calcola la soluzione del sistema lineare Ax=b con tolleranza 1e-12 partendo dal vettore colonna + % di componenti nulle utilizzando il metodo iterativo di Jacobi. \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myLU.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myLU.m new file mode 100644 index 0000000..4f52c34 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/LinearSystems/myLU.m @@ -0,0 +1,51 @@ +function [L,U,P]=myLU(A) + % MYLU + % Fattorizzazione LU con pivoting parziale + % [L,U,P]=myLU(A) + % Input: + % A matrice quadrata + % Output: + % L matrice triangolare inferiore + % U matrice triangolare superiore + % P matrice di permutazione + +[n,n]=size(A); % Controllo dimensioni matrice +L=eye(n); P=L; U=A; % assenziamento iniziale +for k=1:n % loop per inizializzare + [pivot m]=max(abs(U(k:n,k))); % processo di pivoting + m=m+k-1; + if m~=k + % scambia righe m e k in U + temp=U(k,:); % assegnazione di variabile temporanee + U(k,:)=U(m,:); + U(m,:)=temp; % ritorno il valore temporaneo + % scambio righe m e k in P + temp=P(k,:); % assegnazione di temp + P(k,:)=P(m,:); + P(m,:)=temp; % ritorno del valore di temp + if k >= 2 % controllo delle condizioni + temp=L(k,1:k-1); + L(k,1:k-1)=L(m,1:k-1); + L(m,1:k-1)=temp; + end % fine + end + for j=k+1:n % loop per output + L(j,k)=U(j,k)/U(k,k); + U(j,:)=U(j,:)-L(j,k)*U(k,:); + end +end +% ESEMPIO +% A=[1 2 3; 4 5 6; 7 8 10]; +% [L,U,P]=myLU(A) +% L = +% 1.0000 0 0 +% 0.5714 1.0000 0 +% -0.4286 0.5000 1.0000 +% U = +% 7.0000 8.0000 10.0000 +% 0 -1.0000 -2.0000 +% 0 0 0.5000 +% P = +% 0 1 0 +% 1 0 0 +% 0 0 1 diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myBisection.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myBisection.m new file mode 100644 index 0000000..c73057d --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myBisection.m @@ -0,0 +1,44 @@ +function [x, it] = myBisection(f, a, b, tol) +% MYBISECTION +% The program builds a method to compute the root of a function. It builds +% an intervall evaluating the funciton at the range boundarys, it computes +% the midpoint and it decides to move to the left or to the right to reduce +% the interval and checking its size compared to the tolerance. +% +% INPUT +% 'x' = value of the root of the function +% 'it' = number of iteration made +% +% OUTPUT +% 'f' = input function +% 'a' = inferior bound of the range +% 'b' = upper bound of the range +% 'tol' = tollerance + +x(1) = a; x(2) = b; +fa = f(a); fb = f(b); % evaluate the function at the boundarys +if fa * fb >= 0 + disp('Interval not acceptable'); + return; +end + +it = ceil((log(b-a) - log(tol)) / log(2)); % mathematically comput the max +% number of iteration + +for k=3:it+2 + x(k) = (a + b)/2; + fxk = f(x(k)); + if fa * fxk == 0 % if fa * fxk == 0 i've found the root + break + elseif fa * fxk < 0 % if fa * fxk < 0 I move the interval to the right + b = x(k); + fb = fxk; + else + a = x(k); % if fb * fxk < 0 I move the interval to the left + fa = fxk; + end +end + +% Esempio +% f = @(x) x^3 - 2*x - 5; +% [x, it] = myBisection(f, 1, 2, 1e-6); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myFixedPoint.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myFixedPoint.m new file mode 100644 index 0000000..2048a48 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myFixedPoint.m @@ -0,0 +1,39 @@ +function [x, ierr, it] = myFixedPoint(g, x0, tol, kmax) +% MYFIXEDPOINT +% Il programma costruisce un metodo per il calcolo di una radice di una +% funzione. +% +% +% INPUT +% 'x' = valore della radice calcolata dal programma +% 'ierr' = flag per verificare se i termini di tolleranza sono stati +% rispettati +% 'it' = numero di iterazioni effettuate +% +% OUTPUT +% 'g' = funzione in input +% 'x0' = approssimazione iniziale +% 'kmax' = numero massimo di iterazioni da effettuare +% 'tol' = tolleranza + +ierr = -1; +diff = 1 + tol; +k = 1; +while k < kmax && tol < diff + x1 = g(x0); + diff = abs(x1-x0); + %disp(sqrt(2)-x0); + x0 = x1; +end +it = k; +x = x1; +if tol > diff + ierr = 0; +end + +% Esempio +% g = @(x) sqrt(2+x); +% [x, ierr, it] = myFixedPoint(g, 0, 1e-6, 1000); +% disp(x); +% disp(ierr); +% disp(it); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myNewton.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myNewton.m new file mode 100644 index 0000000..5b54092 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/myNewton.m @@ -0,0 +1,51 @@ +function [x, ierr, it] = myNewton(f, fp, x0, tol, kmax) + +% MYNEWTON +% The program builds a method to compute the root of a function. With the +% input of a initial abscissa x_0 the function and its derivative gets +% evaluated in said point in order to get closer to the value of the root. +% The difference between the previous number and the one calculated with +% the inverse ration of the function in the current point with the +% derivative in the same point allows the program to get closer to the +% value of the root. +% +% OUTPUT +% 'x' = value of the root +% 'ierr' = flag to verify if te conditions of the tolerance are met +% 'it' = number of iterations made +% +% OUTPUT +% 'f' = input function +% 'fp' = derivative of the input function +% 'kmax' = maximum number of iteration until the program stops +% 'tol' = tolerance + +ierr = - 1; % the default value of the flag is -1 +x = x0; +k = 0; +fx= feval(f, x); % function gets evaluated in the in the starting point +fpx= feval(fp, x); % derivative gets evaluated in the in the starting point +diff = tol + 1; % use a dummy value of the difference to start the while cycle +v_diff = []; +while diff >= tol && k < kmax + diff = - fx / fpx; + x = x + diff; + diff = abs(diff); + v_diff = [v_diff; diff]; + fx = feval(f,x); + fpx = feval(fp,x); + k = k + 1; +end +if tol > diff % if the conditions of tolerance are met then the flag is + ierr = 0; % put to zero +end +it = k; +end + +% Esempio +% f = @(x) x^3 - 2*x^2 - 5; +% fp = @(x) 3*x^2 - 4*x; +% [x, ierr, it] = myNewton(f, fp, 1, 1e-6, 1000); + + + diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/mySecant.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/mySecant.m new file mode 100644 index 0000000..becddb4 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NonLinearEquations/mySecant.m @@ -0,0 +1,50 @@ +function [x, ierr, it] = mySecant(f, x0, x1, tol, kmax) +% MYSECANT +% Il programma costruisce un metodo per il calcolo di una radice di una +% funzione. La funzione verifica la convergenza della funzione ad un valore +% alpha quando non è possibile verificare la derivata della funzione. Tale +% derivata viene sostituita da un rapporto incrementale calcolato su valori +% di f gia noti che inserisce l'utente; inoltre la velocità di convergenza +% sarà inferirore a quella di Newton non essendoci appunto nessuna +% valutazione della derivata, in particolare la convergenza sarà +% superlineare +% +% +% INPUT +% 'x' = valore della radice calcolata dal programma +% 'ierr' = flag per verificare se i termini di tolleranza sono stati +% rispettati +% 'it' = numero di iterazioni effettuate +% +% OUTPUT +% 'f' = funzione in input +% 'x0' = primo punto da assegnare +% 'x1' = secondo punto da assegnare +% 'kmax' = numero massimo di iterazioni da effettuare +% 'tol' = tolleranza + +ierr = -1; + +f0 = f(x0); +f1 = f(x1); + +x = x1 - (f1*(x1 - x0)/(f1 -f0)); +diff=abs(x-x1); +k = 1;x0=x1; f0=f1; f1=f(x); x1=x; + +while k < kmax && tol diff + ierr = 0; +end +% Esempio +% f = @(x) x^3 - 2*x^2 - 5; +% [x, ierr, it] = mySecant(f, 1, 2, 1e-6, 1000); +% disp(x); +% disp(ierr); +% disp(it); diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/mySimpsonc.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/mySimpsonc.m new file mode 100644 index 0000000..13b28fe --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/mySimpsonc.m @@ -0,0 +1,37 @@ +function [I,errest,x] = mySimpsonc(func,a,b,tol,varargin) +% MYSIMPSONC Calcola l'integrale di una funzione con il metodo di Simpson +% composto +% [I,errest,x] = mySimpsonc(func,a,b,tol,n) +% Input: +% func = funzione integranda +% a,b = estremi di integrazione +% tol = tolleranza richiesta +% Output: +% I = valore dell'integrale +% errest = stima dell'errore +% x = vettore dei nodi di quadratura +if (nargin == 4) + n = 3; +else + n = varargin{1}; +end +h = (b-a)/(n-1); +x = linspace(a,b,n)'; +weight = h/2*[1,2*ones(1,length(x)-2),1]; +Iold = weight*feval(func,x); +x = linspace(a,b,2.*n-1)'; +weight = h*ones(1,n-1); +Inew = weight*feval(func,x(2:2:end-1)); +I = (Inew+Iold)/2; +errest = abs(I-Iold)/2; +if (errest > tol) + warning("Tolleranza non raggiunta"); +% [Il,errestl,xl] = mySimpsonc(func,a,a+(b-a)/2,tol/2,n); +% [Ir,errestr,xr] = mySimpsonc(func,a+(b-a)/2,b,tol/2,n); +% I = Il+Ir; +% errest = errestl+errestr; +% x = union(xl,xr); +end + +% Esempio di utilizzo +% [I,errest,x] = mySimpsonc(@(x) x.^2,0,1,1e-6,3) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/myTrapP.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/myTrapP.m new file mode 100644 index 0000000..a370e46 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/NumericalIntegration/myTrapP.m @@ -0,0 +1,30 @@ +function [Tn] = myTrapP(f,a,b,n) +% MYTRAP valutazione numerica di integrali utilizzando la formula composita dei trapezi +% [Tn] = myTra(f,a,b,n) calcola l'integrale della funzione f in [a,b] con la formula dei trapezi +% su n nodi. +% f e' una stringa contenente la definizione della funzione. + + h=(b-a)/(n-1); + x=a:h:b; + % per certi valori di n, h non fa arrivare a b + if max(size(x))~=n;x(n)=b;end + % + % + y=double(subs(f,x)); + if length(y) tol) + [I,errest,x] = myTrapc(func,a,b,tol,2*n-1); +end + +%Esempio di utilizzo +%[I,errest,x] = myTrapc(@sin,0,pi/2,1e-6,1000) diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_1.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_1.m new file mode 100644 index 0000000..537d1e6 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_1.m @@ -0,0 +1,21 @@ +% funzione per la quale 5^(2/3) e' zero della funzione +f = @(x)x.^3 - 25; + +% Valore di tolleranza +toll = 10^-4; + +% valore teorico del numero di iterazioni necessarie +it_teorico = log2((5-0)/toll) - 1; + +% approssimazione per eccesso +ceil(it_teorico) + +% scelta dell'intervallo per l'algoritmo [0-5] +[x,it_vero] = myBisezione(f,0,5,toll); + +% array conteneti i valori durante i passi di bisezione +disp(x); + +% valore vero del numero di iterazioni necessarie per soddisfare +% la tolleranza +disp(it_vero); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_2.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_2.m new file mode 100644 index 0000000..3aef23f --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_2.m @@ -0,0 +1,41 @@ +% array di input +x = [-1 -0.5 0 0.5]; +f = [0.86199480 0.95802009 1.0986123 1.2943767]; + +% vattore 'z' appoggio per la costruzione della spline [-1, 0.5] +z = linspace(-1,0.5); + +% costituisco i valori per l'asse delle y +j = mySpline(x,f,z); + +% funzione da traccia +f_1 = @(x)log(exp(x) + 2); + +% derivata della funzione da traccia +f_2 = @(x)1 - 2./(2 + exp(x)); + +f_3 = f_2(x); + +j_1 = mySpline(x,f_3,z); + +% faccio il plotting dei punti assieme alla spline +plot(x, f, 'o', z, j); + + +% apporssimazione di f'(0.25) con errore 10^-11 +for i =1:length(j_1) + if f_2(0.25)- j_1(i) < 10^-11 + disp(i) + end +end + +disp(' ') + +% approssimazione di f(0.25) con errore 10^-11 +for i =1:length(j) + if f_1(0.25)- j(i) < 10^-11 + disp(i) + end +end + + diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_3.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_3.m new file mode 100644 index 0000000..54c8801 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_3.m @@ -0,0 +1,16 @@ +% estremi dell'intervallo +a = pi; +b = 0; + +% funzione da integrare +fun = @(x) x.^2.*cos(x); + +% tolleranza +tol = 10.^-4; + +% metodo di integrazione dei Trapezi +[I_t, err_t, x_t] = myTrapc(fun,a,b,tol) + +% metodo di integrazione di Simpson +[I_s, err_s, x_s] = mySimpsonc(fun,a,b,tol) + diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_4.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_4.m new file mode 100644 index 0000000..aed0a30 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_4.m @@ -0,0 +1,16 @@ +% matrice in input +A = [0 2 1 4 1 3 + 1 2 -1 3 4 0 + 0 1 1 -1 2 -1 + 2 3 -4 2 0 5 + 1 1 1 3 0 2 + -1 -1 2 -1 2 0]; + +% eseguo il +[L, U, P] = myLU(A); + +% determinante calcolato a partire da U e L +disp(det(L)*det(U)); + +% determinante calcolato con la funzione classica di matlab +disp(det(A)); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_5.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_5.m new file mode 100644 index 0000000..a76f645 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_5.m @@ -0,0 +1,31 @@ +% matrice in input +A = [3 12 0 -1 0 0 + 4 0 31 1 0 0 + 2 1 0 0 17 -3 + 27 2 0 0 0 1 + 0 0 0 -1 1 11 + 0 0 0 24 -1 0]; + +% trasformazione della matrice +A = sparse(A); + +% vettore dei termini noti +b = [38 117 12 98 14 55]; + +% risoluzione con metodi di BackSub e FarwardSub +[x_1] = SolveLinearSystem(A,b); + +% risoluzione metodi Jacobi e Gauss-Seidel +[xv,iter] = myJacobi(A,b',zeros(8,1),400,1e-4); +[xv_1,iter_1] = myGS(A,b',zeros(8,1), 100,1e-4); + +% Jacobi +disp(xv); +disp(iter); + +% GS +disp(xv_1); +disp(iter_1); + +% solver +disp(x_1); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_6.m b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_6.m new file mode 100644 index 0000000..13565d2 --- /dev/null +++ b/Corsi a Scelta/Esercizi/Scientific Computing/Funzioni risoluzione esercizi/Traccia Marzo 2023/Exercises/ES_6.m @@ -0,0 +1,30 @@ +% Vettori di x e y su cui eseguire i minimi quadrati +x = [70 75 77 80 82 84 87 90]; % [70 - 90] +y = [2.10 2.12 2.15 2.20 2.22 2.23 2.26 2.30];% [2.10 - 2.30] + +% plotto i dati ed estrapolo i coefficienti della retta +plot(x, y, 'o'); +hold on + +% coefficienti della retta +x_dat = myls(x, y, 2); + +%retta +f = @(x)x_dat(2).*x +x_dat(1); + +%plotting della retta +fplot(f, [70 90]); + +% dati modificati in cui aggiungo 95 kg +% x_1 = [70 75 77 80 82 84 87 90 95];% [70 - 95] +%y_1 = [2.10 2.12 2.15 2.20 2.22 2.23 2.26 2.30 2.35];% [2.10 - 2.35] + +% plot(x_1, y_1, 'o'); +% hold on + +% plotto i nuovi dati e verifico la buona rappresentazione +% x_dat = myls(x_1, y_1, 2); +% f = @(x)x_dat(2).*x +x_dat(1); + +% plotting della nuova retta +% fplot(f, [70 95]); \ No newline at end of file diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Soluzione Marzo 2023.pdf b/Corsi a Scelta/Esercizi/Scientific Computing/Soluzione Marzo 2023.pdf new file mode 100644 index 0000000..918c30a Binary files /dev/null and b/Corsi a Scelta/Esercizi/Scientific Computing/Soluzione Marzo 2023.pdf differ diff --git a/Corsi a Scelta/Esercizi/Scientific Computing/Traccia Messina [2022-2023].pdf b/Corsi a Scelta/Esercizi/Scientific Computing/Traccia Messina [2022-2023].pdf new file mode 100644 index 0000000..29b3bc5 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Scientific Computing/Traccia Messina [2022-2023].pdf differ diff --git a/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte [2023].pdf b/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte [2023].pdf new file mode 100644 index 0000000..56c3cab Binary files /dev/null and b/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte [2023].pdf differ diff --git a/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte.pdf b/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte.pdf new file mode 100644 index 0000000..c6e661d Binary files /dev/null and b/Corsi a Scelta/Esercizi/Tec Web/Domande e Risposte.pdf differ diff --git a/Corsi a Scelta/Esercizi/Tec Web/Tracce [2014-2023].pdf b/Corsi a Scelta/Esercizi/Tec Web/Tracce [2014-2023].pdf new file mode 100644 index 0000000..57f49d6 Binary files /dev/null and b/Corsi a Scelta/Esercizi/Tec Web/Tracce [2014-2023].pdf differ diff --git a/Corsi a Scelta/Parallel and Distributing Computing/Slides Laccetti [2021].pdf b/Corsi a Scelta/Parallel and Distributing Computing/Slides Laccetti [2021].pdf new file mode 100644 index 0000000..a6d68b2 Binary files /dev/null and b/Corsi a Scelta/Parallel and Distributing Computing/Slides Laccetti [2021].pdf differ diff --git a/Corsi a Scelta/Tecnologie Web/End-to-End Testing [Starace].pdf b/Corsi a Scelta/Tecnologie Web/End-to-End Testing [Starace].pdf new file mode 100644 index 0000000..5a8326d Binary files /dev/null and b/Corsi a Scelta/Tecnologie Web/End-to-End Testing [Starace].pdf differ diff --git a/Corsi a Scelta/Tecnologie Web/Microservices [Starace].pdf b/Corsi a Scelta/Tecnologie Web/Microservices [Starace].pdf new file mode 100644 index 0000000..6c5280b Binary files /dev/null and b/Corsi a Scelta/Tecnologie Web/Microservices [Starace].pdf differ diff --git a/Corsi a Scelta/Tecnologie Web/Programming meets the Web Internet [Starace].pdf b/Corsi a Scelta/Tecnologie Web/Programming meets the Web Internet [Starace].pdf new file mode 100644 index 0000000..63073f1 Binary files /dev/null and b/Corsi a Scelta/Tecnologie Web/Programming meets the Web Internet [Starace].pdf differ diff --git a/Corsi a Scelta/Tecnologie Web/Tecnologie-Web-slides-Starace_2023_2024.pdf b/Corsi a Scelta/Tecnologie Web/Tecnologie-Web-slides-Starace_2023_2024.pdf new file mode 100644 index 0000000..632cb4f Binary files /dev/null and b/Corsi a Scelta/Tecnologie Web/Tecnologie-Web-slides-Starace_2023_2024.pdf differ diff --git a/Primo Anno/Appunti/AdE/1609 Architettura degli Elaboratori.pdf b/Primo Anno/Appunti/AdE/1609 Architettura degli Elaboratori.pdf deleted file mode 100644 index d41b42a..0000000 Binary files a/Primo Anno/Appunti/AdE/1609 Architettura degli Elaboratori.pdf and /dev/null differ diff --git a/Primo Anno/Esercizi/Analisi/Autovalutazione.pdf b/Primo Anno/Esercizi/Analisi/Autovalutazione.pdf new file mode 100644 index 0000000..e301403 Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Autovalutazione.pdf differ diff --git a/Primo Anno/Esercizi/Analisi/Esercizi.pdf b/Primo Anno/Esercizi/Analisi/Esercizi.pdf new file mode 100644 index 0000000..be16630 Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Esercizi.pdf differ diff --git a/Primo Anno/Esercizi/Analisi/Tracce [2017-2018].pdf b/Primo Anno/Esercizi/Analisi/Tracce [2017-2018].pdf new file mode 100644 index 0000000..856a9fc Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Tracce [2017-2018].pdf differ diff --git a/Primo Anno/Esercizi/Analisi/Tracce [2018-2019].pdf b/Primo Anno/Esercizi/Analisi/Tracce [2018-2019].pdf new file mode 100644 index 0000000..a9ab669 Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Tracce [2018-2019].pdf differ diff --git a/Primo Anno/Esercizi/Analisi/Tracce [2020-2023] - Castorina.pdf b/Primo Anno/Esercizi/Analisi/Tracce [2020-2023] - Castorina.pdf new file mode 100644 index 0000000..ac1b96c Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Tracce [2020-2023] - Castorina.pdf differ diff --git a/Primo Anno/Esercizi/Analisi/Tracce [2021-2022].pdf b/Primo Anno/Esercizi/Analisi/Tracce [2021-2022].pdf new file mode 100644 index 0000000..e0c3fca Binary files /dev/null and b/Primo Anno/Esercizi/Analisi/Tracce [2021-2022].pdf differ diff --git a/Primo Anno/Esercizi/Architettura Degli Elaboratori/Soluzioni [A. Caruso].pdf b/Primo Anno/Esercizi/Architettura Degli Elaboratori/Soluzioni [A. Caruso].pdf new file mode 100644 index 0000000..bd3dac0 Binary files /dev/null and b/Primo Anno/Esercizi/Architettura Degli Elaboratori/Soluzioni [A. Caruso].pdf differ diff --git a/Primo Anno/Esercizi/Architettura Degli Elaboratori/Tracce - Sauro [2019-2023].pdf b/Primo Anno/Esercizi/Architettura Degli Elaboratori/Tracce - Sauro [2019-2023].pdf new file mode 100644 index 0000000..789f67c Binary files /dev/null and b/Primo Anno/Esercizi/Architettura Degli Elaboratori/Tracce - Sauro [2019-2023].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercitazioni [Simone Parete] convertite da V. Bocchetti.pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercitazioni [Simone Parete] convertite da V. Bocchetti.pdf new file mode 100644 index 0000000..93c566b Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercitazioni [Simone Parete] convertite da V. Bocchetti.pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi (Compilation).pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi (Compilation).pdf new file mode 100644 index 0000000..c2f2a89 Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi (Compilation).pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2015-2022].pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2015-2022].pdf new file mode 100644 index 0000000..59d65b8 Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2015-2022].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2019-2021].pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2019-2021].pdf new file mode 100644 index 0000000..f7d0b2e Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi [2019-2021].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi svolti [2021].pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi svolti [2021].pdf new file mode 100644 index 0000000..000ea7f Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Esercizi svolti [2021].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Basi di Dati Modelli e linguaggi di interrogazione_compressed.pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Basi di Dati Modelli e linguaggi di interrogazione_compressed.pdf new file mode 100644 index 0000000..6f76097 Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Basi di Dati Modelli e linguaggi di interrogazione_compressed.pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Svolte (Peron) [2017-2018].pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Svolte (Peron) [2017-2018].pdf new file mode 100644 index 0000000..1bff665 Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Svolte (Peron) [2017-2018].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Tracce 2021.pdf b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Tracce 2021.pdf new file mode 100644 index 0000000..ec6a52c Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Esercizi/Soluzioni Tracce 2021.pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Barra [2021-2023].pdf b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Barra [2021-2023].pdf new file mode 100644 index 0000000..52c080b Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Barra [2021-2023].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Peron [2003-2021].pdf b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Peron [2003-2021].pdf new file mode 100644 index 0000000..81cf15b Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce Peron [2003-2021].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce San Giovanni [2022-2023].pdf b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce San Giovanni [2022-2023].pdf new file mode 100644 index 0000000..c69c029 Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce San Giovanni [2022-2023].pdf differ diff --git a/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce [2012-2022].pdf b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce [2012-2022].pdf new file mode 100644 index 0000000..20b47ec Binary files /dev/null and b/Primo Anno/Esercizi/Base Di Dati/Tracce/Tracce [2012-2022].pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Esercitazioni.pdf b/Primo Anno/Esercizi/Geometria/Esercitazioni.pdf new file mode 100644 index 0000000..c131c1b Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Esercitazioni.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Eserciziario.pdf b/Primo Anno/Esercizi/Geometria/Eserciziario.pdf new file mode 100644 index 0000000..49fc10a Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Eserciziario.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Intercorso [2022].pdf b/Primo Anno/Esercizi/Geometria/Intercorso [2022].pdf new file mode 100644 index 0000000..770c9cd Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Intercorso [2022].pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 01.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 01.pdf new file mode 100644 index 0000000..aa35b93 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 01.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 02.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 02.pdf new file mode 100644 index 0000000..efa3e46 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 02.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 03.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 03.pdf new file mode 100644 index 0000000..8abba1a Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 03.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 04.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 04.pdf new file mode 100644 index 0000000..c63b373 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 04.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 05.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 05.pdf new file mode 100644 index 0000000..027d419 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 05.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 06.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 06.pdf new file mode 100644 index 0000000..ee98ff1 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 06.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 07.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 07.pdf new file mode 100644 index 0000000..02e9bd3 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 07.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 08.pdf b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 08.pdf new file mode 100644 index 0000000..44f0658 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Soluzioni/Soluzioni - Esercitazione - 08.pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2017-2023].pdf b/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2017-2023].pdf new file mode 100644 index 0000000..f0aef38 Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2017-2023].pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2023-2024].pdf b/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2023-2024].pdf new file mode 100644 index 0000000..1a59c3a Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Tracce - Trombetti [2023-2024].pdf differ diff --git a/Primo Anno/Esercizi/Geometria/Tracce [2017-2023].pdf b/Primo Anno/Esercizi/Geometria/Tracce [2017-2023].pdf new file mode 100644 index 0000000..0ebb59d Binary files /dev/null and b/Primo Anno/Esercizi/Geometria/Tracce [2017-2023].pdf differ diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Hello C!/main.c b/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Hello C!/main.c new file mode 100644 index 0000000..feb53e1 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Hello C!/main.c @@ -0,0 +1,7 @@ +#include +#include + +int main(int argc, char **argv) { + printf("Hello World!\n"); + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Matrice/matrice.c b/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Matrice/matrice.c new file mode 100644 index 0000000..bd20a73 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/La-C-cetti/Matrice/matrice.c @@ -0,0 +1,56 @@ +/*Ua se ti dico che sto codice l'ho fatto sul pc del polacco in classe?? +Grazie Sergio...Domani mi riprendo ventoy figlio di troia.*/ + +#include + +// Separo due funzioni cosi' non piangi tu che vuoi un codice pulito +// Questo stampa la matrice +void stampaMatrice(int mat[][100], int n){ + for (int i = 0; i < n; i++){ + for (int j = 0; j < n; j++){ + printf("%d ", mat[i][j]); + } + printf("\n"); + } +} + +// Questo la trasporta +void trasportaMatrice(int mat[][100], int n){ + for (int i = 0; i < n; i++){ + for (int j = i + 1; j < n; j++){ + int temp = mat[i][j]; + mat[i][j] = mat[j][i]; + mat[j][i] = temp; + } + } +} + +// Qui ci sta il main (Ma non mi dire...) +int main(){ + int n; + // Lmao ho fatto gli input fr? + printf("Inserisci l'ordine della matrice: "); + scanf("%d", &n); + + int mat[100][100]; + + // Qui il programma calcola la matrice in base a quanti elementi vanno inseriti + printf("inserisci gli elementi della matrice:\n"); + for (int i=0; i < n; i++){ + for(int j = 0; j < n; j++){ + scanf("%d", &mat[i][j]); + } + } + + // Mentre qui stampo sia la matrice originale che dichiaro i metodi per trasportarla + printf("\nMatrice originale:\n"); + stampaMatrice(mat, n); + + trasportaMatrice(mat, n); + + printf("\nMatrice Trasposta:\n"); + stampaMatrice(mat, n); + + // Il programma qua finisce, iscriviti e metti la campanella womp womp + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/arrayOccorrenze.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/arrayOccorrenze.txt new file mode 100644 index 0000000..c06467a --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/arrayOccorrenze.txt @@ -0,0 +1,43 @@ +14) Siano dati 2 array 1D di tipo character, A di dimensione N, B di dimensione M, con N5, progettare in +P-like un algoritmo, sotto forma di function logica, (quattro_elementi_uguali_somma_altri (A, +ALPHA, BETA) ) che restituisca TRUE se la somma del primo, terzo, quarto, e penultimo elemento di +tutte le righe pari è uguale alla somma dei restanti elementi della medesima riga, FALSE altrimenti. + +logical function quattro_elementi_uguali_somma_altri (in: A, ALPHA, BETA) + var: i, j, somma4, sommarest: integer + var: A[ALPHA, BETA]: array of integer + var: risultato: logical + + risultato:=TRUE + i:= 2 + while (i<= ALPHA AND risultato=TRUE) do + somma4:= A(i, j) + A(i, 3) + A(i, 4) + A(i, BETA-1) + sommarest:=0 + + for j:= 1 to BETA do + sommarest := sommarest+ A(i, j) + endfor + + sommarest:= sommarest- somma4 + + if (somma4 ≠ sommarest) then + risultato:= FALSE + endif + + i:= i+2 + endwhile + + quattro_elementi_uguali_somma_altri:= risultato +end quattro_elementi_uguali_somma_altri \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/duerigDuecol.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/duerigDuecol.txt new file mode 100644 index 0000000..84dcaa4 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/duerigDuecol.txt @@ -0,0 +1,41 @@ +logical funcion duerig_duecol(M, N, matrice) + var: i, j: integer + begin + (*Controllo per due righe consecutive con elementi uguali*) + for i := 1 to M - 1 do + for j := 1 to N do + if (matrice (i, j) = matrice(i + 1, j)) then + (*Controllo per due righe consecutive con elementi uguali*) + if (j < N AND matrice(i, j) = matrice(i, j + 1) AND matrice (i + 1, j) = matrice(i + 1, j + 1)) then + duerig_duecol := TRUE + return + endif + endif + endfor + endfor + duerig_duecol := FALSE + end +end funcion + +begin programma + var: M, N, i, j: integer + var: a [m,n]: array of integer + var: risultato: logical + + read M + read N + + for i := 1 to M do + for J := 1 to N do + read a(i,j) + endfor + endfor + + risultato := duerig_duecol(m,n,a) + + if (risultato = .TRUE.) then + print "La matrice contiene due righe e due colonne consecutive con elementi uguali." + else + print "La matrice NON contiene due righe e due colonne consecutive con elementi uguali." + endif +end programma \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/rotazioneVettori.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/rotazioneVettori.txt new file mode 100644 index 0000000..bb9981f --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/rotazioneVettori.txt @@ -0,0 +1,37 @@ +15) Una rotazione di vettore x è il vettore che si ottiene spostando ogni componente del vettore un +certo numero di posti verso sinistra, assumendo che il vettore sia circolare. Ad esempio, ruotando +di 3 posti il vettore x=(0;1;2;3;4;5;6;7;8;9) si ottiene i, vettore xrot=(3;4;5;6;7;8;9;0;1;2). Progettare +in P like un algoritmo sottoforma di procedure (procedure rotazione_array) che, dati due array X e +Y, di dimensione n, restituisce in output una variabile rotazione di tipo character che vale ‘s’ se uno +è la rotazione dell’altro, ‘n’ altrimenti. + +procedure rotazione(x, y, n) +var: i, j, k: integer +var: x[n], y[n]: array of integer +var: rotation: character + +begin + rotation := 'n' + i := 1 + j := 1 + k := 1 + + while (j <= n .AND. rotation = 'n') do + if (x(i) != y(j)) then + k := k + 1 + i := k + j := 1 + else + i := i + 1 + j := j + 1 + + if (i > n) then + i := 1 + endif + + if (j > n) then + rotation := 's' + endif + endif + endwhile +endprocedure \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/sommaDiversa.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/sommaDiversa.txt new file mode 100644 index 0000000..70e9858 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Array/sommaDiversa.txt @@ -0,0 +1,32 @@ +Dato un array 2D A di tipo intero,di dimensione ALPHAxBETA, con ALPHA pari, BETA>5, progettare in +P-like un algoritmo, sotto forma di function logica, (quattro_elementi_uguali_somma_altri (A, +ALPHA, BETA) ) che restituisca TRUE se la somma del primo, terzo, quarto, e penultimo elemento di +tutte le righe pari è uguale alla somma dei restanti elementi della medesima riga, FALSE altrimenti. + +logical function sommaDiv(a,alpha,beta) +var: i,j,alpha,beta: integer +var: a[alpha,beta]: array of integer +var: somma4, sommarest: integer + +begin + sommaDiv:=TRUE + i:=2 + + while(i<=alpha AND sommaDiv=TRUE) + somma4:=0 + sommarest:=0 + + for j:=1 to beta + sommarest:=sommarest+a(i,j) + endfor + + somma4:=a(i,1)+a(i,3)+a(i,4)+a(i,beta-1) + sommarest=sommarest-somma4 + if (somma4!=sommarest) + sommadiv:=FALSE + else + i:=i+2 + endif + endfor + endwhile +endfunction \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/campoInfoUguale.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/campoInfoUguale.txt new file mode 100644 index 0000000..481279e --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/campoInfoUguale.txt @@ -0,0 +1,19 @@ +Progettare un algoritmo in P-like, sottoforma di function ricorsiva (function campoinfo_uguale) per +verificare se i valori dei campi info, di tipo intero, degli elementi di una data linked list head, +contengono valori uguali; la function restituisce TRUE se ciò è verificato, FALSE altrimenti. + +logical function uguale(head) +var: head, curr: list_pointer +curr=head.link + +if (head=NULL) + uguale:=TRUE +endif + +if (head!=NULL) + if(head.info = curr.info) + uguale:=uguale(head.link) + else + uguale:=FALSE + endif +endif \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/contaElementiUguale.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/contaElementiUguale.txt new file mode 100644 index 0000000..f80558c --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/contaElementiUguale.txt @@ -0,0 +1,15 @@ +function quanti_elementi(head, numero) +var: numero: integer +var: count: list_pointer + +begin + if head:=NULL then + quanti_elementi := 0 + endif + + if (head.info = numero) then + quanti_elementi := quanti_elementi + count(head.next + numero) + else + count(head.next + numero) + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaLista.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaLista.txt new file mode 100644 index 0000000..d581771 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaLista.txt @@ -0,0 +1,26 @@ +Data una linked list list, con il campo info di tipo integer, progettare in P like un algoritmo +sottoforma di function ricorsiva, function elimina_da_lista(list,elem) che restituisca la lista privata +degli elementi con i campi info uguali a elem + +function elimina(list,ele) +var: ele: integer +var: list,temp: list_pointer + +begin + if(list = NULL) + elimina:=list + endif + + if(list != NULL) + if (list.info = ele) + temp:=list + deallloca list + + list:=temp.link + elimina:=elimina(list,ele) + + else + elimina:=elimina(list.link,ele) + endif + endif +endprogramma \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaTesta.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaTesta.txt new file mode 100644 index 0000000..4193ae7 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/eliminaDaTesta.txt @@ -0,0 +1,46 @@ +Data una linked list head con il campo info di tipo intero progettare un algoritmo ricorsivo in p like +che elimini dalla lista tutti gli elementi che nel campo info contengono il valore dato, ELEM. Si +organizzi in 2 procedure, entrambe ricorsive, una che elimina ELEM dalla testa +del_testa(head,ELEM), una che elimina ELEM dal mezzo della lista del_mezzo(head,ELEM), ed una +terza procedura, delete_elem (head, ELEM) che utilizza le altre due. + +(*Elimina da testa*) +procedure del_testa (in/out: head, ELEM) +var: head: list_pointer +var: ELEM: integer + +if (head!=NULL .AND. head.info=ELEM) then + head:=head.link + del_testa(head,ELEM) +endif +end del_testa + +(* +Elimina dal mezzo, ma poi che cazzo vuol dire? +Tu fai un codice dicendo "Elimina nel mezzo" +A sto punto dici direttamente "Elimina un elemento a cazzo che non sia il primo +O che non sia l'ultimo dio quel porco maledetto +*) +(*Comunque, elimina dal mezzo*) +procedure del_mezzo(in/out: head,ELEM) + var: head: list_pointer + var: ELEM: integer + + if (head!=NULL .AND. head.link!=NULL) then + if(head.link.info=ELEM) then + head.link:=head.link.link + del_mezzo(head, ELEM) + else + del_mezzo(head.link, ELEM) + endif + endfunction +end del_mezzo + +(*Chiamiamolo, "chiamante" che utilizza entrambe*) +procedure delete_elem(in/out: head,ELEM) + var: head: list_pointer + var: ELEM: integer + + del_testa(head,ELEM) + del_mezzo(head,ELEM) +end delete_elem \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/incrementaPuntatoriDoppi.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/incrementaPuntatoriDoppi.txt new file mode 100644 index 0000000..0dbda02 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/incrementaPuntatoriDoppi.txt @@ -0,0 +1,27 @@ +Sia head una linked-list i cui campi info possono essere 0 e 1 in modo che head rappresenti sia un +numero binario. La lista head è implementata con puntatori doppi (ogni elemento punta al +precedente e al successivo). Progettare in P like un algoritmo sottoforma di procedure, procedure +incrementa (head, r) che incrementi di 1 il valore rappresentato da head. La chiamata del main è +del tipo r:=1 /r è il riporto /u, incrementa (head, r). + +procedure incrementa (in/out: head, r) +var: head, newnode: list_pointer +var: r: integer + +begin + +while(head!=NULL .AND. r=1) do + if (head.info=1) then + head.info:=0 + if (head.next!=NULL) then + head:=head.next + else + newnode.info:=1 + newnode.prev:=head + newnode.next:=NULL + head.next:=newnode + r:=0 + endif + endif +endwhile +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/iterativaRicorsiva.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/iterativaRicorsiva.txt new file mode 100644 index 0000000..8d259e8 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/iterativaRicorsiva.txt @@ -0,0 +1,45 @@ +Dato un array A di tipo integer, di dimensione n, un sottoarray di A è formato di elementi contigui di +A, ed il suo peso è la somma dei valori di tali elementi. Se A=(1,2,3,4,5,6,7,8,9), il sottoarray A(2…5) +è uguale a (2,3,4,5) e il suo peso è 14, mentre A[4…7] è uguale a (4,5,6,7) ed il suo peso è 22. +Progettare in p like una function ricorsiva (logical function exist_sottoarray_didatopeso) che, dato +un intero PESO ed un array A di dimensione N, di tipo integer, restituisca TRUE se esiste un +sottoarray di A di peso PESO, FALSE altrimenti. Progettare anche una versione iterativa di tale +funzione. + +(*ricorsiva*) +logical function exist_sottoarray_didatopeso (in A, i, j, N, PESO, somma) + var: A(N): array of integer + var: i, j, somma, PESO: integer + + if (i > N) then + exist_sottoarray_didatopeso := FALSE + else if (somma = PESO) then + exist_sottoarray_didatopeso := TRUE + else if (somma < PESO AND j <= N) then + exist_sottoarray_didatopeso := exist_sottoarray_didatopeso(A, i, j+1, N, PESO, somma + A(j)) + else + exist_sottoarray_didatopeso := exist_sottoarray_didatopeso(A, i+1, i+1, N, PESO, 0) + endif +end exist_sottoarray_didatopeso + +(*iterativa*) +logical function exist_sottoarray_didatopeso_iterativo (in A, N, PESO) + var: i, j, somma: integer + var: A(N): array of integer + + for i := 1 to N do + somma := 0 + j := i + while (j <= N AND somma < PESO) do + somma := somma + A(j) + j := j + 1 + endwhile + + if (somma = PESO) then + exist_sottoarray_didatopeso_iterativo := TRUE + return + endif + endfor + + exist_sottoarray_didatopeso_iterativo := FALSE +end exist_sottoarray_didatopeso_iterativo \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListPrivataRicorsiva.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListPrivataRicorsiva.txt new file mode 100644 index 0000000..7dcbef0 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListPrivataRicorsiva.txt @@ -0,0 +1,26 @@ +(*Data una linked list list, con il campo info di tipo integer, progettare in P like un algoritmo +sottoforma di function ricorsiva, function elimina_da_lista(list,elem) che restituisca la lista privata +degli elementi con i campi info uguali a elem *) + +function elimina_da_lista(list, elem) +var: list, temp: list_pointer +var: elem: integer +begin + if (list = NULL) then + elimina_da_lista := NULL (* Se la lista è vuota, restituiamo NULL *) + endif + + if (list != NULL) then + if (list.info = elem) then + (* Se il nodo corrente contiene 'elem', rimuoviamo il nodo *) + temp := list + dealloca list (* Dealloca la memoria del nodo corrente *) + list := temp.link (* Salta il nodo corrente *) + elimina_da_lista := elimina_da_lista(list, elem) (* Chiamata ricorsiva per rimuovere 'elem' dal resto della lista *) + else + (* Se il nodo corrente non contiene 'elem', manteniamo il nodo *) + list.link := elimina_da_lista(list.link, elem) (* Ricorsione per il nodo successivo *) + elimina_da_lista := list (* Restituisce il nodo corrente che non è stato modificato *) + endif + endif +endfunction diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListSpiegazione.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListSpiegazione.plike new file mode 100644 index 0000000..75cedae --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/linkedListSpiegazione.plike @@ -0,0 +1,59 @@ +(*Questo rimane un codice d'esempio per vedere come funziona una linked list*) + +type Nodo = record + data: integer (* Il dato che il nodo contiene *) + next: ^Nodo (* Puntatore al nodo successivo *) +end record + +function creaNodo(valore: integer): ^Nodo + var: nuovoNodo: ^Nodo + nuovoNodo := allocate Nodo (* Allocazione di memoria per il nodo *) + nuovoNodo.data := valore + nuovoNodo.next := NULL (* Puntatore a NULL, perché è l'ultimo nodo per ora *) + return nuovoNodo +endfunction + +procedure inserisciInTesta(var head: ^Nodo, valore: integer) + var: nuovoNodo: ^Nodo + nuovoNodo := creaNodo(valore) (* Crea un nuovo nodo *) + nuovoNodo.next := head (* Il nuovo nodo punta al vecchio head *) + head := nuovoNodo (* Head ora punta al nuovo nodo *) +endprocedure + +procedure visualizzaLista(head: ^Nodo) + var: corrente: ^Nodo + corrente := head + while (corrente != NULL) do + print corrente.data (* Stampa il dato del nodo corrente *) + corrente := corrente.next (* Spostati al nodo successivo *) + endwhile +endprocedure + + +begin + var: head: ^Nodo + head := NULL (* La lista è vuota inizialmente *) + + (* Inserisci alcuni elementi nella lista *) + inserisciInTesta(head, 10) + inserisciInTesta(head, 20) + inserisciInTesta(head, 30) + + (* Visualizza la lista *) + print "Contenuto della LinkedList:" + visualizzaLista(head) + + (* Ricerca un elemento *) + var: nodoTrovato: ^Nodo + nodoTrovato := cercaElemento(head, 20) + if (nodoTrovato != NULL) then + print "Elemento trovato: ", nodoTrovato.data + else + print "Elemento non trovato" + endif + + (* Rimuovi un elemento *) + rimuoviNodo(head, 20) + print "Lista dopo la rimozione:" + visualizzaLista(head) +end diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/listSorting.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/listSorting.txt new file mode 100644 index 0000000..5e18dc5 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/listSorting.txt @@ -0,0 +1,24 @@ +9) Data una linked list head con il campo info di tipo integer, progettare un algoritmo in p like +sottoforma di procedure (procedure list_sort) che, utilizzando il metodo exchange sort, e che restituisca la +lista head ordinata in senso crescente secondo i valori del campo info. Ad esempio, se head= 3->5->6->4- +>2, l’output sarà head=2->3->4->5->6 + +procedure sort(head,n) +var: i,j,n:integer +var: head,current,temp: list_pointer +sort:=FALSE +curr:=head.link +i:=1 + +while(i<=n .AND. sort=FALSE) + sort:=TRUE + for j:=1 to n-i do + if(head.info > curr.info) + temp:=head.info + head.info:=curr.info + curr.info:=temp + sort:=FALSE + endif + endfor + i:=i+1 +endwhile \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/media_cambiosegno.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/media_cambiosegno.txt new file mode 100644 index 0000000..7583b6c --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/media_cambiosegno.txt @@ -0,0 +1,30 @@ +procedure media_e_cambio_segno(in: a,n; out: media,a) +var: i, j, somma, conteggio: integer + +begin + somma:=0 + conteggio:=0 + + for i:=1 to n do + for j:=1 to n do + if (A[i][i] >= 100) then + somma := somma + a[i,j] + conteggio := conteggio + 1 + endif + endfor + endfor + + if conteggio > 0 then + media := somma+conteggio + else + media := 0 + endif + + for i := 1 to n do + for j := 1 to n do + if(i=1) or (i=N) or (j=1) or (j=n) then + A[i,j] := -A[i,j] + endif + endfor + endfor +end diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/pesoLinkedList.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/pesoLinkedList.txt new file mode 100644 index 0000000..aba9293 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/pesoLinkedList.txt @@ -0,0 +1,47 @@ +Data una lista head=L1->L2->L3->…->Ln->NULL, il suo prefisso i-esimo consiste della sotto lista +head(i)=L1->L2->L3->…->L4n (?) con i<=n. Il prefisso i-esimo di head, vale a dire, è costituito dai suoi primi i +elementi. Il peso di una lista head (con il campo info di tipo integer) è la somma dei valori dei campi info. +Data una lista head con il campo info di tipo integer ed un intero PESO, supponendo che i valori dei campi +info siano tutti positivi, si scriva una function ricorsiva di tipo logical (function esiste_prefisso) per verificare +se esiste un prefisso di head di peso PESO. Progettare in p like anche un algoritmo che richiami la function + + +(*Funzione*) +logical function esiste(head,peso,somma) +var: somma: integer +var: head: list_pointer + +begin + if (head=NULL) + esiste:=FALSE + elseif (head!=NULL) do + somma := somma + head.info + if (sommapeso) then + esiste:=false + endif + endif + return FALSE +end + +(*Chiamante*) +begin + +var: head: list_pointer +var: peso, somma, ele, n, i:integer + head := create_list() + read peso, n + for i := 1 to n do + read(ele) + push(head, ele) + endfor + somma := 0 + if esiste(head, peso, somma) then + print("vero") + else + print("falso") + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/precedenteMaggioreSommaSuccessivi.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/precedenteMaggioreSommaSuccessivi.txt new file mode 100644 index 0000000..7acea67 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/precedenteMaggioreSommaSuccessivi.txt @@ -0,0 +1,54 @@ +Progettare in p like un algoritmo sottoforma di function (logical function +precedente_maggiore_sommasuccessivi) che data una linked list head (con campo info di tipo integer), +restituisca TRUE se ciascun valore dei campi info è maggiore della somma di tutti i valori dei campi info +degli elementi successivi, FALSE altrimenti. Utilizzare una function ricorsiva (function +somma_valori_campinfosuccessivi), pure da progettare, in p like, che, data una linked list, restituisca la +somma dei valori dei campi info (di tipo integer) dei suoi elementi. Progettare anche in p like, un algoritmo +che richiami la function precedente_maggiore_sommasuccessivi + +logical function precedente_maggiore_sommasuccessivi (in: head) +var: head: list_pointer +begin + if (head=NULL OR head.link = NULL) then + precedente_maggiore_sommasuccessivi:= TRUE + else if (head.info <= somma_successivi(head.link)) then + precedente_maggiore_sommasuccessivi:= FALSE + elfe + precedente_maggiore_sommasuccessivi:= precedente_maggiore_sommasuccessivi(head.link) + endif +end + +integer function somma_successivi (in: head) +var: head: list_pointer +var: somma: integer +begin + if (head = NULL) then + somma_successivi:= 0 + else + somma_successivi:= head.info + somma_successivi(head.link) + endif +end + + +(*Chiamante*) +var: head: list_pointer +var: risultato: logical +var: ele, N, i: integer + +begin + head:= create_list(head) + read N + + for i:= 1 to N do + read ele + push(head, ele) + endfor + + risultato:= precedente_maggiore_sommasuccessivi(head) + + if (risultato) then + print 'VERO' + else + print 'FALSO' + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sommaListe.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sommaListe.txt new file mode 100644 index 0000000..d716bc3 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sommaListe.txt @@ -0,0 +1,30 @@ +Date 3 linked list list1,list2,list3, progettare in p like un algoritmo sottoforma di function +ricorsiva(logical function somma_lista(head1,head2,head3) che restituisca TRUE se head3 è la +somma di head1 e head2, elemento per elemento. FALSE altrimenti. Si supponga di avere il numero +di elementi di head3 al massimo numero di elementi tra head1 e head2. + +logical function somma_lista(in: head1, head2, head3) +var: head1, head2, head3: list_pointer + +begin + if (head1=NULL .AND. head2=NULL .AND. head3=NULL) then + if(head3.info = head1.info+head2.info) + somma_lista:=somma_lista(head1.link, head2.link, head3.link) + else + somma_lista:=FALSE + endif + endif + + if (head1!=NULL .AND. head2!=NULL .AND. head3!=NULL) + if(head3.info = head2.info) + somma_lista:=somma_lista(head1,head2.link,head3.link) + else + somma_lista:=FALSE + endif + endif + + if(head1=NULL .AND. head2=NULL .AND. head3=NULL) + somma_lista:=TRUE + endfunction + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sottoSequenza.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sottoSequenza.txt new file mode 100644 index 0000000..b4fff4d --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/sottoSequenza.txt @@ -0,0 +1,18 @@ +logical function sottoSequenza (head1, head2) +var: head1, head2: list_pointer + +begin + if (head2:=NULL) + sottoSequenza:=TRUE + elseif (head1=NULL .AND. head2!=NULL) + sottoSequenza:=FALSE + endif + + if (head1!=null and head2!=NULL) + if(head2.info = head1.info) + sottoSequenza:=sottoSequenza(head1.link, head2.link) + else + sotto:=sotto(head1.link, head2) + endif + endif +endfunction \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/stackMerge.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/stackMerge.txt new file mode 100644 index 0000000..0a300ab --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/LinkedList/stackMerge.txt @@ -0,0 +1,29 @@ +Dati 2 stack head1 e head2 “ordinati”, progettare in P like un algoritmo per la costituzione di uno +stack head3, anch’esso “ordinato”, merge tra head1 e head2. Utilizzare la procedure pop +(head,elem) e push (head,elem). + +procedure merge(in/out: head1,head2,head3) +var: head1,head2,head3: list_pointer +var: ele: integer + +begin + while(head1!=NULL AND head2!=NULL) + if(head1.info <= head2.info) + pop(head1,ele) + push(head3,ele) + elseif (head1.info > head2.info) + pop(head2,ele) + push(head3,ele) + endif + while + + while (head1!=NULL AND head2=NULL) + pop(head1,ele) + push(head3,ele) + endwhile + + while(head2!=NULL AND head1=NULL) + pop(head2,ele) + push(head3,ele) + endwhile +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/CarattereInRiga.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/CarattereInRiga.txt new file mode 100644 index 0000000..96a0277 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/CarattereInRiga.txt @@ -0,0 +1,25 @@ +Sia dato un array A 2D di tipo character di dimensioni NxM.Progettare in P-like un algoritmo +sottoforma di function (logical function carattere_in_riga (A,N,M )) che restituisca in output TRUE se +nessuno dei caratteri presenti in una riga è presente nella riga successiva, FALSE altrimenti + +logical function carattere(a,n,m) +var: i,j,k: integer +var: a[n,m]: array of character +carattere:=TRUE + +i:=1 +j:=1 + +while(i<=n-1 AND carattere=TRUE) + while(j<=m AND carattere=TRUE) + + for k:=1 to m do + if (a(i,j) = a(i+1,k)) + carattere:=FALSE + endif + endfor + + j:=j+1 + endwhile + i:=i+1 +endwhile diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/Coordinate.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/Coordinate.txt new file mode 100644 index 0000000..7883888 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/Coordinate.txt @@ -0,0 +1,26 @@ +Sia dato un array 2D A di dimensioni MxN di tipo integer. Progettare un algoritmo in P-like +sottoforma di procedure (procedure elementi_non_di_bordo) che restituisca in output un array 2D +COORDINATE in cui per ogni riga ci siano le coordinate (i,j) degli elementi non di bordo dell’array A +che hanno come elementi adiacenti (nord, est, sud, ovest ) elementi di valore minore + +procedure bordo(a,m,n,coordinate) +var: i,j,k,m,n: integer +var: a[m,n], coordinate [k,2]: array of integer +var: nord,sud,est,ovest: integer + +k=1 + +for i:=2 to m-1 do + for j:=2 to n-1 do + nord:=a(i-1,j) + sud:=a(i+1,j) + est:=a(i,j+1) + ovest:=a(i,j-1) + + if (a(i,j)>nord AND a(i,j)>sud AND a(i,j)>est AND a(i,j)>ovest) + coordinate(k,1):=i + coordinate(k,2):=j + k:=k+1 + endif + endfor +endfor \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/RisulatatoStudente.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/RisulatatoStudente.txt new file mode 100644 index 0000000..7896fef --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/RisulatatoStudente.txt @@ -0,0 +1,29 @@ +Sia dato un array 2D A di dimensioni MxN, con M pari, A[i,j] rappresenta il risultato dello studente j +ottenuto alla prova i. L’array 1D P (di dimensione M) contiene per ciascuna prova, il punteggio +minimo per il superamento della prova stessa (P(i) è il punteggio minimo per superare la prova i). +Progettare in p like, un algoritmo che restituisca sottoforma di procedure l’array RIS(di dimensione +ovviamente N) che fornisca il punteggio totale ottenuto nelle prove superate se lo studente ha +superato almeno metà della prove, altrimenti restituisca 0. + +procedure risultato(in:a,p,m,n; out:ris) +var: i,j,m,n: integer +var: a[m,n], p[m], ris[n]: array of integer +var: tot, sup: integer + +for j:=1 to n do + tot:=0 + sup:=0 + + for i:=1 to m do + if (a(i,j) >= p(i)) + tot:=tot+a(i,j) + sup:=sup+1 + endif + endfor + + if(sup >= m/2) + ris(j):=tot + else + ris(j):=0 + endif +endfor \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/controlloMatrice.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/controlloMatrice.txt new file mode 100644 index 0000000..22ff4f5 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/controlloMatrice.txt @@ -0,0 +1,56 @@ +32) Data una matrice A di dimensione NxN, di tipo intero, progettare un algoritmo sotto forma di +function (logical function controllo_righe_colonne) che restituisca TRUE se la somma degli elementi +di ogni riga è minore di quella della riga precedente e la somma degli elementi di ogni colonna è +maggiore o uguale della somma della colonna precedente, FALSE altrimenti. + +logical function controllo_righe_colonne(a,n) +var: i,j,k,h,n: integer +var: somma_riga, somma_riga_prec, somma_colonna, somma_colonna_prec: integer + +begin + controllo_righe_colonne:=TRUE + i:=n + + while (i>=1 .AND. controllo_righe_colonne=TRUE) do + somma_riga:=0 + somma_riga_prec:=0 + + for j:=1 to N do + somma_riga:=somma_riga+A(i,j) + endfor + + if i>1 then + for k:=1 to N do + somma_riga_prec:=somma_colonna_prec + A(i-1, k) + endfor + endif + + if (somma_riga>=somma_riga_prec) then + controllo_righe_colonne:=FALSE + endfunction + + i:= i-1 + endwhile + j:=n + + while (j>=1 .AND. controllo_righe_colonne=TRUE) do + somma_colonna:=0 + somma_colonna_prec:=0 + + for i:=1 to n do + somma_colonna:=somma_colonna + A(i,j) + endfor + + if j>1 then + for h:=1 to N do + somma_colonna_prec:=somma_colonna_prec + A(h, j-1) + endfor + endif + + if (somma_colonna < somma_colonna_prec) then + controllo_righe_colonne:=FALSE + endif + + j:=j-1 + endwhile +end function \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/coordinate.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/coordinate.plike new file mode 100644 index 0000000..3630155 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/coordinate.plike @@ -0,0 +1,42 @@ +(*Sia dato un array 2D A di dimensioni MxN di tipo integer. Progettare un algoritmo in P-like +sottoforma di procedure (procedure elementi_non_di_bordo) che restituisca in output un array 2D +COORDINATE in cui per ogni riga ci siano le coordinate (i,j) degli elementi non di bordo dell’array A +che hanno come elementi adiacenti (nord, est, sud, ovest ) elementi di valore minore.*) + + +procedure bordo(a,m,n,coordinate) + (* + Dichiarazione delle variabili: + - `i`: Variabile intera utilizzata come contatore nei cicli. + - `j`: Variabile intera utilizzata come contatore nei cicli. + - `k`: Variabile intera utilizzata come contatore nei cicli. + - `m`: Variabile intera utilizzata per memorizzare un valore specifico. + - `n`: Variabile intera utilizzata per memorizzare un valore specifico. + - `array`: Array di interi utilizzato per memorizzare una serie di valori. + - `k`: Variabile intera utilizzata per memorizzare un valore specifico. + *) + + var: i, j, k, m, n: integer + var: a[m,n]m coordinate[k,2]: array of integer + var: nord,sud,est,ovest: integer + k:=1 + + for i:= 2 to m - 1 do + for j:=2 to n-1 do + (* Meomorizzazione degli elementi adiacenti *) + nord := a(i-1 ,j) + sud := a(i+1,j) + est := a(i, j+1) + ovest := a(i, j-1) + + (* Verifica se l'elemento corrente è maggiore degli elementi adiacenti *) + if (a(i,j) > nord AND a(i,j) > sud AND a(i,j) > est AND a(i,j) > ovest) + (* Memorizza le coordinate dell'elemento non di bordo *) + coordinate(k,1):=i + coordinate(k,2):=j + (* Incrementa l'indice per le coordinate *) + k := k+1 + end if + endfor + endfor +end procedure diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/duerig_duecol.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/duerig_duecol.txt new file mode 100644 index 0000000..82502d4 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/duerig_duecol.txt @@ -0,0 +1,63 @@ +logical function consecutive(a,m,n) +var: i,j,m,n: integer +var: a[m,n]: array of integer +var: flag: logical + +begin + consecutive:=FALSE + i:=1 + + while(i<=m-1 AND consecutive=FALSE) + j:=1 + flag:=FALSE + while(j<=n AND flag=FALSE) + + if(a(i,j) = a(i+1,j)) + if(j=n) + consecutive:=TRUE + endif + j:=j+1 + else + flag:=TRUE + endif + endwhile + i:=i+1 + endwhile + + j:=1 + + if(consecutive=TRUE) + flag:=FALSE + consecutive:=FALSE + while(j<=n-1 AND consecutive=FALSE) + i:=1 + flag:=FALSE + while(i<=m AND flag=FALSE) + if(a(i,j) = a(i,j+1)) + if(i=m) + consecutive:=TRUE + endif + if:=i+1 + flag:=TRUE + endif + endwhile + j:=j+1 + endwhile + endif +endfunction + +begin programma + var: i,j,m,n: integer + var: a[m,n]: array of integer + var: consecutive(a,m,n): logical + + function read m,N + for i:=1 to m + for j:=1 to N + read a(i,j) + endfor + endfor + + consecutive(a,m,n) + print consecutive +end programma \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/ipod.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/ipod.plike new file mode 100644 index 0000000..5906f43 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/ipod.plike @@ -0,0 +1,34 @@ +(*Siano dati due array 2D, Ipod_negozio, di dimensioni Kx2 , e ipod_deposito , di dimensioni Yx2, +entrambi di tipo intero. In questi array sono memorizzati, per ciascuna riga, nella colonna 1 il codice +di un ipod, e nella colonna 2 quanti ipod di quel tipo sono presenti, rispettivamente, in negozio ed +in deposito. Le righe di entrambi gli array sono ordinate per codice del ipod. Progettare in P_like un +algoritmo, sotto forma di procedure (procedure Quantita_ipod), che fornisca come risultato un +array 2D Totale_ipod che, sempre rispettando l'ordine secondo il codice-ipod, nella colonna 2 +indichi quanti ipod, per ciascun tipo, sono disponibili in totale (tra negozio e deposito).*) + +procedure Quantita_ipod(input: K,Y, Ipod_negozio, ipod_deposito, Totale_ipod) +var: i,j,x: integer +begin + i:=1 + j:=1 + x:=1 + + while (i<=K, .OR. j<=y) do + if (i<=K .AND. j<=Y .AND. Ipod_negozio(i,1) = ipod_deposito(j,1)) then + Totale_ipod(x,1) := Ipod_negozio(i,1) + Totale_ipod(x,2) := Ipod_negozio(i,2) + ipod_deposito(j,2) + i:=i+1 + j:=j+1 + elseif (i <= K .AND. (j > Y .OR. Ipod_negozio(i,1)< ipod_deposito(j,1))) then + Totale_ipod(x,1) = Ipod_negozio(i,1) + Totale_ipod(x,2) = Ipod_negozio(i,2) + i:=i+1 + elseif (j <= Y .AND. (i > K .OR. Ipod_deposito(j, 1) < Ipod_negozio(i, 1))) then + (* Il codice è presente solo in deposito *) + Totale_ipod(x, 1) := Ipod_deposito(j, 1) + Totale_ipod(x, 2) := Ipod_deposito(j, 2) + j := j + 1 + endif + x:=x+1 + endwhile +endprocedure \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/matriceDiagonale.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/matriceDiagonale.txt new file mode 100644 index 0000000..6c0f29b --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/matriceDiagonale.txt @@ -0,0 +1,40 @@ +13) Sia A una matrice di dimensione nxn, contenente numeri interi. Sviluppare in P-like un algoritmo +ricorsivo, sottoforma di function di tipo logical (function diagonale (A,riga)), con A array 2D di tipo +integer, di dimensioni nxn, implementazione della matrice A, che restituisca TRUE se tutti gli +elementi della diagonale principale sono nulli, FALSE altrimenti. La chiamata main è del tipo: +matrice_diagonale:= diagonale (A,n) + +logical function diagonale (in: A, riga, N) + var: riga, N: integer + var: A(N, N): array of integer + + if (riga = 0) then + diagonale:=TRUE + elseif (A(riga, riga) != 0) then + diagonale:= FALSE + else + diagonale:= diagonale(A, riga - 1, N) + endif +end diagonale + +(*Chiamante*) +var: A(N, N): array of integer +var: N, i, j: integer +var: risultato: logical + +begin + read N + for i:= 1 to N do + for j:= 1 to N do + read A(i, j) + endfor + endfor + + risultato:= diagonale(A, N, N) + + if (risultato) then + print 'VERO' + else + print 'FALSO' + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/occorrenze.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/occorrenze.txt new file mode 100644 index 0000000..c3bffe9 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/occorrenze.txt @@ -0,0 +1,51 @@ +Siano dati 2 array 1D di tipo character, A di dimensione N,B di dimensione M, con N= P(i)) then + studentiPassati := studentiPassati + 1 + RIS(j) := RIS(j) + a(i, j) + endif + endfor + + if (studentiPassati >= M/2) then + RIS(j) := 0 + endif + endfor + +end procedure \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/sommaOpposti.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/sommaOpposti.txt new file mode 100644 index 0000000..54b4557 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Matrici/sommaOpposti.txt @@ -0,0 +1,38 @@ +Sia dato un array 2D A di tipo integer, di dimensioni HxK. Progettare in P-like un algoritmo sotto +forma di function di tipo logical (function sommaRIGA_uguale_elemento) che restituisca TRUE se la +somma degli opposti degli elementi di una riga è uguale ad uno degli elementi della riga successiva, +FALSE altrimenti. + +logical function sommariga(a,h,k) +var: i,j,s,h,k: integer +ar: a[h,k]: array of integer +var: somma: integer +var: flag: logical + +begin + +sommariga:=TRUE +i:=1 + +while (i<=h-1 AND sommariga=TRUE) + somma:=0 + for j:=1 to k + somma:=somma+(a(i,j)) + endfor + + flag:=FALSE + s:=1 + + while(s<=k AND flag=FALSE) + if(somma = a(i+1,s)) + flag:=TRUE + endif + s:=s+1 + endwhile + + if(flag=FALSE) + sommariga:=FALSE + endif + + i:=i+1 +endwhile \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/contaElementiSuccessione.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/contaElementiSuccessione.txt new file mode 100644 index 0000000..793c411 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/contaElementiSuccessione.txt @@ -0,0 +1,32 @@ +Si consideri la successione: a1:=0 a2:=1 a2:=1 a3:=2, anew:=a1+2*a2+a3 per n>3. Progettare in p +like un algoritmo sottoforma di function di tipo intero function +conta_elementi_successione_data(K) che, dato un intero, K>1, restituisca il numero degli elementi +della successione <=K, escludendo i multipli di 3 e di 7. Si supponga di avere a disposizione 2 +functions di tipo logico, is_multiple_of_3(num) e is_multiple_of_7(num), che restituiscono TRUE se +num è multiplo di 3 o di 7, rispettivamente. + +integer function conta_elementi_successione_data(k) +var: a1,a2,a3,aNew,k: integer + +begin + a1:=0 + a2:=1 + a3:=2 + aNew:=a1+2*a2+a3 + conta_elementi_successione_data:=1 + + while (aNew<=k) + if(!m3(aNew) .AND. !m7(aNew)) + conta_elementi_successione_data:=conta_elementi_successione_data+1 + a1:=a2 + a2:=a3 + a3:=aNew + aNew:=a1+2*a2+a3 + else + a1:=a2 + a2:=a3 + a3:=aNew + aNew:=a1+2*a2+a3 + endif + endwhile +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/controlloSuccessioneNumeri.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/controlloSuccessioneNumeri.txt new file mode 100644 index 0000000..2f222f7 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/controlloSuccessioneNumeri.txt @@ -0,0 +1,52 @@ +Si consideri la successione a1=0,a2=1,a3=2, anew=a1+2*a2+a3 con n>3. Progettare in p like, +sottoforma di function (logical function controllo_numeri_successione (N1,N2,N3)) che, dati 3 +numeri interi N1a3, restituisca TRUE se il numero di elementi della successione +compresi tra N1 e N2 (cioè N1<=a3<=N2) è uguale al numero di elementi maggiori di N2 e minori o +uguali di N3, FALSE altrimenti. Progettare anche un chiamante + +(* Funzione *) +logical function controllo(n1, n2, n3) + var: a1, a2, a3, aNew, cont1, cont2: integer +begin + (* Inizializzazione della successione *) + a1 := 0 + a2 := 1 + a3 := 2 + aNew := a1 + 2 * a2 + a3 + + cont1 := 0 + cont2 := 0 + controllo := FALSE + + (* Conteggio dei termini tra n1 e n2 *) + while aNew <= n3 do + if aNew >= n1 .AND. aNew <= n2 then + cont1 := cont1 + 1 + elseif aNew > n2 then + cont2 := cont2 + 1 + endif + + (* Aggiornamento successione *) + a1 := a2 + a2 := a3 + a3 := aNew + aNew := a1 + 2 * a2 + a3 + endwhile + + (* Confronto dei conteggi *) + if cont1 = cont2 then + controllo := TRUE + endif +end + + +(* Chiamante *) +var: n1, n2, n3: integer +begin + read n1, n2, n3 + if controllo(n1, n2, n3) then + print "vero" + else + print "falso" + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/differenzaElementoSuccessione.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/differenzaElementoSuccessione.txt new file mode 100644 index 0000000..c3a59f0 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/differenzaElementoSuccessione.txt @@ -0,0 +1,63 @@ +24) Sia data la successione: a1:=0 a2:=1 a3:=2, anew:=a1+2*+a3 per n>3. Progettare in P-like un +algoritmo sottoforma di procedure (procedure diff_elem_successione) che, dati 2 interi N1 e N2, +con N1a3, restituisca in output l’intero (N1 o N2) che ha una minore differenza rispetto +ad un elemento della successione, ed il valore di tale differenza. Progettare in P-like anche un +esempio di algoritmo che utilizza la procedura. + +procedure diff_elem_successione(N1, N2, min_num, min_diff) + var: a1, a2, a3, an, diff1, diff2: integer + +begin + (* Inizializzazione della successione *) + a1 := 0 + a2 := 1 + a3 := 2 + an := a1 + 2 * a2 + a3 + + (* Generazione della successione fino a superare N1 *) + while an < N1 do + a1 := a2 + a2 := a3 + a3 := an + an := a1 + 2 * a2 + a3 + endwhile + + (* Calcolo della differenza minima per N1 *) + diff1 := abs(N1 - an) + if abs(N1 - a3) < diff1 then + diff1 := abs(N1 - a3) + endif + + (* Generazione della successione fino a superare N2 *) + while an < N2 do + a1 := a2 + a2 := a3 + a3 := an + an := a1 + 2 * a2 + a3 + endwhile + + (* Calcolo della differenza minima per N2 *) + diff2 := abs(N2 - an) + if abs(N2 - a3) < diff2 then + diff2 := abs(N2 - a3) + endif + + (* Determinazione del numero con la differenza minore *) + if diff1 < diff2 then + min_num := N1 + min_diff := diff1 + else + min_num := N2 + min_diff := diff2 + endif +end + +(* Chiamante *) + var: N1, N2, min_num, min_diff: integer + begin + print "Inserisci due numeri (N1 < N2 e N1 > 2):" + read N1, N2 + diff_elem_successione(N1, N2, min_num, min_diff) + print "Numero con la minore differenza:", min_num + print "Valore della differenza:", min_diff + end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/elementoSuccessioneUgualeSomma.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/elementoSuccessioneUgualeSomma.txt new file mode 100644 index 0000000..f17f6e4 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/elementoSuccessioneUgualeSomma.txt @@ -0,0 +1,74 @@ +Si considerino le 2 successioni: +a1=1; a2=3; a4=4 e per n>3 aNew = a n-1, =2a n-1+a n-3 +b1-2; b2=3; b3=4 e oer n>3 aN = b n-1 * b n-2 + 2 * b n-3 + +Progettare un algoritmo in P-Like sotto forma di function "Function elemento_successione_uguale_somma che dato un intero N pari restituisca TRUE se la somma dei primi N elementi di posto pari della prima successione e' un elemento della seconda successione, FALSE altrimenti. +Progettare in P-Like anche se possibile un chiamante per questa function + +logical function elemento_successione_uguale_somma(N) +var: i, somma_elementi_pari, a1, a2, a3, aNew, b1, b2, b3, bNew: integer +begin + (* Inizializzazione delle successioni *) + a1 := 1 + a2 := 3 + a3 := 4 + b1 := 2 + b2 := 3 + b3 := 4 + + (* Calcolo della somma dei primi N elementi di posto pari della prima successione *) + somma_elementi_pari := 0 + for i := 2 to N step 2 do + if (i = 2) then + somma_elementi_pari := somma_elementi_pari + a2 + elseif (i = 4) then + somma_elementi_pari := somma_elementi_pari + a3 + else + aNew := 2 * a2 + a1 + somma_elementi_pari := somma_elementi_pari + aNew + a1 := a2 + a2 := a3 + a3 := aNew + endif + endfor + + (* Verifica se la somma è un elemento della seconda successione *) + if (somma_elementi_pari = b1 .OR. somma_elementi_pari = b2 .OR. somma_elementi_pari = b3) then + return TRUE + endif + + while (bNew < somma_elementi_pari) do + bNew := b2 * b1 + 2 * b3 + if (somma_elementi_pari = bNew) then + return TRUE + endif + b1 := b2 + b2 := b3 + b3 := bNew + endwhile + + return FALSE +endfunction + +(*chamante*) + +var: N: integer +var: risultato: logical +begin + (* Inserisci il valore di N *) + read(N) + + (* Verifica se N è pari *) + if (N MOD 2 != 0) then + print("N deve essere un numero pari.") + return + endif + + (* Chiama la funzione e stampa il risultato *) + risultato := elemento_successione_uguale_somma(N) + if (risultato = TRUE) then + print("La somma dei primi ", N, " elementi di posto pari della prima successione è un elemento della seconda successione.") + else + print("La somma dei primi ", N, " elementi di posto pari della prima successione NON è un elemento della seconda successione.") + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/sommaUgualeElementi.txt b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/sommaUgualeElementi.txt new file mode 100644 index 0000000..e99c353 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Laccettino ESAME/Successioni/sommaUgualeElementi.txt @@ -0,0 +1,30 @@ +procedure sommaUguale (input: k, num; output: somma, valore, posizione) + +var: a1,a2,a3,aNew: integer +var: pos, k, num, valore: integer +var: somma: logical + +a1:=0 +a2:=1 +a3:=2 + +begin + aNew:=a1+2*a2+a3 + pos:=4 + while (aNew + +struct Complex { + double real; + double imag; +}; + +struct Complex add(struct Complex c1, struct Complex c2) { + struct Complex result; + result.real = c1.real + c2.real; + result.imag = c1.imag + c2.imag; + return result; +} + +struct Complex subtract(struct Complex c1, struct Complex c2) { + struct Complex result; + result.real = c1.real - c2.real; + result.imag = c1.imag - c2.imag; + return result; +} + +struct Complex multiply(struct Complex c1, struct Complex c2) { + struct Complex result; + result.real = c1.real * c2.real - c1.imag * c2.imag; + result.imag = c1.real * c2.imag + c1.imag * c2.real; + return result; +} + +struct Complex divide(struct Complex c1, struct Complex c2) { + struct Complex result; + double denominator = c2.real * c2.real + c2.imag * c2.imag; + if (denominator == 0) { + printf("Errore: divisione per zero\n"); + result.real = 0; + result.imag = 0; + } else { + result.real = (c1.real * c2.real + c1.imag * c2.imag) / denominator; + result.imag = (c1.imag * c2.real - c1.real * c2.imag) / denominator; + } + return result; +} + +void printComplex(struct Complex c) { + if (c.imag >= 0) { + printf("%.2f + %.2fi\n", c.real, c.imag); + } else { + printf("%.2f - %.2fi\n", c.real, -c.imag); + } +} + +int main() { + struct Complex c1, c2, result; + + // Input dell'utente + printf("Inserisci la parte reale e immaginaria di c1: "); + scanf("%lf %lf", &c1.real, &c1.imag); + + printf("Inserisci la parte reale e immaginaria di c2: "); + scanf("%lf %lf", &c2.real, &c2.imag); + + // Somma + result = add(c1, c2); + printf("Somma: "); + printComplex(result); + + // Sottrazione + result = subtract(c1, c2); + printf("Differenza: "); + printComplex(result); + + // Moltiplicazione + result = multiply(c1, c2); + printf("Prodotto: "); + printComplex(result); + + // Divisione + result = divide(c1, c2); + printf("Quoziente: "); + printComplex(result); + + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.c b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.c new file mode 100644 index 0000000..246a189 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.c @@ -0,0 +1,55 @@ +#include + +// Funzione per l'ordinamento con insertion sort +void insertionSort(int arr[], int n) { + for (int i = 1; i < n; i++) { + int key = arr[i]; // Elemento corrente da posizionare + int j = i - 1; + + // Sposta gli elementi maggiori di key verso destra + while (j >= 0 && arr[j] > key) { + arr[j + 1] = arr[j]; + j--; + } + + // Inserisce key nella posizione corretta + arr[j + 1] = key; + } +} + +// Funzione per stampare l'array +void printArray(int arr[], int n) { + for (int i = 0; i < n; i++) { + printf("%d ", arr[i]); + } + printf("\n"); +} + +int main() { + int n; + + // Input dimensione dell'array + printf("Inserisci il numero di elementi dell'array: "); + scanf("%d", &n); + + int arr[n]; + + // Input elementi dell'array + printf("Inserisci %d elementi:\n", n); + for (int i = 0; i < n; i++) { + scanf("%d", &arr[i]); + } + + // Stampa array originale + printf("Array originale: "); + printArray(arr, n); + + // Ordinamento con insertion sort + insertionSort(arr, n); + + // Stampa array ordinato + printf("Array ordinato: "); + printArray(arr, n); + + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.plike new file mode 100644 index 0000000..85025cb --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/insertion.plike @@ -0,0 +1,34 @@ +(* Programma che ordina un array con Insertion Sort *) + +begin insertionSort + var: N, i, j, key: integer + var: A[1..100]: array of integer + + (* Lettura della dimensione dell'array *) + print "Inserisci la dimensione dell'array:" + read N + + (* Lettura degli elementi dell'array *) + print "Inserisci gli elementi dell'array:" + for i := 1 to N do + read A(i) + endfor + + (* Algoritmo di Insertion Sort *) + for i := 2 to N do + key := A(i) (* Elemento da posizionare *) + j := i - 1 + while (j > 0 AND A(j) > key) do + A(j + 1) := A(j) (* Sposta l'elemento verso destra *) + j := j - 1 + endwhile + A(j + 1) := key (* Inserisce l'elemento nella posizione corretta *) + endfor + + (* Stampa dell'array ordinato *) + print "Array ordinato:" + for i := 1 to N do + print A(i) + endfor + +end insertionSort \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.c b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.c new file mode 100644 index 0000000..c2f10cd --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.c @@ -0,0 +1,77 @@ +#include +#include + +// Definizione del nodo della linked list +struct Node { + int data; + struct Node* next; +}; + +// Funzioni di supporto +struct Node* createNode(int data) { + struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); + newNode->data = data; + newNode->next = NULL; + return newNode; +} + +void printList(struct Node* head) { + struct Node* current = head; + while (current != NULL) { + printf("%d -> ", current->data); + current = current->next; + } + printf("NULL\n"); +} + +// Inserimento iterativo +void insertSortedIterative(struct Node** head, int data) { + struct Node* newNode = createNode(data); + + if (*head == NULL || (*head)->data >= data) { + newNode->next = *head; + *head = newNode; + return; + } + + struct Node* current = *head; + while (current->next != NULL && current->next->data < data) { + current = current->next; + } + + newNode->next = current->next; + current->next = newNode; +} + +// Inserimento ricorsivo +struct Node* insertSortedRecursive(struct Node* head, int data) { + if (head == NULL || head->data >= data) { + struct Node* newNode = createNode(data); + newNode->next = head; + return newNode; + } + + head->next = insertSortedRecursive(head->next, data); + return head; +} + +int main() { + struct Node* head = NULL; + + // Test con la versione iterativa + printf("Inserimento iterativo:\n"); + insertSortedIterative(&head, 10); + insertSortedIterative(&head, 5); + insertSortedIterative(&head, 20); + insertSortedIterative(&head, 15); + printList(head); + + // Test con la versione ricorsiva + printf("Inserimento ricorsivo:\n"); + head = insertSortedRecursive(head, 12); + head = insertSortedRecursive(head, 1); + head = insertSortedRecursive(head, 25); + printList(head); + + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.plike new file mode 100644 index 0000000..b17807e --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/list.plike @@ -0,0 +1,74 @@ +(* Linked-List Ordinata Iterativa *) +procedure linkedListIterativa + var: head, newnode, curr, prev: list_pointer + + (* Creazione del nuovo nodo *) + newnode := create_node() + newnode.info := valore + newnode.link := NULL + + (* Caso 1: Inserimento in testa o lista vuota *) + if (head = NULL OR valore <= head.info) then + newnode.link := head + head := newnode + else + (* Caso 2: Scorrimento della lista per trovare la posizione corretta *) + prev := NULL + curr := head + while (curr != NULL AND curr.info < valore) do + prev := curr + curr := curr.link + endwhile + + (* Inserimento del nuovo nodo tra prev e curr *) + newnode.link := curr + prev.link := newnode + endif +end procedure + +(* Linked-List Ordinata Ricorsiva*) +procedure linkedlistRicorsiva + var: head, newnode: list_pointer + + (* Caso base: Inserimento in testa o lista vuota *) + if (head = NULL OR valore <= head.info) then + newnode := create_node() + newnode.info := valore + newnode.link := head + head := newnode + else + (* Caso ricorsivo: Passa al nodo successivo *) + inserimento_ordinato_ricorsivo(valore, head.link) + endif +end procedure + +(* Programma per usare entrambe le liste: *) +begin linkedList + var: head, newnode: list_pointer + var: N, i, valore: integer + + (* Creazione della lista inizialmente vuota *) + head := NULL + + print "Inserisci il numero di elementi da aggiungere nella lista ordinata:" + read N + + (* Inserimento di N elementi *) + for i := 1 to N do + print "Inserisci il valore dell'elemento", i, ":" + read valore + + (* Usa una delle due versioni: iterativa o ricorsiva *) + inserimento_ordinato_iterativo(valore, head) + (* oppure: inserimento_ordinato_ricorsivo(valore, head) *) + endfor + + (* Stampa degli elementi della lista *) + print "Elementi della lista ordinata:" + var: temp: list_pointer + temp := head + while (temp != NULL) do + print temp.info + temp := temp.link + endwhile +end linkedList \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.c b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.c new file mode 100644 index 0000000..a60aa7f --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.c @@ -0,0 +1,70 @@ +#include + +// Funzione di partizione +int partition(int arr[], int low, int high) { + int pivot = arr[low]; // Scegliamo il primo elemento come pivot + int left = low + 1; // Puntatore a sinistra + int right = high; // Puntatore a destra + + while (1) { + // Trova un elemento a sinistra che deve essere scambiato + while (left <= right && arr[left] <= pivot) { + left++; + } + + // Trova un elemento a destra che deve essere scambiato + while (left <= right && arr[right] > pivot) { + right--; + } + + // Se i puntatori si incontrano, interrompi + if (left > right) { + break; + } + + // Scambia gli elementi fuori posto + int temp = arr[left]; + arr[left] = arr[right]; + arr[right] = temp; + } + + // Posiziona il pivot nella posizione corretta + arr[low] = arr[right]; + arr[right] = pivot; + + // Restituisce l'indice della posizione del pivot + return right; +} + +// Funzione per stampare l'array +void printArray(int arr[], int n) { + for (int i = 0; i < n; i++) { + printf("%d ", arr[i]); + } + printf("\n"); +} + +int main() { + int n; + + // Input dimensione dell'array + printf("Inserisci il numero di elementi dell'array: "); + scanf("%d", &n); + + int arr[n]; + + // Input elementi dell'array + printf("Inserisci %d elementi:\n", n); + for (int i = 0; i < n; i++) { + scanf("%d", &arr[i]); + } + + // Esegui la partizione + int pivotIndex = partition(arr, 0, n - 1); + + // Stampa i risultati + printf("Array dopo la partizione (pivot in posizione %d):\n", pivotIndex); + printArray(arr, n); + + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.plike new file mode 100644 index 0000000..de9f7d8 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/partition.plike @@ -0,0 +1,48 @@ +begin partition + + var: N, i, j, pivot, temp: integer + var: A[1..100]: array of integer + + (* Lettura della dimensione dell'array *) + print "Inserisci la dimensione dell'array:" + read N + + (* Lettura degli elementi dell'array *) + print "Inserisci gli elementi dell'array:" + for i := 1 to N do + read A(i) + endfor + + (* Lettura del pivot *) + print "Inserisci il valore del pivot:" + read pivot + + (* Inizializzazione degli indici di partizione *) + i := 1 + j := N + + (* Algoritmo di partizione *) + while (i <= j) do + while (A(i) <= pivot AND i <= N) do + i := i + 1 + endwhile + + while (A(j) > pivot AND j >= 1) do + j := j - 1 + endwhile + + if (i < j) then + (* Scambio degli elementi *) + temp := A(i) + A(i) := A(j) + A(j) := temp + endif + endwhile + + (* Stampa del risultato della partizione *) + print "Array dopo la partizione:" + for i := 1 to N do + print A(i) + endfor + +end partition \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.c b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.c new file mode 100644 index 0000000..73d7c58 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.c @@ -0,0 +1,75 @@ +#include +#include + +// Struttura per rappresentare un nodo dello stack +struct Node { + int info; + struct Node* next; +}; + +// Funzione per creare un nuovo nodo +struct Node* createNode(int info) { + struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); + newNode->info = info; + newNode->next = NULL; + return newNode; +} + +// Funzione per aggiungere un elemento allo stack (push) +void push(struct Node** top, int info) { + struct Node* newNode = createNode(info); + newNode->next = *top; + *top = newNode; + printf("%d è stato aggiunto allo stack.\n", info); +} + +// Funzione per rimuovere un elemento dallo stack (pop) +int pop(struct Node** top) { + if (*top == NULL) { + printf("Lo stack è vuoto, impossibile eseguire il pop.\n"); + return -1; // Valore indicativo + } + + struct Node* temp = *top; + int poppedValue = temp->info; + *top = temp->next; + free(temp); + printf("%d è stato rimosso dallo stack.\n", poppedValue); + return poppedValue; +} + +// Funzione per visualizzare i campi info dello stack +void displayStack(struct Node* top) { + if (top == NULL) { + printf("Lo stack è vuoto.\n"); + return; + } + + printf("Contenuto dello stack:\n"); + struct Node* current = top; + while (current != NULL) { + printf("%d -> ", current->info); + current = current->next; + } + printf("NULL\n"); +} + +int main() { + struct Node* stack = NULL; + + // Operazioni di esempio + push(&stack, 10); + push(&stack, 20); + push(&stack, 30); + + // Visualizzazione dello stack + displayStack(stack); + + // Rimozione di un elemento + pop(&stack); + + // Visualizzazione dello stack dopo il pop + displayStack(stack); + + return 0; +} \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.plike new file mode 100644 index 0000000..32e98f9 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Esercizi PreEsame/stack.plike @@ -0,0 +1,45 @@ +procedure visualizzaStack + + var: head, temp: list_pointer + + (* Inizializzazione del puntatore temporaneo *) + temp := head + + (* Controllo se lo stack è vuoto *) + if (temp = NULL) then + print "Lo stack è vuoto." + else + print "I campi info dello stack sono:" + (* Scorrimento dello stack e stampa dei campi info *) + while (temp != NULL) do + print temp.info + temp := temp.link + endwhile + endif +end procedure + +(* Programma per visualizzare lo stack *) +begin stack + + var: head, newnode: list_pointer + var: N, i, value: integer + + (* Creazione dello stack mediante input *) + head := NULL + print "Inserisci il numero di elementi nello stack:" + read N + + for i := 1 to N do + (* Creazione di un nuovo nodo *) + newnode := create_node() + print "Inserisci il valore per l'elemento", i, ":" + read value + newnode.info := value + newnode.link := head (* Inserimento in testa *) + head := newnode + endfor + + (* Visualizzazione dei campi info dello stack *) + visualizza_stack(head) + +end stack \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/calcoloSomma.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/calcoloSomma.plike new file mode 100644 index 0000000..7d96790 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/calcoloSomma.plike @@ -0,0 +1,10 @@ +function somma_lista(list: list_pointer): integer +begin + if (list = NULL) then + somma_lista := 0 + else + somma_lista := list.info + somma_lista(list.link) + endif +end function + + \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/eliminaPari.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/eliminaPari.plike new file mode 100644 index 0000000..aae999f --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/eliminaPari.plike @@ -0,0 +1,13 @@ +function elimina_pari(list): list +begin + if (list = null) then + return null + endif + + if (list.value MOD 2 = 0) then + return elimina_pari(list.next) + else + list.next = elimina_pari(list.next) + return list + endif +endfunction \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/invertiLista.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/invertiLista.plike new file mode 100644 index 0000000..c89c427 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/invertiLista.plike @@ -0,0 +1,14 @@ +function inverti_lista(list): list_pointer +begin + if(list = null OR list.next = null) then + return list + endif + + var: listaInvertita: list_pointer + listaInvertita = inverti_lista(list.next) + + list.next.next = list + list.next = null + + return listaInvertita +endfunction \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/listaPeso.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/listaPeso.plike new file mode 100644 index 0000000..0d42b64 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/listaPeso.plike @@ -0,0 +1,57 @@ +(*Data una lista head=L1->L2->L3->…->Ln->NULL, il suo prefisso i-esimo consiste della sotto lista +head(i)=L1->L2->L3->…->Ln con i<=n. Il prefisso i-esimo di head, è costituito dai suoi primi i +elementi. Il peso di una lista head (con il campo info di tipo integer) è la somma dei valori dei campi info. +Data una lista head con il campo info di tipo integer ed un intero PESO, supponendo che i valori dei campi +info siano tutti positivi, si scriva una function ricorsiva di tipo logical (function esiste_prefisso) per verificare +se esiste un prefisso di head di peso PESO. Progettare in p like anche un algoritmo che richiami la function.*) + + +function esiste_prefisso(input: head: list_pointer, peso: integer): logical +begin + if (head = NULL) then + esiste_prefisso:=.FALSE. + elseif (peso = 0) then + esiste_prefisso := .TRUE. + elseif (peso < 0) then + esiste_prefisso := .FALSE. + else + esiste_prefisso := esiste_prefisso(head.link, peso - head.info) + endif +endfunction + +begin +var: peso, valore, N, i: integer +var: head, newnode, nodocorrente: list_pointer + + repeat + read peso + until (peso >= 0) + + read N + read valore + + "alloca head" + head := NULL + "alloca newnode" + newnode.info := valore + newnode.link := head + head := newnode + nodocorrente:=head + + for i := 2 to N do + repeat + read valore + "alloca newnode" + newnode.info:=valore + newnode.link := nodocorrente.link + nodocorrente.link := newnode + nodocorrente:=nodocorrente.link + until (valore >=0) + endfor + + if (esiste_prefisso(head,peso)) then + print "Esiste un prefisso con somma uguale al peso" + else + print "Non esiste alcun prefisso con somma uguale al peso" + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/occorrenzeLista.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/occorrenzeLista.plike new file mode 100644 index 0000000..b905492 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/LinkedList/occorrenzeLista.plike @@ -0,0 +1,12 @@ +function conta_occorrenze(list, val):integer +begin + if (list = NULL) then + conta_occorrenze := 0 + else + if (list = val) then + conta_occorrenze = 1 + conta_occorrenze(list.link) + endif + else + conta_occorrenze := conta_occorrenze(list.link) + endif +endfunction \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/coordinate b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/coordinate new file mode 100644 index 0000000..1b874e7 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/coordinate @@ -0,0 +1,28 @@ +(*Sia dato un array 2D A di dimensioni NxM di tipo integer. Progettare un algoritmo in P-like sottoforma +di procedure (procedure elementi_non_di_bordo) che restituisca in output un array 2D COORDINATE in +cui per ogni riga ci siano le coordinate (i,J) degli elementi non di bordo dell’array A che hanno +come elementi adiacenti (nord, est, sud, ovest) elementi di valore minore. *) + +procedure elementi_non_di_bordo(input: N,M,A; output: coordinate) +var: N, M, I, J, x, nord, sud, ovest, est: integer +var: a: array of integer +begin + I:=1 + J:=1 + x:=1 + + for I=2 to n-1 do + for J=2 to M-1 do + nord:= a(I-1,J) + sud:= a(I+1,J) + est:= a(I,J+1) + ovest:= a(I,J-1) + + if a(I,J) > nord .AND. a(I,J) > sud .AND. A(I,J) > est .AND. a(I,J) > ovest then + coordinate(x,1) := I + coordinate(x,2) := J + x:=x+1 + endif + endfor + endfor +end elementi_non_di_bordo \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/matriciDuexDue b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/matriciDuexDue new file mode 100644 index 0000000..b92dfb3 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/matriciDuexDue @@ -0,0 +1,45 @@ +(*Sia dato un array 2D di tipo integer, di dimensioni MxN, progettare in p like un algoritmo sottoforma +di function di tipo logical (function duerig_duecol) che restituisca TRUE se vi sono due righe e due +colonne consecutive di elementi uguali tra loro, FALSE altrimenti. Progetta in p like anche un +esempio di algoritmo che utilizza la function.*) + +logical function duerig_duecol(M, N, matrice) + var: i, j: integer + begin + (*Controllo per due righe consecutive con elementi uguali*) + for i := 1 to M - 1 do + for j := 1 to N do + if (matrice (i, j) = matrice(i + 1, j)) then + (*Controllo per due righe consecutive con elementi uguali*) + if (j < N AND matrice(i, j) = matrice(i, j + 1) AND matrice (i + 1, j) = matrice(i + 1, j + 1)) then + duerig_duecol := TRUE + return + endif + endif + endfor + endfor + duerig_duecol := FALSE + end +end funcion +begin + var: M, N, i, j: integer + var: a [m,n]: array of integer + var: risultato: logical + + read M + read N + + for i := 1 to M do + for J := 1 to N do + read a(i,j) + endfor + endfor + + risultato := duerig_duecol(m,n,a) + + if risultato = TRUE then + print "La matrice contiene due righe e due colonne consecutive con elementi uguali." + else + print "La matrice NON contiene due righe e due colonne consecutive con elementi uguali." + endif +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/sommaMatrici b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/sommaMatrici new file mode 100644 index 0000000..088a495 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/Matrici/sommaMatrici @@ -0,0 +1,12 @@ +function sommaMatrici(A, B, M, N): matrice +var: i, j: integer +var: C[M,N] array of integer + +begin + for i := 1 to M do + for j := 1 to N do + C(i,j) := A(i,j) + B(i,j) + endfor + endfor + return C +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/fattoriale.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/fattoriale.plike new file mode 100644 index 0000000..8609514 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/fattoriale.plike @@ -0,0 +1,12 @@ +begin fattorialeNumero + var: numero, fattoriale: integer + + read numero + fattoriale := 1 + + for i := 1 to numero do + fattoriale := fattoriale + i + endfor + + print "Il fattoriale di " numero "e'" fattoriale +end fattorialeNumero \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/listaNumero.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/listaNumero.plike new file mode 100644 index 0000000..59b5be4 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/listaNumero.plike @@ -0,0 +1,13 @@ +begin listaNumeri + var: N, i, numero, somma: integer + somma := 0 + + read N + for i := 1 to N do + read numero + somma := somma + numero + endfor + + print "La somma finale e': " somma + +end listaNumeri \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/maggioreMinore.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/maggioreMinore.plike new file mode 100644 index 0000000..653b0fc --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/maggioreMinore.plike @@ -0,0 +1,14 @@ +begin programma + var: num1, num2: integer + read num1 + read num2 + + if (num1 > num2) + print "Il primo numero e' maggiore di" num2 + elseif (num2 > num1) + print "Il secondo numero "e' minore di" num1 + else + print "I numeri sono uguali." + endif + +end programma \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/pariDispari.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/pariDispari.plike new file mode 100644 index 0000000..3df42a4 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/pariDispari.plike @@ -0,0 +1,12 @@ +(*Verifichiamo se il numero dall'utente scelto sara' pari o dispari:*) +begin verifica + var: numero: integer + read numero + + if (numero MOD 2 = 0) + print "Il numero è pari" + else + print "Il numero è dispari" + endif + +end verifica \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/somma.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/somma.plike new file mode 100644 index 0000000..da10109 --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/EserciziPratica/somma.plike @@ -0,0 +1,6 @@ +begin somma + var: num1, num2, somma: integer + read num1 + read num2 + somma := num1+num2 +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Pigments/pygments.py b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Pigments/pygments.py new file mode 100644 index 0000000..a24319e --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/Pigments/pygments.py @@ -0,0 +1,63 @@ +from pygments.lexer import RegexLexer +from pygments.token import Text, Keyword, Name, String, Number, Operator + +class PLikeLexer(RegexLexer): + name = "PLike" + aliases = ["plike"] + filenames = ["*.plike"] + + tokens = { + 'root': [ + (r'\b(begin|end|var|if|then|else|endif|for|to|do|endfor|while|repeat|until|print|read|procedure|function|logical|integer|real|array|character)\b', Keyword), + (r'\b(TRUE|FALSE)\b', Keyword.Constant), + (r'\:=', Operator), + (r'[+\-*/=<>]', Operator), + (r'[\w_][\w\d_]*', Name), + (r'\".*?\"', String), + (r'\d+\.\d+', Number.Float), + (r'\d+', Number.Integer), + (r'\(\*.*?\*\)', Text), # Commenti (* *) + (r'[\s]+', Text), + ] + } + +# Scrivi un file setup.py per installare il lexer personalizzato +setup_script = """ +from setuptools import setup + +setup( + name='pygments-plike-lexer', + version='1.0', + description='Pygments lexer for P-Like language', + packages=['plike_lexer'], + entry_points=''' + [pygments.lexers] + plikelexer=plike_lexer:PLikeLexer + ''', +) +""" + +# Salva il lexer e il setup script in una struttura di directory +lexer_code = '''from pygments.lexer import RegexLexer +from pygments.token import Text, Keyword, Name, String, Number, Operator + +class PLikeLexer(RegexLexer): + name = "PLike" + aliases = ["plike"] + filenames = ["*.plike"] + + tokens = { + 'root': [ + (r'\\b(begin|end|var|if|then|else|endif|for|to|do|endfor|while|repeat|until|print|read|procedure|function|logical|integer|real|array|character)\\b', Keyword), + (r'\\b(TRUE|FALSE)\\b', Keyword.Constant), + (r'\\:=', Operator), + (r'[+\\-*/=<>]', Operator), + (r'[\\w_][\\w\\d_]*', Name), + (r'\\".*?\\"', String), + (r'\\d+\\.\\d+', Number.Float), + (r'\\d+', Number.Integer), + (r'\\(\\*.*?\\*\\)', Text), # Commenti (* *) + (r'[\\s]+', Text), + ] + } +''' \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/helloworld.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/helloworld.plike new file mode 100644 index 0000000..153c58d --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/helloworld.plike @@ -0,0 +1,3 @@ +Begin hw +Print '(Hello world)' +End \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArray.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArray.plike new file mode 100644 index 0000000..1c2123f --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArray.plike @@ -0,0 +1,35 @@ +// Questa versione e' stata fatta da GPT + +// Dichiaro l'inizio del programma: + +begin maxArray + /* Dichiaro una variabile A contenente un array di numeri reali */ + var: a[100]: array of real + + /* Dichiaro due variabili dove: + i viene usata nel ciclo for per incrmento + n viene usata per indicare un numero generico*/ + var: i, n: integer + var: max: real // Aggiungo max come variabile per il valore massimo + + // Leggi la dimensione dell'array + read n + + /* Inizializzo max al primo elemento dell'array + Siccome Laccetti non ha un cervello l'array inizia da 1 e non da 0 dio cane*/ + max = a(1) + + // Ciclo for per iterare sull'array da 2 fino a n + for i = 2, n do + + // Controllo se l'elemento corrente è maggiore del massimo trovato finora + if (max < a(i)) then + max = a(i) // Aggiorno max se trovo un valore maggiore + endif + + // Fine ciclo for + end for + +// Ora max contiene il valore massimo dell'array +// Chiudiamo l'aborto. +end maxArray \ No newline at end of file diff --git a/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArrayLaccetti.plike b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArrayLaccetti.plike new file mode 100644 index 0000000..321e02a --- /dev/null +++ b/Primo Anno/Esercizi/Informatica (Laccetti)/Yappetti/maxArray/varMaxArrayLaccetti.plike @@ -0,0 +1,24 @@ +//Laccetti non usa i commenti, io si, succhia tu che stai leggendo. + +//Dichiaro l'inizio del programma: +begin maxArray + + /*Dichiaro una variabile A contente un array + di numeri reali*/ + var:a[100]: array of real + + var:i,n:integer + read n + + //Sto ciclo for fa veramente cagare in p like tho funziona cosi. + //Dichiaro l'inizio del for: + for i=2, n do + + //Ciclo if per controllare se il massimo di a raggiuge a(incrementale) + if (max a < a(i)) then + max = a(i) + endif + end for + +//Fine del programma manco fosse VBasic '98 su Excel. +end \ No newline at end of file diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Dispensa - Esercizi svolti.pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Dispensa - Esercizi svolti.pdf new file mode 100644 index 0000000..54f082c Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Dispensa - Esercizi svolti.pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Esercizi svolti [Schaerf].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Esercizi svolti [Schaerf].pdf new file mode 100644 index 0000000..54f082c Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Esercizi svolti [Schaerf].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Apicella [2022-2023].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Apicella [2022-2023].pdf new file mode 100644 index 0000000..596d8af Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Apicella [2022-2023].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Bozzelli [2021-2023].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Bozzelli [2021-2023].pdf new file mode 100644 index 0000000..d15be44 Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Bozzelli [2021-2023].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Isgro [2018-2023].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Isgro [2018-2023].pdf new file mode 100644 index 0000000..c19ab71 Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Isgro [2018-2023].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Origlia [2021-2023].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Origlia [2021-2023].pdf new file mode 100644 index 0000000..6843a65 Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Origlia [2021-2023].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Prevete [2019-2021].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Prevete [2019-2021].pdf new file mode 100644 index 0000000..ff2aa59 Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Prevete [2019-2021].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Stranieri [2022].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Stranieri [2022].pdf new file mode 100644 index 0000000..06bd96b Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce - Stranieri [2022].pdf differ diff --git a/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce [2013-2021].pdf b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce [2013-2021].pdf new file mode 100644 index 0000000..4eeecc4 Binary files /dev/null and b/Primo Anno/Esercizi/Laboratorio di Programmazione/Tracce [2013-2021].pdf differ diff --git a/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce Di Martino [2022].pdf b/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce Di Martino [2022].pdf new file mode 100644 index 0000000..3242cfa Binary files /dev/null and b/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce Di Martino [2022].pdf differ diff --git a/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce [2020-2023].pdf b/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce [2020-2023].pdf new file mode 100644 index 0000000..cfa56c8 Binary files /dev/null and b/Primo Anno/Esercizi/Object Orientation - Oriented/Tracce [2020-2023].pdf differ diff --git a/Primo Anno/Libri/Analisi_1/Analisi_I_2.pdf b/Primo Anno/Libri & Appunti/Analisi_1/Analisi_I_2.pdf similarity index 100% rename from Primo Anno/Libri/Analisi_1/Analisi_I_2.pdf rename to Primo Anno/Libri & Appunti/Analisi_1/Analisi_I_2.pdf diff --git a/Primo Anno/Libri/Architettura degli Elaboratori/Elaboratori.pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Digital Design & Computer Architecture ARM.pdf similarity index 100% rename from Primo Anno/Libri/Architettura degli Elaboratori/Elaboratori.pdf rename to Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Digital Design & Computer Architecture ARM.pdf diff --git a/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Mappe di Karbnaugh.pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Mappe di Karbnaugh.pdf new file mode 100644 index 0000000..52a2e37 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Mappe di Karbnaugh.pdf differ diff --git a/Primo Anno/Libri/Architettura degli Elaboratori/Sistemi digitali e architettura dei calcolatori-1.pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Sistemi digitali e architettura dei calcolatori-1.pdf similarity index 100% rename from Primo Anno/Libri/Architettura degli Elaboratori/Sistemi digitali e architettura dei calcolatori-1.pdf rename to Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Sistemi digitali e architettura dei calcolatori-1.pdf diff --git a/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides Sauro [2021].pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides Sauro [2021].pdf new file mode 100644 index 0000000..28af232 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides Sauro [2021].pdf differ diff --git a/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Prevete].pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Prevete].pdf new file mode 100644 index 0000000..de3054f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Prevete].pdf differ diff --git a/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Rossi].pdf b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Rossi].pdf new file mode 100644 index 0000000..96fc08b Binary files /dev/null and b/Primo Anno/Libri & Appunti/Architettura degli Elaboratori/Slides [Rossi].pdf differ diff --git a/Primo Anno/Libri & Appunti/Base di Dati/Ref SanGiovanni.pdf b/Primo Anno/Libri & Appunti/Base di Dati/Ref SanGiovanni.pdf new file mode 100644 index 0000000..3387e37 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Base di Dati/Ref SanGiovanni.pdf differ diff --git a/Primo Anno/Libri & Appunti/Base di Dati/Slides (Barra).pdf b/Primo Anno/Libri & Appunti/Base di Dati/Slides (Barra).pdf new file mode 100644 index 0000000..b88ef7b Binary files /dev/null and b/Primo Anno/Libri & Appunti/Base di Dati/Slides (Barra).pdf differ diff --git a/Primo Anno/Libri & Appunti/Base di Dati/Slides (Peron, Barra) [2021].pdf b/Primo Anno/Libri & Appunti/Base di Dati/Slides (Peron, Barra) [2021].pdf new file mode 100644 index 0000000..1c52c99 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Base di Dati/Slides (Peron, Barra) [2021].pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 01.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 01.pdf new file mode 100644 index 0000000..64e4e01 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 01.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 02.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 02.pdf new file mode 100644 index 0000000..c407020 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 02.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 03.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 03.pdf new file mode 100644 index 0000000..e4ef1df Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 03.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 04.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 04.pdf new file mode 100644 index 0000000..078f06e Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 04.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 05.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 05.pdf new file mode 100644 index 0000000..9133e67 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 05.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 06.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 06.pdf new file mode 100644 index 0000000..d84d2e8 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 06.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 07.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 07.pdf new file mode 100644 index 0000000..0e9710f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 07.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 08.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 08.pdf new file mode 100644 index 0000000..888e09f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 08.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 09.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 09.pdf new file mode 100644 index 0000000..61c2616 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 09.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 10.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 10.pdf new file mode 100644 index 0000000..ebc85ab Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 10.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 11.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 11.pdf new file mode 100644 index 0000000..8752762 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 11.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 12.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 12.pdf new file mode 100644 index 0000000..df78a84 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 12.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 13.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 13.pdf new file mode 100644 index 0000000..ab3b23d Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 13.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 14.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 14.pdf new file mode 100644 index 0000000..bbc9837 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 14.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 15.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 15.pdf new file mode 100644 index 0000000..de0d15f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 15.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 16.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 16.pdf new file mode 100644 index 0000000..b501133 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 16.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 17.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 17.pdf new file mode 100644 index 0000000..2582664 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 17.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 18.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 18.pdf new file mode 100644 index 0000000..386046e Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 18.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 19.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 19.pdf new file mode 100644 index 0000000..2a0569f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 19.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 20.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 20.pdf new file mode 100644 index 0000000..630284a Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 20.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 21.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 21.pdf new file mode 100644 index 0000000..d0e9667 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 21.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 22.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 22.pdf new file mode 100644 index 0000000..a82463a Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 22.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 23.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 23.pdf new file mode 100644 index 0000000..658fb41 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 23.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 24.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 24.pdf new file mode 100644 index 0000000..7150d3d Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Lezioni/Lezione 24.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Basi somma diretta.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Basi somma diretta.pdf new file mode 100644 index 0000000..31874cd Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Basi somma diretta.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Lemma di Steinitz.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Lemma di Steinitz.pdf new file mode 100644 index 0000000..62afc4a Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Lemma di Steinitz.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Matrici associate alle applicazioni lineari.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Matrici associate alle applicazioni lineari.pdf new file mode 100644 index 0000000..ebc5c08 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Matrici associate alle applicazioni lineari.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sistemi lineari omogenei.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sistemi lineari omogenei.pdf new file mode 100644 index 0000000..f0e775c Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sistemi lineari omogenei.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sottospazi Euclidei e varieta lineari.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sottospazi Euclidei e varieta lineari.pdf new file mode 100644 index 0000000..b34b015 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Sottospazi Euclidei e varieta lineari.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema Rouche Capelli.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema Rouche Capelli.pdf new file mode 100644 index 0000000..67a5ac9 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema Rouche Capelli.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema comune perpendicolare.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema comune perpendicolare.pdf new file mode 100644 index 0000000..65cc269 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Teorema comune perpendicolare.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Vettori liberi.pdf b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Vettori liberi.pdf new file mode 100644 index 0000000..68f1872 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Cioffi/Osservazioni/Vettori liberi.pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/D Andrea/Slides [2019-2020].pdf b/Primo Anno/Libri & Appunti/Geometria/D Andrea/Slides [2019-2020].pdf new file mode 100644 index 0000000..bcff0cb Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/D Andrea/Slides [2019-2020].pdf differ diff --git a/Primo Anno/Libri & Appunti/Geometria/Trombetti/Note [Trombetti].pdf b/Primo Anno/Libri & Appunti/Geometria/Trombetti/Note [Trombetti].pdf new file mode 100644 index 0000000..223495f Binary files /dev/null and b/Primo Anno/Libri & Appunti/Geometria/Trombetti/Note [Trombetti].pdf differ diff --git a/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Apicella [2023].pdf b/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Apicella [2023].pdf new file mode 100644 index 0000000..7c4bc5d Binary files /dev/null and b/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Apicella [2023].pdf differ diff --git a/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Bozzelli [2023].pdf b/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Bozzelli [2023].pdf new file mode 100644 index 0000000..e533df3 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Laboratorio di Programmazione/Slides Bozzelli [2023].pdf differ diff --git a/Primo Anno/Libri & Appunti/Object Orientation - Oriented/2021_OBOR_NOTE_Di Martino - Notes - J. Doe.pdf b/Primo Anno/Libri & Appunti/Object Orientation - Oriented/2021_OBOR_NOTE_Di Martino - Notes - J. Doe.pdf new file mode 100644 index 0000000..d2a19bc Binary files /dev/null and b/Primo Anno/Libri & Appunti/Object Orientation - Oriented/2021_OBOR_NOTE_Di Martino - Notes - J. Doe.pdf differ diff --git a/Primo Anno/Libri & Appunti/Object Orientation - Oriented/Tramontana/Slides (Tramontana) [2022].pdf b/Primo Anno/Libri & Appunti/Object Orientation - Oriented/Tramontana/Slides (Tramontana) [2022].pdf new file mode 100644 index 0000000..e7b8e66 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Object Orientation - Oriented/Tramontana/Slides (Tramontana) [2022].pdf differ diff --git a/Primo Anno/Libri/Programmazione/Bellini guidi linguaggio c.pdf b/Primo Anno/Libri & Appunti/Programmazione/Bellini guidi linguaggio c.pdf similarity index 100% rename from Primo Anno/Libri/Programmazione/Bellini guidi linguaggio c.pdf rename to Primo Anno/Libri & Appunti/Programmazione/Bellini guidi linguaggio c.pdf diff --git a/Primo Anno/Libri/Programmazione/Laboratorio di Programmazione [Murli, Giunta].pdf b/Primo Anno/Libri & Appunti/Programmazione/Laboratorio di Programmazione [Murli, Giunta].pdf similarity index 100% rename from Primo Anno/Libri/Programmazione/Laboratorio di Programmazione [Murli, Giunta].pdf rename to Primo Anno/Libri & Appunti/Programmazione/Laboratorio di Programmazione [Murli, Giunta].pdf diff --git a/Primo Anno/Libri/Programmazione/Linguaggio C (Brian W. Kernighan, Dennis M. Ritchie) (Z-Library).pdf b/Primo Anno/Libri & Appunti/Programmazione/Linguaggio C (Brian W. Kernighan, Dennis M. Ritchie) (Z-Library).pdf similarity index 100% rename from Primo Anno/Libri/Programmazione/Linguaggio C (Brian W. Kernighan, Dennis M. Ritchie) (Z-Library).pdf rename to Primo Anno/Libri & Appunti/Programmazione/Linguaggio C (Brian W. Kernighan, Dennis M. Ritchie) (Z-Library).pdf diff --git a/Primo Anno/Libri & Appunti/Programmazione/Slides Laccetti [2020].pdf b/Primo Anno/Libri & Appunti/Programmazione/Slides Laccetti [2020].pdf new file mode 100644 index 0000000..511ebd2 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Programmazione/Slides Laccetti [2020].pdf differ diff --git a/Primo Anno/Libri & Appunti/Programmazione/Slides Riccio [2022].pdf b/Primo Anno/Libri & Appunti/Programmazione/Slides Riccio [2022].pdf new file mode 100644 index 0000000..236f889 Binary files /dev/null and b/Primo Anno/Libri & Appunti/Programmazione/Slides Riccio [2022].pdf differ diff --git a/README.md b/README.md index bf9daa7..a4f7437 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,5 @@ # UNINA Informatica Forza Napoli sempre + +Oramai gian non so dove sia finito +Questa diventa ora UNINA-Informatica++ diff --git a/Secondo Anno/Algoritmi Strutture Dati/Benerecetti/Slides [2023].pdf b/Secondo Anno/Algoritmi Strutture Dati/Benerecetti/Slides [2023].pdf new file mode 100644 index 0000000..73247ef Binary files /dev/null and b/Secondo Anno/Algoritmi Strutture Dati/Benerecetti/Slides [2023].pdf differ diff --git a/Secondo Anno/Elementi D'Informatica Teorica/EDIT - Alessandro De Luca.pdf b/Secondo Anno/Elementi D'Informatica Teorica/EDIT - Alessandro De Luca.pdf new file mode 100644 index 0000000..aedd0b4 Binary files /dev/null and b/Secondo Anno/Elementi D'Informatica Teorica/EDIT - Alessandro De Luca.pdf differ diff --git a/Secondo Anno/Elementi D'Informatica Teorica/Slides (Murano) [2009].pdf b/Secondo Anno/Elementi D'Informatica Teorica/Slides (Murano) [2009].pdf new file mode 100644 index 0000000..95694ad Binary files /dev/null and b/Secondo Anno/Elementi D'Informatica Teorica/Slides (Murano) [2009].pdf differ diff --git a/Secondo Anno/Esercizi/Algebra/Tracce [2012-2017].pdf b/Secondo Anno/Esercizi/Algebra/Tracce [2012-2017].pdf new file mode 100644 index 0000000..bb323bb Binary files /dev/null and b/Secondo Anno/Esercizi/Algebra/Tracce [2012-2017].pdf differ diff --git a/Secondo Anno/Esercizi/Algebra/Tracce [2018-2024].pdf b/Secondo Anno/Esercizi/Algebra/Tracce [2018-2024].pdf new file mode 100644 index 0000000..bfa1a8f Binary files /dev/null and b/Secondo Anno/Esercizi/Algebra/Tracce [2018-2024].pdf differ diff --git a/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi e Soluzioni [2023].pdf b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi e Soluzioni [2023].pdf new file mode 100644 index 0000000..eb7cbb5 Binary files /dev/null and b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi e Soluzioni [2023].pdf differ diff --git a/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi su Grafi.pdf b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi su Grafi.pdf new file mode 100644 index 0000000..d8fa290 Binary files /dev/null and b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Esercizi/Esercizi su Grafi.pdf differ diff --git a/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Manuale del buon asdino - V. Panzera.pdf b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Manuale del buon asdino - V. Panzera.pdf new file mode 100644 index 0000000..238a1ef Binary files /dev/null and b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Manuale del buon asdino - V. Panzera.pdf differ diff --git a/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce - Benerecetti [2022-2023].pdf b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce - Benerecetti [2022-2023].pdf new file mode 100644 index 0000000..37e4017 Binary files /dev/null and b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce - Benerecetti [2022-2023].pdf differ diff --git a/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce [2000-2022].pdf b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce [2000-2022].pdf new file mode 100644 index 0000000..c7cf11c Binary files /dev/null and b/Secondo Anno/Esercizi/Algoritmi e Strutture Dati/Tracce/Tracce [2000-2022].pdf differ diff --git a/Secondo Anno/Esercizi/EDIT/Domande di teoria frequenti.pdf b/Secondo Anno/Esercizi/EDIT/Domande di teoria frequenti.pdf new file mode 100644 index 0000000..0b4ba2b Binary files /dev/null and b/Secondo Anno/Esercizi/EDIT/Domande di teoria frequenti.pdf differ diff --git a/Secondo Anno/Esercizi/EDIT/Introduction to the Theory of Computation (soluzioni).pdf b/Secondo Anno/Esercizi/EDIT/Introduction to the Theory of Computation (soluzioni).pdf new file mode 100644 index 0000000..1760f9b Binary files /dev/null and b/Secondo Anno/Esercizi/EDIT/Introduction to the Theory of Computation (soluzioni).pdf differ diff --git a/Secondo Anno/Esercizi/EDIT/Tracce De Luca [2023].pdf b/Secondo Anno/Esercizi/EDIT/Tracce De Luca [2023].pdf new file mode 100644 index 0000000..798073c Binary files /dev/null and b/Secondo Anno/Esercizi/EDIT/Tracce De Luca [2023].pdf differ diff --git a/Secondo Anno/Esercizi/EDIT/Tracce Murano [2022-2025].pdf b/Secondo Anno/Esercizi/EDIT/Tracce Murano [2022-2025].pdf new file mode 100644 index 0000000..977f0c4 Binary files /dev/null and b/Secondo Anno/Esercizi/EDIT/Tracce Murano [2022-2025].pdf differ diff --git a/Secondo Anno/Esercizi/EDIT/Tracce [2010-2023].pdf b/Secondo Anno/Esercizi/EDIT/Tracce [2010-2023].pdf new file mode 100644 index 0000000..d2d3aae Binary files /dev/null and b/Secondo Anno/Esercizi/EDIT/Tracce [2010-2023].pdf differ diff --git a/Secondo Anno/Esercizi/Fisica/Tracce [2021-2023].pdf b/Secondo Anno/Esercizi/Fisica/Tracce [2021-2023].pdf new file mode 100644 index 0000000..96bc031 Binary files /dev/null and b/Secondo Anno/Esercizi/Fisica/Tracce [2021-2023].pdf differ diff --git a/Secondo Anno/Esercizi/Laboratorio ASD/Tracce (A. Murano) [2019-2024].pdf b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce (A. Murano) [2019-2024].pdf new file mode 100644 index 0000000..7791eea Binary files /dev/null and b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce (A. Murano) [2019-2024].pdf differ diff --git a/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Mogavero [2022].pdf b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Mogavero [2022].pdf new file mode 100644 index 0000000..fc813ab Binary files /dev/null and b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Mogavero [2022].pdf differ diff --git a/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Murano [2006-2022].pdf b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Murano [2006-2022].pdf new file mode 100644 index 0000000..57aa2db Binary files /dev/null and b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce Murano [2006-2022].pdf differ diff --git a/Secondo Anno/Esercizi/Laboratorio ASD/Tracce [2011-2023].pdf b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce [2011-2023].pdf new file mode 100644 index 0000000..808149a Binary files /dev/null and b/Secondo Anno/Esercizi/Laboratorio ASD/Tracce [2011-2023].pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esami [2020].pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esami [2020].pdf new file mode 100644 index 0000000..5c89248 Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esami [2020].pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esercitazioni.pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esercitazioni.pdf new file mode 100644 index 0000000..5b5c43e Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Esercitazioni.pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Solutions - Domande teoria.pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Solutions - Domande teoria.pdf new file mode 100644 index 0000000..f571745 Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Solutions - Domande teoria.pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Sommario.pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Sommario.pdf new file mode 100644 index 0000000..a055992 Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Sommario.pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Bonatti [2010-2019].pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Bonatti [2010-2019].pdf new file mode 100644 index 0000000..aa1ceb8 Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Bonatti [2010-2019].pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Faella [2023].pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Faella [2023].pdf new file mode 100644 index 0000000..49f7452 Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce Faella [2023].pdf differ diff --git a/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce [2006-2021].pdf b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce [2006-2021].pdf new file mode 100644 index 0000000..d69294e Binary files /dev/null and b/Secondo Anno/Esercizi/Linguaggi di Programmazione 1/Tracce [2006-2021].pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/Domande frequenti.pdf b/Secondo Anno/Esercizi/Sistemi Operativi/Domande frequenti.pdf new file mode 100644 index 0000000..2cf2f5f Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/Domande frequenti.pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/Esercizi (Finzi) [2022].pdf b/Secondo Anno/Esercizi/Sistemi Operativi/Esercizi (Finzi) [2022].pdf new file mode 100644 index 0000000..818975e Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/Esercizi (Finzi) [2022].pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/Tracce Balzano.pdf b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce Balzano.pdf new file mode 100644 index 0000000..2a49311 Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce Balzano.pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2006-2023].pdf b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2006-2023].pdf new file mode 100644 index 0000000..766b150 Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2006-2023].pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2018-2022].pdf b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2018-2022].pdf new file mode 100644 index 0000000..7a554bc Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/Tracce [2018-2022].pdf differ diff --git a/Secondo Anno/Esercizi/Sistemi Operativi/domande_possibili.pdf b/Secondo Anno/Esercizi/Sistemi Operativi/domande_possibili.pdf new file mode 100644 index 0000000..f95caad Binary files /dev/null and b/Secondo Anno/Esercizi/Sistemi Operativi/domande_possibili.pdf differ diff --git a/Secondo Anno/Laboratorio ASD/Slides (A. Murano) [2007].pdf b/Secondo Anno/Laboratorio ASD/Slides (A. Murano) [2007].pdf new file mode 100644 index 0000000..12f7889 Binary files /dev/null and b/Secondo Anno/Laboratorio ASD/Slides (A. Murano) [2007].pdf differ diff --git a/Secondo Anno/Laboratorio ASD/Slides Murano [2022].pdf b/Secondo Anno/Laboratorio ASD/Slides Murano [2022].pdf new file mode 100644 index 0000000..c1655fa Binary files /dev/null and b/Secondo Anno/Laboratorio ASD/Slides Murano [2022].pdf differ diff --git a/Secondo Anno/Linguaggi di Programmazione 1/Slides Bonatti [2021].pdf b/Secondo Anno/Linguaggi di Programmazione 1/Slides Bonatti [2021].pdf new file mode 100644 index 0000000..e6c310e Binary files /dev/null and b/Secondo Anno/Linguaggi di Programmazione 1/Slides Bonatti [2021].pdf differ diff --git a/Secondo Anno/Linguaggi di Programmazione 1/Slides Faella [2022-2023].pdf b/Secondo Anno/Linguaggi di Programmazione 1/Slides Faella [2022-2023].pdf new file mode 100644 index 0000000..349bc80 Binary files /dev/null and b/Secondo Anno/Linguaggi di Programmazione 1/Slides Faella [2022-2023].pdf differ diff --git a/Secondo Anno/Sistemi Operativi 1/Slides Finzi [2022].pdf b/Secondo Anno/Sistemi Operativi 1/Slides Finzi [2022].pdf new file mode 100644 index 0000000..daee766 Binary files /dev/null and b/Secondo Anno/Sistemi Operativi 1/Slides Finzi [2022].pdf differ diff --git a/Secondo Anno/Sistemi Operativi 1/Slides [Balzano].pdf b/Secondo Anno/Sistemi Operativi 1/Slides [Balzano].pdf new file mode 100644 index 0000000..dcef2fe Binary files /dev/null and b/Secondo Anno/Sistemi Operativi 1/Slides [Balzano].pdf differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 01 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 01 [2021-2023].pdf" new file mode 100644 index 0000000..163549f Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 01 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 02 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 02 [2021-2023].pdf" new file mode 100644 index 0000000..7585643 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 02 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 03 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 03 [2021-2023].pdf" new file mode 100644 index 0000000..db50597 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 03 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 04 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 04 [2021-2023].pdf" new file mode 100644 index 0000000..5ea48ac Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 04 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 05 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 05 [2021-2023].pdf" new file mode 100644 index 0000000..0405768 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 05 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 06 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 06 [2021-2023].pdf" new file mode 100644 index 0000000..885bdeb Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 06 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 07 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 07 [2021-2023].pdf" new file mode 100644 index 0000000..3f9452c Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 07 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 08 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 08 [2021-2023].pdf" new file mode 100644 index 0000000..c875e13 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 08 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 09 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 09 [2021-2023].pdf" new file mode 100644 index 0000000..d42d68b Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 09 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 10 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 10 [2021-2023].pdf" new file mode 100644 index 0000000..0165b12 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 10 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 11 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 11 [2021-2023].pdf" new file mode 100644 index 0000000..52549d6 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 11 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 12 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 12 [2021-2023].pdf" new file mode 100644 index 0000000..b39c117 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 12 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 13 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 13 [2021-2023].pdf" new file mode 100644 index 0000000..e7e6b76 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 13 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 14 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 14 [2021-2023].pdf" new file mode 100644 index 0000000..d640559 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 14 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 15 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 15 [2021-2023].pdf" new file mode 100644 index 0000000..9159b63 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 15 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 16 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 16 [2021-2023].pdf" new file mode 100644 index 0000000..0eef877 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 16 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 17 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 17 [2021-2023].pdf" new file mode 100644 index 0000000..0d0973e Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 17 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 18 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 18 [2021-2023].pdf" new file mode 100644 index 0000000..1cd3388 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 18 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 19 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 19 [2021-2023].pdf" new file mode 100644 index 0000000..873f48e Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 19 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 20 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 20 [2021-2023].pdf" new file mode 100644 index 0000000..fb73e4c Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 20 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 21 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 21 [2021-2023].pdf" new file mode 100644 index 0000000..4003d9f Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 21 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 22 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 22 [2021-2023].pdf" new file mode 100644 index 0000000..d2daa6b Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 22 [2021-2023].pdf" differ diff --git "a/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 23 [2021-2023].pdf" "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 23 [2021-2023].pdf" new file mode 100644 index 0000000..17855b7 Binary files /dev/null and "b/Terzo Anno/Calcolo Probabilit\303\240 Statistica/Lezione 23 [2021{"code":"deadline_exceeded","msg":"operation timed out"}