Question 1

In un'architettura software orientata agli oggetti in Python, quale combinazione di algoritmi e concetti UML è corretta per ottimizzare la ricerca di un elemento in una lista di grandi dimensioni mantenuta ordinata tramite ereditarietà?

Accepted Answer

Utilizzare la ricerca binaria con complessità temporale

O(log n)

e rappresentare la relazione tra classe base e derivata tramite una freccia con punta a triangolo vuoto in UML.

Answer

Utilizzare il Bubble Sort per riordinare la lista ad ogni inserimento e definire l'associazione come aggregazione forte (composizione) nel diagramma delle classi.

Answer

Utilizzare la ricerca lineare con complessità

O(log n)

e impostare una cardinalità

1..*

per indicare l'incapsulamento dei metodi privati.

Answer

Utilizzare il Selection Sort poiché ha una complessità nel caso peggiore di

O(log n)

e nascondere gli attributi tramite l'ereditarietà multipla.

Question 2

Si consideri una classe Python che implementa il protocollo di incapsulamento per proteggere un attributo sensibile. Quale delle seguenti affermazioni descrive correttamente la gestione della visibilità e l'interazione con un algoritmo di ordinamento Selection Sort?

Accepted Answer

L'uso del prefisso a doppio underscore (es. __valore) attiva il name mangling, impedendo l'accesso diretto esterno, mentre il Selection Sort scambierà gli elementi effettuando

O(log n)

confronti e al massimo

1..*

scambi.

Answer

L'uso di un singolo underscore (es. _valore) rende l'attributo fisicamente inaccessibile all'interprete, e il Selection Sort richiede memoria ausiliaria

O(log n)

per operare.

Answer

L'incapsulamento si realizza tramite la cardinalità UML

O(log n)

, e il Selection Sort è un algoritmo stabile che riduce drasticamente i confronti se la lista è già parzialmente ordinata.

Answer

L'incapsulamento in Python garantisce che gli attributi privati siano inaccessibili anche tramite metodi getter, mentre il Selection Sort è preferito al Bubble Sort perché ha una complessità nel caso ottimo di

O(log n)

.

Question 3

In un contesto di programmazione a oggetti in Python, se una classe 'A' ha un'associazione con cardinalità

O(log n)

verso una classe 'B' e dobbiamo garantire che gli elementi di 'B' siano sempre accessibili in modo rapido tramite una chiave univoca, quale struttura e algoritmo sono i più indicati rispettando l'incapsulamento?

Accepted Answer

Utilizzare un dizionario privato in 'A' per memorizzare le istanze di 'B' e implementare un metodo 'getter' che sfrutti la ricerca binaria se gli elementi sono ordinati, garantendo una complessità

O(log n)

.

Answer

Utilizzare una lista pubblica in 'A' e applicare il Bubble Sort ad ogni ricerca per garantire che l'elemento trovato sia sempre in posizione

O(log n)

.

Answer

Definire un'ereditarietà tra 'A' e 'B' in modo che 'A' possa accedere direttamente agli attributi privati di 'B' tramite una ricerca lineare

O(log n)

.

Answer

Rappresentare l'associazione in UML con un rombo pieno (composizione) e forzare l'uso del Selection Sort per mantenere la cardinalità fissa a

O(log n)

.

Question 4

In un sistema Python che gestisce le relazioni tra classi, quale affermazione descrive correttamente il legame tra l'efficienza degli algoritmi e i diagrammi UML?

Accepted Answer

Una cardinalità

O(log n)

in un'associazione UML suggerisce che l'attributo incapsulato può essere nullo; se tale attributo è una collezione ordinata, la ricerca binaria riduce i tempi di accesso rispetto alla ricerca lineare.

Answer

L'incapsulamento impedisce l'uso del Selection Sort poiché gli algoritmi di ordinamento non possono scambiare valori tra attributi definiti come privati in UML.

Answer

L'ereditarietà in Python permette di trasformare automaticamente un algoritmo di ricerca lineare in ricerca binaria senza modificare il codice della sottoclasse.

Answer

Il Bubble Sort è preferibile per gestire cardinalità

O(log n)

perché la sua complessità

1..*

decresce linearmente all'aumentare degli oggetti ereditati.

Question 5

Se una classe Python 'GestoreDati' utilizza l'ereditarietà per estendere una classe base 'Ordinatore' e deve mantenere una collezione di oggetti con cardinalità

O(log n)

costantemente ordinata per permettere ricerche frequenti, quale approccio garantisce la migliore efficienza complessiva?

Accepted Answer

Implementare l'incapsulamento della lista come attributo privato, utilizzare il Selection Sort per l'ordinamento iniziale e la ricerca binaria con complessità

O(log n)

per il recupero dei dati.

Answer

Definire l'associazione tra le classi come una dipendenza debole e applicare la ricerca lineare, ignorando l'incapsulamento per velocizzare l'accesso ai dati della sottoclasse.

Answer

Sostituire la ricerca binaria con il Selection Sort durante la fase di interrogazione, poiché quest'ultimo riduce la cardinalità minima definita nel diagramma delle classi.

Answer

Utilizzare il Bubble Sort per ogni inserimento in quanto la sua complessità

O(log n)

è più efficiente della ricerca lineare in termini di memoria UML.

Question 6

Data una gerarchia di classi Python dove una 'ClasseBase' definisce un metodo di ricerca lineare e una 'ClasseDerivata' lo sovrascrive (override) per implementare una ricerca binaria su una lista protetta da incapsulamento, quale delle seguenti condizioni è necessaria affinché l'operazione nella sottoclasse sia corretta ed efficiente?

Accepted Answer

La lista deve essere mantenuta ordinata, l'attributo deve essere accessibile ai metodi della sottoclasse (es. tramite nome mangling o getter) e la complessità passerà da

O(log n)

a

1..*

.

Answer

L'ereditarietà deve essere di tipo multiplo per consentire alla ricerca binaria di operare in tempo lineare

O(log n)

su liste non ordinate.

Answer

La cardinalità dell'associazione UML deve essere necessariamente

O(log n)

e la lista deve essere riordinata con Bubble Sort dopo ogni singola operazione di lettura.

Answer

L'incapsulamento deve essere rimosso rendendo l'attributo pubblico, altrimenti il Selection Sort non potrà operare con complessità

O(log n)

.

Question 7

In un sistema Python che rispetta i principi dell'ereditarietà e dell'incapsulamento, si deve gestire una collezione di oggetti rappresentata in UML con una cardinalità

O(log n)

. Se la collezione è ordinata, quale algoritmo di ricerca è più coerente con l'obiettivo di massimizzare le prestazioni e come dovrebbero essere gestiti i dati?

Accepted Answer

La ricerca binaria è la scelta ottimale con complessità

O(log n)

, a patto che l'attributo sia incapsulato (es. usando __nome) per impedire modifiche esterne che compromettano l'ordinamento.

Answer

L'algoritmo Bubble Sort deve essere integrato direttamente nel diagramma UML tra le classi per trasformare la cardinalità

O(log n)

in

1..*

.

Answer

Il Selection Sort è più indicato della ricerca binaria perché consente di trovare l'elemento in

O(log n)

senza dover accedere ai metodi getter.

Answer

La ricerca lineare è l'unica opzione possibile se si usa l'ereditarietà, poiché l'incapsulamento impedisce l'accesso agli indici mediani necessari per la ricerca binaria.

Question 8

In Python, si sta progettando una classe 'Anagrafe' che contiene una collezione di oggetti 'Cittadino' (cardinalità

O(log n)

). Se si desidera mantenere i cittadini ordinati per codice fiscale utilizzando il Bubble Sort e cercarli frequentemente, quale affermazione combina correttamente i principi di programmazione ad oggetti e gli algoritmi?

Accepted Answer

L'incapsulamento della lista tramite l'uso di

O(log n)

protegge l'ordine stabilito dal Bubble Sort, permettendo l'uso della ricerca binaria per trovare un cittadino in

1..*

.

Answer

La ricerca lineare è preferibile alla ricerca binaria quando la cardinalità è

O(log n)

, poiché l'incapsulamento impedisce di calcolare l'indice centrale della lista.

Answer

L'uso dell'ereditarietà tra 'Anagrafe' e 'Cittadino' è obbligatorio per permettere al Selection Sort di accedere agli attributi privati in tempo

O(log n)

.

Answer

Il Bubble Sort riduce la complessità della ricerca lineare a

O(log n)

, rendendo superflua la distinzione tra associazione e composizione in UML.

Question 9

In un diagramma UML, una relazione di composizione (rombo pieno) tra una classe 'Catalogo' e una classe 'Prodotto' implica una cardinalità

O(log n)

. Se gli oggetti 'Prodotto' sono memorizzati in una lista Python incapsulata, quale combinazione di algoritmi rappresenta la strategia migliore per inserire un nuovo elemento mantenendo l'ordine e cercarlo successivamente?

Accepted Answer

Incaspulare la lista con il prefisso '__', utilizzare il Selection Sort per l'ordinamento (complessità

O(log n)

) e la ricerca binaria per il recupero (complessità

1..*

).

Answer

Rendere la lista pubblica per permettere all'ereditarietà di eseguire la ricerca lineare con una complessità migliorata di

O(log n)

senza bisogno di ordinamento.

Answer

Implementare la ricerca binaria sulla lista non ordinata e delegare l'incapsulamento dei dati all'algoritmo Selection Sort per ridurre la complessità a

O(log n)

.

Answer

Utilizzare il Bubble Sort per la ricerca dell'elemento, sfruttando il fatto che la cardinalità UML

O(log n)

elimina i casi peggiori dell'algoritmo.

Question 10

In un sistema Python, se una classe 'Azienda' è associata a 'Dipendente' con una cardinalità

O(log n)

e si implementa l'ereditarietà per specializzare i dipendenti in 'Manager', quale delle seguenti affermazioni sulla gestione della collezione tramite incapsulamento e algoritmi è corretta?

Accepted Answer

Utilizzando l'incapsulamento per rendere la lista dei dipendenti privata, è possibile garantire che rimanga ordinata per matricola tramite Bubble Sort, abilitando l'uso della ricerca binaria con complessità

O(log n)

.

Answer

L'incapsulamento impedisce l'uso del Selection Sort perché l'ereditarietà in Python trasforma automaticamente ogni associazione UML in una ricerca lineare

O(log n)

.

Answer

La ricerca binaria è sconsigliata quando la cardinalità è

O(log n)

, poiché la complessità del Bubble Sort renderebbe l'accesso ai dati della sottoclasse più lento di una ricerca lineare

1..*

.

Answer

In UML, la relazione tra 'Azienda' e 'Dipendente' deve essere una generalizzazione affinché il Selection Sort possa ordinare gli attributi privati senza getter e setter.

Related quizzes

Related quizzes