Saggio di Informatica – Classe 3A (B)

04 Marzo 2015
Saggio di Informatica – Classe 3A
(B)
CONSEGNE
 Scegli uno o più quesiti a piacere e svolgili in modo completo.
 Per ciascun quesito affrontato, produci: 1. Un frammento significativo del DABS risolutivo; 2. Il codice
in C completo e documentato; 3. Un campione significativo di dati di prova; 4. Modelli e
rappresentazioni grafiche a corredo.
PROBLEMI
1. Accettare in input una qualsiasi data( gg:mm:aaaa) con anno non bisestile nell’intervallo di annualità
[inf , sup], essendo inf un qualsiasi anno precedente il 1960 ma successivo al 1952.
(PUNTI 2)
2. Data una matrice EUR di valori monetari (espressi in euro): a) Definire e valorizzare la matrice; b)
generare il vettore SC delle somme di colonna ; c) Produrre in output su righe diverse la matrice
EUR ed il vettore SC
(PUNTI 2)
3. Il Sudoku usa una matrice 9x9 composta da 9 sottomatrici 3x3. Si chiede di: a) Definire un array a più
dimensioni che consenta di identificare ogni sottomatrice con due indici, ed operare in modo diretto su
ciascuna di esse come se si trattasse di una matrice a se stante; b) valorizzare in fase di dichiarazione la
sottomatrice di indici (1 , 2) in modo da assegnarle le seguenti 3(tre) terne di valori:
5 1 7
3 2 6
9 8 4
c) Produrre in output una qualsiasi delle sottomatrici specificata attraverso una coppia di indici
valorizzati mediante input.
(PUNTI 4)
4. A partire dall’esercizio 3. precedente si chiede di: a) Determinare se, data una qualsiasi sottomatrice
della griglia di un Sudoku, essa è completa (si codifichi ciascuna casella libera secondo una convenzione
ragionevole); b) Stabilire se, data una qualsiasi sottomatrice, essa è completa e valida (cioè contiene tutti
i numeri da 1(uno) a 9 (nove); c) Determinare se tutte le sottomatrici della griglia di un Sudoku sono
complete e valide; d) Determinare se, una data matrice, può rappresentare un Sudoku completamente
risolto; e) Produrre in output tutta la griglia del Sudoku e un messaggio relativo alla sua risoluzione.
(PUNTI 6)
5. Data la matrice rettangolare Cruciverba di dimensioni MxN, si chiede di: a) Usare la tecnica della
generazione pseudocasuale per costruire uno schema di cruciverba tenendo presente che la griglia non
deve mai contenere blocchi rettangolari di 4 o più caselle nere); b) Definire e valorizzare il vettore
Orizzontali contenente i numeri delle caselle che nella griglia individuano la prima lettera di ciascuna
parola orizzontale ; c) Produrre in output lo schema del cruciverba e la colonna dei numeri delle
definizioni orizzontali. (PUNTI 5)
6. L’array T, di capacità N, contiene una stringa che rappresenta una qualsiasi frase della lingua italiana
(da intendersi come serie di parole ciascuna delle quali separata dalla successiva da uno o più spazi). a)
Definire e valorizzare l’array T; b) Definire e poi usare una matrice EP a 2 dimensioni in modo che le
sue prime K righe contengano le K parole presenti nella frase in T; c) Produrre in output la stringa in T
e la lista numerata delle parole contenute in EP.
(PUNTI 5)
7. L’array V, di capacità K, contiene una serie di P parole, ciascuna separata da un solo carattere di
spaziatura (“ “) dalla parola che la segue. a) Definire e valorizzare l’array V; b) Definire e poi usare una
matrice POS a due dimensioni in modo tale che ciascuna riga di POS contenga le posizioni del primo e
dell’ultimo carattere di ciascuna delle P parole presenti nell’array V; c) Consentire che l’utente possa
chiedere la visualizzazione di una qualsiasi sequenza di caratteri di V specificando un indice
appropriato su POS; d) Produrre in output su righe successive il contenuto di V, la riga di POS di indice
specificato, e la sequenza di caratteri individuata in V.
(PUNTI 4)
8. Si consideri una assegnata matrice di caratteri ICS di dimensione NxN.
Determinare se: a) La cornice di caratteri più grande rappresentabile in ICS è formata dalla alternanza
di 2 soli caratteri; b) Le righe di indici j ed k contengono gli stessi caratteri indipendentemente
dall’ordine; c) Le colonne di indici u e vcontengono gli stessi caratteri nello stesso ordine; d) La
diagonale secondaria è formata solo da caratteri numerici; e) Produrre in output su righe successive: la
cornice di caratteri, le righe di indici j e k, le colonne di indici u e v, e la diagonale secondaria.
(PUNTI 3)
9. La matrice TI può memorizzare come stringhe nelle sue R righe al più R-1 parole della lingua italiana,
dato che l’ultima parola utile è sempre seguita da una stringa di soli caratteri chiocciola (“at”). Si chiede
di definire ed usare un array V che permetta di concatenate tutte le parole di TI separando con un solo
carattere trattino orizzontale “-“ ogni parola dalla parola che la segue: il programma deve produrre in
output il contenuto di V ed il numero delle parole in esso presenti
(PUNTI 5)
/*
SOLUZIONE compito classe 3
04 Marzo 2015
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <string.h>
#define N 200
#define ROW N/2
#define
#define
#define
#define
#define
R 50
MAX_LUN_PAR_ITA 25
DIM R*MAX_LUN_PAR_ITA
STR_AT "@@@@@@@@@@@@@@@@"
BLANK " "
#define M 20
#define N 30
main(){
int i, j, r, c, inizio, fine, primoB, iCar, iPar;
int nove[] = {-10,1,2,3,4,5,6,7,8,9};
/*
PROBLEMA #6
CAMPIONI DI DATI DI INPUT (per il testing di base del programma)
char T[N+1]={"ITALIANO: Maria aveva
un piccolo agnellino INGLESE:
Mary had a little
lamb"};
char T[N+1]={"ITALIANO:"};
char T[N+1]={""};
char T[N+1]={"ITALIANO:
INGLESE:"};
char T[N+1]={"Vi-va la pa-ppa pa-ppa col po-popo-popo-popo-modoro
viva la pa-ppa
pa-ppa che e' un ca-caca-capo-popo-lavoro"};
*/
/*-------------------------------------------------------------------*/
char T[N+1]={"a b c
d e f g
h i l
m n o p q r s t u v z A
B C D E F G H I L
M N O P Q R
S T U
V Z"};
char EP[ROW][N+1];
/*-------------------------------------------------------------------*/
char TI[R][MAX_LUN_PAR_ITA + 1] = {"Informatica",
"Linguaggio",
"Istruzione",
"Iterazione",
"Selezione",
"while",
"for",
"if",
"if-else",
"switch-case",
"void",
"NULL",
"int",
STR_AT
};
char V[DIM];
int sizeV;
/*--------------------------------------------------------------------*/
/* PROBLEMA # 3 (SUDOKU) */
/*
int sudoku[9][3][3]={ {{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}} ,
{{5,1,7},{3,2,6},{0,0,0}} ,
{{0,0,0},{0,0,0},{0,0,0}}
};
int suDoku[3][3][9]={
{{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0}} ,
{{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0}},
{{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0}}
};
*/
int Sudoku[3][3][3][3] = {
{ { {8,7,-2} , {60,-1,0} , {0,7,8} }, {
{0,0,0} , {0,0,0} , {0,0,0} }, { {0,0,0} , {0,0,0} , {0,0,0} } },
{ { {0,0,0} , {0,0,0} , {0,0,0} }, {
{2,5,8} , {3,4,7} , {8,2,1} }, { {0,0,0} , {0,0,0} , {0,0,0} } },
{ { {0,0,0} , {0,0,0} , {0,0,0} }, {
{0,0,0} , {0,0,0} , {0,0,0} },{ {5,1,7} , {3,2,6} , {9,8,4} } }
};
/*
Il 1-0 ciclo individua - se esiste - l'inizio della prima 'parola' in
T[]
Esegue lo skipping di tutti i blank in testa
*/
puts("\t\t\t\tPROBLEMA #6");
i = 0;
while(T[i] != '\0')
if (T[i] == ' ')
i++;
else{
inizio = i;
break;
}
if (T[i] == '\0'){
puts("Non ci sono parole da elaborare\n PREMI il tasto INVIO
(ENTER) per terminare il programma...");
getch();
return;
}
/* FINE 1-0 CICLO */
/*
CICLO PRINCIPALE
Usa la variabile flag 'primoB' (primo blank) come variabile logica
per stabilire se è iniziata la fase di skipping dei blank
di separazione tra due parole consecutive.
La variabile è settata a 1 non appena si rileva il primo blank della
sequenza di blank di separazione.
La variabile è settata a 0 quando si incontra il primo carattere
della parola successiva.
Il valore di questa variabile consente di determinare le posizioni
del primo e dell'ultimo carttere di ogni parola.
*/
primoB = 0;
iPar = 0;
while (T[i] !='\0'){
if (T[i] == ' ' && !primoB){
fine = i - 1;
primoB = 1;
for(iCar=inizio, j=0; iCar <= fine; iCar++,j++)
EP[iPar][j]=T[iCar];
EP[iPar][j]='\0';
iPar++;
}
if (T[i] != ' ' && primoB){
inizio = i;
primoB = 0;
}
i++;
}
/*
Dell'ultima parola potrebbe non essere stata rilevata la posizione
dell'ultimo carattere se l'ultimo carattere è subito seguito dal
carattere NULL: in questo caso si dovrà eseguire una copia fuori-ciclo
*/
if (T[i-1] != ' '){
fine = i-1;
for(iCar=inizio, j=0; iCar <= fine; iCar++,j++)
EP[iPar][j]=T[iCar];
EP[iPar][j]='\0';
iPar++;
}
for(i=0; i < iPar; i++)
printf("%d) %s\n",i+1,EP[i]);
getch();
/*-------------------------------------------------------------------*/
puts("\t\t\t\tPROBLEMA #9");
/*-------------------------------------------------------------------*/
puts("\nEcco le parole da concatenare:\n");
i = 0;
while(strcmp(TI[i],STR_AT) != 0){
printf("%d) %s\n",i+1,TI[i]);
i++;
}
i = 0;
if (strcmp(TI[i],STR_AT) != 0)
strcpy(V,TI[i]);
strcat(V,BLANK);
i++;
while(strcmp(TI[i],STR_AT) != 0){
strcat(V,TI[i]);
strcat(V,BLANK);
i++;
}
sizeV = strlen(V);
V[sizeV - 1]='\0';
puts("\nEcco le parole concatenate:\n");
puts(V);
getch();
/*-------------------------------------------------------------------*/
puts("\n\n\n\t\t\t\tPROBLEMA #3 (SUDOKU I) ");
/*-------------------------------------------------------------------*/
puts("\nSOTTOMATRICE del Sudoku di indici (2,2):\n");
for (i=0;i<3;i++){
printf("\t");
for(j=0; j<3; j++)
printf("%d ",Sudoku[2][2][i][j]);
puts("");
}
getch();
do{
printf("Immetti 2 numeri compresi tra 0 e 2 (inclusi):...");
scanf("%d %d",&r,&c);
} while (r<0 || r >2 || c<0 || c>2);
printf("\nHai scelto di visualizzare la SOTTOMATRICE del Sudoku di
indici (%d , %d)\n",r,c);
for (i=0;i<3;i++){
printf("\t");
for(j=0; j<3; j++)
printf("%d ",Sudoku[r][c][i][j]);
puts("");
}
getch();
/*-------------------------------------------------------------------*/
puts("\n\n\n\t\t\t\tPROBLEMA #4 (SUDOKU II)");
/*-------------------------------------------------------------------*/
/*
La presenza di uno 0 (zero) indica un valore mancante
*/
/*Una sottomatrice è INCOMPLETA se contiene almeno uno 0 (zero)*/
/* PUNTO 4.a */
/*
CODICE COMMENTATO sino a PUNTO 4.b incluso
fine = 0;
i=0;j=0;
r = 0;
while (r < 3){
c = 0;
while (c < 3){
if (Sudoku[i][j][r][c] == 0){
r = 2; c = 3;
fine = 1;
}
else c++;
}
r++;
}
if (fine==1)
printf("La SOTTOMATRICE di indici (%d,%d) e' INCOMPLETA ", i,j);
else printf("La SOTTOMATRICE di indici (%d,%d) e' COMPLETA ", i,j);
getch();
/* PUNTO 4.b */
fine = 0;
i=1;j=1;
r = 0;
while (r < 3){
c = 0;
while (c < 3){
if (Sudoku[i][j][r][c] < 1 || Sudoku[i][j][r][c] > 9 ||
nove[Sudoku[i][j][r][c]] == 0){
r = 2; c = 3;
fine = 1;
}
else {
nove[Sudoku[i][j][r][c]] = 0;
c++;
}
}
r++;
}
if (fine == 1)
printf("\nLa SOTTOMATRICE di indici (%d,%d) NON E'VALIDA ", i,j);
else printf("\nLa SOTTOMATRICE di indici (%d,%d) E' VALIDA ", i,j);
getch();
*/
/* I punti a. e b. in effetti possono essere risolti insieme
Come nel frammento successivo che permette di rilevare tutte le
possibili condizioni di errore su tutti gli elementi della matrice
(i due codici precedenti interrompono l’iterazione non appena si verifica
un errore
*/
/* Soluzione 4.a + 4.b con iterazione estesa a tutti gli elementi della
matrice
*/
fine = 0; /* variabile flag */
i=0;j=0;
r = 0;
while (r < 3){
c = 0;
while (c < 3){
if (Sudoku[i][j][r][c] == 0){
if ( fine != 1 && fine != 3 && fine != 5 && fine != 7)
fine += 1;
}
else if (Sudoku[i][j][r][c] < 0 || Sudoku[i][j][r][c] > 9){
if (fine != 2 && fine != 3 && fine != 6 && fine !=7)
fine += 2;
}
else if (nove[Sudoku[i][j][r][c]] == 0){
if (fine !=4 && fine !=5 && fine !=6 && fine != 7)
fine += 4;
}
else nove[Sudoku[i][j][r][c]] = 0;
c++;
}
}
r++;
}
switch (fine){
case 1: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' INCOMPLETA
(Caselle Vuote)", i,j); break;
case 2: printf("\nLa SOTTOMATRICE di indici (%d,%d) NON E'VALIDA
(Contiene numeri errati)", i,j); break;
case 3: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' INCOMPLETA
(Caselle Vuote) e NON E'VALIDA (Contiene numeri errati)", i,j); break;
case 4: printf("\nLa SOTTOMATRICE di indici (%d,%d) NON E'VALIDA
(Numeri Ripetuti)", i,j); break;
case 5: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' INCOMPLETA
(Caselle Vuote) e NON E'VALIDA (Numeri Ripetuti)", i,j); break;
case 6: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' INCOMPLETA
(Caselle Vuote) e NON E'VALIDA (Numeri Errati)", i,j); break;
case 7: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' INCOMPLETA
(Caselle Vuote) e NON E'VALIDA (Numeri Errati e Ripetuti)", i,j); break;
default: printf("\nLa SOTTOMATRICE di indici (%d,%d) E' VALIDA
(Caselle Incomplete)", i,j); break;
}
printf("\nLa variabile 'fine' =
getch();
}
%d\n",fine);