Corso on

SQLLeetCode - 2356 - Number of Unique Subjects Taught by Each Teacher

Wed, 25 Feb 2026 14:01:43 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to calculate the number of unique subjects each teacher teaches in the university.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Teacher contiene le informazioni sugli insegnanti: teacher_id, subject_id, dept_id.

L’obiettivo è contare il numero di materie uniche insegnate da ciascun insegnante. Poiché un insegnante può insegnare la stessa materia in dipartimenti diversi, dobbiamo contare solo le materie distinte per ogni insegnante.

SQLLeetCode - 1934 - Confirmation Rate

Wed, 25 Feb 2026 14:01:42 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

The confirmation rate of a user is the number of ‘confirmed’ messages divided by the total number of requested confirmation messages. The confirmation rate of a user that did not request any confirmation messages is 0. Round the confirmation rate to two decimal places.

Write a solution to find the confirmation rate of each user.

Return the result table in any order.

SQLLeetCode - 1757 - Recyclable and Low Fat Products

Wed, 25 Feb 2026 14:01:41 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the ids of products that are both low fat and recyclable.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Products contiene le informazioni sui prodotti: product_id (ID del prodotto), low_fats (indica se il prodotto è a basso contenuto di grassi - ‘Y’ o ‘N’), recyclable (indica se il prodotto è riciclabile - ‘Y’ o ‘N’).

SQLLeetCode - 1731 - The Number of Employees Which Report to Each Employee

Wed, 25 Feb 2026 14:01:40 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the ids and the names of all managers, the number of employees who report directly to them, and the average age of the reports rounded to the nearest integer.

Return the result table ordered by employee_id.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Employees contiene le informazioni sui dipendenti: employee_id, name, age, reports_to.

SQLLeetCode - 1729 - Find Followers Count

Wed, 25 Feb 2026 14:01:39 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution that will, for each user, return the number of followers.

Return the result table ordered by user_id in ascending order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Followers contiene le informazioni sui follower: user_id (l’utente che viene seguito), follower_id (l’utente che segue).

L’obiettivo è contare il numero di follower per ogni utente. Poiché un utente può avere più follower, dobbiamo raggruppare per user_id e contare i follower distinti.

SQLLeetCode - 1683 - Invalid Tweets

Wed, 25 Feb 2026 14:01:38 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the IDs of the invalid tweets. The tweet is invalid if the number of characters used in the content of the tweet is strictly greater than 15.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Tweets contiene le informazioni sui tweet: tweet_id (ID del tweet), content (contenuto del tweet).

SQLLeetCode - 1661 - Average Time Of Process Per Machine

Wed, 25 Feb 2026 14:01:37 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the average time each machine takes to complete a process. The time to complete a process is the ’end’ timestamp minus the ‘start’ timestamp. The average time is calculated by the total time to complete every process on the machine divided by the number of processes that were run.

The resulting table should have the machine_id along with the average time as processing_time, which should be rounded to 3 decimal places.

SQLLeetCode - 1633 - Percentage of Users Attended a Contest

Wed, 25 Feb 2026 14:01:36 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the percentage of the users registered in each contest rounded to two decimals.

Return the result table ordered by percentage in descending order. In case of a tie, order it by contest_id in ascending order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Users (con user_id) e Register (con contest_id, user_id).

SQLLeetCode - 1581 - Customer Who Visited but Did Not Make Any Transactions

Wed, 25 Feb 2026 14:01:35 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the IDs of the users who visited without making any transactions and the number of times they made these types of visits.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Visits (con visit_id, customer_id, visit_date) e Transactions (con transaction_id, visit_id, amount).

L’obiettivo è trovare i clienti che hanno visitato il negozio ma non hanno effettuato alcuna transazione e quante volte lo hanno fatto. Per farlo, dobbiamo collegare le due tabelle e identificare le visite senza transazioni associate.

SQLLeetCode - 1378 - Replace Employee Id With The Unique Identifier

Wed, 25 Feb 2026 14:01:34 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to show the unique ID of each user, If a user does not have a unique ID replace just show null.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Employees (con id e name) e EmployeeUNI (con id e unique_id).

L’obiettivo è unire le due tabelle per ottenere per ogni dipendente il suo unique_id dalla tabella EmployeeUNI. Dobbiamo usare una LEFT JOIN perché vogliamo includere tutti i dipendenti, anche quelli che non hanno un unique_id assegnato (in quel caso unique_id sarà NULL).

SQLLeetCode - 1280 - Students And Examinations

Wed, 25 Feb 2026 14:01:33 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the number of examinations each student attended for each subject.

Return the result table sorted by student_id and subject_name.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono tre tabelle: Students (con student_id, student_name), Subjects (con subject_name), e Examinations (con student_id, subject_name).

L’obiettivo è trovare per ogni combinazione studente-materia, quante volte lo studente ha sostenuto quell’esame. Dobbiamo includere tutti gli studenti e tutte le materie, anche se lo studente non ha sostenuto alcun esame per quella materia (in quel caso il conteggio sarà 0).

SQLLeetCode - 1251 - Average Selling Price

Wed, 25 Feb 2026 14:01:32 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the average selling price for each product. average_price should be rounded to 2 decimal places. If a product does not have any sold units, its average selling price is assumed to be 0.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Prices (con product_id, start_date, end_date, price) e UnitsSold (con product_id, purchase_date, units).

SQLLeetCode - 1211 - Queries Quality and Percentage

Wed, 25 Feb 2026 14:01:31 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

We define query quality as:

The average of the ratio between query rating and its position.

We also define poor query percentage as:

The percentage of all queries with rating less than 3.

Write a solution to find each query_name, the quality and poor_query_percentage.

Both quality and poor_query_percentage should be rounded to 2 decimal places.

Return the result table in any order.

SQLLeetCode - 1193 - Monthly Transactions I

Wed, 25 Feb 2026 14:01:30 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write an SQL query to find for each month and country, the number of transactions and their total amount, the number of approved transactions and their total amount.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Transactions contiene le informazioni sulle transazioni: id, country, state (approved/void), amount, trans_date.

L’obiettivo è raggruppare le transazioni per mese (anno-mese) e paese, e calcolare:

SQLLeetCode - 1174 - Immediate Food Delivery II

Wed, 25 Feb 2026 14:01:29 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the percentage of immediate orders in the first orders of all customers, rounded to 2 decimal places.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Delivery contiene le informazioni sulle consegne: delivery_id, customer_id, order_date, customer_pref_delivery_date.

L’obiettivo è calcolare la percentuale di ordini immediati rispetto al primo ordine di ogni cliente. Un ordine è considerato “immediato” se order_date = customer_pref_delivery_date, cioè se la data di consegna coincide con la data preferita del cliente.

SQLLeetCode - 1164 - Product Price at a Given Date

Wed, 25 Feb 2026 14:01:28 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the prices of all products on 2019-08-16. Assume the price of all products before any change is 10.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Products contiene le informazioni sui prezzi dei prodotti: product_id, new_price, change_date.

L’obiettivo è trovare il prezzo di tutti i prodotti alla data specifica (2019-08-16). La regola è:

SQLLeetCode - 1148 - Article Views I

Wed, 25 Feb 2026 14:01:27 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find all the authors that viewed at least one of their own articles.

Return the result table sorted by author_id.

The author_id of the author is the same as the viewer_id of the view.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Views contiene le informazioni sulle visualizzazioni degli articoli: article_id (ID dell’articolo), author_id (ID dell’autore dell’articolo), viewer_id (ID di chi ha visualizzato l’articolo), view_date (data della visualizzazione).

SQLLeetCode - 1141 - User Activity for the Past 30 Days I

Wed, 25 Feb 2026 14:01:26 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the daily active user count for a 30-day period ending on 2019-07-27 inclusively. A user became active on a given day if they made at least one activity on that day.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Activity contiene le informazioni sulle attività degli utenti: user_id, activity_date, activity_type, activity_id.

SQLLeetCode - 1075 - Project Employees I

Wed, 25 Feb 2026 14:01:25 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the average experience years of all the employees for each project rounded to 2 digit

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Project (con project_id, employee_id) e Employee (con employee_id, name, experience_years).

L’obiettivo è calcolare la media degli anni di esperienza per ogni progetto. Ogni progetto può avere più dipendenti, e dobbiamo calcolare la media degli anni di esperienza di tutti i dipendenti assegnati a quel progetto.

SQLLeetCode - 1070 - Product Sales Analysis III

Wed, 25 Feb 2026 14:01:24 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the first year of sales for each product id.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Sales contiene le informazioni sulle vendite: sale_id, product_id, year, quantity, price.

L’obiettivo è trovare per ogni prodotto l’anno della prima vendita (l’anno più vecchio). Dobbiamo selezionare la riga con l’anno minimo per ogni prodotto.

SQLLeetCode - 1068 - Product Sales Analysis I

Wed, 25 Feb 2026 14:01:23 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the product_name, year, and price for each sales entry in the Sales table.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Sales (con sale_id, product_id, year, quantity, price) e Product (con product_id, product_name).

L’obiettivo è unire le due tabelle per ottenere il nome del prodotto insieme alle informazioni di vendita. Dobbiamo collegare le tabelle usando product_id come chiave di join.

SQLLeetCode - 1045 - Customers Who Bought All Products

Wed, 25 Feb 2026 14:01:22 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the customer_id of customers that bought all the products.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che ci sono due tabelle: Customer (con customer_id, product_key) e Product (con product_key).

L’obiettivo è trovare i clienti che hanno acquistato tutti i prodotti disponibili. Dobbiamo confrontare il numero di prodotti acquistati da ogni cliente con il numero totale di prodotti disponibili.

SQLLeetCode - 620 - Not Boring Movies

Wed, 25 Feb 2026 14:01:21 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the interesting movies. An interesting movie has an id that is odd, and its description is not “boring”.

Return the result table sorted by rating in descending order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Cinema (o Movie) contiene le informazioni sui film: id, movie, description, rating.

L’obiettivo è trovare i film “interessanti” che soddisfano due condizioni:

SQLLeetCode - 619 - Biggest Single Number

Wed, 25 Feb 2026 14:01:20 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

A “single” number is a number that appears exactly once in the MyNumbers table.

Write a solution to find the biggest single number. If there is no single number, the answer is null.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella MyNumbers contiene solo una colonna num con vari numeri, alcuni dei quali possono essere ripetuti.

SQLLeetCode - 596 - Classes More Than 5 Students

Wed, 25 Feb 2026 14:01:19 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find all classes that have at least five students.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Courses contiene le informazioni sugli studenti iscritti ai corsi: student (nome dello studente), class (nome del corso).

L’obiettivo è trovare tutti i corsi che hanno almeno cinque studenti iscritti. Per fare ciò, dobbiamo raggruppare gli studenti per classe e contare quanti studenti ci sono in ciascun corso, poi filtrare quelli con count >= 5.

SQLLeetCode - 595 - Big Countries

Wed, 25 Feb 2026 14:01:18 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

A country is big if:

it has an area of at least 3,000,000 km², or

it has a population of at least 25,000,000.

Write a SQL query to report the name, population, and area of the big countries.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella World contiene le informazioni sui paesi: name (nome del paese), population (popolazione), area (superficie in km²).

SQLLeetCode - 584 - Find Customer RefereeFind Customer Referee

Wed, 25 Feb 2026 14:01:17 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Find the names of the customer that are either:

referred by any customer with id != 2.

not referred by any customer.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Customer contiene anche il campo referee_id, che indica quale cliente ha fatto da referente (referrer) per un altro cliente. Tuttavia, questo campo può essere NULL nel caso in cui il cliente non abbia alcun referente.

SQLLeetCode - 577 - Employee Bonus

Wed, 25 Feb 2026 14:01:16 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the name and bonus amount of each employee who satisfies either of the following:

The employee has a bonus less than 1000.

The employee did not get any bonus.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Employee contiene tutti i dipendenti, mentre la tabella Bonus associa eventualmente un bonus a ciascun dipendente tramite empId. Tuttavia, non tutti i dipendenti hanno necessariamente un bonus assegnato.

SQLLeetCode - 570 - Managers with at Least 5 Direct Reports

Wed, 25 Feb 2026 14:01:15 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find managers with at least five direct reports.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Employee contiene sia i dipendenti che i manager, e il campo managerId indica a quale manager ogni dipendente riporta.

L’obiettivo è quindi individuare i manager che hanno almeno 5 dipendenti diretti (direct reports).

SQLLeetCode - 550 - Game Play Analysis IV

Wed, 25 Feb 2026 14:01:14 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the fraction of players that logged in again on the day after the day they first logged in, rounded to 2 decimal places.

In other words, you need to determine the number of players who logged in on the day immediately following their initial login, and divide it by the number of total players.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Activity registra gli accessi degli utenti nel tempo, identificando ogni giocatore tramite player_id e ogni login tramite la data event_date.

SQLLeetCode - 197 - Rising Temperature

Wed, 25 Feb 2026 14:01:13 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find all dates’ id with higher temperatures compared to its previous dates (yesterday).

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Weather contiene le registrazioni giornaliere della temperatura, dove ogni riga è identificata da una data (recordDate) e da un id univoco.

L’obiettivo è quindi confrontare la temperatura di un giorno con quella del giorno precedente, per trovare i casi in cui la temperatura è aumentata.

SQLLeetCode - 183 - Customers Who Never Order

Wed, 25 Feb 2026 14:01:12 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find all customers who never order anything.

WReturn the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Customers contiene tutti i clienti, mentre la tabella Orders tiene traccia degli ordini effettuati e collega ogni ordine a un cliente tramite il campo customerId.

Di conseguenza, per trovare i clienti che non hanno mai effettuato ordini, è sufficiente selezionare quelli il cui id non compare tra i customerId presenti nella tabella Orders.

SQLLeetCode - 181 - Employees Earning More Than Their Managers

Wed, 25 Feb 2026 14:01:11 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to find the employees who earn more than their managers.

Return the result table in any order.W

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Employee contiene sia le informazioni dei dipendenti che dei manager, distinguendoli tramite il campo managerId, che rappresenta un riferimento all’id di un altro dipendente. Inoltre, non tutti i dipendenti hanno un manager (ad esempio il CEO), quindi in alcuni casi managerId può essere NULL.

SQLLeetCode - 175 - Combine Two Tables

Wed, 25 Feb 2026 14:01:10 +0000

Oggi vediamo il seguente esercizio di LeetCode a tema SQL:

Write a solution to report the first name, last name, city, and state of each person in the Person table. If the address of a personId is not present in the Address table, report null instead.

Return the result table in any order.

Guardando le tabelle fornite dall’esercizio si può notare che la tabella Person contiene le informazioni anagrafiche (firstName, lastName) identificate da personId, mentre la tabella Address contiene città e stato associati allo stesso personId. Tuttavia, non è garantito che ogni persona abbia un indirizzo corrispondente nella tabella Address.

DesignPatternTeoria - Structural - adapter

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: ADAPTER

L’Adapter (o Adattatore / Wrapper) è un pattern strutturale che consente a due classi con interfacce incompatibili di collaborare.

L’adattatore funge da “traduttore” tra l’interfaccia attesa dal codice client (Target) e quella realmente offerta da un oggetto esistente (Adaptee), senza modificare né il client né la classe originale.

QUANDO UTILIZZARLO

Integrazione di librerie o componenti di terze parti.
Uniformare formati di input/output differenti (es. XML ⇆ JSON, sistemi di coordinate diversi).
Migrare verso una nuova API senza interrompere il funzionamento del codice esistente.

VANTAGGI

Basso accoppiamento: il client dipende solo dall’interfaccia Target.
Nessuna modifica a codice esistente: adattamento non invasivo.
Flessibilità nella sostituzione: puoi introdurre più adattatori per transizioni graduali.
Riutilizzo di codice: componenti vecchi possono integrarsi con sistemi nuovi.

POTENZIALI SVANTAGGI

Aumento della complessità: più formati = più adapter da gestire.
Prestazioni: un layer aggiuntivo può introdurre overhead.
Soluzione temporanea: spesso è un “cerotto” invece di una riprogettazione strutturale.

CODICE

/**
 * Sorgenti dati JSON ok
 */
class JSONData {
	content: Object;

	constructor(content: Object) {
		this.content = content;
	}
}

/**
 * Sorgenti dati XML ok => da adattare con il nostro design pattern
 */
class XMLData {
	content: string;

	constructor(content: string) {
		this.content = content;
	}
}

/**
 * ADAPTER
 * Interfaccia comune per l'adattamento a un MCM
 */
interface CommonData {
	convertToCommonData(): JSONData;
}

/**
 * CONVERTITORE JSON
 */
class convertJSONData implements CommonData {
	jsonData: JSONData;

	constructor(jsonData: JSONData) {
		this.jsonData = jsonData;
	}

	convertToCommonData(): JSONData {
		return this.jsonData;
	}
}

/**
 * CONVERTITORE XML
 */
class convertXMLData implements CommonData {
	xmlData: XMLData;

	constructor(xmlData: XMLData) {
		this.xmlData = xmlData;
	}

	convertToCommonData(): JSONData {
		//Parsing manuale semplificato (solo per esempio)
		const matches = this.xmlData.content.match(/<campo1 xml>(.*?)<\/campo1 xml>[\s\S]*<campo2 xml>(.*?)<\/campo2 xml>/);

		if (!matches) {
			throw new Error("Formato XML non valido");
		}

		const jsonObj: Object = {
			"campo 1 xml": matches[1],
			"campo 2 xml": matches[2]
		};

		return new JSONData(jsonObj);
	}
}

//USO ADAPTER
const jsonData: JSONData = new JSONData({
	"campo 1 json": "valore 1 json",
	"campo 2 json": "valore 2 json",
});

const xmlData: XMLData = new XMLData(`
 <root>
 <campo1 xml>valore 1 xml</campo1 xml>
 <campo2 xml>valore 2 xml</campo2 xml>
 </root>
`);

const commonDataFromJSON: JSONData = new convertJSONData(jsonData).convertToCommonData();
const commonDataFromXML: JSONData = new convertXMLData(xmlData).convertToCommonData();
console.log("JSON convertito a JSON: ", commonDataFromJSON);
console.log("XML convertito a JSON: ", commonDataFromXML);

DesignPatternTeoria - Structural - decorator

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: DECORATOR

Il Decorator è un pattern strutturale che consente di aggiungere, in modo dinamico, nuove funzionalità a un oggetto senza modificarne la classe originale.

Il principio di base è “impacchettare” (wrapping) l’oggetto originale all’interno di un altro oggetto che implementa la stessa interfaccia, delegando le chiamate e arricchendole prima o dopo l’esecuzione.

QUANDO UTILIZZARLO

Vuoi estendere il comportamento di un oggetto a runtime senza usare l’ereditarietà.
Vuoi evitare la proliferazione di sottoclassi per ogni combinazione di funzionalità (es. ButtonBlueLargeWithIcon, ButtonRedSmallNoIcon, ecc.).
Necessiti di combinare funzionalità in modo flessibile e modulare.

VANTAGGI

Modularità: aggiungi funzionalità senza toccare la classe originale.
Flessibilità: puoi impilare più decoratori in qualunque ordine.
Open/Closed Principle: estendi il comportamento senza modificare codice esistente.

POTENZIALI SVANTAGGI

Maggiore complessità: troppi oggetti annidati possono rendere il flusso poco chiaro.
Configurazione verbosa: la creazione e combinazione dei decoratori può diventare prolissa.

CODICE

/**
 * Interfaccia comune per DataSource
 */
interface DataSource {
	writeData(data: string): void;
	readData(): string;
}

/**
 * Classe concreta: sorgente dati base
 */
class FileDataSource implements DataSource {
	private storage: string = "";

	writeData(data: string): void {
		console.log("Scrittura dati nel file:", data);
		this.storage = data;
	}

	readData(): string {
		console.log("Lettura dati dal file");
		return this.storage;
	}
}

/**
 * DECORATOR
 * Decoratore concreto che implementa DataSource e ha un riferimento a un DataSource
 * Inoltre aggiunge compressione ai dati
 * Serve per dare piu struttura al codice ma si può evitare e fare direttamente il Decoratore concreto
 */
class DataSourceDecorator implements DataSource{
	//Oggetto di base wrappato
	protected wrapper: DataSource;

	constructor(source: DataSource) {
		this.wrapper = source;
	}

	//riutilizzo le funzioni del wrapper e aggiungo altra logica
	writeData(data: string): void {
		data = this.compress(data);
		this.wrapper.writeData(data);
	}

	readData(): string {
		let data = this.wrapper.readData();
		return this.decompress(data);
	}

	//aggiungo ulteriori funzioni
	private compress(data: string): string {
		//Implementazione di compressione fittizia (esempio semplice)
		return data.split("").reverse().join("");
	}

	private decompress(data: string): string {
		//Decompressione fittizia(in questo caso inversa della compressione)
		return data.split("").reverse().join("");
	}
}

//Da questo momento in poi potrei procedere in 2 modi:
//VERTICALE: Aggiungo un nuovo decoratore(virtuale e concreto) 'wrappando' un oggetto di tipo CompressionDecorator
//ORIZZONTALE: Aggiungo un nuovo decoratore(virtuale e concreto) 'wrappando' un oggetto di tipo DataSource => Consigliato

//USO DECORATOR
const fileSource: FileDataSource = new FileDataSource();
const compressedSource: DataSourceDecorator = new DataSourceDecorator(fileSource);

compressedSource.writeData("Questo è un testo da salvare");
const result: string = compressedSource.readData();

console.log("Dati letti decompressi:", result);

DesignPatternTeoria - Structural - facade

Wed, 25 Feb 2026 14:01:09 +0000

DESIGN PATTERN: FACADE

Il Facade è un pattern strutturale che fornisce un’interfaccia unificata e semplificata a un insieme di sottosistemi complessi.

La “facciata” nasconde i dettagli interni e offre al client un solo punto di accesso, riducendo l’accoppiamento tra componenti e migliorando la leggibilità.

QUANDO USARLO

Quando il sistema ha API verbose, complesse o frammentate.
Quando vuoi esporre solo facciate e non classi interne ai livelli superiori.

VANTAGGI

Semplifica l’uso del sistema, nascondendo la complessità.
Riduce l’accoppiamento tra client e sottosistemi.
Fornisce un punto unico di controllo (utile per logging, sicurezza, transazioni).
Facilita modifiche e manutenzione, isolando le dipendenze.

POTENZIALI SVANTAGGI

Se il client necessita di funzionalità molto specifiche, potrebbe comunque dover accedere ai sottosistemi.
Un eccessivo numero di facciate può portare a duplicazione di logica già presente nei moduli interni.

CODICE

/**
 * Interfaccia comune
 */
interface Crypto {
	currency: string;
	doPayment(amount: number): void;
	getCurrency(): string;
}

/**
 * Implementazioni concrete
 */
class BTC implements Crypto {
	currency: string = "BTC";

	doPayment(amount: number): void {
		console.log("[BTC] Avvio pagamento di " + amount + " BTC");
		console.log("[BTC] Operazione riuscita");
		console.log("[BTC] Invio mail di conferma");
	}

	getCurrency(): string {
		return this.currency;
	}
}

class Dogecoin implements Crypto {
	currency: string = "Dogecoin";

	doPayment(amount: number): void {
		console.log("[Dogecoin] Avvio pagamento di " + amount + " Dogecoin");
		console.log("[Dogecoin] Operazione riuscita");
		console.log("[Dogecoin] Invio mail di conferma");
	}

	getCurrency(): string {
		return this.currency;
	}
}

/**
 * FACADE
 * Espone un'interfaccia semplificata per il client
 */
class CryptoFacade {
	private wallet: Map<string, Crypto> = new Map();

	constructor() {
		// Registrazione delle crypto disponibili
		const btc = new BTC();
		const dogecoin = new Dogecoin();
		this.wallet.set(btc.getCurrency(), btc);
		this.wallet.set(dogecoin.getCurrency(), dogecoin);
	}

	// Metodo comune per pagare
	public pay(amount: number, currency: string): void {
		const crypto = this.wallet.get(currency);
		if (!crypto) {
			console.log("Valuta non supportata: " + currency);
			return;
		}
		console.log("=== Avvio pagamento tramite Facade ===");
		crypto.doPayment(amount);
		console.log("=== Fine pagamento ===");
	}
}

/**
 * USO DEL FACADE
 * Il client vede solo la Facade, non le classi concrete
 */
const paymentSystem = new CryptoFacade();
paymentSystem.pay(500, "BTC");
paymentSystem.pay(2000, "Dogecoin");
paymentSystem.pay(100, "Ethereum"); // non supportata

DesignPatternTeoria - Creational - builder

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: BUILDER

Il Builder è un pattern creazionale che consente di costruire oggetti complessi passo dopo passo.

A differenza del Factory, che si concentra solo sulla creazione, il Builder gestisce anche la composizione graduale dell’oggetto, rendendo il processo più leggibile e flessibile.

QUANDO UTILIZZARLO

La costruzione dell’oggetto richiede molti passaggi o parametri opzionali.
Vuoi evitare il “telescoping constructor” (costruttori con troppi parametri).
Vuoi che l’oggetto finale sia immutabile, ma la sua creazione rimanga flessibile.
Necessiti di creare varianti partendo da una configurazione di base.

VANTAGGI

Chiarezza: sequenze come .setX().setY().build() rendono il codice leggibile e modulare.
Flessibilità: permette di configurare solo ciò che serve.
Immutabilità: l’oggetto finale può essere reso non modificabile.
Pulizia del costruttore: evita l’uso di costruttori con troppi parametri.
Riutilizzo: puoi partire da un builder già configurato per creare varianti.

POTENZIALI SVANTAGGI

Maggiore complessità: richiede classi aggiuntive anche per casi semplici.
Overkill: non necessario per oggetti con poche proprietà.
Validazione assente: di default non impone controlli sui dati forniti.

CHICCA OPZIONALE: DIRETTIVE

Nel caso in cui notiamo nel codice dei casi in cui abbiamo diversi build che hanno lo stesso set di parametri allora conviene utilizzare oltre ai builder anche le DIRETTIVE, ovvero dei builder pre-compilati

DesignPatternTeoria - Creational - factory method

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: FACTORY METHOD

Il Factory Method è un pattern creazionale che definisce un’interfaccia per la creazione di oggetti, delegando alle sottoclassi la decisione su quale classe concreta istanziare.

Questo approccio separa la logica di creazione dal codice che utilizza gli oggetti, migliorando flessibilità e manutenibilità.

QUANDO UTILIZZARLO

Quando non conosci a priori la classe concreta da istanziare.
Quando vuoi centralizzare la logica di creazione degli oggetti.
Quando desideri ridurre le dipendenze dirette da classi specifiche.

VANTAGGI

Separazione delle responsabilità: isola la logica di istanziazione dal codice client.
Estendibilità: per supportare nuovi tipi di oggetti basta estendere la factory.
Open/Closed Principle: il codice client dipende da interfacce, non da implementazioni concrete.
Codice più pulito e modulare: la creazione è incapsulata.

POTENZIALI SVANTAGGI

Potrebbe richiedere molte sottoclassi o rami condizionali per gestire vari tipi di oggetti.
Non è ottimale per oggetti con numerose varianti di configurazione.
L’aggiunta di nuovi tipi può richiedere modifiche alla factory esistente.

CODICE

/**
 * Interfaccia di base(necessaria)
 */
interface Notifica {
 invia(messaggio: string): void;
}

/**
 * Classi specializzate che implementano l'interfaccia di partenza
 */
class NotificaEmail implements Notifica {
 //Override del metodo
 invia(messaggio: string): void {
 console.log(`Invio email con messaggio: ${messaggio}`);
 }
}

/**
 * Classi specializzate che implementano l'interfaccia di partenza
 */
class NotificaSMS implements Notifica {
 //Override del metodo
 invia(messaggio: string): void {
 console.log(`Invio SMS con messaggio: ${messaggio}`);
 }
}

/**FACTORY
* Andremo a eseguire le new passando per il metodo statico della factory
* Deleghiamo come avviene la creazione/costruzione dell'oggetto alla factory
* Per funzionare le classi devono avere un padre comune(interfaccia o classe)
*/
class NotificaFactory {
 static creaNotifica(tipo: string) {
 switch (tipo) {
 case "email":
 return new NotificaEmail();
 case "sms":
 return new NotificaSMS();
 default:
 throw new Error("Tipo di notifica non supportato");
 }
 }
}

//USO FACORY
//Nelle righe a seguire io non so come viene creata una notifica -> delego questa logica alla 'NotificaFactory'
let notifica = NotificaFactory.creaNotifica("sms");
notifica.invia("Ciao utente!");
notifica = NotificaFactory.creaNotifica("email");
notifica.invia("Come stai?");

DesignPatternTeoria - Creational - singleton

Wed, 25 Feb 2026 14:01:08 +0000

DESIGN PATTERN: SINGLETON

Il pattern Singleton è una soluzione architetturale che garantisce la creazione di una sola istanza di una determinata classe per l’intera durata dell’applicazione.

Viene utilizzato quando è necessario un unico punto di accesso globale a una risorsa condivisa, ad esempio:

configurazioni dell’applicazione
connessioni a database
sistemi di logging

QUANDO UTILIZZARLO

Serve una sola istanza condivisa
Lo stato deve essere centralizzato
L’oggetto è costoso da creare
È richiesta una visione globale dello stato

VANTAGGI

Consistenza globale: tutti gli utilizzatori condividono lo stesso stato.
Controllo centralizzato: gestione unificata della risorsa.
Risparmio di memoria: un’unica istanza evita duplicazioni inutili.

POTENZIALI SVANTAGGI

Testing più complesso: può introdurre dipendenze nascoste, ostacolando i test unitari.
Accesso globale rischioso: se abusato, può portare a un design meno modulare e più difficile da manutenere.

CODICE

/**
 * SINGLETON
 */
class Logger {
	//Istanza statica per conservare le informazioni
	private static instance?: Logger;
	private message?: string;

	//Costruttore privato
	private constructor(message: string) {
		this.message = message;
	}

	//Punto in cui avviene la magia
	static getInstance(message: string): Logger {
		//Attenzione nei linguaggi multi thread in questo punto 
		if (this.instance) {
			return this.instance;
		}

		this.instance = new Logger(message);
		return this.instance
	}

	public getMessage() {
		return this.message;
	}
}

//USO SINGLETON
const logger1 = Logger.getInstance("ciao mondo");
const logger2 = Logger.getInstance("seconda instanza, non mi vedi");

console.log(logger1 === logger2); // true -> stessa istanza!
console.log(logger1.getMessage());
console.log(logger2.getMessage());

DesignPatternTeoria - Behavioral - command

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: COMMAND

Il Command è un pattern comportamentale che incapsula una richiesta all’interno di un oggetto, consentendo di parametrizzare i client con richieste differenti, mettere in coda o salvare operazioni, e supportare funzionalità come undo/redo.

Il pattern separa chi invoca un’operazione (Invoker) da chi la esegue (Receiver), permettendo maggiore flessibilità nella gestione delle azioni.

QUANDO USARLO

Vuoi separare il codice che invoca un’operazione dal codice che la esegue.
Vuoi implementare operazioni annullabili (undo/redo).
Vuoi registrare, ritardare o eseguire operazioni in batch.
Vuoi implementare macro che combinano più comandi in sequenza.

VANTAGGI

Separazione delle responsabilità: chi invoca non conosce i dettagli dell’esecuzione.
Flessibilità: code di comandi, esecuzione ritardata, batch, macro.
Undo/Redo: possibile mantenendo lo stato o registrando operazioni inverse.
Estendibilità: nuovi comandi possono essere aggiunti senza modificare il codice esistente.

POTENZIALI SVANTAGGI

Maggiore complessità: richiede una classe separata per ogni comando.
Overkill per sistemi semplici: il vantaggio si percepisce in scenari più complessi.

CODICE

/**
 * Classe ricevente(del comando)
 */
class Light {
	private state: boolean = false;

	getState(): boolean {
		return this.state;
	}

	setState(newState: boolean): void {
		this.state = newState;
	}

	toString(): string {
		return this.state ? "accesa" : "spenta";
	}
}

/**
 * COMMAND
 */
interface CommandLight {
	//comando astratto
	executeSwitchOnOffLight(): void;
}

/**
 * Classe mandante(del comando)
 * Deve implementare correttamente l'interfaccia command
 */
class Room implements CommandLight {
	roomLight: Light;

	constructor(light: Light) {
		this.roomLight = light;
	}

	/**
	 * Comando contreto
	 */
	executeSwitchOnOffLight(): void {
		const oldState = this.roomLight.getState();
		this.roomLight.setState(!oldState);
		console.log("La lampadina è", this.roomLight.toString());
	}
}

//USO COMMAND
let light: Light = new Light();
let room: Room = new Room(light);
room.executeSwitchOnOffLight();
room.executeSwitchOnOffLight();

DesignPatternTeoria - Behavioral - observer

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: OBSERVER

L’Observer è un pattern comportamentale che permette a un oggetto (Subject) di notificare automaticamente un insieme di oggetti (Observers) ogni volta che il suo stato cambia.
È alla base di molti sistemi basati su eventi e della programmazione reattiva.

QUANDO USARLO

Più oggetti devono reagire ai cambiamenti di stato di un altro oggetto.
Vuoi implementare sistemi di eventi o flussi di dati asincroni.
Vuoi disaccoppiare il publisher dai subscriber, evitando dipendenze dirette.

VANTAGGI

Broadcasting semplice verso più listener contemporaneamente.
Disaccoppiamento tra chi emette eventi e chi li gestisce.
Perfetto per UI reattive, flussi di dati in tempo reale e sistemi asincroni.
Supportato nativamente in librerie come RxJS.

POTENZIALI SVANTAGGI

Possibili memory leak se gli observer non vengono disiscritti.
La complessità aumenta con il numero di observer e interazioni.
Debug più complesso in sistemi con molti eventi concatenati.

STRUTTURA

SUBJECT -> OBSERVER 1, OBSERVER 2, …, OBSERVER N(stesso tipo) -> NOTIFICATION

DesignPatternTeoria - Behavioral - state

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: STATE

Lo State è un pattern comportamentale che permette a un oggetto di modificare il proprio comportamento quando cambia il suo stato interno.
È come se l’oggetto cambiasse “classe” in modo dinamico.

QUANDO USARLO

Un oggetto deve cambiare comportamento in base al suo stato.
Vuoi evitare grandi istruzioni if o switch che controllano lo stato.
Vuoi centralizzare i comportamenti di uno stato in una classe dedicata.

VANTAGGI

Elimina if-else o switch-case complessi.
Ogni stato è isolato in una classe separata (Single Responsibility Principle).
Facile aggiungere nuovi stati senza modificare quelli esistenti.
Migliora leggibilità e manutenzione del codice.

POTENZIALI SVANTAGGI

Aumenta il numero di classi nel sistema.
Può risultare eccessivo per macchine a stati semplici.

CODICE

/**
 * Classe con internamente il riferimento a uno degli stati esterni
 */
class Semaforo {
 //Determino solo che esiste uno stato, non mi interessa la logica di aggiornamento
 private stato: StatoSemaforo = new Rosso();

 aggiornataStato(): void {
 this.stato = this.stato.cambia();
 }

 getStato(): void {
 this.stato.mostra();
 }
}

/**
 * STATE
 * State interfaccia comune
 */
interface StatoSemaforo {
 cambia(): StatoSemaforo;
 mostra(): void;
}

/**
 * Stati concreto => Rosso 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Rosso implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da ROSSO a VERDE');
 return new Verde();
 }

 mostra(): void {
 console.log('Rosso: STOP');
 }
}

/**
 * Stati concreto => Verde 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Verde implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da VERDE a GIALLO');
 return new Giallo();
 }

 mostra(): void {
 console.log('Verde: VAI');
 }
}

/**
 * Stati concreto => Giallo 
 * Slego il cambio stato dalla "classe con stato" agli "stati effettivi"
 */
class Giallo implements StatoSemaforo {
 cambia(): StatoSemaforo {
 console.log('Cambio da GIALLO a ROSSO');
 return new Rosso();
 }

 mostra(): void {
 console.log('Giallo: ATTENZIONE');
 }
}

// USO STATE
const semaforo = new Semaforo();

semaforo.getStato();
semaforo.aggiornataStato();

semaforo.getStato();
semaforo.aggiornataStato();

semaforo.getStato();
semaforo.aggiornataStato();

DesignPatternTeoria - Behavioral - strategy

Wed, 25 Feb 2026 14:01:07 +0000

DESIGN PATTERN: STRATEGY

Lo Strategy è un pattern comportamentale che permette di definire una famiglia di algoritmi, incapsularli e renderli intercambiabili a runtime senza modificare il contesto che li utilizza.
In pratica, consente di cambiare il “comportamento” di un oggetto in modo flessibile.

QUANDO USARLO

Più algoritmi alternativi devono essere scelti dinamicamente.
Vuoi evitare lunghi if-else o switch-case pieni di logica condizionale.
Vuoi rispettare l’Open/Closed Principle: estendere il comportamento senza modificare il codice esistente.

VANTAGGI

Possibilità di aggiungere nuovi algoritmi senza modificare il codice principale.
Migliora leggibilità eliminando if/switch complessi.
Promuove la composizione invece dell’ereditarietà.
Algoritmi intercambiabili a runtime.

POTENZIALI SVANTAGGI

Aumenta il numero di classi/funzioni (una per strategia).
Il contesto deve conoscere l’interfaccia comune.
Più complesso rispetto a una semplice funzione inline per problemi banali.

CODICE

/**
 * Strategy astratta comune
 */
interface Strategy {
 esegui(a: number, b: number): number;
}

/**
 * Strategy concrete
 */
class StrategiaAddizione implements Strategy {
 esegui(a: number, b: number): number {
 return a + b;
 }
}

/**
 * Strategy concrete
 */
class StrategiaSottrazione implements Strategy {
 esegui(a: number, b: number): number {
 return a - b;
 }
}

/**
 * Strategy concrete
 */
class StrategiaMoltiplicazione implements Strategy {
 esegui(a: number, b: number): number {
 return a * b;
 }
}

/**
 * STRATEGY
 * Classe che utilizza una strategia interna
 */
class Calcolatrice {
 private StrategiaCalcolo: Strategy;

 constructor(strategia: Strategy) {
 this.StrategiaCalcolo = strategia;
 }

 setStrategia(strategia: Strategy): void {
 this.StrategiaCalcolo = strategia;
 }

 eseguiStrategia(a: number, b: number): number {
 return this.StrategiaCalcolo.esegui(a, b);
 }
}

// USO STRATEGY
const calcolatrice = new Calcolatrice(new StrategiaAddizione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

calcolatrice.setStrategia(new StrategiaSottrazione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

calcolatrice.setStrategia(new StrategiaMoltiplicazione());
console.log("Risultato:", calcolatrice.eseguiStrategia(5, 3));

Corso C - lezione 24 - esercizi sulle stringhe

Wed, 25 Feb 2026 14:01:06 +0000

lezione 24 - esercizi sulle stringhe.c

Corso C - lezione 23 - stringhe

Wed, 25 Feb 2026 14:01:05 +0000

STRING IN C

Nel linguaggio C, le stringhe non sono un tipo di dato primitivo, ma vengono rappresentate come array di caratteri terminati da un carattere speciale che indica la fine della sequenza.

COSA SONO?

Una stringa è una sequenza di caratteri memorizzata in memoria in modo contiguo. La sua particolarità è la presenza di un terminatore finale che segnala dove la stringa finisce, permettendo alle funzioni di riconoscerne la lunghezza.

Corso C - lezione 22 - esercizi matrici

Wed, 25 Feb 2026 14:01:04 +0000

ESERCIZI SULLE MATRICI

ES 1

Disegno di una scacchiera su una matrice di char

ES 2

Calcolo della diagonale maggiore

ES 3

Calcolo della diagonale minore

#include <stdio.h>

//es 1: disegno di una scacchiera su una matrice di char
void disegno(char M[3][3], int r, int c){
 for(int i = 0; i < r; i++){
 for(int j = 0; j < c; j++){
 if(i % 2 == 0 && j % 2 == 0){
 M[i][j] = '+';
 }else{
 M[i][j] = '-';
 }
 }
 }
}

void stampa(char M[3][3], int r, int c){
 for(int i = 0; i < r; i++){
 for(int j = 0; j < c; j++){
 printf("%c ", M[i][j]);
 }
 printf("\n");
 }
}

//es 2: calcolo della diagonale maggiore
int somma_DM(int M[3][3], int r, int c){
 int somma = 0;
 for(int i = 0; i < r; i++){
 somma = somma + M[i][i];
 }
 return somma;
}

//es 3: calcolo della diagonale minore
int somma_dm(int M[3][3], int r, int c){
 int somma = 0;
 for(int i = 0; i < r; i++){
 somma = somma + M[i][c-i-1];
 }
 return somma;
}

int main() {
 int M[3][3] = {
 {1, 2, 13},
 {4, 15, 6},
 {7, 8, 9}
 };

 char scac[3][3];
 disegno(scac, 3, 3);
 stampa(scac, 3, 3);
 printf("es2: %d\n", somma_DM(M, 3, 3));
 printf("es3: %d", somma_dm(M, 3, 3));
 
 return 0;
}

Corso C - lezione 21 - matrici

Wed, 25 Feb 2026 14:01:03 +0000

MATRICI

Nel linguaggio C, le matrici sono un’estensione degli array che permettono di organizzare i dati in più dimensioni, tipicamente in forma di tabella con righe e colonne.

COSA SONO

Una matrice è una struttura dati bidimensionale composta da elementi dello stesso tipo, disposti in righe e colonne. Ogni elemento è identificato da una coppia di indici che rappresentano la sua posizione.

REGOLE

Le matrici in C hanno dimensioni fisse definite al momento della dichiarazione. Gli indici partono da zero per ogni dimensione, quindi sia righe che colonne seguono questa convenzione. È fondamentale rispettare i limiti per evitare accessi a memoria non validi.

Corso C - lezione 20 - esercizi array

Wed, 25 Feb 2026 14:01:02 +0000

ESERCIZI SUGLI ARRAY

ES 1

Determinare se un array contiene solo numeri pari

ES 2

Scrivere una funzione sub_mult che dato un array di interi v e un intero n, stampi solo i multipli di n

ES 3

Scrivere una funzione cumulative_sum che dato un array di interi v, stampi un nuovo array di interi contenente le somme cumulative per ogni elemento del vettore in input. Ovvero, in ogni posizione i del nuovo array, dovrà essere la somma di tutti gli elementi in v fino alla posizione i (compresa).

Corso C - lezione 19 - array

Wed, 25 Feb 2026 14:01:01 +0000

ARRAY

Nel linguaggio C, gli array sono strutture dati che permettono di memorizzare più valori dello stesso tipo in una sequenza ordinata.

COSA SONO

Un array è una collezione di elementi omogenei, cioè tutti dello stesso tipo, memorizzati in posizioni di memoria contigue. Ogni elemento è accessibile tramite un indice che rappresenta la sua posizione.

REGOLE

Gli array in C hanno una dimensione fissa definita al momento della dichiarazione e non può essere modificata successivamente. Gli indici partono da zero, quindi il primo elemento si trova sempre in posizione zero. È importante non accedere a posizioni fuori dai limiti, perché può causare errori gravi.

Corso C - lezione 18 - esercizi puntatori

Wed, 25 Feb 2026 14:01:00 +0000

ESERCIZI SUI PUNTATORI

ES 1

Scrivi un programma in C che dichiari due variabili intere. Implementa una funzione swap che prende in input due puntatori a intero e scambia i valori delle due variabili.

ES 2

Scrivi un programma che dichiari una funzione int quadrato(int x) che restituisce il quadrato di un numero. Nel main, dichiara un puntatore a funzione e usalo per chiamare la funzione quadrato.

Corso C - lezione 17 - puntatori

Wed, 25 Feb 2026 14:00:59 +0000

PUNTATORI

Nel linguaggio C, i puntatori sono uno degli strumenti più potenti e caratteristici. Permettono di lavorare direttamente con la memoria, offrendo un controllo molto preciso sul comportamento del programma.

COSA SONO

Un puntatore è una variabile che contiene l’indirizzo di memoria di un’altra variabile. Invece di memorizzare direttamente un valore, “punta” alla posizione in cui quel valore è salvato.

COME SI SCRIVONO

Un puntatore viene dichiarato specificando il tipo di dato a cui fa riferimento e un simbolo che indica che si tratta di un indirizzo. Questo tipo deve essere coerente con il dato a cui il puntatore si riferisce.

Corso C - lezione 16 - esercizi funzioni

Wed, 25 Feb 2026 14:00:58 +0000

ESERCIZI SULLE FUNZIONI

ES 1

Scrivi una funzione area_rettangolo(base, altezza) che restituisca l’area di un rettangolo. Poi chiedi all’utente i valori di base e altezza e stampa il risultato.

ES 2

Scrivi una funzione pari_o_dispari(n) che ritorni la valore 1 se il numero è pari e 0 se il numero è dispari.

ES 3

Scrivi una funzione calcola(a, b, operatore) che prenda due numeri e una carattere che rappresenta l’operazione (’+’, ‘-’, ‘*’, ‘/’). La funzione deve restituire il risultato dell’operazione. Poi crea un programma che chieda i due numeri e l’operatore all’utente e mostri il risultato.

Corso C - lezione 15 - funzioni

Wed, 25 Feb 2026 14:00:57 +0000

FUNZIONI

Nel linguaggio C, le funzioni sono blocchi di codice riutilizzabili progettati per svolgere un compito specifico. Permettono di suddividere un programma in parti più piccole, migliorandone organizzazione e leggibilità.

COSA SONO

Una funzione è una sequenza di istruzioni identificata da un nome, che può essere eseguita ogni volta che viene richiamata. Può ricevere dei dati in ingresso e, opzionalmente, restituire un risultato.

COME SI SCRIVONO

Una funzione in C è definita specificando un tipo di ritorno, un nome e un insieme di parametri. Il suo corpo contiene le istruzioni da eseguire. Questa struttura permette di isolare una logica precisa dal resto del programma.

Corso C - lezione 14 - confronto tra for, while e do while

Wed, 25 Feb 2026 14:00:56 +0000

CONFRONTO FOR, WHILE E DO WHILE

Nel linguaggio C, i cicli for, while e do while servono tutti a ripetere un blocco di codice, ma si differenziano per struttura e modalità di utilizzo.

CICLO FOR

Il ciclo for è ideale quando si conosce in anticipo il numero di iterazioni da eseguire, perché racchiude inizializzazione, condizione e aggiornamento in un’unica struttura compatta.

CICLO WHILE

Il ciclo while è più flessibile ed è utilizzato quando il numero di iterazioni non è noto a priori, ma dipende da una condizione che viene valutata prima di ogni esecuzione del ciclo.

Corso C - lezione 13 - esercizi while e do while

Wed, 25 Feb 2026 14:00:55 +0000

ESERCIZI SUI WHILE E DO WHILE

ES 1

Scrivi un programma che chieda all’utente un numero intero positivo e stampi a video un conto alla rovescia fino a 0.

ES 2

Chiedi all’utente di inserire numeri interi. Il programma continua a chiedere numeri fino a quando l’utente inserisce 0. Alla fine stampa la somma di tutti i numeri inseriti (escluso lo zero).

Corso C - lezione 12 - while e do while

Wed, 25 Feb 2026 14:00:54 +0000

CICLI WHILE

Nel linguaggio C, i cicli while sono strutture iterative che permettono di eseguire un blocco di codice finché una determinata condizione rimane vera.

COSA SONO

I while sono cicli “a controllo iniziale”, ovvero valutano la condizione prima di ogni iterazione. Se la condizione è vera, il ciclo continua; se è falsa, il ciclo termina.

COME SI SCRIVONO

La struttura di un while prevede una condizione logica e un blocco di istruzioni associato. Il programma verifica la condizione e, se soddisfatta, esegue il blocco, ripetendo il processo fino a quando la condizione non diventa falsa.

Corso C - lezione 11 - esercizi for

Wed, 25 Feb 2026 14:00:53 +0000

ESERCIZI FOR

ES 1

Scrivi un programma che stampi i numeri da 10 a 1 in ordine decrescente utilizzando un ciclo for.

ES 2

Calcola la somma di tutti i numeri pari da 1 a 100 usando un ciclo for.

ES 3

Chiedi all’utente un numero n e stampa la sua tabellina fino a n × 10.

SOLUZIONI

#include <stdio.h>

int main() {
 /*
 ES 1
 Scrivi un programma che stampi i numeri da 10 a 1 in ordine decrescente utilizzando un ciclo for.
 */
 int start = 10;
 int end = 1;
 int i;
 for(i = start; i >= end; i--){
 printf("%d ", i);
 }
 
 /*
 ES 2
 Calcola la somma di tutti i numeri pari da 1 a 100 usando un ciclo for.
 */
 int somma = 0;
 int start = 1;
 int end = 100;
 int i;
 for(i = start; i <= end; i++){
 //all'interno di somma ci metto il vecchio valore + l'elemento di ciclo(dipende dallo step)
 somma = somma + i;
 }
 printf("%d", somma);
 
 /*
 ES 3
 Chiedi all’utente un numero n e stampa la sua tabellina fino a n × 10.
 */
 int valore;
 printf("inserisci valore del quale si vuole calcolare la tabellina\n");
 scanf("%d", &valore);
 int i;
 for(i = 1; i <= 10; i++){
 printf("%d x %d = %d\n", i, valore, i * valore);
 }
}

Corso C - lezione 10 - for

Wed, 25 Feb 2026 14:00:52 +0000

FOR

Nel linguaggio C, il ciclo for è una struttura iterativa che permette di eseguire un blocco di istruzioni più volte, in modo controllato.

COSA SONO

I for sono costrutti utilizzati per ripetere una sequenza di operazioni per un numero definito di volte. Sono particolarmente adatti quando si conosce in anticipo quante iterazioni devono essere eseguite.

PERCHÈ SERVONO

Servono per automatizzare operazioni ripetitive, evitando di scrivere più volte lo stesso codice. Sono molto utilizzati, ad esempio, per scorrere sequenze di dati, eseguire calcoli ripetuti o iterare su strutture come array.

Corso C - lezione 9 - esercizi switch

Wed, 25 Feb 2026 14:00:51 +0000

ESERCIZI SWITCH

ES 1

Scrivi un programma che, dato un numero da 1 a 7, stampi il nome del giorno corrispondente. 1 → Lunedì 2 → Martedì … 7 → Domenica

ES 2

Scrivi un programma che, dato un voto scolastico da 1 a 10, stampi il giudizio: 1–4 → “Insufficiente” 5 → “Mediocre” 6 → “Sufficiente” 7–8 → “Buono” 9–10 → “Ottimo”

Corso C - lezione 8 - switch

Wed, 25 Feb 2026 14:00:50 +0000

SWITCH

Nel linguaggio C, lo switch è una struttura di controllo che permette di selezionare tra diversi blocchi di codice in base al valore di una variabile o espressione.

COSA SONO

Gli switch sono costrutti decisionali alternativi agli if, pensati per gestire in modo più ordinato situazioni in cui una variabile può assumere diversi valori distinti. Ogni possibile valore corrisponde a un ramo specifico del programma.

Corso C - lezione 7 - esercizi sulle tabelle di verita

Wed, 25 Feb 2026 14:00:49 +0000

ESERCIZI SULLE TABELLE DI VERITA'

ES 1

Un utente può entrare in una stanza solo se ha la chiave e conosce il codice di sicurezza. Usare l’operatore AND per determinare se l’accesso è consentito.

ES 2

Una persona può guidare un’auto se ha la patente oppure è accompagnata da un istruttore. Usare OR per stabilire se può guidare.

ES 3

Un allarme deve scattare solo se la finestra è aperta e non c’è una persona autorizzata in casa. Usare NOT e AND.

Corso C - lezione 6 - tabelle di verita

Wed, 25 Feb 2026 14:00:48 +0000

TABELLE DI VERITA

NOT

Nel linguaggio C, l’operatore NOT serve per invertire il valore di una condizione booleana. È un operatore unario, quindi agisce su una sola espressione. Il simbolo utilizzato per rappresentare il NOT in C è il punto esclamativo. Viene posto prima della condizione che si vuole invertire.

! 1 -> 0 0 -> 1

AND

Nel linguaggio C, l’operatore AND viene utilizzato per combinare due o più condizioni booleane. Il risultato è vero solo se tutte le condizioni coinvolte sono vere. L’AND lavora confrontando almeno due condizioni. Queste condizioni vengono valutate insieme per determinare un unico risultato logico. Il simbolo utilizzato per rappresentare l’AND in C è la doppia e commerciale. Serve per collegare più condizioni all’interno di un’unica espressione.

Corso C - lezione 5 - esercizi if else

Wed, 25 Feb 2026 14:00:47 +0000

ESERCIZI SUGLI IF

ES 1

Utilizzare una struttura if per determinare se un numero è positivo, negativo o zero.

ES 2

Confrontare due numeri interi e stampare il maggiore.

ES 3

Controllare se un voto è valido (0–30) e determinare se è sufficiente (≥18).

SOLUZIONI

#include <stdio.h>

int main()
{
 /*
 es 1
 Utilizzare una struttura if per determinare se un numero è positivo, negativo o zero.
 */

 // v1
 /*int val = -1;
 if(val > 0){
 printf("positivo");
 }else{
 if(val < 0){
 printf("negativo");
 }else{
 printf("zero");
 }
 }*/

 // v2
 int val = 0;
 if (val > 0)
 {
 printf("positivo");
 }
 else if (val < 0)
 {
 printf("negativo");
 }
 else
 {
 printf("zero");
 }

 /*
 es 2
 Confrontare due numeri interi e stampare il maggiore.
 */
 int v1 = 12;
 int v2 = 6;
 if (v1 > v2)
 {
 printf("max: %d", v1);
 }
 else
 {
 printf("max: %d", v2);
 }

 /*
 es 3
 Controllare se un voto è valido (0–30) e determinare se è sufficiente (≥18).
 */
 int voto = 18;
 // 0 <= 60 <= 30 -> no
 // 0 <= 60 <= 30 -> 0 <= 60 e 60 <= 30
 if (0 <= voto && voto <= 30)
 {
 printf("valido\n");
 if (voto >= 18)
 {
 printf("sufficiente\n");
 }
 else
 {
 printf("insufficiente\n");
 }
 }
 else
 {
 printf("non valido\n");
 }

 return 0;
}

Corso C - lezione 4 - if else

Wed, 25 Feb 2026 14:00:46 +0000

IF

Nel linguaggio C, le istruzioni condizionali permettono di controllare il flusso del programma in base a determinate condizioni. L’istruzione più comune per questo scopo è l’if, che consente di eseguire porzioni di codice solo quando una certa condizione risulta vera.

COSA SONO

Gli if sono costrutti decisionali che valutano un’espressione logica. Se il risultato della valutazione è vero, il programma esegue un certo blocco di istruzioni; in caso contrario, quel blocco viene saltato.

Corso C - lezione 3 - esercizi variabili

Wed, 25 Feb 2026 14:00:45 +0000

ESERCIZI SUI TIPI

ES1

Dichiarare due variabili intere, assegnare loro un valore e stampare la loro somma.

ES2

Usare variabili float per calcolare area e perimetro di un rettangolo.

ES3

Scambiare i valori di due variabili intere utilizzando una variabile temporanea.

SOLUZIONI

#include <stdio.h>
#include <stdbool.h> // Per il tipo bool(non nativo di C, in caso si possono usare gli interi)

int main()
{
 // commento di singola riga
 /*
 commento su più righe
 */

 /*
 es1
 Dichiarare due variabili intere, assegnare loro un valore e stampare la loro somma.
 */
 int A = 5;
 int B = 4;
 int somma = A + B;
 printf("la somma è: %d", somma);

 /*
 es2
 Usare variabili float per calcolare area e perimetro di un rettangolo.
 */
 float B;
 float H;

 printf("inserisci base: ");
 scanf("%f", &B);
 printf("inserisci altezza: ");
 scanf("%f", &H);

 float P = B * 2 + H * 2;
 float A = B * H;

 printf("P: %f", P);
 printf("A: %f", A);

 /*
 es3
 Scambiare i valori di due variabili intere utilizzando una variabile temporanea.
 */
 int v1 = 1;
 int v2 = 2;
 int backup;
 printf("prima: %d %d\n", v1, v2);
 backup = v1;
 v1 = v2;
 v2 = backup;
 printf("dopo: %d %d\n", v1, v2);

 return 0;
}

Corso C - lezione 2 - tipi

Wed, 25 Feb 2026 14:00:44 +0000

TIPI

Nel linguaggio C, i tipi di dato definiscono la natura delle informazioni che una variabile può contenere. Sono fondamentali perché permettono al compilatore di sapere come interpretare i dati e quanta memoria allocare.

QUANTI SONO

In C esistono diversi tipi di dato primitivi, come numeri interi, numeri con virgola, caratteri e valori booleani (anche se questi ultimi non sono nativi nelle versioni più vecchie). Ogni tipo ha caratteristiche specifiche in termini di dimensione e utilizzo.

Corso C - lezione 1 - variabili

Wed, 25 Feb 2026 14:00:43 +0000

VARIABILI

Nel linguaggio C, le variabili rappresentano delle porzioni di memoria che vengono utilizzate per memorizzare dati durante l’esecuzione di un programma. Sono uno degli elementi fondamentali della programmazione, perché permettono di salvare informazioni, modificarle e riutilizzarle nel tempo.

COSA SONO LE VARIABILI

Una variabile è essenzialmente un contenitore con un nome (identificatore) e un tipo. Il tipo definisce che tipo di dato può contenere (ad esempio numeri interi, numeri decimali o caratteri), mentre il nome serve per poterla richiamare all’interno del programma.

CodingLeetCode - 2798 - Number of Employees Who Met the Target

Wed, 25 Feb 2026 14:00:42 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given an array hours representing the working hours of employees and an integer target. Return the number of employees who worked at least target hours.

Possiamo risolvere questo problema contando semplicemente quanti valori soddisfano la condizione, come nel codice proposto.

L’idea chiave è:

inizializziamo un contatore a 0
scorriamo l’array hours elemento per elemento
per ogni valore controlliamo se è maggiore o uguale al target
se la condizione è vera, incrementiamo il contatore
al termine restituiamo il numero totale di elementi validi

Questo approccio permette di ottenere una complessità O(n), dove n è la lunghezza dell’array, ed è ottimale perché richiede una sola scansione senza strutture dati aggiuntive.

CodingLeetCode - 2399 - Check Distances Between Same Letters

Wed, 25 Feb 2026 14:00:41 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given a string s consisting of lowercase English letters and an integer array distance of length 26. For every letter from ‘a’ to ‘z’, if it appears twice in s, the distance between its two occurrences must be equal to distance[i]. Return true if all distances match, otherwise return false.

Possiamo risolvere questo problema calcolando la distanza tra le due occorrenze di ogni carattere, come nei due codici proposti.

CodingLeetCode - 2011 - Final Value of Variable After Performing Operations

Wed, 25 Feb 2026 14:00:40 +0000

Oggi vediamo il seguente esercizio di LeetCode:

There is a programming language with only four operations: ++X, X++, –X, X–. Given an array of strings operations, return the final value of X after performing all the operations starting from X = 0.

Possiamo risolvere questo problema simulando direttamente l’esecuzione delle operazioni, come nel codice proposto.

L’idea chiave è:

inizializziamo una variabile value a 0
scorriamo l’array di operazioni una per una
se l’operazione è incremento (++X o X++), aumentiamo il valore di 1
altrimenti, per le operazioni di decremento (–X o X–), diminuiamo il valore di 1
continuiamo fino alla fine dell’array
restituiamo il valore finale

Questo approccio permette di ottenere una complessità O(n), dove n è il numero di operazioni, ed è efficiente perché simula direttamente il comportamento richiesto senza strutture dati aggiuntive o trasformazioni intermedie.

CodingLeetCode - 1672 - Richest Customer Wealth

Wed, 25 Feb 2026 14:00:39 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given an m x n integer grid accounts where accounts[i][j] is the amount of money the i-th customer has in the j-th bank. Return the wealth that the richest customer has.

Possiamo risolvere questo problema calcolando la somma di ogni riga della matrice, come nel codice proposto.

L’idea chiave è:

ogni riga dell’array rappresenta un cliente
ogni elemento della riga rappresenta il denaro in una banca
per ogni cliente, calcoliamo la somma di tutti i suoi conti
confrontiamo la somma ottenuta con il massimo attuale
se la somma è maggiore, aggiorniamo il massimo
alla fine restituiamo il valore massimo trovato

Questo approccio permette di ottenere una complessità O(m × n), dove m è il numero di clienti e n il numero di conti per cliente. È una soluzione semplice e diretta, che scorre la matrice una sola volta senza strutture dati aggiuntive

CodingLeetCode - 1603 - Design Parking System

Wed, 25 Feb 2026 14:00:38 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Design a parking system for a parking lot. The parking lot has three types of parking spaces: big, medium, and small. Each type has a fixed number of slots.

Implement the ParkingSystem class:

ParkingSystem(int big, int medium, int small) bool addCar(int carType)

Possiamo risolvere questo problema modellando direttamente lo stato del parcheggio, come nel codice proposto.

L’idea chiave è:

memorizziamo il numero di posti disponibili per ogni tipo di auto: big, medium, small
nel costruttore inizializziamo la disponibilità di ciascuna categoria
quando arriva una richiesta addCar(carType):
- se il tipo è 1 (big) e c’è disponibilità, decrementiamo e ritorniamo true
- se il tipo è 2 (medium) e c’è disponibilità, decrementiamo e ritorniamo true
- se il tipo è 3 (small) e c’è disponibilità, decrementiamo e ritorniamo true
- se non c’è spazio disponibile per quel tipo, ritorniamo false

Questo approccio permette di ottenere una complessità O(1) per ogni operazione, ed è efficiente perché rappresenta direttamente lo stato del sistema senza strutture dati aggiuntive o logica complessa.

CodingLeetCode - 1470 - Shuffle the Array

Wed, 25 Feb 2026 14:00:37 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given the array nums consisting of 2n elements in the form [x1,x2,…,xn,y1,y2,…,yn]. Return the array in the form [x1,y1,x2,y2,…,xn,yn].

Possiamo risolvere questo problema intercalando gli elementi delle due metà dell’array, come nel codice proposto.

L’idea chiave è:

dividiamo logicamente l’array in due metà: la prima contiene gli elementi x, la seconda gli elementi y
calcoliamo la metà della lunghezza dell’array
scorriamo i primi n elementi
per ogni indice i:
- aggiungiamo nums[i] (parte sinistra)
- aggiungiamo nums[i + n] (parte destra)
continuiamo fino a ricostruire l’array alternato

Questo approccio permette di ottenere una complessità O(n), dove n è la metà della lunghezza dell’array, ed è efficiente perché costruisce direttamente il risultato senza passaggi aggiuntivi o riorganizzazioni intermedie.

CodingLeetCode - 1431 - Kids With the Greatest Number of Candies

Wed, 25 Feb 2026 14:00:36 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an array candies, where candies[i] represents the number of candies the i-th kid has, and an integer extraCandies. Return a boolean array result, where result[i] is true if, after giving the i-th kid all the extraCandies, they will have the greatest number of candies among all kids.

Possiamo risolvere questo problema confrontando ogni bambino con il massimo attuale, come nel codice proposto.

CodingLeetCode - 1108 - Defanging an IP Address

Wed, 25 Feb 2026 14:00:35 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a valid (IPv4) IP address address, return a defanged version of that IP address. defanged IP address replaces every period “.” with “[.]”.

Possiamo risolvere questo problema dividendo l’indirizzo IP nelle sue componenti e ricostruendolo con la forma richiesta, come nel codice proposto.

L’idea chiave è:

dividiamo la stringa dell’IP utilizzando il punto come separatore otteniamo così le quattro parti dell’indirizzo IPv4 ricostruiamo la stringa inserendo tra ogni parte la sequenza “[.]” restituiamo il risultato finale

CodingLeetCode - 771 - Jewels and Stones

Wed, 25 Feb 2026 14:00:34 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You’re given strings jewels representing the types of stones that are jewels, and stones representing the stones you have. Each character in stones is a type of stone you have. You want to know how many of the stones you have are also jewels.

Possiamo risolvere questo problema usando una struttura dati che ci permetta di verificare rapidamente se un carattere è un “jewel”, come nel codice proposto.

CodingLeetCode - 605 - Can Place Flowers

Wed, 25 Feb 2026 14:00:33 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots. Given an integer array flowerbed containing 0’s and 1’s, where 0 means empty and 1 means planted, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule.

CodingLeetCode - 345 - Reverse Vowels of a String

Wed, 25 Feb 2026 14:00:32 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a string s, reverse only all the vowels in the string and return it.

Possiamo risolvere questo problema raccogliendo prima le vocali e poi reinserendole in ordine inverso, come nel codice proposto.

L’idea chiave è:

scorriamo la stringa da destra verso sinistra e salviamo tutte le vocali in un array
in questo modo otteniamo già le vocali in ordine inverso
scorriamo nuovamente la stringa da sinistra verso destra
ogni volta che incontriamo una vocale, la sostituiamo con quella successiva nell’array delle vocali invertite
utilizziamo una funzione di supporto per sostituire il carattere nella posizione corretta
continuiamo fino a ricostruire tutta la stringa

Questo approccio permette di ottenere una complessità O(n), ma utilizza memoria aggiuntiva e operazioni di slicing che creano nuove stringhe. Una soluzione più ottimale utilizza due puntatori (uno all’inizio e uno alla fine) e scambia direttamente le vocali senza creare strutture ausiliarie.

CodingLeetCode - 344 - Reverse String

Wed, 25 Feb 2026 14:00:31 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Write a function that reverses a string. The input string is given as an array of characters s. You must do this by modifying the input array in-place with O(1) extra memory.

Possiamo risolvere questo problema invertendo direttamente gli elementi dell’array, come nel codice proposto.

L’idea chiave è:

utilizziamo due puntatori: uno all’inizio e uno alla fine dell’array
scorriamo solo metà dell’array
ad ogni iterazione scambiamo gli elementi simmetrici
utilizziamo una variabile temporanea per effettuare lo scambio
continuiamo fino a raggiungere il centro dell’array

Questo approccio permette di ottenere una complessità O(n) e spazio O(1), ed è ottimale perché modifica l’array direttamente senza utilizzare strutture dati aggiuntive.

CodingLeetCode - 283 - Move Zeroes

Wed, 25 Feb 2026 14:00:30 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an integer array nums, move all 0’s to the end of it while maintaining the relative order of the non-zero elements. Note that you must do this in-place without making a copy of the array.

Possiamo risolvere questo problema rimuovendo gli zeri e aggiungendoli alla fine, come nel codice proposto.

L’idea chiave è:

scorriamo l’array elemento per elemento
quando troviamo uno zero, lo rimuoviamo usando splice
teniamo traccia del numero di zeri rimossi
non incrementiamo l’indice dopo la rimozione, perché gli elementi si spostano
se l’elemento non è zero, passiamo al successivo
al termine della scansione, aggiungiamo tanti zeri quanti ne abbiamo rimossi

Questo approccio permette di ottenere una soluzione corretta e mantiene l’ordine relativo degli elementi. Tuttavia, ha una complessità O(n²) a causa delle operazioni di splice, che spostano gli elementi dell’array: una soluzione più efficiente utilizza due puntatori e lavora in O(n) senza operazioni costose.

CodingLeetCode - 242 - Valid Anagram

Wed, 25 Feb 2026 14:00:29 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

Possiamo risolvere questo problema confrontando le versioni ordinate delle due stringhe, come nel codice proposto.

L’idea chiave è:

controlliamo subito se le due stringhe hanno lunghezze diverse
se sì, non possono essere anagrammi
convertiamo entrambe le stringhe in array di caratteri
ordiniamo i due array
confrontiamo i caratteri posizione per posizione
se troviamo una differenza, le stringhe non sono anagrammi
se tutti i caratteri coincidono, allora sono anagrammi

Questo approccio permette di ottenere una complessità O(n log n) a causa dell’ordinamento. È una soluzione semplice e intuitiva, anche se non la più efficiente: si può migliorare utilizzando una struttura di conteggio delle frequenze per raggiungere una complessità O(n).

CodingLeetCode - 239 - Sliding Window Maximum

Wed, 25 Feb 2026 14:00:28 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given an array of integers nums, and there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position, return the maximum value in the window.

Possiamo risolvere questo problema calcolando il massimo per ogni finestra, come nel codice proposto.

CodingLeetCode - 217 - Contains Duplicate

Wed, 25 Feb 2026 14:00:27 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Possiamo risolvere questo problema ordinando l’array e controllando elementi consecutivi, come nel codice proposto.

L’idea chiave è:

ordiniamo l’array utilizzando un algoritmo di ordinamento (in questo caso merge sort)
una volta ordinato, eventuali duplicati saranno adiacenti
scorriamo l’array a partire dal secondo elemento
confrontiamo ogni elemento con il precedente
se troviamo due elementi uguali consecutivi, esiste un duplicato
altrimenti, se arriviamo alla fine senza trovare uguaglianze, tutti gli elementi sono distinti

Questo approccio permette di ottenere una complessità O(n log n) a causa dell’ordinamento. Tuttavia, utilizza più operazioni del necessario: una soluzione più efficiente sfrutta una struttura dati come un set per ottenere una complessità O(n), evitando l’ordinamento.

CodingLeetCode - 169 - Majority Element

Wed, 25 Feb 2026 14:00:26 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an array nums of size n, return the majority element. The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

Possiamo risolvere questo problema contando le occorrenze di ogni elemento, come nel codice proposto.

L’idea chiave è:

utilizziamo una mappa per tenere traccia del numero di occorrenze di ciascun elemento
scorriamo l’array e aggiorniamo il contatore per ogni numero
una volta popolata la mappa, estraiamo tutte le chiavi
per ogni chiave, verifichiamo se il numero di occorrenze è maggiore di n / 2
quando troviamo l’elemento che soddisfa la condizione, lo restituiamo

Questo approccio permette di ottenere una complessità O(n), ma utilizza memoria aggiuntiva per la mappa. Esiste una soluzione più ottimale (algoritmo di Boyer-Moore) che permette di trovare l’elemento di maggioranza in O(n) tempo e O(1) spazio, evitando strutture dati ausiliarie.

CodingLeetCode - 141 - Linked List Cycle

Wed, 25 Feb 2026 14:00:25 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given head, the head of a linked list, determine if the linked list has a cycle in it. There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer.

Possiamo risolvere questo problema tenendo traccia dei nodi già visitati durante la scansione, come nel codice proposto.

L’idea chiave è:

CodingLeetCode - 125 - Valid Palindrome

Wed, 25 Feb 2026 14:00:24 +0000

Oggi vediamo il seguente esercizio di LeetCode:

A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Given a string s, return true if it is a palindrome, or false otherwise.

Possiamo risolvere questo problema normalizzando prima la stringa e poi confrontandola simmetricamente, come nel codice proposto.

L’idea chiave è:

scorriamo la stringa e costruiamo una nuova stringa contenente solo caratteri alfanumerici
convertiamo tutti i caratteri in minuscolo per evitare problemi di confronto
confrontiamo i caratteri agli estremi: il primo con l’ultimo, il secondo con il penultimo, e così via
se troviamo una differenza, la stringa non è palindroma
se tutti i confronti vanno a buon fine, la stringa è palindroma
gestiamo come casi validi anche stringhe vuote o con un solo carattere

Questo approccio permette di ottenere una complessità O(n), dove n è la lunghezza della stringa, ed è efficace perché filtra prima i caratteri non validi e poi applica un semplice confronto simmetrico. Una possibile ottimizzazione consiste nell’evitare la creazione di una nuova stringa e lavorare direttamente con due puntatori sulla stringa originale.

CodingLeetCode - 121 - Best Time to Buy and Sell Stock

Wed, 25 Feb 2026 14:00:23 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given an array prices where prices[i] is the price of a given stock on the i-th day. You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

CodingLeetCode - 88 - Merge Sorted Array

Wed, 25 Feb 2026 14:00:22 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively. Merge nums2 into nums1 as one sorted array. The final sorted array should not be returned, but instead be stored inside nums1.

Possiamo risolvere questo problema unendo i due array ordinati, come nel codice proposto, utilizzando una struttura temporanea per costruire il risultato.

CodingLeetCode - 86 - Partition List

Wed, 25 Feb 2026 14:00:21 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of the nodes in each of the two partitions.

Possiamo risolvere questo problema separando i valori in due gruppi distinti e poi ricombinandoli, come nel codice proposto.

CodingLeetCode - 70 - Climbing Stairs

Wed, 25 Feb 2026 14:00:20 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Possiamo risolvere questo problema osservando che il numero di modi per arrivare a uno scalino dipende da quelli precedenti, come nel codice proposto.

L’idea chiave è:

per arrivare allo scalino n possiamo provenire da n-1 (facendo 1 passo) oppure da n-2 (facendo 2 passi)
quindi il numero di modi per arrivare a n è la somma dei modi per arrivare a n-1 e n-2
gestiamo i casi base: per 0 e 1 c’è un solo modo
utilizziamo due variabili per tenere traccia dei risultati precedenti
ad ogni iterazione aggiorniamo i valori sommando i due precedenti
continuiamo fino a raggiungere n

Questo approccio permette di ottenere una complessità O(n) e spazio O(1), ed è equivalente al calcolo della successione di Fibonacci, evitando l’uso della ricorsione che sarebbe meno efficiente.

CodingLeetCode - 66 - Plus One

Wed, 25 Feb 2026 14:00:19 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given a large integer represented as an integer array digits, where each digits[i] is the i-th digit of the integer. The digits are ordered from most significant to least significant. Increment the large integer by one and return the resulting array of digits.

Possiamo risolvere questo problema simulando la somma di uno come faremmo manualmente, partendo dalla cifra meno significativa, come nel codice proposto.

CodingLeetCode - 58 - Length of Last Word

Wed, 25 Feb 2026 14:00:18 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a string s consisting of words and spaces, return the length of the last word in the string. A word is a maximal substring consisting of non-space characters only.

Possiamo risolvere questo problema analizzando la stringa e individuando l’ultima parola valida, come nel codice proposto.

L’idea chiave è:

dividiamo la stringa utilizzando lo spazio come separatore
otteniamo così un array di possibili parole (inclusi eventuali elementi vuoti)
scorriamo l’array a ritroso, partendo dall’ultima posizione
ignoriamo le stringhe vuote causate da spazi multipli o finali
appena troviamo una parola valida, ne restituiamo la lunghezza
se non troviamo parole, restituiamo un valore di fallback

Questo approccio permette di ottenere una complessità O(n), dove n è la lunghezza della stringa, ed è semplice da implementare. Tuttavia, crea una struttura ausiliaria (l’array) che può essere evitata scorrendo direttamente la stringa da destra verso sinistra.

CodingLeetCode - 27 - Remove Element

Wed, 25 Feb 2026 14:00:17 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Return the number of elements in nums which are not equal to val.

Possiamo risolvere questo problema modificando direttamente l’array durante l’iterazione, come nel codice proposto.

L’idea chiave è:

scorriamo l’array utilizzando un indice
se troviamo un elemento uguale a val, lo rimuoviamo con splice
non incrementiamo l’indice dopo la rimozione, perché gli elementi successivi vengono spostati
se l’elemento è diverso da val, passiamo a quello successivo
continuiamo fino alla fine dell’array

Questo approccio permette di ottenere una soluzione corretta, ma con una complessità O(n²), perché ogni rimozione comporta uno shift degli elementi. Una soluzione più efficiente utilizza due puntatori e lavora in O(n), evitando operazioni costose sull’array.

CodingLeetCode - 26 - Remove Duplicates from Sorted Array

Wed, 25 Feb 2026 14:00:16 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same. Return the number of unique elements.

Possiamo risolvere questo problema modificando direttamente l’array durante l’iterazione, come nel codice proposto.

L’idea chiave è:

partiamo dal secondo elemento dell’array
confrontiamo ogni elemento con quello precedente
se sono uguali, significa che abbiamo trovato un duplicato
in questo caso rimuoviamo l’elemento usando splice
non incrementiamo l’indice, perché dopo la rimozione gli elementi si spostano
se invece sono diversi, passiamo all’elemento successivo
continuiamo fino alla fine dell’array

Questo approccio permette di ottenere una soluzione corretta, ma con una complessità O(n²), perché ogni splice comporta uno spostamento degli elementi. Una soluzione più ottimale utilizza due puntatori e lavora in O(n), evitando operazioni costose sull’array.

CodingLeetCode - 21 - Merge Two Sorted Lists

Wed, 25 Feb 2026 14:00:15 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists. Return the head of the merged linked list.

Possiamo risolvere questo problema confrontando gli elementi delle due liste e costruendo una nuova struttura ordinata, come nel codice proposto.

CodingLeetCode - 20 - Valid Parentheses

Wed, 25 Feb 2026 14:00:14 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a string s containing just the characters ‘(’, ‘)’, ‘{’, ‘}’, ‘[’ and ‘]’, determine if the input string is valid. An input string is valid if: Open brackets must be closed by the same type of brackets. Open brackets must be closed in the correct order.

Possiamo risolvere questo problema utilizzando una struttura dati che segue il principio LIFO (Last In, First Out), come nel codice proposto.

CodingLeetCode - 14 - Longest Common Prefix

Wed, 25 Feb 2026 14:00:13 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Write a function to find the longest common prefix string amongst an array of strings. If there is no common prefix, return an empty string “”.

Possiamo risolvere questo problema confrontando i caratteri delle stringhe posizione per posizione, come nel codice proposto.

L’idea chiave è:

prendiamo la prima stringa come riferimento
scorriamo i suoi caratteri uno alla volta
ad ogni iterazione aggiungiamo il carattere corrente al prefisso comune
verifichiamo che tutte le altre stringhe abbiano lo stesso carattere in quella posizione
se una stringa è più corta oppure il carattere non coincide, rimuoviamo l’ultimo carattere aggiunto e interrompiamo il ciclo
continuiamo finché tutti i controlli sono soddisfatti

Questo approccio permette di ottenere una complessità O(n * m), dove n è il numero di stringhe e m è la lunghezza del prefisso comune. È una soluzione semplice e leggibile, anche se può essere leggermente ottimizzata interrompendo subito il ciclo interno appena si trova una discordanza.

CodingLeetCode - 13 - Roman to Integer

Wed, 25 Feb 2026 14:00:12 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a roman numeral, convert it to an integer.

Possiamo risolvere questo problema scorrendo la stringa e gestendo separatamente i casi “standard” e quelli in cui una cifra più piccola precede una più grande (notazione sottrattiva), come nel codice proposto.

L’idea chiave è:

utilizziamo una mappa per associare ogni simbolo romano al suo valore numerico
scorriamo la stringa carattere per carattere
per ogni simbolo, controlliamo se forma una coppia speciale (IV, IX, XL, XC, CD, CM)
se sì, sottraiamo il valore corrente da quello successivo e saltiamo il prossimo carattere
altrimenti, sommiamo semplicemente il valore del simbolo corrente
continuiamo fino alla fine della stringa

Questo approccio permette di ottenere una complessità O(n), dove n è la lunghezza della stringa, ed è efficace nel gestire correttamente tutti i casi. Tuttavia, nel codice proposto la gestione delle coppie speciali è suddivisa in più funzioni (checkI, checkX, checkC), rendendo la soluzione più verbosa: può essere semplificata confrontando direttamente il valore corrente con quello successivo in un unico passaggio.

CodingLeetCode - 9 - Palindrome Number

Wed, 25 Feb 2026 14:00:11 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an integer x, return true if x is a palindrome, and false otherwise.

Possiamo risolvere questo problema confrontando le cifre del numero da entrambi i lati, proprio come fatto nel codice proposto.

L’idea chiave è:

escludiamo subito i numeri negativi, perché non possono essere palindromi
convertiamo il numero in stringa per poter accedere facilmente alle singole cifre
trasformiamo la stringa in un array di cifre
confrontiamo gli elementi simmetrici: il primo con l’ultimo, il secondo con il penultimo, e così via
se troviamo anche una sola differenza, il numero non è palindromo
se tutti i confronti vanno a buon fine, il numero è palindromo

Questo approccio permette di ottenere una complessità O(n), dove n è il numero di cifre, ed è semplice da implementare. Tuttavia, il ciclo potrebbe essere ottimizzato fermandosi a metà dell’array, evitando confronti ridondanti.

CodingLeetCode - 7 - Reverse Integer

Wed, 25 Feb 2026 14:00:10 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range

Possiamo risolvere questo problema invertendo le cifre del numero, come nel codice proposto, ma prestando attenzione alla gestione del segno e dell’overflow.

L’idea chiave è:

gestiamo separatamente il segno del numero (positivo o negativo)
convertiamo il numero in stringa per poter lavorare facilmente sulle singole cifre
invertiamo l’array di caratteri scambiando gli elementi simmetrici
ricostruiamo il numero a partire dalle cifre invertite
riapplichiamo il segno se necessario
infine, controlliamo che il risultato rientri nei limiti di un intero a 32 bit

Questo approccio permette di ottenere una soluzione semplice da implementare, ma nel codice proposto la gestione dell’overflow è hardcoded su alcuni casi specifici, rendendola poco scalabile. Una soluzione più robusta prevede invece un controllo generale sui limiti, evitando di elencare manualmente i casi fuori range.

CodingLeetCode - 2 - Add Two Numbers

Wed, 25 Feb 2026 14:00:09 +0000

Oggi vediamo il seguente esercizio di LeetCode:

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes > contains a single digit. Add the two numbers and return the sum as a linked list.

Possiamo analizzare questo problema partendo da un approccio in due fasi, come nel codice proposto, in cui utilizziamo una struttura dati per memorizzare le informazioni utili durante l’elaborazione.

CodingLeetCode - 1 - Two Sum

Wed, 25 Feb 2026 14:00:08 +0000

Oggi vediamo il seguente esercizio di LeetCode:

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Possiamo risolvere questo problema sfruttando una struttura dati che ci permetta di controllare rapidamente se esiste il complemento di un numero rispetto al target.

AlgoritmiTeoria - 7 - graph - belman-ford

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: BELLMAN-FORD

L’algoritmo di Bellman-Ford calcola i percorsi minimi da un nodo sorgente a tutti gli altri nodi in un grafo orientato o non orientato pesato, anche con archi a peso negativo, a condizione che non siano presenti cicli negativi raggiungibili dalla sorgente.

PRECONDIZIONI

Il grafo può contenere archi con peso negativo.
Non devono esserci cicli negativi raggiungibili dalla sorgente.
Funziona su grafi orientati e non orientati pesati.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso (positivo o negativo).
Distanza → costo cumulativo minimo dal nodo sorgente a un nodo.
Predecessore (Parent/Predecessor) → nodo precedente lungo il percorso minimo.
Rilassamento (Relaxation) → operazione che aggiorna la distanza di un nodo se si trova un percorso più corto.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice nel grafo.
aggiungiArco(v1, v2, peso) → aggiunge un arco orientato o non orientato con peso.
bellmanFord(start) → calcola i percorsi minimi dal nodo sorgente start a tutti gli altri nodi, restituendo:
- le distanze minime
- i predecessori per ricostruire i percorsi.
Rileva cicli negativi: se dopo |V|-1 rilassamenti un arco può ancora essere rilassato, esiste un ciclo negativo raggiungibile dalla sorgente.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza tutte le distanze a ∞, eccetto il nodo sorgente (distanza = 0).
Ripeti |V| - 1 volte (dove |V| è il numero di vertici):
- Per ogni arco (u, v) con peso w:
  - Se distanza[u] + w < distanza[v] → aggiorna distanza[v] e imposta u come predecessore.
Controlla tutti gli archi una volta in più per rilevare eventuali cicli negativi.
Al termine:
- le distanze minime sono corrette se non ci sono cicli negativi.
- è possibile ricostruire i percorsi minimi seguendo i predecessori.

COMPLESSITÀ

Tempo → O(V * E)
Spazio → O(V) per memorizzare distanze e predecessori

ESEMPIO DI USCITA

Grafo: A -> B(4), C(2) B -> C(-1), D(5) C -> D(3), E(4) D -> E(7) E ->

AlgoritmiTeoria - 7 - graph - dijkstra

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: DIJKSTRA

L’algoritmo di Dijkstra calcola i percorsi minimi da un nodo sorgente a tutti gli altri nodi in un grafo orientato o non orientato pesato, con pesi non negativi.
È uno degli algoritmi fondamentali per il calcolo di percorsi minimi in informatica e nelle reti.

PRECONDIZIONI

Il grafo può essere orientato o non orientato.
I pesi degli archi devono essere non negativi.
Non gestisce correttamente grafi con archi a peso negativo (per quelli serve Bellman-Ford).

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con peso associato.
Distanza → costo cumulativo minimo dal nodo sorgente a un nodo.
Predecessore (Parent/Predecessor) → nodo precedente lungo il percorso minimo.
Coda di Priorità (Priority Queue / Min-Heap) → struttura utilizzata per selezionare il nodo con distanza minima.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice nel grafo.
aggiungiArco(v1, v2, peso) → aggiunge un arco orientato o non orientato con peso.
dijkstra(start) → calcola i percorsi minimi dal nodo sorgente start a tutti gli altri nodi, restituendo:
- le distanze minime
- i predecessori per ricostruire i percorsi.

RAPPRESENTAZIONE

Lista di adiacenza con pesi:
Esempio → { A: [{node: B, peso: 4}, {node: C, peso: 2}], B: [{node: C, peso: 5}], ... }

FUNZIONAMENTO DELL’ALGORITMO

Inizializza tutte le distanze a ∞, eccetto il nodo sorgente (distanza = 0).
Inserisci tutti i nodi in una coda di priorità basata sulla distanza minima.
Finché la coda non è vuota:
- Estrai il nodo con distanza minima.
- Aggiorna le distanze dei suoi vicini se si trova un percorso più corto.
- Aggiorna i predecessori dei vicini per tracciare il percorso minimo.
Al termine, si ottengono:
- la distanza minima da sorgente a ogni nodo
- il cammino più breve ricostruibile seguendo i predecessori.

COMPLESSITÀ

Inserimento vertice → O(1)
Inserimento arco → O(1)
Calcolo percorso minimo:
- Con min-heap / coda di priorità → O(V + E log V)
- Con semplice array → O(V^2)

ESEMPIO DI USCITA

Grafo: A -> B(4), C(2) B -> C(5), D(10) C -> D(3), E(4) D -> E(7) E ->

AlgoritmiTeoria - 7 - graph - edmonds-karp

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: EDMONDS-KARP

L’algoritmo di Edmonds-Karp è una specifica implementazione dell’algoritmo di Ford-Fulkerson per il calcolo del flusso massimo in un grafo connesso e pesato.
La differenza principale è l’uso della ricerca in ampiezza (BFS) per trovare i percorsi aumentanti.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco con Capacità (Capacity Edge) → connessione tra due vertici con capacità massima.
Flusso (Flow) → quantità di risorsa trasportata lungo un arco.
Percorso Aumentante (Augmenting Path) → percorso dalla sorgente al pozzo con capacità residua disponibile.
Sorgente (Source) → nodo iniziale del flusso.
Pozzo / Destinazione (Sink) → nodo finale del flusso.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza il flusso di tutti gli archi a 0.
Usa BFS per trovare il percorso aumentante più corto (minimo numero di archi) dalla sorgente alla destinazione.
Determina il flusso massimo possibile lungo questo percorso (minima capacità residua).
Aggiorna il flusso lungo gli archi diretti e inversi del percorso.
Ripeti finché non esistono più percorsi aumentanti.

STRUTTURE DI SUPPORTO

Grafo con capacità residua → memorizza capacità disponibili sugli archi.
Coda per BFS → utilizzata per individuare il percorso aumentante più breve.

COMPLESSITÀ

Tempo → O(V * E²) nel caso peggiore.
Spazio → O(V + E) per memorizzare il grafo e le capacità residue.

ESEMPIO DI UTILIZZO

Grafo con capacità: S → A(10), S → B(5), A → B(15), A → T(10), B → T(10)

AlgoritmiTeoria - 7 - graph - ford-fulkerson

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: FORD-FULKERSON

L’algoritmo di Ford-Fulkerson calcola il flusso massimo in un grafo connesso e pesato, dove i pesi rappresentano le capacità massime degli archi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco con Capacità (Capacity Edge) → connessione tra due vertici con capacità massima.
Flusso (Flow) → quantità di risorsa trasportata lungo un arco.
Percorso Aumentante (Augmenting Path) → percorso dalla sorgente al pozzo con capacità residua disponibile.
Sorgente (Source) → nodo iniziale del flusso.
Pozzo / Destinazione (Sink) → nodo finale del flusso.

FUNZIONAMENTO DELL’ALGORITMO

Inizializza il flusso di tutti gli archi a 0.
Cerca un percorso aumentante dalla sorgente alla destinazione con capacità residua > 0.
Determina il flusso massimo possibile lungo questo percorso (minima capacità residua).
Aumenta il flusso sugli archi del percorso di questa quantità.
Aggiorna le capacità residue lungo gli archi diretti e inversi.
Ripeti finché non esistono più percorsi aumentanti.

STRUTTURE DI SUPPORTO

Grafo con capacità residua → memorizza capacità disponibili lungo gli archi.
Algoritmo di ricerca → BFS (Edmonds-Karp) o DFS per trovare percorsi aumentanti.

COMPLESSITÀ

Dipende dalla scelta della tecnica di ricerca:
- Con BFS (Edmonds-Karp) → O(V * E²)
- Con DFS → complessità può variare e dipende dai valori dei flussi.
Spazio → O(V + E) per memorizzare il grafo e le capacità residue.

ESEMPIO DI UTILIZZO

Grafo con capacità: S → A(10), S → B(5), A → B(15), A → T(10), B → T(10)

AlgoritmiTeoria - 7 - graph - kruskal

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: KRUSKAL

L’algoritmo di Kruskal è utilizzato per trovare un albero ricoprente minimo (Minimum Spanning Tree - MST) in un grafo connesso e pesato.
L’MST collega tutti i vertici senza formare cicli e minimizza la somma dei pesi degli archi inclusi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso associato.
Albero Ricoprente (Spanning Tree) → sottoinsieme di archi che collega tutti i vertici senza cicli.
MST (Minimum Spanning Tree) → albero ricoprente con somma minima dei pesi degli archi.
Union-Find / Disjoint Set → struttura dati per rilevare cicli durante l’inclusione degli archi.

FUNZIONAMENTO DELL’ALGORITMO

Ordina tutti gli archi del grafo in ordine crescente di peso.
Inizia con un grafo MST vuoto.
Per ciascun arco (u, v) nell’ordine ordinato:
- Se aggiungendo l’arco non si forma un ciclo → includilo nel MST.
- Altrimenti → scartalo.
Ripeti fino a includere V - 1 archi, dove V è il numero di vertici.

STRUTTURE DI SUPPORTO

Union-Find (Disjoint Set) → per verificare rapidamente se due vertici appartengono allo stesso sottoalbero (evita cicli).
Array / Lista di archi → per ordinare gli archi in base al peso.

COMPLESSITÀ

Tempo → O(E log E), principalmente per l’ordinamento degli archi.
Spazio → O(V + E) per memorizzare il grafo e le strutture ausiliarie.

ESEMPIO DI UTILIZZO

Grafo con archi pesati: A - B(4), A - C(2), B - C(1), B - D(5), C - D(3)

AlgoritmiTeoria - 7 - graph - not-oriented-graph

Wed, 25 Feb 2026 14:00:07 +0000

STRUTTURA DATI: GRAFO NON ORIENTATO

Un grafo non orientato è una collezione di nodi (vertici) connessi da archi che rappresentano relazioni bidirezionali.

PROPRIETÀ PRINCIPALI

Rappresentato come coppia (V, E):
- V → insieme dei vertici (nodi).
- E → insieme degli archi (coppie non ordinate di vertici).
Gli archi non hanno direzione:
se esiste un arco tra A e B, si può navigare sia da A a B che da B a A.

TERMINOLOGIA

Vertice (Vertex) → un nodo del grafo.
Arco (Edge) → connessione tra due vertici.
Grado (Degree) → numero di archi connessi a un vertice.
Percorso (Path) → sequenza di vertici connessi da archi.
Ciclo (Cycle) → percorso chiuso (inizio = fine).
Componente Connessa → sottoinsieme di vertici in cui ogni coppia è collegata direttamente o indirettamente.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice.
aggiungiArco(v1, v2) → crea un arco tra due vertici (aggiunge i vertici se non esistono).
rimuoviArco(v1, v2) → elimina un arco se presente.
rimuoviVertice(v) → elimina un vertice e tutti i suoi archi.
verificaConnesso(v1, v2) → controlla se esiste un percorso tra due vertici.
visitaAmpiezza(v) → BFS a partire da un vertice.
visitaProfondità(v) → DFS a partire da un vertice.

RAPPRESENTAZIONE

Lista di adiacenza (efficiente in grafi sparsi):
Esempio → { A: [B, C], B: [A, D], C: [A], D: [B] }
Matrice di adiacenza (più adatta in grafi densi).

EFFICIENZA

Inserimento vertice → O(1)
Inserimento arco → O(1)
Rimozione arco → O(d) (d = grado massimo tra i due vertici).
Attraversamento BFS/DFS → O(V + E)

APPLICAZIONI

Reti sociali.
Mappe stradali.
Reti di computer.
Pianificazione di percorsi senza direzione.
Analisi di sistemi complessi.

VANTAGGI

Struttura flessibile, adatta a molti problemi reali.
Operazioni ottimizzabili a seconda della rappresentazione.

LIMITAZIONI

Grafi densi → memoria elevata.
Operazioni come rimozione arco o verifica connessione possono essere costose rispetto a strutture specializzate.

NOTE

Base per algoritmi fondamentali:
- calcolo delle componenti connesse,
- rilevamento cicli,
- cammino minimo.

CODICE

/**
 * Interfaccia che rappresenta un arco pesato.
 */
export interface Edge<E> {
 node: E;
 weight: number;
}

/**
 * Implementazione di un grafo generico pesato e non orientato.
 * @typeParam E - Tipo dei vertici
 */
export class NotOrientedGraph<E> {
 private adjacencyList: Record<string, Edge<E>[]>;

 constructor() {
 this.adjacencyList = {};
 }

 /**
 * Aggiunge un vertice al grafo.
 * Se il vertice è già presente, non fa nulla.
 * @param vertex - Il vertice da aggiungere
 */
 aggiungiVertice(vertex: E): void {
 const key = String(vertex);
 if (!this.adjacencyList[key]) {
 this.adjacencyList[key] = [];
 }
 }

 /**
 * Aggiunge un arco pesato non orientato tra due vertici.
 * Se i vertici non esistono, vengono creati automaticamente.
 * @param vertex1 - Primo vertice
 * @param vertex2 - Secondo vertice
 * @param weight - Peso dell'arco
 */
 aggiungiArco(vertex1: E, vertex2: E, weight: number): void {
 const v1 = String(vertex1);
 const v2 = String(vertex2);

 if (!this.adjacencyList[v1]) {
 this.aggiungiVertice(vertex1);
 }
 if (!this.adjacencyList[v2]) {
 this.aggiungiVertice(vertex2);
 }

 this.adjacencyList[v1].push({
 node: vertex2, weight
 });
 this.adjacencyList[v2].push({
 node: vertex1, weight
 });
 }

 /**
 * Rimuove un arco tra due vertici, se esiste.
 * @param vertex1 - Primo vertice
 * @param vertex2 - Secondo vertice
 */
 rimuoviArco(vertex1: E, vertex2: E): void {
 const v1 = String(vertex1);
 const v2 = String(vertex2);

 this.adjacencyList[v1] = this.adjacencyList[v1]?.filter(edge => edge.node !== vertex2) || [];
 this.adjacencyList[v2] = this.adjacencyList[v2]?.filter(edge => edge.node !== vertex1) || [];
 }

 /**
 * Rimuove un vertice e tutti i relativi archi.
 * @param vertex - Il vertice da rimuovere
 */
 rimuoviVertice(vertex: E): void {
 const v = String(vertex);
 while (this.adjacencyList[v]?.length) {
 const adjacentEdge = this.adjacencyList[v].pop() as Edge<E>;
 this.rimuoviArco(vertex, adjacentEdge.node);
 }
 delete this.adjacencyList[v];
 }

 /**
 * Visualizza il grafo in console.
 */
 display(): void {
 for (const vertex in this.adjacencyList) {
 const edges = this.adjacencyList[vertex];
 const rappresentazione = edges.length > 0
 ? edges.map(e => `${e.node}(${e.weight})`).join(", ")
 : "NULL";
 console.log(`${vertex} -> ${rappresentazione}`);
 }
 }

 /**
 * Verifica se il grafo è connesso.
 * @returns true se il grafo è connesso, false altrimenti
 */
 verificaConnesso(): boolean {
 const visitati = new Set<string>();
 const vertices = Object.keys(this.adjacencyList);

 if (vertices.length === 0) return true; // grafo vuoto = connesso

 const dfs = (vertex: string) => {
 visitati.add(vertex);
 for (const edge of this.adjacencyList[vertex]) {
 const key = String(edge.node);
 if (!visitati.has(key)) {
 dfs(key);
 }
 }
 };

 dfs(vertices[0]);

 return vertices.length === visitati.size;
 }

 /**
 * Visita in ampiezza (BFS) a partire da un vertice.
 * @param start - Vertice di partenza
 * @returns Lista dei vertici visitati in ordine BFS
 */
 visitaAmpiezza(start: E): E[] {
 const result: E[] = [];
 const visitati = new Set<string>();
 const queue: E[] = [start];

 visitati.add(String(start));

 while (queue.length > 0) {
 const nodo = queue.shift() as E;
 result.push(nodo);

 for (const edge of this.adjacencyList[String(nodo)]) {
 const key = String(edge.node);
 if (!visitati.has(key)) {
 visitati.add(key);
 queue.push(edge.node);
 }
 }
 }

 return result;
 }

 /**
 * Visita in profondità (DFS) a partire da un vertice.
 * @param start - Vertice di partenza
 * @returns Lista dei vertici visitati in ordine DFS
 */
 visitaProfondita(start: E): E[] {
 const result: E[] = [];
 const visitati = new Set<string>();

 const dfs = (vertex: E) => {
 visitati.add(String(vertex));
 result.push(vertex);

 for (const edge of this.adjacencyList[String(vertex)]) {
 if (!visitati.has(String(edge.node))) {
 dfs(edge.node);
 }
 }
 };

 dfs(start);
 return result;
 }

 /**
 * Restituisce tutti i vertici del grafo
 * @returns tutti i vertici del grafo
 */
 getVertices(): E[] {
 const verticesSet = new Set<E>();
 for (const key in this.adjacencyList) {
 verticesSet.add(key as unknown as E);
 for (const edge of this.adjacencyList[key]) {
 verticesSet.add(edge.node);
 }
 }
 return Array.from(verticesSet);
 }
 
 /**
 * Restituisce tutti gli archi senza duplicati
 * @returns tutti gli archi senza duplicati
 */
 getEdges(): { from: E; to: E; weight: number }[] {
 const edges: { from: E; to: E; weight: number }[] = [];
 const visited = new Set<string>();

 for (const key in this.adjacencyList) {
 for (const edge of this.adjacencyList[key]) {
 // Crea un id unico indipendente dall'ordine dei nodi
 const id = [String(key), String(edge.node)].sort().join('-');
 if (!visited.has(id)) {
 edges.push({ from: key as unknown as E, to: edge.node, weight: edge.weight });
 visited.add(id);
 }
 }
 }

 return edges;
 }

 /**
 * Fornisce la lista di adiacenza dei nodi del grafo 
 * @returns lista di adiacenza
 */
 getAdjacencyList(){
 return this.adjacencyList;
 }
}

// =============================
// Test della struttura dati
// =============================

const graph = new NotOrientedGraph<string>();

graph.aggiungiVertice("A");
graph.aggiungiVertice("B");
graph.aggiungiVertice("C");

graph.aggiungiArco("A", "B", 5);
graph.aggiungiArco("A", "C", 2);
graph.aggiungiArco("B", "C", 3);

graph.display();

console.log("\nGrafo connesso:", graph.verificaConnesso());
console.log("Visita in ampiezza da A:", graph.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graph.visitaProfondita("A"));

graph.rimuoviArco("A", "C");
console.log("\nDopo aver rimosso l'arco A-C:");
graph.display();

graph.rimuoviVertice("B");
console.log("\nDopo aver rimosso il vertice B:");
graph.display();

console.log("\nGrafo connesso:", graph.verificaConnesso());
console.log("Visita in ampiezza da A:", graph.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graph.visitaProfondita("A"));

AlgoritmiTeoria - 7 - graph - oriented-graph

Wed, 25 Feb 2026 14:00:07 +0000

STRUTTURA DATI: GRAFO ORIENTATO

Un grafo orientato è una collezione di nodi (vertici) connessi da archi direzionati, dove ciascun arco rappresenta una relazione unidirezionale tra due nodi.

PROPRIETÀ PRINCIPALI

Rappresentato come coppia (V, E):
- V → insieme dei vertici (nodi).
- E → insieme degli archi (coppie ordinate di vertici).
Gli archi hanno direzione:
se esiste un arco da A a B, si può navigare solo da A a B e non viceversa.

TERMINOLOGIA

Vertice (Vertex) → un nodo del grafo.
Arco (Edge) → connessione direzionata tra due vertici.
Grado di Entrata (In-Degree) → numero di archi che arrivano a un vertice.
Grado di Uscita (Out-Degree) → numero di archi che partono da un vertice.
Percorso (Path) → sequenza di vertici connessi da archi direzionati.
Ciclo (Cycle) → percorso chiuso (inizio = fine).
Componente Fortemente Connessa → sottoinsieme di vertici in cui ogni coppia è raggiungibile reciprocamente.

OPERAZIONI PRINCIPALI

aggiungiVertice(v) → inserisce un nuovo vertice.
aggiungiArco(v1, v2) → crea un arco orientato da v1 a v2.
rimuoviArco(v1, v2) → elimina l’arco orientato da v1 a v2.
rimuoviVertice(v) → elimina un vertice e tutti i suoi archi.
verificaConnesso() → controlla se il grafo è fortemente connesso.
visitaAmpiezza(v) → BFS a partire da un vertice.
visitaProfondità(v) → DFS a partire da un vertice.

RAPPRESENTAZIONE

Lista di adiacenza (più comune):
Esempio → { A: [B, C], B: [D], C: [], D: [B] }
Matrice di adiacenza (più adatta in grafi densi).

EFFICIENZA

Inserimento vertice → O(1)
Inserimento arco → O(1)
Rimozione arco → O(d) (d = grado di uscita del vertice).
Attraversamento BFS/DFS → O(V + E)

APPLICAZIONI

Reti sociali con relazioni asimmetriche.
Modellazione di flussi di dati.
Reti di computer.
Pianificazione di percorsi con direzione.
Analisi di dipendenze in sistemi complessi.

VANTAGGI

Modellano in modo naturale relazioni asimmetriche.
Utili per processi sequenziali e dipendenze.

LIMITAZIONI

Più complessi da visualizzare rispetto ai grafi non orientati.
La connettività richiede algoritmi specifici.

NOTE

Base per algoritmi fondamentali:
- calcolo delle componenti fortemente connesse,
- rilevamento di cicli orientati,
- calcolo dei percorsi minimi.

CODICE

/**
 * Classe che rappresenta un arco orientato e pesato
 */
export class Edge<E> {
 nodo: E;
 peso: number;

 constructor(nodo: E, peso: number) {
 this.nodo = nodo;
 this.peso = peso;
 }
}

/**
 * Classe che rappresenta un grafo orientato pesato
 */
export class DirectedGraph<E> {
 private adjacencyList: Map<E, Edge<E>[]>;

 constructor() {
 this.adjacencyList = new Map();
 }

 /**
 * Aggiunge un vertice al grafo.
 * Se il vertice esiste già, non fa nulla.
 */
 aggiungiVertice(vertex: E): void {
 if (!this.adjacencyList.has(vertex)) {
 this.adjacencyList.set(vertex, []);
 }
 }

	/**
	 * Fornisce la lista di adiacenza dei nodi del grafo 
	 * @returns lista di adiacenza
	 */
	getAdjacencyList(){
		return this.adjacencyList;
	}

 /**
 * Aggiunge un arco orientato e pesato tra due vertici.
 * Se i vertici non esistono, vengono creati automaticamente.
 */
 aggiungiArco(from: E, to: E, peso: number = 1): void {
 if (!this.adjacencyList.has(from)) this.aggiungiVertice(from);
 if (!this.adjacencyList.has(to)) this.aggiungiVertice(to);

 this.adjacencyList.get(from)!.push(new Edge(to, peso));
 }

 /**
 * Rimuove un arco orientato dal grafo.
 */
 rimuoviArco(from: E, to: E): void {
 if (this.adjacencyList.has(from)) {
 this.adjacencyList.set(
 from,
 this.adjacencyList.get(from)!.filter((edge) => edge.nodo !== to)
 );
 }
 }

 /**
 * Rimuove un vertice e tutti gli archi entranti/ uscenti.
 */
 rimuoviVertice(vertex: E): void {
 this.adjacencyList.delete(vertex);

 for (const [key, edges] of this.adjacencyList.entries()) {
 this.adjacencyList.set(
 key,
 edges.filter((edge) => edge.nodo !== vertex)
 );
 }
 }

 /**
 * Visualizza il grafo (lista di adiacenza).
 */
 display(): void {
 for (const [vertex, edges] of this.adjacencyList.entries()) {
 const out = edges.map((e) => `${e.nodo}(${e.peso})`).join(", ");
 console.log(`${vertex} -> ${out || "NULL"}`);
 }
 }

 /**
 * Verifica se il grafo è fortemente connesso.
 * (Semplificato: controlla raggiungibilità da un nodo di partenza)
 */
 verificaConnesso(): boolean {
 const vertices = Array.from(this.adjacencyList.keys());
 if (vertices.length === 0) return true;

 const visitati = new Set<E>();

 const dfs = (start: E) => {
 const stack: E[] = [start];
 visitati.add(start);

 while (stack.length) {
 const v = stack.pop()!;
 for (const vicino of this.adjacencyList.get(v)!) {
 if (!visitati.has(vicino.nodo)) {
 visitati.add(vicino.nodo);
 stack.push(vicino.nodo);
 }
 }
 }
 };

 dfs(vertices[0]);
 return visitati.size === vertices.length;
 }

 /**
 * Visita in ampiezza (BFS).
 */
 visitaAmpiezza(start: E): E[] {
 const visitati = new Set<E>();
 const risultato: E[] = [];
 const coda: E[] = [start];

 visitati.add(start);

 while (coda.length > 0) {
 const nodo = coda.shift()!;
 risultato.push(nodo);

 for (const vicino of this.adjacencyList.get(nodo)!) {
 if (!visitati.has(vicino.nodo)) {
 visitati.add(vicino.nodo);
 coda.push(vicino.nodo);
 }
 }
 }

 return risultato;
 }

 /**
 * Visita in profondità (DFS).
 */
 visitaProfondita(start: E): E[] {
 const visitati = new Set<E>();
 const risultato: E[] = [];

 const dfs = (v: E) => {
 visitati.add(v);
 risultato.push(v);

 for (const vicino of this.adjacencyList.get(v)!) {
 if (!visitati.has(vicino.nodo)) {
 dfs(vicino.nodo);
 }
 }
 };

 dfs(start);
 return risultato;
 }
}

// =============================
// Test della struttura dati
// =============================
let graphTest = new DirectedGraph<string>();

graphTest.aggiungiVertice("A");
graphTest.aggiungiVertice("B");
graphTest.aggiungiVertice("C");

graphTest.aggiungiArco("A", "B", 2);
graphTest.aggiungiArco("A", "C", 5);
graphTest.aggiungiArco("B", "C", 1);

graphTest.display();

console.log("\nGrafo fortemente connesso:", graphTest.verificaConnesso());
console.log("Visita in ampiezza da A:", graphTest.visitaAmpiezza("A"));
console.log("Visita in profondità da A:", graphTest.visitaProfondita("A"));

graphTest.rimuoviArco("A", "C");
console.log("\nDopo aver rimosso l'arco A->C:");
graphTest.display();

graphTest.rimuoviVertice("B");
console.log("\nDopo aver rimosso il vertice B:");
graphTest.display();

AlgoritmiTeoria - 7 - graph - prim

Wed, 25 Feb 2026 14:00:07 +0000

ALGORITMO: PRIM

L’algoritmo di Prim è utilizzato per trovare un albero ricoprente minimo (Minimum Spanning Tree - MST) in un grafo connesso e pesato.
L’MST collega tutti i vertici senza formare cicli e minimizza la somma dei pesi degli archi inclusi.

TERMINOLOGIA

Vertice (Vertex) → nodo del grafo.
Arco Pesato (Weighted Edge) → connessione tra due vertici con un peso associato.
Albero Ricoprente (Spanning Tree) → sottoinsieme di archi che collega tutti i vertici senza cicli.
MST (Minimum Spanning Tree) → albero ricoprente con somma minima dei pesi degli archi.
Nodo Visitato / Non Visitato → stato dei vertici durante l’esecuzione dell’algoritmo.

FUNZIONAMENTO DELL’ALGORITMO

Scegli un nodo sorgente e aggiungilo al MST.
Seleziona l’arco più leggero che connette un nodo del MST con un nodo non ancora incluso.
Aggiungi il nodo collegato al MST e marca come visitato.
Ripeti fino a includere tutti i nodi.

STRUTTURE DI SUPPORTO

Coda di priorità (Min-Heap) → per selezionare rapidamente l’arco di peso minimo.
Array / Lista di adiacenza → per memorizzare il grafo pesato.

COMPLESSITÀ

Tempo → O(E log V) con coda di priorità.
Spazio → O(V + E) per memorizzare il grafo e le strutture ausiliarie.

ESEMPIO DI UTILIZZO

Grafo con archi pesati: A - B(4), A - C(2), B - C(1), B - D(5), C - D(3)

AlgoritmiTeoria - 6 - tree - AVL tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO AVL

L’Albero AVL (Adelson-Velsky e Landis) è una variante bilanciata dei Binary Search Tree (BST).
Mantiene l’altezza dei sottoalberi sempre bilanciata, evitando il problema degli alberi sbilanciati e garantendo prestazioni efficienti.

PROPRIETÀ DI BILANCIAMENTO

Per ogni nodo N:
|altezza(sottoalbero sinistro) - altezza(sottoalbero destro)| ≤ 1

Questa proprietà viene mantenuta dinamicamente attraverso rotazioni dopo inserimenti o eliminazioni.

PROPRIETÀ DI RICERCA

Come in un BST:

AlgoritmiTeoria - 6 - tree - binary search tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO BINARIO DI RICERCA (BST)

Un Binary Search Tree (BST) è una struttura dati ad albero che organizza i valori in modo ordinato per consentire ricerca, inserimento e rimozione efficienti.

PROPRIETÀ DI RICERCA

Ogni nodo contiene un valore univoco.
Per ogni nodo N:
- Sottoalbero sinistro → valori < N.value
- Sottoalbero destro → valori > N.value
Grazie a questa proprietà, è possibile sfruttare la ricerca binaria durante la navigazione.

TERMINOLOGIA

Nodo → contiene un valore e i puntatori a sinistra e destra.
Radice (Root) → nodo principale dell’albero.
Foglia (Leaf) → nodo senza figli.
Padre (Parent) → nodo con almeno un figlio.
Figlio (Child) → nodo collegato a un padre.
Sottoalbero (Subtree) → albero discendente da un nodo.
Altezza dell’Albero → percorso più lungo dalla radice a una foglia.

OPERAZIONI PRINCIPALI

inserisci(valore) → aggiunge un nodo rispettando la proprietà BST.
cerca(valore) → verifica la presenza di un valore.
elimina(valore) → rimuove un nodo:
- Nessun figlio → eliminato direttamente.
- Un figlio → sostituito con il figlio.
- Due figli → sostituito dal successore in ordine (minimo del sottoalbero destro).
visitaInOrdine() → restituisce valori ordinati crescenti.
visitaPreOrdine() → visita radice → sottoalbero sinistro → sottoalbero destro.
visitaPostOrdine() → visita sottoalberi → radice.
altezza() → calcola la profondità massima.
contaNodi() → numero totale di nodi.

OPERAZIONI AUSILIARIE

getMin() → valore minimo (nodo più a sinistra).
getMax() → valore massimo (nodo più a destra).
isBalanced() → verifica che le altezze dei sottoalberi differiscano al massimo di 1.

EFFICIENZA

Ricerca → O(log n) (medio), O(n) (peggiore caso).
Inserimento → O(log n) (medio), O(n) (peggiore caso).
Eliminazione → O(log n) (medio), O(n) (peggiore caso).
Spazio → O(n).

APPLICAZIONI

Strutture di database.
Implementazioni di insiemi e mappe ordinate.
Algoritmi di ordinamento.
Gestione di intervalli e dati gerarchici.

NOTE

Più semplice rispetto ad AVL.
Non garantisce bilanciamento automatico.
Può degradare in una lista se i dati sono inseriti in ordine.

CODICE

class Node<E> {
 value: E;
 left: Node<E> | null;
 right: Node<E> | null;

 constructor(value: E) {
 this.value = value;
 this.left = null;
 this.right = null;
 }
}

class BinarySearchTree<E> {
 root: Node<E> | null;

 constructor() {
 this.root = null;
 }

 /**
 * Inserisce un valore nell'albero rispettando la proprieta di ricerca
 * @param value valore da inserire nell'albero
 * @returns nuovo nodo inserito
 */
 insert(value: E) : Node<E> | null{
 const newNode = new Node(value);
 if (!this.root) {
 this.root = newNode;
 return this.root;
 }

 let current = this.root;
 while (true) {
 // valori duplicati non consentiti
 if (value === current.value) return null;
 if (value < current.value) {
 if (!current.left) {
 current.left = newNode;
 return this.root;
 }
 current = current.left;
 } else {
 if (!current.right) {
 current.right = newNode;
 return this.root;
 }
 current = current.right;
 }
 }
 }

 /**
 * Cerca un valore nell'albero sfruttando la proprietà di ricerca
 * @param value valore da cercare nell'albero
 * @returns true se esiste un nodo con il valore "value", false altrimenti
 */
 find(value: E): boolean {
 if (!this.root) return false;
 let current: Node<E> | null = this.root;
 while (current) {
 if (value === current.value) return true;
 if (value < current.value) {
 current = current.left;
 } else {
 current = current.right;
 }
 }
 return false;
 }

 /**
 * Funzione ausiliaria che effettua l'eleminazione
 * @param node nodo da cui deve partire l'eliminazione, valore di partenza la radice
 * @param value valore da eliminare
 * @returns nuova radice dell'albero
 */
 private auxRemove(node: Node<E> | null, value: E): Node<E> | null {
 if (!node) return null;
 if (value < node.value) {
 node.left = this.auxRemove(node.left, value);
 return node;
 } else if (value > node.value) {
 node.right = this.auxRemove(node.right, value);
 return node;
 } else {
 // Caso 1: Nessun figlio
 if (!node.left && !node.right) return null;
 // Caso 2: Un figlio
 if (!node.left) return node.right;
 if (!node.right) return node.left;
 // Caso 3: Due figli
 let temp = this.getMin(node.right);
 if (temp) {
 node.value = temp.value;
 node.right = this.auxRemove(node.right, temp.value);
 return node;
 }
 return null;
 }
 }

 /**
 * Rimuove un nodo dall'albero
 * @param value valore del nodo da eliminare
 */
 remove(value: E): void {
 this.root = this.auxRemove(this.root, value);
 }

 /**
 * Trova il valore minimo in un sottoalbero sfruttando la proprietà di ricerca
 * @param node nodo da cui deve partire la ricerca, valore di partenza la radice
 * @returns nodo con il valore minimo, null se l'albero è vuoto
 */
 getMin(node: Node<E> | null = this.root): Node<E> | null {
 while (node && node.left) {
 node = node.left;
 }
 return node;
 }

 /**
 * Trova il valore massimo in un sottoalbero sfruttando la proprietà di ricerca
 * @param node nodo da cui deve partire la ricerca, valore di partenza la radice
 * @returns nodo con il valore massimo, null se l'albero è vuoto
 */
 getMax(node: Node<E> | null = this.root): Node<E> | null {
 while (node && node.right) {
 node = node.right;
 }
 return node;
 }

 /**
 * Funzione ausiliara che detrmina se l'albero radicato su nodo in input è bilanciato o meno
 * @param node nodo da verificare se è bilanciato
 * @returns oggetto con contenuto se è bilanciato o meno e l'altezza
 */
 private isBalancedAux(node: Node<E> | null): { balanced: boolean, height: number } {
 if (!node) return { balanced: true, height: 0 };

 const left = this.isBalancedAux(node.left);
 const right = this.isBalancedAux(node.right);

 const balanced = left.balanced && right.balanced && Math.abs(left.height - right.height) <= 1;
 const height = Math.max(left.height, right.height) + 1;

 return { balanced, height };
 };

 /**
 * Verifica che l'albero è bilanciato
 * @returns oggetto con contenuto se è bilanciato o meno e l'altezza 
 */
 isBalanced(): { balanced: boolean, height: number } {
 return this.isBalancedAux(this.root);
 }

 /**
 * Visita in ordine dell'albero
 * @returns array con i
 */
 inOrderTraversal(): E[] {
 let result: E[] = [];
 let node = this.root;
 this.auxInOrderTraversal(node, result)
 return result
 }

 /**
 * Ritorna l'albero in ordine (in-order traversal)[sx - r - dx]
 * @param node nodo da cui far partire la visita, di solito la radice
 * @param result array contenente i valori in ordine in base alla visita
 */
 auxInOrderTraversal(node: Node<E> | null, result: E[]) {
 if (node) {
 if (node.left)
 this.auxInOrderTraversal(node.left, result);

 result.push(node.value);

 if (node.right)
 this.auxInOrderTraversal(node.right, result);
 }
 }
};

// test della struttura dati
const bst = new BinarySearchTree();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(3);
bst.insert(7);
bst.insert(13);
bst.insert(18);

console.log("Attraversamento in preordine:", bst.inOrderTraversal());
console.log("Ricerca di valori:");
console.log("Cerca 7:", bst.find(7));
console.log("Cerca 20:", bst.find(20));

console.log("Eliminazione di un nodo (10)");
bst.remove(10);
console.log("Attraversamento in preordine dopo aver rimosso il 10:", bst.inOrderTraversal());

AlgoritmiTeoria - 6 - tree - binary tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: ALBERO BINARIO

L’Albero Binario è una struttura dati gerarchica formata da nodi, dove ciascun nodo può avere al massimo due figli:
➡ un figlio sinistro e un figlio destro.

È ideale per rappresentare dati con relazioni gerarchiche e per implementare altre strutture complesse (es. BST, Heap, Alberi Bilanciati).

TERMINOLOGIA

Nodo → elemento dell’albero contenente un valore e puntatori ai figli.
Radice (Root) → il nodo principale, punto di partenza di tutte le operazioni.
Foglia (Leaf) → nodo senza figli.
Padre (Parent) → nodo che ha almeno un figlio.
Figlio (Child) → nodo collegato a un padre.
Fratelli (Siblings) → nodi che condividono lo stesso padre.
Sottoalbero (Subtree) → albero derivato da un nodo specifico.
Albero Vuoto → struttura senza nodi (radice nulla).
Profondità (Depth) → distanza di un nodo dalla radice.
Altezza di un Nodo → distanza fino alla foglia più lontana.
Livello (Level) → insieme dei nodi alla stessa profondità.
Altezza dell’Albero → percorso più lungo radice → foglia.
Dimensione (Size) → numero totale di nodi.

OPERAZIONI DI VISITA

Pre-Ordine → Nodo → Sottoalbero Sinistro → Sottoalbero Destro.
In-Ordine → Sottoalbero Sinistro → Nodo → Sottoalbero Destro.
Post-Ordine → Sottoalbero Sinistro → Sottoalbero Destro → Nodo.
Per Livelli (Level-Order) → attraversamento livello per livello (con una coda).

OPERAZIONI PRINCIPALI

inserisci(valore) → aggiunge un nuovo nodo nell’albero.
cerca(valore) → verifica se un valore è presente.
elimina(valore) → rimuove un nodo con valore specifico.
visitaInOrdine() → restituisce i valori in ordine simmetrico.
visitaPreOrdine() → attraversa prima il nodo, poi i sottoalberi.
visitaPostOrdine() → attraversa prima i sottoalberi, poi il nodo.
altezza() → calcola la profondità massima.
contaNodi() → restituisce il numero totale di nodi.

PRESTAZIONI

Alberi bilanciati:
• Inserimento → O(log n)
• Ricerca → O(log n)
• Eliminazione → O(log n)
Alberi sbilanciati:
• Tutte le operazioni possono degradare a O(n).

➡ L’efficienza dipende dal bilanciamento dell’albero.

AlgoritmiTeoria - 6 - tree - k-tree

Wed, 25 Feb 2026 14:00:06 +0000

STRUTTURA DATI: K-ARY TREE

Un K-Ary Tree è una struttura dati gerarchica in cui ogni nodo può avere al massimo K figli.
È una generalizzazione dell’albero binario (dove K=2) e viene usato in contesti dove servono più di due rami di navigazione.

QUANDO USARLO

Implementazione di B-Tree e B+ Tree per database.
File system gerarchici.
rappresentazione di alberi di decisione con più alternative.
Strutture per trie (alberi di prefissi).

TERMINOLOGIA

K → numero massimo di figli per ogni nodo.
Nodo → contenitore del valore e array di figli.
Radice (Root) → nodo principale dell’albero.
Foglia (Leaf) → nodo senza figli.
Altezza → percorso più lungo dalla radice a una foglia.
Profondità → livello del nodo (radice = 0).

OPERAZIONI PRINCIPALI

inserisci(valore, parent) → aggiunge un nodo come figlio di parent.
cerca(valore) → verifica la presenza di un valore.
rimuovi(valore) → rimuove un nodo e i suoi discendenti.
visitaLivelli() → attraversamento livello per livello.
contaNodi() → numero totale di nodi.
getProfondità() → profondità massima dell’albero.

IMPLEMENTAZIONE

Ogni nodo ha un array figli di dimensione massima K.
L’inserimento fillows la prima posizione disponibile nell’array.
La ricerca è tipicamente in ampiezza (BFS) o profondità (DFS).

PRESTAZIONI

Inserimento → O(1) (se c’è spazio nel parent), altrimenti ricerca.
Ricerca → O(n) (caso peggiore, bisogna visitare tutti i nodi).
Attraversamento → O(n).

NOTE

Più flessibile dell’albero binario per rappresentare strutture complesse.
L’efficienza dipende dalla scelta di K e dalla distribuzione dei figli.
Spesso usato come base per algoritmi ottimizzati di ricerca.

CODICE

class KNode<T> {
 value: T;
 children: KNode<T>[];

 constructor(value: T) {
 this.value = value;
 this.children = [];
 }
}

class KTree<T> {
 root: KNode<T> | null;
 k: number; // massimo numero di figli

 constructor(k: number = 2) {
 this.root = null;
 this.k = k;
 }

 /**
 * Inserisce un nodo come figlio di un nodo padre esistente
 * @param value valore del nuovo nodo
 * @param parentValue valore del nodo padre (se null, inserisce alla radice)
 * @returns true se l'inserimento è riuscito, false altrimenti
 */
 insert(value: T, parentValue: T | null): boolean {
 const newNode = new KNode(value);

 // Se non c'è radice, il primo nodo diventa radice
 if (!this.root) {
 if (parentValue === null) {
 this.root = newNode;
 return true;
 }
 return false;
 }

 // Se parentValue è null, inserisci alla radice
 if (parentValue === null) {
 if (this.root.children.length < this.k) {
 this.root.children.push(newNode);
 return true;
 }
 return false;
 }

 // Trova il padre e inserisci
 return this.insertNode(this.root, parentValue, newNode);
 }

 /**
 * Funzione ausiliaria ricorsiva per inserire un nodo
 */
 private insertNode(node: KNode<T>, parentValue: T, newNode: KNode<T>): boolean {
 if (node.value === parentValue) {
 if (node.children.length < this.k) {
 node.children.push(newNode);
 return true;
 }
 return false;
 }

 // Cerca nei figli
 for (const child of node.children) {
 if (this.insertNode(child, parentValue, newNode)) {
 return true;
 }
 }
 return false;
 }

 /**
 * Cerca un valore nell'albero
 * @param value valore da cercare
 * @returns true se trovato, false altrimenti
 */
 search(value: T): boolean {
 if (!this.root) return false;
 return this.searchNode(this.root, value);
 }

 /**
 * Funzione ausiliaria per la ricerca
 */
 private searchNode(node: KNode<T>, value: T): boolean {
 if (node.value === value) return true;
 for (const child of node.children) {
 if (this.searchNode(child, value)) return true;
 }
 return false;
 }

 /**
 * Attraversamento livello per livello (BFS)
 * @returns array con i valori nell'ordine di visita
 */
 levelOrderTraversal(): T[] {
 if (!this.root) return [];
 
 const result: T[] = [];
 const queue: KNode<T>[] = [this.root];
 
 while (queue.length > 0) {
 const node = queue.shift()!;
 result.push(node.value);
 
 for (const child of node.children) {
 queue.push(child);
 }
 }
 
 return result;
 }

 /**
 * Conta il numero totale di nodi
 * @returns numero di nodi
 */
 countNodes(): number {
 if (!this.root) return 0;
 return this.countNodesRecursive(this.root);
 }

 /**
 * Funzione ausiliaria per contare i nodi
 */
 private countNodesRecursive(node: KNode<T>): number {
 let count = 1;
 for (const child of node.children) {
 count += this.countNodesRecursive(child);
 }
 return count;
 }

 /**
 * Calcola la profondità massima dell'albero
 * @returns profondità massima
 */
 getDepth(): number {
 if (!this.root) return 0;
 return this.getDepthRecursive(this.root);
 }

 /**
 * Funzione ausiliaria per calcolare la profondità
 */
 private getDepthRecursive(node: KNode<T>): number {
 if (node.children.length === 0) return 1;
 
 let maxDepth = 0;
 for (const child of node.children) {
 maxDepth = Math.max(maxDepth, this.getDepthRecursive(child));
 }
 return maxDepth + 1;
 }
}

// Esempio d'uso
const kTree = new KTree<number>(3); // K = 3

kTree.insert(1, null); // Radice
kTree.insert(2, 1); // Figlio di 1
kTree.insert(3, 1); // Figlio di 1
kTree.insert(4, 1); // Figlio di 1
kTree.insert(5, 2); // Figlio di 2
kTree.insert(6, 2); // Figlio di 2

console.log("Attraversamento livello per livello:", kTree.levelOrderTraversal());
console.log("Cerca 5:", kTree.search(5));
console.log("Cerca 10:", kTree.search(10));
console.log("Numero nodi:", kTree.countNodes());
console.log("Profondità:", kTree.getDepth());

AlgoritmiTeoria - 5 - map - map

Wed, 25 Feb 2026 14:00:05 +0000

STRUTTURA DATI: MYMAP

La MyMap è una struttura dati che implementa il concetto di mappa (o dizionario):
➡ Consente di memorizzare e recuperare coppie chiave-valore in modo rapido ed efficiente.

È ideale per scenari dove occorre associare un identificatore a un valore, ad esempio:

rubrica telefonica (nome → numero),
cache di dati,
configurazioni applicative.

STRUTTURA INTERNA

Utilizza un array come struttura sottostante.
Una funzione di hash converte la chiave in un indice dell’array.
In caso di collisione (più chiavi con stesso indice), viene utilizzato il chaining → ogni bucket contiene una lista di coppie [chiave, valore].

OPERAZIONI PRINCIPALI

set(key, value) → inserisce una nuova coppia o aggiorna il valore se la chiave esiste già.
get(key) → restituisce il valore associato a una chiave, oppure undefined se non trovata.
has(key) → verifica se una chiave è presente nella mappa (true/false).
delete(key) → rimuove una coppia chiave-valore, restituisce true se eliminata, altrimenti false.
keys() → restituisce un array contenente tutte le chiavi.
values() → restituisce un array contenente tutti i valori.
size() → restituisce il numero totale di coppie presenti.
clear() → rimuove tutte le coppie chiave-valore.

PRESTAZIONI

set → O(1) in media, O(n) in caso di collisioni estreme.
get → O(1) in media, O(n) in caso di collisioni estreme.
has → O(1) in media.
delete → O(1) in media.
keys / values → O(n) (serve attraversare tutti i bucket).

➡ La mappa è molto efficiente per la maggior parte delle operazioni, ma la qualità della funzione di hash influisce notevolmente sulle prestazioni.

AlgoritmiTeoria - 4 - queue - queue

Wed, 25 Feb 2026 14:00:04 +0000

STRUTTURA DATI: QUEUE (CODA)

La Queue (coda) è una struttura dati lineare che segue il principio FIFO (First In, First Out):
➡ Il primo elemento inserito è anche il primo a essere rimosso.

È ideale per gestire dati in ordine di arrivo, come:

gestione delle richieste in un server,
code di stampa,
algoritmi di scheduling dei processi.

STRUTTURA INTERNA

Gli elementi vengono inseriti in fondo (enqueue).
Gli elementi vengono rimossi dalla testa (dequeue).
L’ordine di arrivo viene sempre rispettato.

OPERAZIONI PRINCIPALI

enqueue(element) → inserisce un elemento in fondo alla coda.
dequeue() → rimuove e restituisce l’elemento in testa (oppure undefined se vuota).
peek() → restituisce l’elemento in testa senza rimuoverlo.
isEmpty() → restituisce true se la coda è vuota, false altrimenti.
size() → restituisce il numero di elementi nella coda.
printQueue() → stampa tutti gli elementi dalla testa alla fine.

PRESTAZIONI

enqueue → O(1)
dequeue → O(1)
peek → O(1)
isEmpty → O(1)
size → O(1)

➡ Tutte le operazioni principali sono in tempo costante.
La coda è particolarmente efficiente per scenari di gestione in tempo reale.

AlgoritmiTeoria - 3 - stack - stack

Wed, 25 Feb 2026 14:00:03 +0000

STRUTTURA DATI: STACK (PILA)

Lo Stack (pila) è una struttura dati lineare che segue il principio LIFO (Last In, First Out):
➡ L’ultimo elemento inserito è il primo a essere rimosso.

È molto utile in contesti in cui i dati devono essere gestiti in ordine inverso rispetto all’inserimento, ad esempio:

gestione delle chiamate annidate (call stack),
algoritmi di backtracking,
undo/redo in editor di testo.

STRUTTURA INTERNA

Gli elementi vengono inseriti e rimossi solo dalla cima (top).
Gli elementi sottostanti restano temporaneamente inaccessibili finché non si rimuove quello in cima.

OPERAZIONI PRINCIPALI

push(element) → inserisce un elemento in cima allo stack.
pop() → rimuove e restituisce l’elemento in cima (oppure undefined se vuoto).
peek() → restituisce l’elemento in cima senza rimuoverlo.
isEmpty() → restituisce true se la pila è vuota, false altrimenti.
size() → restituisce il numero di elementi nello stack.
printStack() → stampa tutti gli elementi dallo top alla base.

PRESTAZIONI

push → O(1)
pop → O(1)
peek → O(1)
isEmpty → O(1)
size → O(1)

➡ Tutte le operazioni avvengono in tempo costante, poiché non richiedono spostamenti o ridistribuzioni degli elementi.

AlgoritmiTeoria - 2 - list - linked list

Wed, 25 Feb 2026 14:00:02 +0000

STRUTTURA DATI: LISTA SEMPLICE

La Lista Semplice è una struttura dati dinamica composta da nodi collegati tra loro.
A differenza degli array, non ha una dimensione fissa e permette di inserire o rimuovere elementi senza dover ridimensionare l’intera struttura.
L’accesso agli elementi, però, è sequenziale, poiché non esiste un indice diretto.

STRUTTURA INTERNA

Ogni nodo della lista è composto da due campi:

data: il valore contenuto nel nodo.
next: riferimento al nodo successivo (oppure null se è l’ultimo).

La lista è gestita tramite un puntatore alla testa (head), che rappresenta il primo nodo e consente di accedere all’intera struttura.

AlgoritmiTeoria - 1 - array - binary search

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RICERCA BINARIA

La ricerca binaria è un algoritmo che consente di verificare se un elemento è presente all’interno di un array ordinato. Funziona dividendo progressivamente l’array a metà fino a trovare l’elemento cercato o determinare che non esiste.

QUANDO USARLO

Vuoi cercare un elemento in un array ordinato (crescente o decrescente).
Vuoi ridurre i tempi di ricerca rispetto alla scansione sequenziale.
Vuoi un algoritmo efficiente con complessità logaritmica.

FUNZIONAMENTO

Si considerano gli estremi dell’array (inizialmente 0 e n-1).
Si calcola l’indice dell’elemento centrale.
Si confronta l’elemento centrale con quello da cercare:

Se uguale, restituisce la posizione.
Se maggiore, si ripete la ricerca nella prima metà.
Se minore, si ripete la ricerca nella seconda metà.

Il processo continua fino a trovare l’elemento o esaurire l’array.

OUTPUT

Restituisce la posizione (tra 0 e n-1) se l’elemento è presente.
Restituisce -1 se l’elemento non è stato trovato.

COMPLESSITÀ

Caso peggiore: O(log n) a ogni passo la dimensione del problema si dimezza.

AlgoritmiTeoria - 1 - array - bubble sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: BUBBLE SORT

Il Bubble Sort è un algoritmo di ordinamento semplice che riordina un array confrontando ripetutamente coppie di elementi adiacenti e scambiandoli se sono nell’ordine sbagliato. Il processo continua finché l’array non risulta ordinato.

Visualizzazione: https://en.wikipedia.org/wiki/Bubble_sort#/media/File:Bubble-sort-example-300px.gif

QUANDO USARLO

Vuoi un algoritmo di ordinamento semplice da comprendere e implementare.
Stai lavorando con array di piccole dimensioni.
Vuoi un algoritmo didattico per introdurre i concetti di ordinamento.

FUNZIONAMENTO

Si confrontano due elementi consecutivi:

Se il primo ≤ il secondo, non si fa nulla. Esempio: (1, 3) → (1, 3)
Se il primo > il secondo, si scambiano. Esempio: (3, 2) → (2, 3)

Questo confronto viene fatto per tutte le coppie di elementi.
Una scansione completa dell’array si chiama passata.
Alla fine di ogni passata, l’elemento più grande “scivola” in fondo all’array, nella sua posizione definitiva.
L’algoritmo termina quando una passata non esegue alcuno scambio.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n) (quando l’array è già ordinato, basta una sola passata).
Caso medio: O(n²) (numerosi scambi distribuiti tra le passate).
Caso peggiore: O(n²) (array ordinato al contrario, massimo numero di scambi).

NOTE

È un algoritmo semplice ma inefficiente per array grandi.
È stabile (non cambia l’ordine relativo di elementi uguali).
Non è adatto a contesti pratici di ordinamento su grandi dataset.

CODICE

/**
 * Ordina l'array seguendo le logiche del bubbleSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function bblSort(arr: number[]): number[] {
	for (let i = 0; i < arr.length; i++) {
		for (let j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] && arr[j + 1] && arr[j]! > arr[j + 1]!) {
				const temp: number = arr[j]!;
				arr[j] = arr[j + 1]!;
				arr[j + 1] = temp;
			}
		}
	}
	return arr;
}

// Test sort
const arr = [234, 43, 55, 63, 5, 6, 235, 547];
console.log("TEST DEL BUBBLESORT");
console.log("Pre ordinamento:", arr);
const sorted = bblSort(arr)
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - counting sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: COUNTING SORT

Questo algoritmo permette di mettere in ordine un array in base agli elementi che lo compongono visualizzazione: https://it.wikipedia.org/wiki/Counting_sort#/media/File:Counting_Sort_Animation.gif

Descrizione dell’algoritmo Questo algoritmo presenta una precondizione fondamentale:

Gli elementi dell’array devono trovarsi in un intervallo compreso tra 0 e K.
La grandezza dell’intervallo determina anche la sua efficenza

FUNZIONAMENTO

Creazione di un array di supporto:
- Viene creato un array di supporto di dimensione K chiamato “array delle occorrenze” (o countArray).
- Tutti i valori di questo array vengono inizializzati a 0.
Conteggio delle occorrenze:
- L’algoritmo scorre l’array di partenza e utilizza ogni elemento come indice nell’array delle occorrenze.
- Incrementa il valore corrispondente in countArray di 1.
  Esempio: se l’elemento è 5, viene eseguito countArray[5]++.
Calcolo delle somme prefix:
- Viene modificato l’array delle occorrenze per calcolare la somma cumulativa (o somma dei prefissi) per ogni indice.
- Ogni posizione di countArray conterrà il numero totale di elementi minori o uguali a quell’indice.
Ordinamento dell’array di partenza:
- Utilizzando i prefissi calcolati nel passo precedente, l’algoritmo determina la posizione corretta di ogni elemento nell’array ordinato.

Questo processo garantisce un ordinamento stabile e rapido per array che soddisfano la precondizione iniziale.

AlgoritmiTeoria - 1 - array - insertion sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: INSERTION SORT

L’Insertion Sort è un algoritmo di ordinamento semplice e intuitivo, che costruisce progressivamente una parte ordinata dell’array inserendo ogni nuovo elemento nella posizione corretta.
Funziona in modo simile al processo di ordinare manualmente le carte da gioco in mano.

Visualizzazione:
https://it.wikipedia.org/wiki/Insertion_sort#/media/File:Sorting_insertion_sort_anim.gif

QUANDO USARLO

L’array ha piccole dimensioni o è già quasi ordinato.
Vuoi un algoritmo semplice da implementare e stabile.
È utile come parte di algoritmi più complessi (es. Shell Sort).

FUNZIONAMENTO

Si assume che il primo elemento sia già ordinato.
Per ogni elemento successivo (dal secondo fino all’ultimo):
- Si confronta l’elemento con quelli nella parte ordinata.
- Se l’elemento è maggiore del massimo ordinato → viene posto in fondo alla parte ordinata.
- Altrimenti, si spostano (shift) gli elementi più grandi di lui per fare spazio e inserirlo nella posizione corretta.
La parte ordinata cresce progressivamente di un elemento per volta, fino a includere l’intero array.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n)
(array già ordinato → basta un confronto per elemento).
Caso medio: O(n²)
(inserimenti distribuiti con vari spostamenti).
Caso peggiore: O(n²)
(array ordinato in senso opposto, massimo numero di spostamenti).

NOTE

È un algoritmo stabile (mantiene l’ordine relativo di elementi uguali).
Funziona bene su insiemi piccoli o quasi ordinati.
Per array grandi non è efficiente rispetto a QuickSort, MergeSort, ecc.

CODICE

/**
 * Ordina l'array seguendo le logiche del insertionSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function insertionSort(arr: number[]): number[] {
	for (let i = 1; i < arr.length; i++) {
		const key = arr[i]!;
		let j = i - 1;

		// Sposta gli elementi maggiori di "key" una posizione avanti
		while (j >= 0 && arr[j] && arr[j]! > key) {
			arr[j + 1] = arr[j]!;
			j = j - 1;
		}
		arr[j + 1] = key;
	}
	return arr;
}

// Test sort
const arr = [12, 11, 13, 5, 6];
console.log("TEST DELL'INSERTIONSORT");
console.log("Pre ordinamento:", arr);
const sorted = insertionSort(arr);
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - linear search

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RICERCA LINEARE

La ricerca lineare è un algoritmo che consente di verificare se un elemento è presente all’interno di un array.
Non richiede che l’array sia ordinato: controlla gli elementi uno a uno fino a trovare il valore cercato oppure fino alla fine dell’array.

QUANDO USARLO

Vuoi cercare un elemento in un array non ordinato.
L’array è di piccole dimensioni, quindi la semplicità conta più dell’efficienza.
Non hai bisogno di strutture dati avanzate o logiche di ricerca complesse.

FUNZIONAMENTO

Si scorre l’array dall’inizio alla fine.
Per ogni elemento si confronta con quello da cercare:
- Se uguale, restituisce la posizione e termina.
- Se diverso, continua con l’elemento successivo.
Se si arriva alla fine senza trovare l’elemento, l’algoritmo restituisce -1.

OUTPUT

Restituisce la posizione (tra 0 e n-1) se l’elemento è presente.
Restituisce -1 se l’elemento non è stato trovato.

COMPLESSITÀ

Caso migliore: O(1)
(se l’elemento si trova subito all’inizio).
Caso medio: O(n)
(in media deve scorrere metà dell’array).
Caso peggiore: O(n)
(se l’elemento è alla fine o non è presente).

CODICE

/**
 * Ricerca di un elmento all'interno dell'array tramite scansione lineare
 * @param arr array sul quale dobbiamo fare la ricerca
 * @param x elemento da cercare
 * @returns posizione dell'elemento all'interno dell'array se esiste, altrimenti -1
 */
function linearSearch(array: number[], x: number): number {
	for (let i = 0; i < array.length; i++) {
		if (array[i] === x) {
			return i;
		}
	}
	return -1;
}

let numbers = [1, 3, 5, 7, 8, 9];
console.log("Visualizza array:", numbers);
console.log("Ricerca all'interno dell'array dell'elemento 8, indice:", linearSearch(numbers, 8));
console.log("Ricerca all'interno dell'array dell'elemento 28, indice:", linearSearch(numbers, 28));

AlgoritmiTeoria - 1 - array - merge sort

Wed, 25 Feb 2026 14:00:01 +0000

sort/mergesort.ts

ALGORITMO: MERGE SORT

Il Merge Sort è un algoritmo di ordinamento basato sul paradigma Divide et Impera.
Divide ricorsivamente l’array in parti sempre più piccole, le ordina e poi le ricompone fino a ottenere l’array ordinato completo.

Visualizzazione:
https://it.wikipedia.org/wiki/Merge_sort#/media/File:Merge_sort_animation2.gif

QUANDO USARLO

L’array è di grandi dimensioni.
Vuoi un algoritmo stabile e con complessità garantita O(n log n).
È utile quando serve un ordinamento prevedibile, indipendente dalla disposizione iniziale dei dati.

FUNZIONAMENTO

Divisione:
- L’array viene suddiviso ricorsivamente in due metà fino a ottenere micro-array di un solo elemento.
Ricombinazione ordinata (Merge):
- Due micro-array vengono uniti confrontando i loro elementi e inserendoli in ordine crescente in un array temporaneo.
- Questo processo si ripete risalendo la ricorsione, fino a ricomporre l’intero array ordinato.

OUTPUT

Restituisce l’array ordinato sfruttando dei sottoarray

COMPLESSITÀ

Caso migliore: O(n log n)
Caso medio: O(n log n)
Caso peggiore: O(n log n)

Nota di merito alla complessità spaziale aggiuntiva, che in questo caso è O(n) in quanto ho bisogno di un array di supporto grande quanto quello di input

AlgoritmiTeoria - 1 - array - quick sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: QUICK SORT

Il Quick Sort è un algoritmo di ordinamento Divide et Impera che suddivide ricorsivamente l’array intorno a un elemento chiamato pivot.
Gli elementi minori del pivot vengono posizionati a sinistra, quelli maggiori a destra, e il processo viene ripetuto su entrambe le sotto-sezioni.

Visualizzazione:
https://en.wikipedia.org/wiki/Quicksort#/media/File:Sorting_quicksort_anim.gif

QUANDO USARLO

Vuoi un algoritmo di ordinamento rapido e con buona performance media.
L’array è di grandi dimensioni.
Puoi tollerare casi peggiori rari (O(n²)) con scelte di pivot non ottimali.
È utile quando serve un algoritmo in-place (senza array aggiuntivi significativi).

FUNZIONAMENTO

Scelta del pivot:
- Si seleziona un elemento dell’array (spesso primo, ultimo o centrale).
Partizionamento:
- Gli elementi minori del pivot vengono spostati a sinistra.
- Gli elementi maggiori del pivot vengono spostati a destra.
- Il pivot viene posizionato nella sua posizione finale.
Ricorsione:
- La procedura viene applicata ricorsivamente alla sotto-sezione sinistra e destra del pivot.
L’array diventa ordinato quando tutte le sotto-sezioni sono ordinate.

OUTPUT

Restituisce l’array ordinato come side effect (modifica in-place).

COMPLESSITÀ

Caso migliore: O(n log n)
(pivot divide sempre in modo bilanciato).
Caso medio: O(n log n)
Caso peggiore: O(n²)
(pivot scelto male, ad esempio array già ordinato e pivot sempre massimo/minimo).

NOTE

È un algoritmo non stabile (l’ordine relativo di elementi uguali può cambiare).
Molto efficiente in media e con poca memoria aggiuntiva.
L’uso di strategie di pivot migliori (es. pivot casuale) riduce il rischio di caso peggiore.

CODICE

/**
 * Funzione ausiliaria del quickSort per individuare e posizionare correttamente il pivot
 * @param arr array da ordinare
 * @param low estremo sx dell'array
 * @param high estremo dx dell'array
 * @returns la posizione del pivot una volta ordinato
 */
function partition(arr: any, low: number, high: number): number {
	const pivot = arr[high]; // pivot finale
	let i = low - 1;

	for (let j = low; j <= high - 1; j++) {
		if (arr[j] < pivot) { // nessun !
			i++;
			[arr[i], arr[j]] = [arr[j], arr[i]];
		}
	}

	[arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
	return i + 1;
}

/**
 * Ordina l'array seguendo le logiche del quickSort
 * @param arr array da ordinare
 * @param low estremo sx dell'array, valore di partenza 0
 * @param high estremo dx dell'array, valore di partenza "dimensione dell'array - 1"
 * @returns array ordinato
 */
function quickSort(arr: number[], low: number, high: number): number[] {
	if (low < high) {
		const pi = partition(arr, low, high);
		quickSort(arr, low, pi - 1);
		quickSort(arr, pi + 1, high);
		return arr;
	} else {
		return [];
	}
}

// Test
const arr = [10, 7, 8, 9, 1, 5];
console.log("TEST DEL QUICKSORT");
console.log("Pre ordinamento:", arr);
const sorted = quickSort(arr, 0, arr.length - 1);
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - radix sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: RADIX SORT

Il Radix Sort è un algoritmo di ordinamento non basato sui confronti che ordina i numeri considerando le loro cifre, dalla meno significativa alla più significativa (LSD – Least Significant Digit).
È molto efficiente quando gli elementi hanno un numero limitato di cifre.

Visualizzazione:
https://it.wikipedia.org/wiki/Radix_sort#/media/File:Radix.JPG

QUANDO USARLO

Gli elementi sono numeri interi non negativi.
Le cifre dei numeri si trovano in un intervallo limitato [0, K].
Vuoi un ordinamento stabile e più efficiente di O(n log n) per insiemi di numeri con range limitato.
Utile come base per algoritmi più complessi di ordinamento di grandi dataset.

FUNZIONAMENTO

Si considerano tutti i numeri dell’array.
Si ordina ogni numero cifra per cifra, partendo dalla cifra meno significativa (unità) fino alla più significativa:
- Esempio: Array iniziale: 142, 456, 228
  - Passo 1: ordino le cifre meno significative → 142, 228, 456
  - Passo 2: ordino le cifre successive → 142, 228, 456
  - Passo 3: ordino le cifre più significative → 142, 228, 456
Dopo l’ultima iterazione, l’array risulta completamente ordinato.

OUTPUT

Restituisce l’array ordinato in modo stabile.

COMPLESSITÀ

Caso migliore: O(m(n + K))
Caso medio: O(m(n + K))
Caso peggiore: O(m(n + K))
Dove:
- m = numero di elementi nell’array
- n = numero di cifre di ciascun elemento
- K = valore massimo possibile delle cifre

NOTE

È un algoritmo stabile, quindi mantiene l’ordine relativo di elementi uguali.
Non utilizza confronti diretti tra numeri.
Particolarmente efficiente per grandi array di numeri con cifre limitate.

CODICE

/**
 * Calcola la cifra di un numero in una certa posizione
 * @param num numero di partenza
 * @param place posizione di cui si vuole sapere la cifra
 * @returns la cifra in posizione "place" del numero "num"
 */
function getDigit(num: number, place: number) {
	return Math.floor(Math.abs(num) / Math.pow(10, place)) % 10
}

/**
 * Calcola il numero di cifre totali di un numero
 * @param num numero di partenza
 * @returns totale delle cifre del numero "num"
 */
function digitCount(num: number) {
	if (num === 0) return 1
	return Math.floor(Math.log10(Math.abs(num))) + 1
}

/**
 * Calcola quall'è il numero con piu cifre in assoluto di un array
 * @param nums array di numeri
 * @returns quante cifre ha il numero con più cifre all'interno di "nums"
 */
function mostDigits(nums: number[]) {
	let maxDigits = 0
	for (let i = 0; i < nums.length; i++) {
		maxDigits = Math.max(maxDigits, digitCount(nums[i]!))
	}
	return maxDigits
}

/**
 * Ordina l'array seguendo le logiche del radicSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function radixSort(arr: number[]): number[] {
	const maxDigitCount = mostDigits(arr);

	for (let k = 0; k < maxDigitCount; k++) {
		const digitBuckets: number[][] = Array.from({ length: 10 }, () => []);

		for (const num of arr) {
			const digit = getDigit(num, k);
			if (digitBuckets[digit]) { // controllo
				digitBuckets[digit].push(num);
			}
		}

		// Ricostruisci l'array in base ai buckets
		arr = ([] as number[]).concat(...digitBuckets);
	}

	return arr;
}

// Test sort
const arr = [1, 33, 444, 0, 3, 2];
console.log("TEST DEL RADICSORT");
console.log("Pre ordinamento:", arr);
const sorted = radixSort(arr)
console.log("Post ordinamento:", sorted);

AlgoritmiTeoria - 1 - array - selection sort

Wed, 25 Feb 2026 14:00:01 +0000

ALGORITMO: SELECTION SORT

Il Selection Sort è un algoritmo di ordinamento semplice che funziona selezionando ripetutamente il minimo elemento da un sotto-array non ordinato e scambiandolo con il primo elemento non ordinato.
Ripetendo questo processo, l’array diventa ordinato.

Visualizzazione:
https://en.wikipedia.org/wiki/Selection_sort#/media/File:Selection-Sort-Animation.gif

QUANDO USARLO

L’array è di piccole dimensioni.
Vuoi un algoritmo semplice da implementare.
Non hai necessità di stabilità nell’ordinamento.

FUNZIONAMENTO

Si individua l’elemento minimo nell’array o sotto-array corrente.
Si scambia il minimo con il primo elemento non ordinato.
Si ripete la procedura sul sotto-array che va dalla posizione successiva fino alla fine dell’array.
L’array è ordinato quando tutti gli elementi sono stati posizionati.

OUTPUT

Restituisce l’array ordinato.

COMPLESSITÀ

Caso migliore: O(n²)
Caso medio: O(n²)
Caso peggiore: O(n²)

NOTE

È un algoritmo non stabile (l’ordine relativo degli elementi uguali può cambiare).
Funziona bene su array piccoli ma inefficiente su array grandi.
Ha il vantaggio di fare un numero minimo di scambi rispetto ad altri algoritmi O(n²).

CODICE

/**
 * Ordina l'array seguendo le logiche del selectionSort
 * @param arr array da ordinare
 * @returns array ordinato
 */
function selectionSort(arr: number[]): number[] {
	const arrToSort = [...arr]; // copia locale
	const n = arrToSort.length;

	for (let i = 0; i < n; i++) {
		let min = i;
		for (let j = i + 1; j < n; j++) {
			if (arrToSort[j] && arrToSort[min] && arrToSort[j]! < arrToSort[min]!) {
				min = j;
			}
		}
		if (min !== i && arrToSort[i] && arrToSort[min]) {
			const tmp = arrToSort[i]!;
			arrToSort[i] = arrToSort[min]!;
			arrToSort[min] = tmp;
		}
	}

	return arrToSort;
}

// Test sort
let arr: number[] = [234, 43, 55, 63, 5, 6, 235, 547];
console.log("TEST DEL SELECTIONSORT");
console.log("Pre ordinamento:", arr);
const sorted = selectionSort(arr);
console.log("Post ordinamento:", sorted);