Sistemi Operativi - User contributions [en]

Esercizio 1, prova pratica 12/02/2009

2014-11-25T17:35:52Z

LorenzoV:

Ho provato a svolgere l'esercizio 1 dell'esame di laboratorio del 2 febbraio 2009 ([http://www.cs.unibo.it/~renzo/so/pratiche/2009.02.12.pdf]).

Consegna:
<source lang="text">
Esercizio1 (obbligatorio): (10 punti)
Scrivere un programma C denominato “invarg” che esegua il programma passato come parametro invertendo gli argomenti.
Esempio:
invarg cat a b c
deve avere l'effetto di
cat c b a
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(int argc , char* argv[]){
char *nargv[argc-1] ; /*nargv è il vettore degli argomenti da passare al programma da eseguire*/
int i , j ; /*puntatori che scorrono, rispettivamente, argv ed nargv per riempire correttamente nargv*/
nargv[0] = argv[1] ; /*il primo valore di nargv deve essere il programma chiamato, l'ultimo deve essere NULL*/
nargv[argc-1] = NULL ;
for( i = argc - 1 , j = 1 ; i > 1 , j < (argc - 1) ; i-- , j++ ) nargv[j] = argv[i] ; /*metto in nargv (dal secondo elemento in poi) gli argomenti presenti
in argv in ordine invertito*/
execvp( nargv[0] , nargv ) ; /*eseguo il programma (il cui nome è contenuto in nargv[0]) passandogli nargv come vettore di parametri*/
fprintf( stderr , "programma errato\n" ) ; /*se ci troviamo in questo punto significa che la chiamata a execvp è fallita, probabilmente
perchè il programma indicato non è stato trovato*/
exit(1) ;
}
</source>

==Soluzione di Eddy==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

void scambia_ordine(int argc, char **argv, int j);

int main(int argc , char* argv[])
{
if (argc < 2) return 2;
argv++; argc--;
scambia_ordine(argc, argv, 1);
execvp(argv[0], argv);
perror("execvp");
return 3;
}

/* piccola funzione ricorsiva che:
* -memorizza in tmp gli argomenti dalla fine
* -assegna ad argv in ordine inverso
*
* non scambia il primo argomento
*/
void scambia_ordine(int argc, char **argv, int j)
{
char *tmp;
if (argc > 1){
tmp = argv[argc-1];
scambia_ordine (argc-1, argv, j+1);
argv[j]=tmp;
}

}
</source>
[[User:Eddy|Eddy]] ([[User talk:Eddy|talk]]) 21:00 Saturday, 22 November 2014 (CET)

==Soluzione di GFede==
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

void scambia(int offset, int argc, char* argv[]);

int main(int argc, char* argv[])
{
if(argc <= 1)
{
printf("Usage: invarg.exe command [arguments...]\n");
return 2;
}
scambia(2, argc - 1, argv);

execvp(argv[1], argv + 1);
perror("execvp");
return 1;
}

/**
* Scambia le stringhe all'interno dell'array
* void scambia
* int offset Indice da cui iniziare a scambiare
* int argc Numero di valori nell'array (Compreso l'offset)
* char* argv[] array di stringhe da scambiare
*/
void scambia(int offset, int argc, char* argv[])
{
int i;
char* tmp;
for( i = offset; i < argc - i + offset; i++ )
{
tmp = argv[i];
argv[i] = argv[argc - i + offset];
argv[argc - i + offset] = tmp;
}
}
</source>

==Soluzione di LorenzoV==
<source lang="c">
#include <stdlib.h>
#include <stdio.h>

void swap(char **p, char **q){ // La swap modifica solo i puntatori
char *tmp;
tmp=*p;
*p=*q;
*q=tmp;
}

int main(int argc, char* argv[]){
char **begin, **end;
if (argc<3){
fprintf(stderr, "Usage:\n\t%s command ...arguments...\n", argv[0]);
exit(1);
}
begin=argv+2;
end=argv+argc-1;
while (begin<end){ // Inverte i parametri passati al comando
swap(begin, end);
begin++;
end--;
}
execvp(argv[1], argv+1);
return 0;
}
</source>
--[[User:LorenzoV|LorenzoV]] ([[User talk:LorenzoV|talk]]) 18:35, 25 November 2014 (CET)

(Programma C) Un quadrato nella matrice

2014-11-01T16:31:30Z

LorenzoV:

Questo è un problema uscito per le fasi di qualificazione della Facebook Hacker Cup 2014.
Il codice sorgente del programma di seguito riportato è in grado di riconoscere se in una matrice quadrata è presente un quadrato "pieno": il programma accetta in '''input''' un file come da esempio:
<source lang="text">
5
4
..##
..##
....
....
4
..##
..##
#...
....
4
####
#..#
#..#
####
5
#####
#####
#####
#####
.....
5
#####
#####
#####
#####
#####
</source>
Dove il primo intero T indica il numero di casi (o test) e gli altri interi n indicano la grandezza di ogni matrice nxn. 
Valgono i seguenti vincoli:
 
1 ≤ T ≤ 20 
1 ≤ N ≤ 20
 
Seguendo questo esempio, in '''output''' il programma stamperà le seguenti righe:
<source lang="text">
Case #1: YES
Case #2: NO
Case #3: NO
Case #4: NO
Case #5: YES
</source>
La matrice n. 2 contiene un # fuori dal quadrato, la matrice n. 3 contiene un quadrato non riempito e la matrice n. 4 contiene un rettangolo. 
Ecco il codice della mia soluzione:
<source lang="c">
#include <stdio.h>

typedef struct coordinate{
int x;
int y;
}coord;

int max(int x, int y){
if (x>y) return x;
else return y;
}

int min(int x, int y){
if (x<y) return x;
else return y;
}

int main(int argc, char *argv[]){
FILE *fin;
const int N=20;
int i, j, k, h, n, T, M[N][N];
int acase, find;
coord asx, adx, bsx, bdx;
char str[N];
fin = fopen("input.txt","r");
if (fin == NULL){
fprintf(stderr, "Error opening file\n");
exit(1);
}
fscanf(fin, "%d", &T);
if (T>20 || T<1){
fprintf(stderr, "Number of test cases not valid\n");
exit(1);
}
for (k=0; k<T; k++){
fscanf(fin, "%d", &n);
if (n>N){
fprintf(stderr, "Number of cells too high\n");
exit(1);
}
for (i=0; i<n; i++){
fscanf(fin, "%s", &str);
for (j=0; j<n; j++){
M[i][j]=str[j];
}
}
asx.x=asx.y=-1;
adx.x=adx.y=-1;
bsx.x=bsx.y=-1;
bdx.x=bdx.y=-1;
/*Angolo in alto a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
asx.x=i;
asx.y=j;
find=1;
}
}
}
/*Angolo in alto a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
adx.x=i;
adx.y=j;
find=1;
}
}
}
/*Angolo in basso a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bsx.x=i;
bsx.y=j;
find=1;
}
}
}
/*Angolo in basso a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bdx.x=i;
bdx.y=j;
find=1;
}
}
}
/*Verifico che non sia un rettangolo*/
acase=1;
if (max(bsx.x, bdx.x)-min(asx.x, adx.x)!=max(bsx.y, bdx.y)-min(asx.y, adx.y)){
acase=0;
} else {
/*Verifico se il quadrato è pieno*/
for (i=min(asx.x, adx.x); i<=max(bsx.x, bdx.x); i++){
for (j=min(asx.y, adx.y); j<=max(bsx.y, bdx.y); j++){
if (M[i][j]!='#'){
acase=0;
}
}
}
}
if (acase) printf("Case #%i: YES\n", k+1);
else printf("Case #%i: NO\n", k+1);
}
fclose(fin);
return 0;
}
</source>
--[[User:LorenzoV|LorenzoV]] ([[User talk:LorenzoV|talk]]) 17:25, 1 November 2014 (CET)

(Programma C) Un quadrato nella matrice

2014-11-01T16:25:37Z

LorenzoV:

Questo è un problema uscito per le fasi di qualificazione della Facebook Hacker Cup 2014.
Il codice sorgente del programma di seguito riportato è in grado di riconoscere se in una matrice quadrata è presente un quadrato "pieno": il programma accetta in '''input''' un file come da esempio:
<source lang="text">
5
4
..##
..##
....
....
4
..##
..##
#...
....
4
####
#..#
#..#
####
5
#####
#####
#####
#####
.....
5
#####
#####
#####
#####
#####
</source>
Dove il primo intero T indica il numero di casi (o test) e gli altri interi n indicano la grandezza di ogni matrice nxn. 
Valgono i seguenti vincoli:
 
1 ≤ T ≤ 20 
1 ≤ N ≤ 20
 
Seguendo questo esempio, in '''output''' il programma stamperà le seguenti righe:
<source lang="text">
Case #1: YES
Case #2: NO
Case #3: NO
Case #4: NO
Case #5: YES
</source>
La matrice n. 2 contiene un # fuori dal quadrato, la matrice n. 3 contiene un quadrato non riempito e la matrice n. 4 contiene un rettangolo. 
Ecco il codice della mia soluzione:
<source lang="c">
#include <stdio.h>

typedef struct coordinate{
int x;
int y;
}coord;

int max(int x, int y){
if (x>y) return x;
else return y;
}

int min(int x, int y){
if (x<y) return x;
else return y;
}

int main(int argc, char *argv[]){
FILE *fin, *fout;
const int N=20;
int i, j, k, h, n, T, M[N][N];
int acase, find;
coord asx, adx, bsx, bdx;
char str[N];
fin = fopen("input.txt","r");
if (fin == NULL){
fprintf(stderr, "Error opening file\n");
exit(1);
}
fscanf(fin, "%d", &T);
if (T>20 || T<1){
fprintf(stderr, "Number of test cases not valid\n");
exit(1);
}
for (k=0; k<T; k++){
fscanf(fin, "%d", &n);
if (n>N){
fprintf(stderr, "Number of cells too high\n");
exit(1);
}
for (i=0; i<n; i++){
fscanf(fin, "%s", &str);
for (j=0; j<n; j++){
M[i][j]=str[j];
}
}
asx.x=asx.y=-1;
adx.x=adx.y=-1;
bsx.x=bsx.y=-1;
bdx.x=bdx.y=-1;
/*Angolo in alto a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
asx.x=i;
asx.y=j;
find=1;
}
}
}
/*Angolo in alto a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
adx.x=i;
adx.y=j;
find=1;
}
}
}
/*Angolo in basso a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bsx.x=i;
bsx.y=j;
find=1;
}
}
}
/*Angolo in basso a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bdx.x=i;
bdx.y=j;
find=1;
}
}
}
/*Verifico che non sia un rettangolo*/
acase=1;
if (max(bsx.x, bdx.x)-min(asx.x, adx.x)!=max(bsx.y, bdx.y)-min(asx.y, adx.y)){
acase=0;
} else {
/*Verifico se il quadrato è pieno*/
for (i=min(asx.x, adx.x); i<=max(bsx.x, bdx.x); i++){
for (j=min(asx.y, adx.y); j<=max(bsx.y, bdx.y); j++){
if (M[i][j]!='#'){
acase=0;
}
}
}
}
if (acase) printf("Case #%i: YES\n", k+1);
else printf("Case #%i: NO\n", k+1);
}
fclose(fin);
return 0;
}
</source>
--[[User:LorenzoV|LorenzoV]] ([[User talk:LorenzoV|talk]]) 17:25, 1 November 2014 (CET)

(Programma C) Un quadrato nella matrice

2014-11-01T16:21:44Z

LorenzoV: Created page with "Questo è un problema uscito per le fasi di qualificazione della Facebook Hacker Cup 2014. Il codice sorgente del programma di seguito riportato è in grado di riconoscere se ..."

Questo è un problema uscito per le fasi di qualificazione della Facebook Hacker Cup 2014.
Il codice sorgente del programma di seguito riportato è in grado di riconoscere se in una matrice quadrata è presente un quadrato "pieno": il programma accetta in '''input''' un file come da esempio:
<source lang="text">
5
4
..##
..##
....
....
4
..##
..##
#...
....
4
####
#..#
#..#
####
5
#####
#####
#####
#####
.....
5
#####
#####
#####
#####
#####
</source>
Dove il primo intero T indica il numero di casi (o test) e gli altri indicano la grandezza di ogni matrice nxn. 
Valgono i seguenti vincoli:
 
1 ≤ T ≤ 20 
1 ≤ N ≤ 20
 
Seguendo questo esempio, in '''output''' il programma stamperà le seguenti righe:
<source lang="text">
Case #1: YES
Case #2: NO
Case #3: NO
Case #4: NO
Case #5: YES
</source>
La matrice n. 2 contiene un # fuori dal quadrato, la matrice n. 3 contiene un quadrato non riempito e la matrice n. 4 contiene un rettangolo. 
Ecco il codice della mia soluzione:
<source lang="c">
#include <stdio.h>

typedef struct coordinate{
int x;
int y;
}coord;

int max(int x, int y){
if (x>y) return x;
else return y;
}

int min(int x, int y){
if (x<y) return x;
else return y;
}

int main(int argc, char *argv[]){
FILE *fin, *fout;
const int N=20;
int i, j, k, h, n, T, M[N][N];
int acase, find;
coord asx, adx, bsx, bdx;
char str[N];
fin = fopen("input.txt","r");
if (fin == NULL){
fprintf(stderr, "Error opening file\n");
exit(1);
}
fscanf(fin, "%d", &T);
if (T>20 || T<1){
fprintf(stderr, "Number of test cases not valid\n");
exit(1);
}
for (k=0; k<T; k++){
fscanf(fin, "%d", &n);
if (n>N){
fprintf(stderr, "Number of cells too high\n");
exit(1);
}
for (i=0; i<n; i++){
fscanf(fin, "%s", &str);
for (j=0; j<n; j++){
M[i][j]=str[j];
}
}
asx.x=asx.y=-1;
adx.x=adx.y=-1;
bsx.x=bsx.y=-1;
bdx.x=bdx.y=-1;
/*Angolo in alto a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
asx.x=i;
asx.y=j;
find=1;
}
}
}
/*Angolo in alto a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=0; j<n && !find; j++){
if (M[i][j]=='#'){
adx.x=i;
adx.y=j;
find=1;
}
}
}
/*Angolo in basso a sinistra*/
find=0;
for (i=0; i<n; i++){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bsx.x=i;
bsx.y=j;
find=1;
}
}
}
/*Angolo in basso a destra*/
find=0;
for (i=n; i>=0; i--){
for (j=n; j>=0 && !find; j--){
if (M[i][j]=='#'){
bdx.x=i;
bdx.y=j;
find=1;
}
}
}
/*Verifico che non sia un rettangolo*/
acase=1;
if (max(bsx.x, bdx.x)-min(asx.x, adx.x)!=max(bsx.y, bdx.y)-min(asx.y, adx.y)){
acase=0;
} else {
/*Verifico se il quadrato è pieno*/
for (i=min(asx.x, adx.x); i<=max(bsx.x, bdx.x); i++){
for (j=min(asx.y, adx.y); j<=max(bsx.y, bdx.y); j++){
if (M[i][j]!='#'){
acase=0;
}
}
}
}
if (acase) printf("Case #%i: YES\n", k+1);
else printf("Case #%i: NO\n", k+1);
}
fclose(fin);
return 0;
}
</source>