Domande a risposta multipla

Le risposte esatte sono contrassegnate dal simbolo X
Domande a risposta multipla -- 60 min.
             
             
  -------------------------------------------------------------------------          
001) Un bit è:          
XA una cifra binaria          
B una sequenza di otto byte          
C la cifra più significativa di un numero in base due          
D la cifra meno significativa di un numero in base due          
  -------------------------------------------------------------------------          
002) Aggiungendo la cifra '1' alla destra della rappresentazione binaria          
  di un numero naturale N si ottiene la rappresentazione binaria di:          
A 2*N          
B N*N          
C N+1          
XD 2*N+1          
  -------------------------------------------------------------------------          
003) Con sette bit possiamo rappresentare i naturali          
  appartenenti all'intervallo:          
A [0,128]          
XB [0,127]          
C [0,64]          
D [0,63]          
  -------------------------------------------------------------------------          
004) Con nove bit possiamo rappresentare (sfruttando la rappresentazione          
  in "complemento a due") gli interi relativi appartenenti all'intervallo:          
A [0,511]          
B [-512,511]          
XC [-256,255]          
D [-255,256]          
  -------------------------------------------------------------------------          
005) Sommando due numeri A e B rappresentati in "complemento a due" si          
  ottiene overflow quando:          
A A e B hanno segno opposto          
B A e B hanno lo stesso segno          
XC il segno di A+B è diverso dal segno del risultato calcolato          
D c'è un riporto che non può essere ulteriormente propagato a sinistra          
  -------------------------------------------------------------------------          
006) Dati due numeri positivi A e B la differenza A-B causa overflow:          
XA mai          
B sempre          
C quando B>A          
D quando A<B e B è pari (e ha quindi il bit meno significativo eguale          
  a zero)          
  -------------------------------------------------------------------------          
007) Un byte è:          
A un carattere          
B una sequenza di otto caratteri          
XC una sequenza di otto cifre binarie          
D un insieme di otto bit          
  -------------------------------------------------------------------------          
008) Un KB (kilobyte) è costituito (approssimativamente) da:          
XA ottomila bit          
B mille bit          
C 0.5 MB (megabyte)          
D diecimila bit          
  -------------------------------------------------------------------------          
009) Un MB (megabyte) è costituito da:          
XA più di mille KB (kilobyte)          
B circa otto milioni di byte          
C 8192 bit          
D circa un milione di bit          
  -------------------------------------------------------------------------          
010) L'overflow o trabocco è un fenomeno che interviene quando:          
XA non è disponibile un numero di bit sufficiente a rappresentare il          
  risultato di una operazione          
B effettuando una somma, non è possibile propagare ulteriormente un          
  riporto a sinistra          
C si sommano due numeri negativi molto piccoli          
D un numero molto piccolo viene considerato nullo (approssimato a zero)          
  -------------------------------------------------------------------------          
011) Si assuma di rappresentare numeri in complemento a due. Se la          
  rappresentazione di un numero mediante quattro bit è 1101, la sua          
  rappresentazione mediante sei bit è:          
A 1101          
B 11101          
C 101101          
XD 111101          
  -------------------------------------------------------------------------          
012) Si assuma di rappresentare numeri in complemento a due. La          
  somma 11000101+00110111:          
A genera overflow          
B genera overflow e accende il bit di carry          
C accende il bit di carry          
XD non genera overflow né accende il bit di carry          
  -------------------------------------------------------------------------          
013) Si assuma di rappresentare numeri in complemento a due. La          
  somma 01011011+01101110:          
XA genera overflow          
B genera overflow e accende il bit di carry          
C accende il bit di carry          
D non genera overflow né accende il bit di carry          
  -------------------------------------------------------------------------          
014) Si assuma di rappresentare numeri in complemento a due. La          
  somma 11011000+11110011:          
A genera overflow          
B genera overflow e accende il bit di carry          
XC accende il bit di carry          
D non genera overflow né accende il bit di carry          
  -------------------------------------------------------------------------          
015) La rappresentazione "floating point" dei razionali sfrutta:          
A le proprietà dell'AND logico          
XB la notazione esponenziale normalizzata          
C la definizione di razionale (rapporto fra due interi)          
D l'assenza di overflow nelle operazioni fra razionali          
  -------------------------------------------------------------------------          
016) La rappresentazione in virgola fissa dei razionali è          
  insoddisfacente perché:          
XA non massimizza il numero di cifre significative rappresentate con i          
  bit a disposizione          
B non consente di rappresentare le potenze di 2          
C non permette di rappresentare numeri negativi          
D non consente di rappresentare le potenze di 10          
  -------------------------------------------------------------------------          
017) Il numero di operazioni binarie differenti definibili nell'Algebra di          
  Boole è:          
A 2          
B 4          
C 8          
XD 16          
  -------------------------------------------------------------------------          
018) Quale delle seguenti espressioni booleane è sempre          
  falsa (contraddizione):          
A X && !Y          
B Y && (X || Y)          
C (X && !Y) || (!X && Y)          
XD (!X || Y) && (X && !Y)          
  -------------------------------------------------------------------------          
019) Quale delle seguenti espressioni booleane è sempre vera (tautologia):          
A X && !X          
B !X || !Y          
XC (X || Y) || (!X || Z)          
D (X && Y) || (X && !Y)          
  -------------------------------------------------------------------------          
020) Quale delle seguenti eguaglianze è falsa:          
A !(X || !Z) && X == !X && (Z && X)          
B (X && !!Z) || !X == (X || !X) && (Z || !X)          
XC (X && !Y) || (!X && Y) == (X && Y) || (!X && !Y)          
D X && !X == 0          
  -------------------------------------------------------------------------          
021) La negazione di "l'esonero è facile" e "il tempo stringe" è:          
A "l'esonero non è facile" e "il tempo non stringe"          
XB "l'esonero non è facile" o "il tempo non stringe"          
C "l'esonero è difficile" e "il tempo stringe"          
D "l'esonero non è difficile" ma "il tempo stringe"          
  -------------------------------------------------------------------------          
022) Il software di base:          
A è una parte del sistema operativo          
XB contiene il sistema operativo          
C è il sistema operativo          
D è costituito dall'insieme dell'editor e del compilatore          
  -------------------------------------------------------------------------          
023) Il C è un linguaggio di programmazione:          
A per personal computer con processore PowerPC          
B a basso livello          
XC ad alto livello          
D per personal computer con processore Intel Pentium          
  -------------------------------------------------------------------------          
024) Un algoritmo è:          
A un insieme di azioni          
B un compito da svolgere          
C un problema da risolvere          
XD una sequenza di azioni elementari          
  -------------------------------------------------------------------------          
025) Con riferimento a un personal computer, non fa parte dell'hardware:          
A la tastiera          
B il mouse          
C l'hard disk          
XD il sistema operativo          
  -------------------------------------------------------------------------          
026) L'algoritmo di ricerca binaria o dicotomica:          
A consente ricerche efficienti su tabelle          
B ordina una tabella in ordine alfabetico          
XC consente ricerche efficienti su tabelle ordinate          
D è inefficiente su tabelle non ordinate          
  -------------------------------------------------------------------------          
027) Un programma è:          
XA un algoritmo descritto mediante un linguaggio di programmazione          
B un insieme di regole sintattiche che debbono essere verificate da          
  un compilatore          
C la descrizione top-down di un algoritmo          
D il piano di utilizzo di un elaboratore          
  -------------------------------------------------------------------------          
028) L'informatica è la scienza che studia:          
A gli elaboratori elettronici          
B la teoria dell'informazione          
XC le modalità di memorizzazione ed elaborazione dei dati          
D i calcolatori          
  -------------------------------------------------------------------------          
029) In cosa consiste un editor?          
A è una applicazione che costruisce programmi          
B è una applicazione che aiuta a costruire programmi          
XC è una applicazione che consente di creare e/o modificare file di testo          
D è una componente di un compilatore          
  -------------------------------------------------------------------------          
030) Per copiare un file dal disco rigido a un floppy disk, disponendo di          
  un moderno sistema operativo a finestre (tipo Windows), occorre:          
A selezionare l'icona del file e immediatamente dopo selezionare quella          
  del dischetto          
XB trascinare l'icona del file su quella del floppy disk e rilasciare il          
  tasto del mouse          
C selezionare l'icona del dischetto e immediatamente dopo selezionare          
  quella del file          
D trascinare l'icona del floppy disk su quella del file          
  -------------------------------------------------------------------------          
031) Il Registro Istruzione Corrente contiene di norma:          
A il codice operativo dell'istruzione corrente          
XB il codice operativo e gli operandi dell'istruzione corrente          
C l'indirizzo RAM in cui è memorizzata l'istruzione corrente          
D l'indicazione della massima intensità di corrente ammissibile per          
  alimentare la CPU          
  -------------------------------------------------------------------------          
032) Il Registro Dati ha dimensione pari a:          
XA la dimensione della parola di memoria          
B il logaritmo (base 2) del numero di parole di memoria          
C il logaritmo (base 2) del numero di byte di memoria          
D il numero di bit del Registro di Stato          
  -------------------------------------------------------------------------          
033) L'assembler è:          
A un linguaggio di programmazione ad alto livello          
B un traduttore che produce codice eseguibile          
XC un linguaggio di programmazione a basso livello          
D il programma che collega riferimenti simbolici che non sono stati          
  risolti precedentemente          
  -------------------------------------------------------------------------          
034) Un file è:          
A un dispositivo fisico per la memorizzazione permanente di informazioni          
B una sequenza di 512 bit          
XC una struttura logica per la memorizzazione permanente di informazioni          
D un tipo di memoria          
  -------------------------------------------------------------------------          
035) Per dichiarare una variabile X di tipo int è necessario scrivere:          
A type int X;          
B X int;          
C X=int;          
XD int X;          
  -------------------------------------------------------------------------          
036) Per assegnare il valore della variabile B alla variabile A è          
  necessario scrivere:          
A A==B;          
B B==A;          
C B=A;          
XD A=B;          
  -------------------------------------------------------------------------          
037) Il ciclo a condizione iniziale:          
A viene comunque eseguito almeno una volta          
B viene eseguito solo se la variabile di ciclo non è zero          
C non può essere infinito;          
XD può contenere al suo interno un ciclo a condizione iniziale          
  -------------------------------------------------------------------------          
038) L'espressione C { A=B=C; }:          
A è sintatticamente scorretta;          
XB assegna C ad A e B          
C assegna B ad A e C          
D assegna A a B e C          
  -------------------------------------------------------------------------          
039) L'espressione C { A=B==C; }:          
XA assegna 1 ad A se B e C hanno lo stesso valore, 0 altrimenti          
B assegna C ad A e B          
C assegna A a B e C          
D è sintatticamente scorretta          
  -------------------------------------------------------------------------          
040) Dato un numero N rappresentato in base otto, il numero ottenuto          
  eliminando le due cifre meno significative della rappresentazione è          
  pari a:          
A N/8          
B N/64          
XC parte intera inferiore di N/64          
D N/16          
  -------------------------------------------------------------------------          
041) Il frammento di programma { int a,b; float c; a=7; b=2; c=a/b;          
  printf("%f",c); }:          
A è sintatticamente scorretto          
B stampa 3.500000          
XC stampa 3.000000          
D stampa 0.35E1          
  -------------------------------------------------------------------------          
042) Il frammento di programma C { if(A<=B) if(A<=C) MIN=A; else MIN=C; }:          
A assegna a MIN il minimo fra A, B e C          
XB se A non è maggiore di B, assegna a MIN il minimo fra A, B e C          
C se A è maggiore di B assegna a MIN il valore di C          
D è sintatticamente scorretta          
  -------------------------------------------------------------------------          
043) Il blocco { if(x!=y); x=x+1; }:          
A è sintatticamente scorretto perché c'è ';' subito dopo l'if          
B è ammissibile ma non esegue istruzione alcuna;          
XC incrementa x, qualunque sia la relazione fra x e y          
D incrementa x solo se x è differente da y          
  -------------------------------------------------------------------------          
044) Il seguente frammento C { typedef int valori[20]; }:          
A è sintatticamente scorretto;          
B definisce un nuovo tipo utente di nome valori[20]          
XC definisce un tipo di nome valori, corrispondente a un array di 20          
  elementi di tipo int          
D crea un vettore di 20 interi          
  -------------------------------------------------------------------------          
045) La definizione { typedef float int; }          
A ridefinisce il tipo float come tipo intero          
B ridefinisce il tipo int come tipo in virgola mobile          
XC è sintatticamente scorretta          
D non ha effetto, perché non si possono cambiare le caratteristiche          
  dei tipi predefiniti          
  -------------------------------------------------------------------------          
046) Il frammento C { char stringa[20]; }:          
XA dichiara un array di 20 caratteri          
B dichiara un array di 19 caratteri          
C definisce un tipo stringa          
D definisce un tipo array          
  -------------------------------------------------------------------------          
047) Le stringhe standard secondo l'ANSI C sono memorizzate come:          
A array di char          
B array monodimensionali di char          
C array contenenti 0 nell'ultima cella          
XD array di char contenenti uno 0          
  -------------------------------------------------------------------------          
048) Quale differenza c'è in C fra 'z' e "z" (il codice ASCII della          
  lettera z è 122):          
A nessuna, poiché sono due stringhe identiche          
B anche se 'z' è un carattere e "z" è una stringa in memoria hanno la          
  stessa identica rappresentazione (l'intero 122)          
XC 'z' è memorizzata in un byte il cui valore numerico è 122, "z" è          
  memorizzata in due byte consecutivi di valore 122 e 0          
D 'z' è una costante di tipo carattere, "z" è una espressione          
  sintatticamente scorretta          
  -------------------------------------------------------------------------          
049) Se u e v sono due variabili C di tipo char, il test (u<v)          
A è vero se la lettera memorizzata in u precede, nell'ordine          
  alfabetico, la lettera memorizzata in v          
B è sintatticamente scorretto          
XC è vero se e solo se il codice ASCII del carattere memorizzato in u          
  è inferiore al codice ASCII del carattere memorizzato in v          
D è sempre falso          
  -------------------------------------------------------------------------          
050) In C, la scrittura { A="ciao"; }, dove A è dichiarata come array di          
  20 char:          
XA è sintatticamente scorretta          
B assegna ad A una stringa di cui vengono precisati solo i primi          
  quattro caratteri, mentre gli altri 16 saranno casuali          
C assegna ad A una stringa di cinque caratteri          
D rende, di fatto, la variabile A una costante di tipo stringa          
  -------------------------------------------------------------------------          
051) Dopo l'esecuzione del frammento di programma C { for(i=0; i<10; i          
  =i+1) if(A[i]==B[i]) uguali=1; else uguali=0; }, in cui A e B sono due          
  array di 10 interi:          
A la variabile uguali vale 1 se gli array sono identici, vale 0 se gli          
  array presentano almeno una differenza (in una posizione)          
XB la variabile uguali vale 0 se gli elementi di indice 9 dei due array          
  sono differenti, vale 1 altrimenti          
C la variabile uguali vale 0 se gli array sono differenti in tutte le          
  posizioni, vale 1 altrimenti          
D la variabile uguali vale 0 se gli elementi di indice 0 dei due array          
  sono differenti, vale 1 altrimenti          
  -------------------------------------------------------------------------          
052) Se u e v sono due variabili C di tipo char, l'operazione (u<v)          
A ha risultato 1 se la lettera memorizzata in u precede, nell'ordine          
  alfabetico, la lettera memorizzata in v          
B è sintatticamente scorretta          
XC ha risultato 1 se e solo se il codice ASCII del carattere memorizzato          
  in u è inferiore al codice ASCII del carattere memorizzato in v          
D ha risultato 0          
  -------------------------------------------------------------------------          
053) Il frammento C { a=0; for(i=0; i<10; i=i+1) a=a+(A[i]==B[i]); if(!a)          
  printf("vero"); else printf("falso"); }, dove A e B sono due array di          
  10 char:          
A stampa vero se i due array sono eguali, falso altrimenti          
B stampa vero se i due array non sono eguali, falso altrimenti          
C stampa falso se i due array differiscono in tutte le posizioni,          
  vero altrimenti          
XD stampa vero se i due array differiscono in tutte le posizioni,          
  falso altrimenti          
  -------------------------------------------------------------------------          
054) In C, date due variabili A e B che memorizzano matrici di interi, per          
  rendere A eguale a B:          
A si scrive { A = B; }          
B si scrive { B = A; }          
C si scrive { A == B; }          
XD occorre scrivere due cicli annidati per assegnare singolarmente gli          
  elementi di B a quelli di A          
  -------------------------------------------------------------------------          
055) Per utilizzare una costante N di valore 10 all'interno di un          
  programma C quale direttiva del pre-processore può essere usata?          
XA #define N 10          
B #define N 10;          
C #define N = 10          
D #define N = 10;          
  -------------------------------------------------------------------------          
056) Per includere in un sorgente C un file di nome premessa.c memorizzato          
  nello stesso direttorio del sorgente quale direttiva del pre-processore          
  può essere usata?          
A #include <premessa.c>          
XB #include "premessa.c"          
C #include premessa.c;          
D #include 'premessa.c'          
  -------------------------------------------------------------------------          
057) In C, l'istruzione break è ammessa:          
A in un qualunque punto di un programma in cui si possa mettere          
  una istruzione          
B solo all'interno di una istruzione switch          
C solo all'interno di switch e while          
XD solo all'interno di un ciclo o di una switch          
  -------------------------------------------------------------------------          
058) Un ciclo a condizione finale è equivalente a:          
A un opportuno ciclo a condizione iniziale          
B nessun ciclo a condizione iniziale          
XC un ciclo a condizione iniziale preceduto da opportune istruzioni          
D un ciclo a condizione iniziale preceduto da un opportuna istruzione if          
  -------------------------------------------------------------------------          
059) Il frammento C { sw=1; switch(sw) { case 1: printf("casa e");          
  default: printf("chiesa");} }, dove sw è una variabile int, stampa:          
A casa e chiesa          
XB casa e          
C chiesa          
D niente, poiché c'è un errore di sintassi          
  -------------------------------------------------------------------------          
060) Il frammento C { sw=1; switch(sw) { case '1': printf("casa e");          
  default: printf("chiesa");} }, dove sw è una variabile int, stampa:          
A casa e chiesa          
B casa e          
XC chiesa          
D niente, poiché c'è un errore di sintassi