import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); } import { useState, useEffect, useCallback } from "react" import { Studente, Corso, Esame } from "./modelli" import { fetchAPI, handleError } from "./utils" const API_BASE = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3000" const TIMEOUT = 5_000 async function fetchStudente(matricola: number): Promise<Studente | null> { try { const res = await fetch(`${API_BASE}/studenti/${matricola}`, { signal: AbortSignal.timeout(TIMEOUT), headers: { "Content-Type": "application/json" }, }) if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`) return (await res.json()) as Studente } catch (err) { handleError(err) return null } } export function useStudente(matricola: number) { const [studente, setStudente] = useState<Studente | null>(null) const [loading, setLoading] = useState(false) const [error, setError] = useState<string | null>(null) const load = useCallback(async () => { setLoading(true) setError(null) const data = await fetchStudente(matricola) if (data) setStudente(data) else setError("Studente non trovato") setLoading(false) }, [matricola]) useEffect(() => { load() }, [load]) return { studente, loading, error, reload: load } } def calcola_media(voti: list[float], pesi: list[float] | None = None) -> float: if not voti: return 0.0 if pesi is None: return sum(voti) / len(voti) if len(voti) != len(pesi): raise ValueError("voti e pesi devono avere la stessa lunghezza") return sum(v * p for v, p in zip(voti, pesi)) / sum(pesi) class Studente: __slots__ = ("nome", "cognome", "matricola", "_voti") def __init__(self, nome: str, cognome: str, matricola: int) -> None: self.nome = nome self.cognome = cognome self.matricola = matricola self._voti: list[tuple[str, float, int]] = [] def registra_voto(self, corso: str, voto: float, cfu: int) -> None: if not (18 <= voto <= 30): raise ValueError(f"voto non valido: {voto!r}") self._voti.append((corso, voto, cfu)) @property def media_ponderata(self) -> float: if not self._voti: return 0.0 return sum(v * c for _, v, c in self._voti) / sum(c for _, _, c in self._voti) def __repr__(self) -> str: return f"Studente({self.nome!r}, media={self.media_ponderata:.2f})" public class GestoreCorsi { private final Map<String, Corso> corsi = new HashMap<>(); private final List<Iscrizione> iscrizioni = new ArrayList<>(); public void aggiungiCorso(String codice, String nome, int cfu) { if (corsi.containsKey(codice)) throw new IllegalArgumentException("Corso già presente: " + codice); corsi.put(codice, new Corso(codice, nome, cfu)); } public Optional<Corso> trovaCorsoByCodice(String codice) { return Optional.ofNullable(corsi.get(codice)); } public List<Corso> corsiConPiuDi(int cfu) { return corsi.values().stream() .filter(c -> c.getCfu() > cfu) .sorted(Comparator.comparing(Corso::getNome)) .collect(Collectors.toList()); } public double mediaVotiStudente(int matricola) { return iscrizioni.stream() .filter(i -> i.getMatricola() == matricola) .mapToDouble(Iscrizione::getVoto) .average() .orElse(0.0); } } function mergeSort(arr: number[]): number[] { if (arr.length <= 1) return arr const mid = Math.floor(arr.length / 2) const left = mergeSort(arr.slice(0, mid)) const right = mergeSort(arr.slice(mid)) return merge(left, right) } function merge(left: number[], right: number[]): number[] { const result: number[] = [] let i = 0, j = 0 while (i < left.length && j < right.length) { result.push(left[i] <= right[j] ? left[i++] : right[j++]) } return result.concat(left.slice(i), right.slice(j)) } #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Nodo { int valore; struct Nodo *sinistro; struct Nodo *destro; } Nodo; Nodo *crea_nodo(int valore) { Nodo *n = malloc(sizeof(Nodo)); if (!n) { perror("malloc"); exit(EXIT_FAILURE); } n->valore = valore; n->sinistro = n->destro = NULL; return n; } Nodo *inserisci(Nodo *radice, int valore) { if (!radice) return crea_nodo(valore); if (valore < radice->valore) radice->sinistro = inserisci(radice->sinistro, valore); else if (valore > radice->valore) radice->destro = inserisci(radice->destro, valore); return radice; } void inorder(const Nodo *r) { if (!r) return; inorder(r->sinistro); printf("%d ", r->valore); inorder(r->destro); } int altezza(const Nodo *r) { if (!r) return 0; int sx = altezza(r->sinistro); int dx = altezza(r->destro); return 1 + (sx > dx ? sx : dx); }
Ripetizioni di programmazione online
Per superare l'esame capendo davvero
quello che
scrivi.Per superare l'esame capendo davvero
quello che
scrivi.
Tutoraggio individuale per studenti universitari e delle scuole superiori. Un metodo per pensare, non un linguaggio da memorizzare.
Inizia gratis →Per chi
Tre modi in cui posso aiutarti
Profili diversi, stessa idea di fondo: capire davvero, non sopravvivere.
Sviluppare un progetto
Hai un progetto di corso o una tesi che chiede tempo e direzione. Cerchi qualcuno che lo costruisca insieme a te, per sciogliere i nodi quando si formano e accompagnarti fino alla consegna.
Preparare un esame
Hai un esame o un appello in arrivo, e vuoi arrivarci con la sicurezza di sapere cosa fare. Andiamo dritti al pratico: gli strumenti concreti per ragionare con lucidità il giorno dell'esame.
Chiarire un argomento
Hai un argomento che non ti è mai stato chiaro: un capitolo che ti porti dietro, un concetto che non riesci a mettere a fuoco. Bastano poche ore mirate, e da lì prosegui in autonomia.
Linguaggi e ambiti
C
C++
Python
Java
PHP
HTML
JavaScript
TypeScript
React
Node.js
Ruby on Rails
Introduzione e fondamenti di programmazioneProgrammazione a oggettiAlgoritmi e strutture datiBasi di datiSviluppo web (front-end, back-end, full-stack)Sistemi operativiVersionamento con Git
Formazione ed esperienza
Chi sono
Mi chiamo Noemi. Mi sono formata come ingegnera informatica tra il Politecnico di Torino e Télécom Paris, e ho lavorato per anni nel software — sia in contesti di ricerca, sia in corporate a Parigi, dove ho vissuto quattro anni. In quegli anni ho fatto da riferimento tecnico per i colleghi, e in università ho lavorato anche come tutor accademica, a contatto diretto con gli studenti e con le loro difficoltà reali. Spiegare codice, fare review, accompagnare chi sta imparando è sempre stato uno dei pezzi del lavoro che mi è venuto più naturale.
Oggi, accanto alla mia formazione tecnica, porto avanti una carriera artistica: lavoro come compositrice di musica per multimedia — film, videogiochi, installazioni — e come programmatrice creativa, un ambito in cui il codice diventa il mezzo per costruire opere ed esperienze. Credo che il codice sia uno strumento per immaginare mondi e progettare realtà, non una grammatica astratta da subire. Negli anni ho costruito un modo intuitivo di leggerlo e scriverlo, lo stesso che mi permette di farne arte. È quello che da tutor lavoro per trasmetterti: un modo tuo di stare nel codice, non una sintassi da memorizzare.
Nelle lezioni questo si traduce in attenzione tecnica e attenzione alla persona insieme — e nell'idea che ogni percorso debba lasciare un segno: un esame superato, un progetto che funziona, un argomento finalmente chiaro.
In sintesi
- —Doppia laurea magistrale in Ingegneria Informatica — Politecnico di Torino e Télécom Paris (Francia)
- —Esperienza in ricerca e sviluppo presso INRIA
- —Anni di esperienza come sviluppatrice in ambiente corporate a Parigi
- —Tutor accademica in università e mentor tecnica per colleghi in azienda
- —Formazione e lavoro in ambienti internazionali, dinamici, multilingue
Tariffe
Un percorso per ogni obiettivo
Progetto
20 ore
€22/h
€700€440 totali· sconto 37%
Per un lavoro che chiede continuità: un progetto di corso, una tesi, un'idea da costruire. Sviluppiamo insieme, sessione dopo sessione, fino alla consegna.
Recupero
5 ore
€31/h
€175€155 totali· sconto 11%
Per rimetterti in pari su un argomento, chiudere una lacuna, sciogliere un nodo. Poche ore concentrate per tornare a procedere in autonomia.
Oppure
Senza pacchetto — €35/h
Stessi percorsi mirati. Decidi tu quante lezioni e quando, man mano che andiamo avanti.
Inizia gratis →
Una prima lezione gratuita di 60 minuti, senza impegno. Capiamo da dove parti, dove vuoi arrivare, e se sono la persona giusta per aiutarti.
Per ulteriori informazioni, consulta i Termini e Condizioni.
Metodo
Come lavoriamo
1.
Pianifichiamo
Prima di scrivere, facciamo una mappa: cosa deve fare il codice, quali passi servono, dove vogliamo arrivare. Non un esercizio teorico, ma il minimo essenziale che serve per non procedere alla cieca.
2.
Sperimentiamo
Scriviamo e facciamo girare. Il codice è materia viva: risponde subito, e ogni esecuzione è un'occasione per vedere cosa succede davvero. È nel feedback immediato che si costruisce l'intuito su come le cose funzionano.
3.
Verifichiamo
Quello che il codice ha prodotto coincide con quello che volevamo? Se no, cerchiamo cosa è andato storto e aggiustiamo il tiro. Se sì, capiamo perché ha funzionato — è la differenza tra un esercizio chiuso e un metodo che resta tuo.
Domande frequenti
La prima lezione è totalmente gratuita, dura 60 minuti e non ti impegna a nulla. Capiamo insieme da dove parti, cosa vuoi raggiungere e se sono la persona giusta per aiutarti — poi decidi tu se continuare.
Sì, e per la programmazione funzionano meglio che di persona. Possiamo lavorare contemporaneamente sullo stesso codice, vedere il tuo schermo o il mio, fare debug fianco a fianco — esattamente come si fa nel mondo del lavoro. Serve solo una connessione stabile.
Hai la possibilità di cancellare e riprogrammare la lezione fino a 24 ore prima, senza problemi: il modo più rapido è usare i link nell'email di conferma o nell'invito calendar; in alternativa, scrivimi. Per le disdette dell'ultimo minuto preferisco valutare caso per caso — gli imprevisti capitano, e non ha senso essere rigidi.
Da qualunque punto del tuo percorso di studi. Che tu stia affrontando la programmazione per la prima volta, o che ci siano dei pezzi che non tornano, o che tu voglia una guida esperta che dia direzione e ritmo a un progetto. Non ci sono prerequisiti!
Un computer e una connessione, niente di più. Se hai già un ambiente di sviluppo configurato e funzionante, perfetto — usiamo quello. Altrimenti, almeno per la prima lezione, lavoriamo su strumenti immediati che girano direttamente nel browser: gli stessi che usano molti professionisti, niente da installare e niente tempo perso. Passare a un ambiente sul tuo computer ha senso solo se reputiamo insieme che rientra nei tuoi obiettivi formativi.
I pacchetti non hanno vincoli. Se a un certo punto vuoi interrompere, le lezioni rimaste restano disponibili per un anno e puoi usarle quando vuoi. Se senti che il metodo non funziona, scrivimi: ne parliamo e troviamo una soluzione.
Sì, è il percorso "Senza pacchetto": €35 all'ora, senza impegno anticipato. Stessa attenzione all'obiettivo e al metodo. L'unica differenza è che procedi una lezione alla volta, decidendo di volta in volta se continuare.
Prenota
Inizia con una prima lezione gratuita
Scegli un orario qui sotto. 60 minuti, gratuiti, senza impegno.
Se hai dubbi prima di prenotare, scrivimi.
Continuando, confermi di avere più di 14 anni, di aver preso visione dei Termini e Condizioni e dell'Informativa sulla Privacy.