Untitled

Quale tra le seguenti affermazioni descrive meglio il concetto di 'modularizzazione' nella progettazione del software?

Qual è il beneficio principale derivante dal riuso di componenti software già esistenti e verificate?

Cosa si intende per 'astrazione funzionale' nel contesto dello sviluppo di software?

In che modo l'astrazione aiuta a gestire la complessità nello sviluppo di sistemi informatici di grandi dimensioni?

Considerando i principi di astrazione e information hiding, quale delle seguenti strategie architetturali li implementa al meglio?

Cosa succede se !q o q->numel==MAXPQ nella funzione insert?

Qual è lo scopo principale della funzione sali?

In un grafo orientato, cosa rappresenta l'insieme A?

Cosa rappresenta la condizione pos > 1 all'interno del ciclo while nella funzione sali?

Considerando l'esempio di grafo orientato fornito, quale delle seguenti affermazioni è corretta riguardo agli archi?

Quale delle seguenti affermazioni descrive correttamente un albero in informatica?

Nella funzione sali, perché la variabile i è inizializzata come pos/2?

Supponendo di avere una PQueue q con q->vet = {0, 3, 7, 5, 1} e q->numel = 4, cosa succederebbe immediatamente dopo l'esecuzione di sali(q) all'interno della funzione insert con una nuova key = 9?

Qual è la caratteristica distintiva della radice in un albero?

Cosa rappresenta la 'foglia' in un albero?

Come è definito il 'cammino' in un albero?

Cosa indica il 'livello' di un nodo in un albero?

Come si calcola l'altezza di un albero?

Quale delle seguenti affermazioni descrive correttamente un sottoalbero?

In un albero binario, quale distinzione fondamentale viene fatta tra i figli di un nodo?

Considerando un albero in cui ogni nodo ha un'etichetta numerica, e sapendo che l'altezza dell'albero è $h$, qual è il numero massimo di nodi che l'albero può contenere, assumendo che ogni livello sia completamente pieno?

Qual il contenuto del riferimento nell'ultimo nodo di una lista concatenata?

Qual uno dei principali vantaggi delle liste concatenate rispetto agli array?

Qual uno svantaggio principale delle liste concatenate rispetto agli array nell'accesso agli elementi?

Come si inserisce un nuovo elemento in testa a una lista concatenata?

Qual la complessit temporale per accedere all'i-esimo elemento in una lista concatenata?

In una lista concatenata, quale operazione generalmente pi efficiente rispetto agli array quando si tratta di modificare la struttura della collezione?

Supponendo di avere una lista concatenata semplice, non ordinata, quale sarebbe la complessit temporale nel caso peggiore per cercare un elemento specifico nella lista?

Se si dovesse invertire una lista concatenata semplice, qual la complessit spaziale aggiuntiva minima che si pu ottenere in un algoritmo iterativo?

Considera una lista concatenata in cui ogni nodo ha un puntatore al nodo successivo e un puntatore al nodo precedente (lista doppiamente concatenata). Come influisce questo sulla complessit temporale per cancellare un nodo arbitrario (non la testa o la coda) conoscendo il puntatore a quel nodo?

Supponiamo di avere due liste concatenate ordinate, lista1 e lista2, di lunghezza m e n rispettivamente. Qual la complessit temporale ottimale per fondere (merge) le due liste in una nuova lista concatenata ordinata?

Quale delle seguenti affermazioni descrive correttamente la funzione newStack()?

Cosa restituisce la funzione emptyStack(stack s)?

Qual è il valore di ritorno della funzione push(item val, stack s) se lo stack è pieno?

Qual è lo scopo della funzione top(stack s)?

Cosa succede se si chiama pop(stack s) su uno stack vuoto?

Considerando l'implementazione dello stack basata su array, quale operazione potrebbe causare un errore di 'stack overflow'?

Qual è il risultato della verifica di bilanciamento delle parentesi per la stringa (a + b[c - d]) * {e / f}?

Nella funzione verifica(char *expr), cosa succede se l'espressione expr è NULL?

Data l'espressione ()[{}], quale sarà il contenuto dello stack S immediatamente prima che la funzione verifica restituisca il valore finale?

Quale modifica all'implementazione dello stack basata su array permetterebbe di evitare la limitazione di MAXSTACK (insanely difficult)?

Nell'implementazione dello stack basata su array dinamico, quale sequenza di eventi si verifica esattamente quando la funzione push viene chiamata con uno stack pieno (s->top == s->size) e la realloc fallisce?

Considerando l'implementazione dello stack con liste collegate, cosa accadrebbe se, all'interno della funzione pop, la riga s->top = s->top->next; venisse eseguita prima dell'assegnazione di s->top a temp?

Nell'implementazione dello stack con array dinamico, se volessimo implementare una funzione clearStack(stack s) che svuota lo stack e rilascia la memoria allocata, quale sarebbe l'implementazione più corretta per evitare memory leak e dangling pointers?

Si consideri l'implementazione dello stack basata su lista concatenata. Quale delle seguenti affermazioni descrive accuratamente la complessità temporale nel caso peggiore per una sequenza di $n$ operazioni push seguite da $n$ operazioni pop?

Supponiamo di voler estendere l'implementazione dello stack basata su array dinamico per includere una funzione duplicateStack(stack s) che crea una copia profonda dello stack originale. Quale delle seguenti implementazioni garantirebbe la corretta gestione della memoria e l'indipendenza tra lo stack originale e la copia?

In un'implementazione di posItem (versione ricorsiva), quali implicazioni deriverebbero da una gestione impropria della ricorsione terminale (tail recursion) in termini di consumo di risorse?

Considerando l'implementazione iterativa di posItem, quale sarebbe l'effetto di sostituire l = tailList(l) con l = newList() all'interno del ciclo while, assumendo che newList() crei una nuova lista vuota?

Nell'implementazione di getItem, quale sarebbe l'impatto di invertire l'ordine delle condizioni nel ciclo while in while (!emptyList(l) && i < pos)?

Considerando la funzione reverseList, quale sarebbe la complessità computazionale nel caso in cui la funzione consList avesse una complessità temporale di $O(n)$, dove $n$ è la lunghezza della lista?

Supponendo di avere una lista lst1 contenente stringhe, e che la funzione output_item(val) stampi la stringa val. Se lst1 contiene le stringhe {"alfa", "beta", "gamma"}, in quale ordine verrebbero stampate le stringhe utilizzando la funzione outputList?

Data l'implementazione di reverseList, se la lista originale l condividesse alcuni elementi (in memoria) con un'altra lista l2, quale sarebbe l'effetto collaterale potenziale sull'altra lista dopo l'esecuzione di reverseList(l)?

Nell'implementazione ricorsiva di posItem, supponendo che la lista l sia ciclica, cosa accadrebbe all'esecuzione della funzione?

Considerando una variante di outputList che utilizzi la ricorsione terminale per la visualizzazione degli elementi, quale ottimizzazione specifica del compilatore potrebbe prevenire lo stack overflow per liste estremamente lunghe?

In una implementazione alternativa di reverseList che modifica in-place la lista originale (senza creare una nuova lista), quale sarebbe la complessità spaziale di tale algoritmo?

Supponiamo di voler modificare la funzione getItem per supportare l'accesso a elementi con indice negativo, dove un indice negativo -k indica il $k$-esimo elemento a partire dalla fine della lista. Come si dovrebbe modificare l'implementazione per gestire correttamente gli indici negativi mantenendo l'efficienza?

Considerando l'implementazione dell'ADT Btree fornita, quale implicazione critica scaturisce dall'indipendenza del tipo item e come influisce sulla polimorfizzazione dell'ADT stesso?

Nell'implementazione di consBtree, la gestione della memoria tramite malloc e la successiva assegnazione di valori ai campi left e right del nuovo nodo possono potenzialmente portare a scenari problematici in sistemi con risorse limitate. Quale tra le seguenti strategie di gestione della memoria risulterebbe più efficace per mitigare tali problematiche, preservando al contempo la corretta semantica dell'ADT?

Data l'implementazione dell'ADT Btree fornita, e ipotizzando di voler estendere l'interfaccia con una funzione altezzaBtree(Btree T) che calcola l'altezza dell'albero, quale delle seguenti implementazioni risulterebbe la più efficiente in termini di complessità computazionale, considerando il caso di un albero degenere (ovvero, un albero in cui ogni nodo ha al più un figlio)?

Si consideri l'implementazione fornita e si ipotizzi di voler aggiungere all'ADT Btree la funzionalità di ricerca di un nodo con un determinato valore item. Quale tra le seguenti strategie di ricerca risulterebbe la meno efficiente in termini di complessità temporale nel caso medio, assumendo che l'albero non sia ordinato e che la funzione di confronto tra item abbia complessità $O(1)$?

Nell'implementazione dell'ADT Btree basata su puntatori, quale meccanismo di protezione avanzata potrebbe essere integrato per prevenire vulnerabilità legate a dangling pointers o double free, considerando che l'ambiente di esecuzione non fornisce garbage collection automatica?

Si consideri lo scenario in cui sia necessario serializzare un albero binario (Btree) implementato secondo l'ADT fornito, al fine di trasferirlo su una rete o memorizzarlo su disco. Quale tra i seguenti approcci di serializzazione risulterebbe più robusto e versatile per gestire alberi binari di forma arbitraria, inclusi quelli sbilanciati o degeneri, garantendo al contempo una deserializzazione corretta e efficiente?

Supponendo di voler parallelizzare l'algoritmo di visita di un albero binario (Btree) implementato secondo l'ADT fornito, con l'obiettivo di massimizzare l'utilizzo delle risorse di un'architettura multi-core, quale tra le seguenti strategie di parallelizzazione risulterebbe più efficace, considerando che la funzione getItem(node *N) potrebbe avere effetti collaterali (side effects) non trascurabili?

In un'implementazione di una coda (queue) basata su lista concatenata, quale tra le seguenti situazioni provocherebbe una perdita di memoria (memory leak) non immediatamente evidente durante ripetute operazioni di enqueue e dequeue?

Considerando l'implementazione di una coda con array circolari, in quale scenario specifico l'operazione di enqueue fallirebbe anche se q->size < MAXQUEUE-1, e come si potrebbe correggere?

In un sistema embedded con risorse di memoria estremamente limitate, quale tra le seguenti ottimizzazioni complesse nell'implementazione di una coda basata su lista concatenata potrebbe ridurre significativamente l'overhead di memoria, pur mantenendo la funzionalità?

Considerando una coda implementata con un array circolare di dimensione MAXQUEUE, quale combinazione di operazioni di enqueue e dequeue porterebbe alla situazione più critica in termini di frammentazione dello spazio nell'array, rendendo difficile il riutilizzo efficiente dello spazio anche se la coda non è piena?

In un'implementazione concorrente di una coda, dove più thread eseguono operazioni di enqueue e dequeue simultaneamente, quale meccanismo di sincronizzazione avanzato sarebbe il più appropriato per garantire l'assenza di starvation e la massimizzazione della throughput, minimizzando la contesa?

Data un'implementazione di coda basata su array con prestazioni degradanti a causa di frequenti spostamenti di elementi (quando head si avvicina alla fine dell'array), quale strategia di ristrutturazione dinamica della coda risulterebbe più efficace per mitigare questo problema senza introdurre latenza inaspettata nelle operazioni di base?

In un contesto di simulazione ad eventi discreti, dove è necessario gestire una coda di eventi ordinati per tempo di esecuzione, quale struttura dati ibrida combinerebbe i vantaggi di una coda e di un albero di ricerca bilanciato per ottimizzare sia l'inserimento (enqueue) che l'estrazione (dequeue) dell'evento con il tempo di esecuzione più imminente?

Considerando un'applicazione real-time in cui la latenza massima di un'operazione di dequeue è critica, quale implementazione di coda, combinata con quale strategia di prevenzione della frammentazione della memoria, offrirebbe la garanzia più rigorosa di rispetto dei vincoli temporali?

In un sistema distribuito dove le operazioni di enqueue e dequeue avvengono su nodi differenti e la consistenza della coda deve essere garantita in presenza di guasti, quale protocollo di consenso distribuito e quale struttura dati tollerante ai guasti sarebbero più appropriati per implementare una coda distribuita ad alta affidabilità?

Nell'analisi asintotica della complessità computazionale, quale combinazione di implementazione di coda e pattern di utilizzo renderebbe più evidente la differenza tra la complessità teorica e le prestazioni reali a causa di effetti di cache e branch prediction?

Considerando la specifica semantica dell'operatore removeItem(l, e), quale delle seguenti affermazioni descrive con la maggiore precisione il comportamento in caso di molteplici occorrenze dell'elemento e nella lista l?

Nell'implementazione dell'ADT Lista, se si volesse estendere la funzionalit base per includere un operatore concatList(list l1, list l2) che concateni due liste, creando una nuova lista contenente gli elementi di l1 seguiti da quelli di l2, quale sarebbe l'approccio pi efficiente in termini di complessit temporale, assumendo che le liste non siano ordinate e che si voglia preservare l'ordine originale degli elementi?

Si consideri una lista concatenata implementata con le funzioni consList, tailList, getFirst ed emptyList. Si vuole implementare una funzione filterList(list l, boolean (*filter)(item)) che restituisca una nuova lista contenente solo gli elementi di l per cui la funzione filter(item) restituisce true. Quale delle seguenti implementazioni garantisce la preservazione dell'ordine originale degli elementi filtrati e minimizza l'uso di memoria aggiuntiva?

Supponendo di avere accesso solo agli operatori di base dell'ADT lista ( newList, emptyList, consList, headList, tailList ), come implementeresti in modo efficiente una funzione reverseList_inplace(list l) che inverta la lista data modificandola direttamente, senza allocare nuova memoria per i nodi della lista (cio, senza creare nuovi nodi)?

Si consideri una variante dell'ADT lista in cui ogni nodo contiene, oltre al valore dell'elemento e al puntatore al nodo successivo, un puntatore a una funzione di confronto int (*compare)(item a, item b). Come influirebbe la presenza di tale funzione sull'implementazione di un operatore sortList(list l) che ordina la lista sul posto (cio, senza allocare nuova memoria per i nodi), e quale algoritmo di ordinamento sarebbe pi appropriato in questo contesto, considerando che non si possono usare array temporanei?

In un'implementazione dell'ADT lista, si supponga di voler aggiungere una funzionalit di 'undo' che permetta di ripristinare lo stato della lista a un certo punto precedente nel tempo. Quale tra le seguenti strategie sarebbe pi appropriata per minimizzare l'impatto sulla performance delle operazioni di base (aggiunta, rimozione, accesso) e sull'utilizzo di memoria, considerando che la funzionalit di 'undo' non deve essere persistente (cio, lo stato pu essere perso alla chiusura del programma)?

Si consideri una lista doppiamente concatenata in cui ogni nodo ha puntatori sia al nodo successivo (next) che al nodo precedente (prev). Se si volesse implementare una funzione moveNode(node* nodeToMove, list* destList) che sposta un nodo arbitrario nodeToMove da una lista ad un'altra destList, garantendo che tutte le operazioni di aggiornamento dei puntatori siano eseguite in tempo costante ($O(1)$), quale delle seguenti implementazioni minimizzerebbe il rischio di errori (come puntatori pendenti o liste corrotte) e massimizzerebbe la robustezza del codice?

Si consideri un'applicazione che utilizza l'ADT Lista per rappresentare una sequenza di transazioni finanziarie. A causa di requisiti normativi, necessario garantire che la lista delle transazioni sia immutabile: una volta creata, non pu essere modificata. Tuttavia, necessario supportare operazioni di filtraggio (selezionare transazioni in un certo intervallo di date) e aggregazione (calcolare la somma delle transazioni per categoria). Quale tra le seguenti combinazioni di tecniche di implementazione sarebbe pi adatta per soddisfare questi requisiti, ottimizzando al contempo le prestazioni per le operazioni di filtraggio e aggregazione?

Data una lista concatenata che rappresenta un polinomio, dove ogni nodo contiene il coefficiente e l'esponente di un termine (es. $3x^2$ sarebbe un nodo con coefficiente 3 ed esponente 2), e sapendo che la lista ordinata per esponente decrescente, quale algoritmo sarebbe pi efficiente per valutare il polinomio per un dato valore di $x$, minimizzando le operazioni aritmetiche e l'uso di memoria aggiuntiva?

Considerando l'implementazione iterativa di posItem, cosa accadrebbe se la condizione !emptyList(l) && !found venisse modificata in !found && !emptyList(l)?

Nell'implementazione ricorsiva di posItem, cosa succederebbe se si omettesse il controllo if emptyList(l) return -1;?

Nella funzione getItem, se la condizione pos < 0 fosse omessa, quale sarebbe il comportamento della funzione quando pos un numero negativo?

Supponiamo di voler modificare getItem per gestire posizioni superiori alla lunghezza della lista, restituendo l'ultimo elemento anzich NULLITEM. Come si dovrebbe modificare la funzione?

Nella funzione reverseList, cosa succederebbe se la riga l = tailList(l) venisse omessa all'interno del ciclo while?

Supponendo che la funzione consList abbia una complessit temporale di $O(1)$, qual la complessit temporale della funzione reverseList?

Nella funzione outputList, cosa accadrebbe se la riga i++; venisse spostata prima della chiamata a output_item(val)?

Si consideri una variante di outputList in cui si desidera interrompere la visualizzazione dopo un certo numero di elementi, ad esempio 5. Quale modifica sarebbe necessaria per implementare questa funzionalit?

Qual è la differenza fondamentale tra un file header (.h) e un file di implementazione (.c) in un modulo C?

Quale dei seguenti è un vantaggio chiave dell'utilizzo di moduli in C per l'implementazione di astrazioni funzionali?

Dove dovrebbero essere inseriti i commenti relativi alla specifica di una funzione in un modulo C?

Considerando un modulo vettore con funzioni come ordina_array e ricerca_array, e un programma principale ordina_array.c che utilizza questo modulo, quale direttiva #include è necessaria in ordina_array.c per utilizzare le funzioni del modulo vettore?

Nell'esempio fornito, la funzione minimo_i è dichiarata nel file vettore.c, ma non nel file vettore.h. Cosa implica questo?

Se il modulo utile contiene una funzione scambia e il modulo vettore necessita di utilizzare scambia, come dovrebbe essere gestita l'inclusione dei file header?

Quale delle seguenti affermazioni descrive meglio lo scopo del file header di un modulo C dal punto di vista del "cliente" del modulo?

Un modulo client include il file header di un altro modulo. Se quest'ultimo modulo viene aggiornato con nuove funzioni o modifiche implementative, quale tra le seguenti azioni non è generalmente necessaria nel modulo client, assumendo che l'interfaccia pubblica (dichiarazioni nell'header file) rimanga compatibile?

Considerando l'implementazione dello stack con array, quale svantaggio principale emerge quando si raggiunge la capacità massima MAXSTACK?

Nella specifica semantica dell'ADT Stack, cosa rappresenta l'elemento 'nil'?

Secondo la specifica semantica dell'operatore push(e, s) → s', cosa implica la condizione s = <a1, a2, ..., an> e s' = <e, a1, a2, ..., an>?

Supponendo di avere uno stack s = <5, 8, 2>, quale sarà il risultato dell'operazione top(s)?

Nell'implementazione di uno stack con array, cosa indica il valore della variabile top?

Considerando uno stack implementato con un array di dimensione MAXSTACK, in quale momento preciso l'operazione push fallisce?

Quale tra le seguenti affermazioni descrive meglio l'utilità dell'header file stack.h in un'implementazione di stack in C?

Se si volesse modificare l'implementazione dello stack per supportare tipi di dati diversi da item, pur mantenendo l'indipendenza dal tipo, quale approccio sarebbe più appropriato?

Quale tra le seguenti descrizioni rappresenta meglio il concetto di 'astrazione sui dati'?

In che modo il concetto di 'information hiding' contribuisce alla realizzazione di alti livelli di astrazione?

Qual è la differenza fondamentale tra 'astrazione' e 'information hiding' nella progettazione di un sistema software?

Quale delle seguenti affermazioni descrive meglio la funzione di un'interfaccia di un modulo?

In un modulo software, qual è lo scopo principale della sezione implementativa (body)?

Come si realizza tipicamente il concetto di modulo nel linguaggio di programmazione C, considerando che C non ha un costrutto esplicito per i moduli?

Qual è la funzione principale di un header file (.h) in C quando viene utilizzato per definire l'interfaccia di un modulo?

Per accedere alle risorse (funzioni, variabili, tipi di dato) esportate da un modulo in C, cosa è necessario fare?

Nel contesto del codice fornito, quale delle seguenti affermazioni descrive meglio lo scopo della funzione input_punti?

Considerando la funzione coppie_vicine, cosa accadrebbe se il ciclo for interno fosse modificato in for(j=0; j < n; j++)?

Quale delle seguenti modifiche al codice punto.h comprometterebbe la compilazione del file vicini.c senza alterare l'interfaccia pubblica (nomi e parametri delle funzioni)?

Se la funzione creaPunto non allocasse memoria dinamicamente utilizzando malloc, quale problema si verificherebbe nel programma principale?

Supponendo che la funzione distanza venisse modificata per calcolare il quadrato della distanza invece della distanza effettiva (rimuovendo la sqrt), come influenzerebbe il risultato finale del programma?

Nell'esercizio proposto sull'ADT Vettore, se si utilizzasse un array statico (anziché allocazione dinamica) per implementare il vettore, quale sarebbe la principale limitazione?

Quale delle seguenti modifiche minime al codice renderebbe la funzione coppie_vicine più efficiente in termini di prestazioni, specialmente per un grande numero di punti?

Se si volesse estendere l'ADT punto con una funzione traslaPunto(punto p, float dx, float dy) che trasla il punto di dx e dy, quale sarebbe l'implementazione corretta mantenendo l'incapsulamento?

In un programma che utilizza l'ADT Vettore, se dopo aver allocato dinamicamente un vettore con malloc, non si deallocasse la memoria con free quando il vettore non è più necessario, quale problema si presenterebbe?

Considerando l'importanza dell'astrazione, quale beneficio non è direttamente ottenuto dall'uso di un ADT (Abstract Data Type) ben progettato, come l'ADT punto?

Quale delle seguenti affermazioni descrive meglio il comportamento della funzione top(stack s) quando lo stack s è vuoto?

Considerando l'implementazione dello stack basata su array, cosa succede se si tenta di inserire un elemento in uno stack già pieno?

Nella funzione verifica(char *expr), quale condizione implica che l'espressione contiene parentesi sbilanciate?

Cosa rappresenta la funzione corrisp(char a, char b)?

Se la funzione verifica riceve in input la stringa (a+b[c-d, cosa accadrà?

Quale è il ruolo della funzione newStack()?

Cosa si intende quando si dice che l'espressione (4 + a) * {[1 – (2/x)] * (8 – a)} è ben bilanciata?

Nell'implementazione fornita, qual è la complessità temporale della funzione push?

Nell'implementazione dell'ADT stack con array, quale modifica sarebbe necessaria per gestire dinamicamente la dimensione massima dello stack ( MAXSTACK )?

Perché nella progettazione dell'algoritmo di verifica del bilanciamento delle parentesi si suggerisce di 'estrarre dall’espressione solo le parentesi, cancellando tutto il resto'?

Cosa cambierebbe nell'algoritmo di verifica del bilanciamento se si volesse considerare una priorità tra i tipi di parentesi (es. le parentesi tonde devono essere chiuse prima delle quadre)?

Se l'espressione da analizzare contenesse caratteri diversi dalle parentesi (es. lettere, numeri, operatori), quale delle seguenti scelte sarebbe la più efficiente in termini di prestazioni?

Cosa si dovrebbe fare per implementare uno stack che non abbia una dimensione massima fissa?

Quale tra queste affermazioni è vera riguardo all'uso di malloc nella funzione newStack()?

Supponendo di voler modificare l'implementazione dello stack per supportare un numero illimitato di elementi, quale sarebbe la principale implicazione in termini di gestione della memoria?

In un ADT Lista, quale tra le seguenti affermazioni descrive meglio la relazione tra l'operatore tailList(l) e la lista originale l dopo l'esecuzione dell'operazione, considerando che l non sia vuota?

Quale delle seguenti affermazioni descrive completamente le implicazioni dell'uso di un tipo item generico nella specifica dell'ADT Lista?

Si consideri una lista concatenata l implementata secondo l'ADT fornito, contenente $n$ elementi. Qual è la complessità computazionale minima nel caso peggiore per inserire un nuovo elemento in una posizione specifica (diversa dall'inizio) della lista, se non si ha un riferimento diretto al nodo precedente?

Considerando l'implementazione di una coda con liste collegate, quale tra le seguenti operazioni richiederebbe una gestione specialmente attenta per evitare race conditions in un ambiente multithreaded?

Nell'implementazione di una lista concatenata, quale tra le seguenti strategie sarebbe più efficace per minimizzare il rischio di memory leak e dangling pointer durante l'eliminazione di un nodo, specialmente in un ambiente senza garbage collection automatica?

Supponendo di voler implementare una funzione concatList(list l1, list l2) che concateni due liste immutabili l1 e l2, creando una nuova lista l3 contenente gli elementi di l1 seguiti da quelli di l2, quale tra le seguenti implementazioni sarebbe più efficiente in termini di complessità temporale e spaziale, garantendo al contempo che le liste originali l1 e l2 rimangano inalterate (cioè, preservando l'immutabilità)?

Data un'implementazione di coda tramite array circolari, quale sequenza di operazioni porterebbe più rapidamente a una situazione in cui la coda risulta piena, ma in realtà presenta ancora spazio disponibile a causa della natura circolare dell'array?

In un'implementazione di coda basata su array, quale condizione aggiuntiva deve essere verificata per determinare se la coda è vuota, oltre al semplice confronto tra gli indici head e tail?

Nell'implementazione dell'ADT Queue con liste concatenate, come si adatterebbe la gestione della memoria se si volesse supportare una politica di "coda persistente", in cui ogni operazione di enqueue o dequeue non modifica la coda originale, ma ne crea una nuova versione?

In un sistema real-time in cui si utilizza una coda per gestire task con priorità diverse e stringenti vincoli temporali sull'esecuzione, quale tra le seguenti modifiche all'implementazione standard dell'ADT Queue non sarebbe appropriata?

Quale delle seguenti affermazioni descrive correttamente la differenza fondamentale tra la visita in preordine e la visita in postordine di un albero binario?

Nella visita simmetrica (inorder) di un albero binario, quale tra le seguenti è la sequenza corretta di operazioni?

Considerando l'implementazione ricorsiva della funzione inputBtree(), quale condizione determina il caso base della ricorsione, arrestando la costruzione di un ramo dell'albero?

Durante la costruzione ricorsiva di un albero binario tramite la funzione inputBtree(), in quale ordine preciso vengono richieste le informazioni all'utente?

Volendo implementare una funzione iterativa per la visita in preordine di un albero binario, quale struttura dati si rivela fondamentale per mantenere traccia dei nodi da visitare?

Considerando che le visite in preordine, inordine e postordine possono essere implementate sia ricorsivamente che iterativamente, quale delle seguenti affermazioni descrive accuratamente una differenza chiave tra i due approcci in termini di gestione della memoria?

Nel contesto dell'ADT Lista, quale delle seguenti affermazioni cattura l'essenza del concetto di sequenza?

Quale tra le seguenti è una limitazione intrinseca del tipo astratto di dato (ADT) Lista, rispetto ad altre strutture dati come gli alberi o i grafi?

In una lista concatenata, quale tra le seguenti operazioni ha la complessità temporale più alta nel caso peggiore?

Si consideri l'inserimento di un nuovo nodo in testa a una lista concatenata. Quale sequenza di operazioni è strettamente necessaria per garantire che la lista rimanga coerente e accessibile?

In una lista concatenata, quale delle seguenti affermazioni descrive correttamente la relazione tra la flessibilità della lista e l'accesso agli elementi?

Se si dovesse progettare una struttura dati che combini la flessibilità delle liste concatenate con la capacità di accesso rapido agli elementi tipica degli array, quale delle seguenti strutture dati ibride sarebbe la più appropriata, considerando l'overhead di spazio e la complessità di implementazione?

In una lista concatenata che rappresenta una coda, dove gli elementi vengono aggiunti alla fine e rimossi dall'inizio, quale sarebbe l'impatto sull'efficienza dell'operazione di dequeue se la lista fosse implementata senza un puntatore alla coda (ultimo elemento)?

Quale delle seguenti affermazioni descrive correttamente la distinzione fondamentale tra la specifica sintattica e la specifica semantica di un tipo di dato astratto?

Considerando il tipo di dato astratto 'libro', quale delle seguenti asserzioni rappresenta correttamente una possibile estensione della specifica semantica dell'operatore creaLibro con una precondizione?

Nell'esempio del tipo di dato astratto 'libro', le postcondizioni degli operatori autore, titolo, editore e anno sono tutte nella forma Post: lb = (aut, tit, ed, an). Quale delle seguenti interpretazioni descrive al meglio il significato di queste postcondizioni?

Supponiamo di voler aggiungere un operatore modificaAnno(libro, intero) al tipo di dato astratto 'libro'. Quale delle seguenti coppie precondizione/postcondizione descrive correttamente il comportamento di un operatore che modifica l'anno di pubblicazione solo se l'anno fornito è valido (positivo)?

Nel contesto della realizzazione di un tipo di dato astratto, quale dei seguenti aspetti è primariamente gestito dai meccanismi di programmazione modulare?

Considerando l'astrazione del tipo di dato 'libro', se volessimo aggiungere un operatore confrontaLibri(libro lb1, libro lb2) che restituisce un valore booleano indicando se due libri sono uguali (stesso autore, titolo, editore e anno), quale sarebbe la specifica semantica più completa per questo operatore?

Supponiamo di avere una realizzazione del tipo di dato astratto 'libro' in cui l'anno è rappresentato come una stringa anziché un intero. Quale impatto avrebbe questo cambiamento principalmente sulla specifica del tipo di dato?

In termini di information hiding nella realizzazione del tipo di dato astratto 'libro', quale delle seguenti scelte progettuali supporta meglio questo principio?

Se la precondizione di un operatore in un tipo di dato astratto non è soddisfatta al momento della chiamata, quale fra le seguenti è la conseguenza più appropriata in termini di progettazione e robustezza del software?

Nell'ambito della manutenzione e dell'evoluzione di un tipo di dato astratto, quale tra le seguenti modifiche sarebbe meno problematica per i client che utilizzano il tipo di dato, assumendo che le specifiche sintattiche e semantiche degli operatori rimangano invariate?

Nell'implementazione dinamica dello stack (senza dimensione massima fissa), cosa accadrebbe se la funzione realloc in push restituisse NULL?

Nell'implementazione dello stack basata su array dinamico, perché è necessario utilizzare realloc anziché malloc per aumentare la dimensione dell'array?

In una implementazione di stack basata su array dinamico, se si verificasse un errore durante la realloc nella funzione push, quale sarebbe la migliore strategia per la gestione della memoria al fine di prevenire memory leaks?

Nell'implementazione dello stack con lista concatenata, quale operazione deve essere eseguita prima di modificare s->top nella funzione pop per evitare memory leaks?

In una implementazione di stack basata su lista concatenata, quale sarebbe l'effetto più probabile di non decrementare il campo numel nella funzione pop dopo aver rimosso un elemento?

Considerando l'implementazione dello stack basata su liste collegate, cosa accadrebbe se nella funzione push la riga nuovo->next = s->top; venisse omessa?

Nel contesto dell'implementazione dello stack con lista concatenata, quale è il principale svantaggio in termini di overhead di memoria rispetto all'implementazione con array dinamico?

Se si volesse implementare una funzione clearStack(stack s) per l'implementazione dello stack basata su lista concatenata, quale sarebbe l'implementazione più corretta per evitare memory leaks?

Nell'implementazione dello stack basata sul modulo lista, cosa cambierebbe fondamentalmente nel comportamento dello stack se si decidesse di utilizzare una lista coda (con puntatori sia alla testa che alla coda) invece di una lista semplice?

Considerando l'implementazione dello stack basata sull'uso del modulo lista fornito, e supponendo di voler aggiungere una funzione sizeStack(stack s) che restituisca il numero di elementi nello stack, quale delle seguenti affermazioni è più accurata riguardo alla sua implementazione e complessità?