Giovanni Di Grezia - VFX Artist Forum - C

Bitbucket Source

xgiovio — Sat, 15 Mar 2014 12:53:55 GMT

PHP Code:


https://bitbucket.org/xgiovio/unisa_lab_reti_2013_2014

Pacchetti creati durante le lezioni in laboratorio del corso di reti presso l'universit� di Salerno. Docente: Cicalese. II anno, II semestre. Classe dispari 2013/2014. Per bug o info --> xgiovio@gmail.com

[os] sync 4 processes ( n ) with shared memory and mutex locking ( atomic access )

xgiovio — Tue, 04 Jun 2013 22:06:02 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *          Process syncronization between 4 processes
 *          2 processes will decrement a variable  of 1 unit 50000 times
 *          Other 2 processes will increment the same variable of 1 unit 50000 times
 *
 *          The result is 0 using mutex in a shared memory.
 *
 *          Typical Output:
 *          I'm process 1 and i have the control NOW! I'm incrementing the shared variable
 *          I'm process 2 and i'm waiting to decrement the shared variable..
 *          I'm process 4 and i'm waiting to decrement the shared variable..
 *          I'm process 3 and i'm waiting to increment the shared variable..
 *          I'm process 2 and i have the control NOW! I'm decrementing the shared variable
 *          I'm process 4 and i'm waiting to decrement the shared variable..
 *          I'm process 3 and i have the control NOW! I'm incrementing the shared variable
 *          I'm process 4 and i have the control NOW! I'm decrementing the shared variable
 *          Numero finale  :0
 */

#define SHMSZ 500
#define KEY 9999

int main ( void ) {

    int shmid, status, shmdet, shmcontrol,err;
    void * shmatt;
    int * new_area;
    
    /////////////creazione memoria condivisa
    shmid = shmget ( KEY, SHMSZ, IPC_CREAT | IPC_EXCL | 660);
        if (shmid == -1) { fprintf (stderr, "Impossibile creare segmento condiviso\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-1);}
    //////////// attacco memoria condivisa a spazio processo
    shmatt = shmat ( shmid, (void *)0 ,0);
        if (shmatt == (void *) -1) { fprintf (stderr, "Impossibile modificare spazio indirizzi processo\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-2);}
            
       //////////////////////////////// setting uo variables in shared memory    
    new_area = (int *) shmatt;
    
    int *waiting;
        waiting = new_area;
        
    int *shared_variable;
        shared_variable = new_area + 4;
        *shared_variable = 0;
        
    pthread_mutex_t * x_mute_x; // mutex variable
        x_mute_x = (pthread_mutex_t *)(new_area + 5);
        pthread_mutex_init(x_mute_x,NULL); // mutex initialized
    
    
    ///////////////////////////////////// begin fork /////////////////////////////////////////////////////////
    
    int i;
    int key;
    int current,next;
    
    int pid1,pid2,pid3,pid4;
    pid1 = fork();
    if ( pid1 == 0) {
        
                                //precritical section
                                    *(waiting + 0)=1;
                                    key=1;
                                    current = 0;
                                    
                                    for (;(*(waiting + 0)) == 1 && key!=0;) {
                                        key = (int) (pthread_mutex_trylock(x_mute_x));
                                        if ( key!=0) {
                                              fprintf(stdout,"I'm process 1 and i'm waiting to increment the shared variable..\n");
                                              sleep(1);
                                        }
                                    }
                                    fprintf(stdout,"I'm process 1 and i have the control NOW! I'm incrementing the shared variable\n");
                                    (*(waiting + 0)) = 0;                                    
                                    
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(shared_variable))++;}
                                
                                
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    next = ( current + 1) % 4;
                                    for (;next!=current && !(*(waiting + next));) {
                                        next = ( next + 1) % 4;}
                                        
                                    if ( next == current) {
                                        pthread_mutex_unlock(x_mute_x);
                                    } else{
                                        (*(waiting + next))= 0;
                                    }
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
        exit(0);
    }
    pid2 = fork();
    if ( pid2 == 0) {
        
                                //precritical section
                                    *(waiting + 1)=1;
                                    key=1;
                                    current = 1;
                                    
                                    for (;(*(waiting + 1)) == 1 && key!=0;) {
                                        key = (int) (pthread_mutex_trylock(x_mute_x));
                                        if ( key!=0) {
                                              fprintf(stdout,"I'm process 2 and i'm waiting to decrement the shared variable..\n");
                                              sleep(1);
                                        }
                                    }
                                    fprintf(stdout,"I'm process 2 and i have the control NOW! I'm decrementing the shared variable\n");
                                    (*(waiting + 1)) = 0;                                    
                                    
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(shared_variable))--;}
                                
                                
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    next = ( current + 1) % 4;
                                    for (;next!=current && !(*(waiting + next));) {
                                        next = ( next + 1) % 4;}
                                        
                                    if ( next == current) {
                                        pthread_mutex_unlock(x_mute_x);
                                    } else{
                                        (*(waiting + next))= 0;
                                    }
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
        exit(0);
    }
    pid3 = fork();
    if ( pid3 == 0) {
        
                                //precritical section
                                    *(waiting + 2)=1;
                                    key=1;
                                    current = 2;
                                    
                                    for (;(*(waiting + 2)) == 1 && key!=0;) {
                                        key = (int) (pthread_mutex_trylock(x_mute_x));
                                        if ( key!=0) {
                                              fprintf(stdout,"I'm process 3 and i'm waiting to increment the shared variable..\n");
                                              sleep(1);
                                        }
                                     }
                                    fprintf(stdout,"I'm process 3 and i have the control NOW! I'm incrementing the shared variable\n");
                                    (*(waiting + 2)) = 0;                                    
                                    
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(shared_variable))++;}
                                
                                
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    next = ( current + 1) % 4;
                                    for (;next!=current && !(*(waiting + next));) {
                                        next = ( next + 1) % 4;}
                                        
                                    if ( next == current) {
                                        pthread_mutex_unlock(x_mute_x);
                                    } else{
                                        (*(waiting + next))= 0;
                                    }
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
        exit(0);
    }
    pid4 = fork();
    if ( pid4 == 0) {
        
                                //precritical section
                                    *(waiting + 3)=1;
                                    key=1;
                                    current = 3;
                                    
                                    for (;(*(waiting + 3)) == 1 && key!=0;) {
                                        key = (int) (pthread_mutex_trylock(x_mute_x));
                                        if ( key!=0) {
                                              fprintf(stdout,"I'm process 4 and i'm waiting to decrement the shared variable..\n");
                                              sleep(1);
                                        }
                                     }
                                    fprintf(stdout,"I'm process 4 and i have the control NOW! I'm decrementing the shared variable\n");
                                    (*(waiting + 3)) = 0;                                    
                                    
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(shared_variable))--;}
                                
                                
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    next = ( current + 1) % 4;
                                    for (;next!=current && !(*(waiting + next));) {
                                        next = ( next + 1) % 4;}
                                        
                                    if ( next == current) {
                                        pthread_mutex_unlock(x_mute_x);
                                    } else{
                                        (*(waiting + next))= 0;
                                    }
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
        exit(0);
    }
        
            int waiterr;
            
            waiterr = waitpid(-1,&status,0);
            for (;waiterr > 0;){
                waiterr = waitpid(-1,&status,0);
            }
            
            printf ( "Numero finale  :%d\n",*(shared_variable));
            
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-4);}
            shmcontrol = shmctl (shmid,IPC_RMID,NULL );
                if (shmcontrol == -1) { fprintf (stderr, "Impossibile settare memoria condivisa per eliminazione\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-5);}

    return 0;
}

[os] Different results - Fork with and without Peterson syncronization

xgiovio — Sat, 25 May 2013 14:19:05 GMT

Lo scopo � di fare una fork. Il figlio incrementer� una variabile settata a 0 in memoria condivisa di 1 unita 50mila volte. Il padre invece la decrementer�.
Il risultato dovrebbe essere 0 poiche 0 + 50000 - 50000 = 0
A causa del timesharing, del processo a singolo thread e per la sovrascrittura dei registri del processore durante i cambi di contesto questo non accadr�.
Provare ad eseguire il primo codice piu volte e si vedranno continue variazioni di valore.
Nel secondo codice invece questo non avverr�.

Nessuna sincronizzazione

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *
 *          Critical sections between parent and child - fork()
 *          Parent will decrement a variable  of 1 unit 50000 times
 *          Child will increment the same variable of 1 unit 50000 times
 *
 *          The result should be 0 but this isn't true.
 *          Without syncronization the result is unpredictable.
 *        
 */

#define SHMSZ 100
#define KEY 9999

int main ( void ) {

    int shmid, status, shmdet, shmcontrol,err;
    void * shmatt;
    int * new_area;
    
    /////////////creazione memoria condivisa
    shmid = shmget ( KEY, SHMSZ, IPC_CREAT | IPC_EXCL | 660);
        if (shmid == -1) { fprintf (stderr, "Impossibile creare segmento condiviso\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-1);}
    //////////// attacco memoria condivisa a spazio processo
    shmatt = shmat ( shmid, (void *)0 ,0);
        if (shmatt == (void *) -1) { fprintf (stderr, "Impossibile modificare spazio indirizzi processo\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-2);}
            
    new_area = (int *) shmatt;
    
    ///////////////////////////////////// begin fork /////////////////////////////////////////////////////////
    
    *(new_area + 3)=0;
    int i;
    
    int pid;
    pid = fork();
    
    
    
    if ( pid == 0) {
        
                                //precritical section

                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(new_area + 3))++;}
                                
                                
            
            ///////////////////////////// end critical section child process
            
                                // post critical section

                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
            
    } else {
        
                                //precritical section

            
            ////////////////////////////// begin critical section parent process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(new_area + 3))--;}
            
            ///////////////////////////// end critical section parent process
            
                                // post critical section

                                
            
            waitpid(-1,&status,0);
            printf ( "Numero :%d\n",*(new_area + 3));
            
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-4);}
            shmcontrol = shmctl (shmid,IPC_RMID,NULL );
                if (shmcontrol == -1) { fprintf (stderr, "Impossibile settare memoria condivisa per eliminazione\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-5);}
    }

    return 0;
}

Sincronizzazione di Peterson

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *          Process syncronization between parent and child - fork()
 *          Parent will decrement a variable  of 1 unit 50000 times
 *          Child will increment the same variable of 1 unit 50000 times
 *
 *          The result is 0 using Peterson Algorithm to syncronize processes.    
 */

#define SHMSZ 100
#define KEY 9999

int main ( void ) {

    int shmid, status, shmdet, shmcontrol,err;
    void * shmatt;
    int * new_area;
    
    /////////////creazione memoria condivisa
    shmid = shmget ( KEY, SHMSZ, IPC_CREAT | IPC_EXCL | 660);
        if (shmid == -1) { fprintf (stderr, "Impossibile creare segmento condiviso\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-1);}
    //////////// attacco memoria condivisa a spazio processo
    shmatt = shmat ( shmid, (void *)0 ,0);
        if (shmatt == (void *) -1) { fprintf (stderr, "Impossibile modificare spazio indirizzi processo\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-2);}
            
    new_area = (int *) shmatt;
    int *flag; /// signal that process wants to go into critical section
        flag = new_area;
    int *turn;
        turn = new_area + 2;
    
    ///////////////////////////////////// begin fork /////////////////////////////////////////////////////////
    
    *(new_area + 3)=0;
    int i;
    
    int pid;
    pid = fork();
    
    
    
    if ( pid == 0) {
        
                                //precritical section
                                    *(flag + 1)=1; // processo figlio vuole andare in sezione critica
                                    *turn=0; // turno del processo padre
                                    
                                    for (;(*turn) == 0 && *(flag)==1;) {sleep(1);} // attendo che il processo padre esca dalla sezione critica
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(new_area + 3))++;}
                                
                                
            
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    *(flag + 1)=0;
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
            
    } else {
        
                                //precritical section
                                *flag=1; // processo padre vuole andare in sezione critica
                                *turn=1; // turno del processo figlio
                                
                                for (;(*turn) == 1 && *(flag + 1)==1;) {sleep(1);} // attendo che il processo figlio esca dalla sezione critica
            
            ////////////////////////////// begin critical section parent process
            
                                //critical section
                                for (i=0;i<50000;i++){(*(new_area + 3))--;}
            
            ///////////////////////////// end critical section parent process
            
                                // post critical section
                                *(flag)=0;
                                
            
            waitpid(-1,&status,0);
            printf ( "Numero :%d\n",*(new_area + 3));
            
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-4);}
            shmcontrol = shmctl (shmid,IPC_RMID,NULL );
                if (shmcontrol == -1) { fprintf (stderr, "Impossibile settare memoria condivisa per eliminazione\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-5);}
    }

    return 0;
}

[os] sincronizzazione di 2 processi ( fork) usando shared memory e Peterson

xgiovio — Sat, 25 May 2013 14:03:38 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *
 *          Process syncronization between parent and child - fork()
 *                  Shared Memory and Critical Sections + Peterson Solution ( 2 processes)
 *        
 */

#define SHMSZ 100
#define KEY 9999

int main ( void ) {

    int shmid, status, shmdet, shmcontrol,err;
    void * shmatt;
    int * new_area;
    
    /////////////creazione memoria condivisa
    shmid = shmget ( KEY, SHMSZ, IPC_CREAT | IPC_EXCL | 660);
        if (shmid == -1) { fprintf (stderr, "Impossibile creare segmento condiviso\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-1);}
    //////////// attacco memoria condivisa a spazio processo
    shmatt = shmat ( shmid, (void *)0 ,0);
        if (shmatt == (void *) -1) { fprintf (stderr, "Impossibile modificare spazio indirizzi processo\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-2);}
            
    new_area = (int *) shmatt;
    int *flag; /// signal that process wants to go into critical section
        flag = new_area;
    int *turn;
        turn = new_area + 2;
    
    ///////////////////////////////////// begin fork /////////////////////////////////////////////////////////
    
    int pid;
    pid = fork();
    
    
    
    if ( pid == 0) {
        
                                //precritical section
                                    *(flag + 1)=1; // processo figlio vuole andare in sezione critica
                                    *turn=0; // turno del processo padre
                                    
                                    for (;(*turn) == 0 && *(flag)==1;) {sleep(1);} // attendo che il processo padre esca dalla sezione critica
                                
            ////////////////////////////// begin critical section child process
            
                                //critical section
                                
                                
            
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                    *(flag + 1)=0;
                                    
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
            
    } else {
        
                                //precritical section
                                *flag=1; // processo padre vuole andare in sezione critica
                                *turn=1; // turno del processo figlio
                                
                                for (;(*turn) == 1 && *(flag + 1)==1;) {sleep(1);} // attendo che il processo figlio esca dalla sezione critica
            
            ////////////////////////////// begin critical section parent process
            
                                //critical section
            
            ///////////////////////////// end critical section parent process
            
                                // post critical section
                                *(flag)=0;
                                
            
            waitpid(-1,&status,0);
            
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-4);}
            shmcontrol = shmctl (shmid,IPC_RMID,NULL );
                if (shmcontrol == -1) { fprintf (stderr, "Impossibile settare memoria condivisa per eliminazione\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-5);}
    }

    return 0;
}

[os] sezione critica tra padre e figlio ( fork ) usando shared memory

xgiovio — Sat, 25 May 2013 12:49:05 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *
 *          Shared Memory and Critical Sections between parent and child - fork()
 *                  
 *        
 */

#define SHMSZ 100
#define KEY 9999

int main ( void ) {

    int shmid, status, shmdet, shmcontrol,err;
    void * shmatt;
    int * new_area;
    
    /////////////creazione memoria condivisa
    shmid = shmget ( KEY, SHMSZ, IPC_CREAT | IPC_EXCL | 660);
        if (shmid == -1) { fprintf (stderr, "Impossibile creare segmento condiviso\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-1);}
    //////////// attacco memoria condivisa a spazio processo
    shmatt = shmat ( shmid, (void *)0 ,0);
        if (shmatt == (void *) -1) { fprintf (stderr, "Impossibile modificare spazio indirizzi processo\n");
            err= errno;
            fprintf (stderr, "Errore %d\n",err);
            exit (-2);}
            
    new_area = (int *) shmatt;
    
    ///////////////////////////////////// begin fork /////////////////////////////////////////////////////////
    int pid;
    pid = fork();
    
    if ( pid == 0) {
        
                                //precritical section
            
            ////////////////////////////// begin critical section child process
            
                                //critical section
            
            ///////////////////////////// end critical section child process
            
                                // post critical section
                                
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                    err= errno;
                    fprintf (stderr, "Errore %d\n",err);
                    exit (-3);}
            
    } else {
        
                                //precritical section
            
            ////////////////////////////// begin critical section parent process
            
                                //critical section
            
            ///////////////////////////// end critical section parent process
            
                                // post critical section
                                
            
            waitpid(-1,&status,0);
            
            shmdet = shmdt (shmatt);
                if (shmatt == (void *)-1) { fprintf (stderr, "Impossibile detachare memoria condivisa\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-4);}
            shmcontrol = shmctl (shmid,IPC_RMID,NULL );
                if (shmcontrol == -1) { fprintf (stderr, "Impossibile settare memoria condivisa per eliminazione\n");
                err= errno;
                fprintf (stderr, "Errore %d\n",err);
                exit (-5);}
    }

    return 0;
}

[os] sezione critica mediante file

xgiovio — Sun, 19 May 2013 09:08:45 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 
#include 

/***
 *
 *
 *
 *  Simulazione di gestione sezione critica mediante uso di file
 *
 *
 *
 *
 ****/
#define PATH "/tmp/lock"
#define TRY 5

int check ( void ) {
    
    int fd,t,err;
    
    fd=open(PATH,O_CREAT | O_RDWR | O_EXCL,00751);
    err=errno;
    
    if (fd > 0) {return 1;}
    
    for(t=1;fd==-1 && err == EEXIST && t <= TRY;t++) {
        
        fd=open(PATH,O_CREAT | O_RDWR | O_EXCL,00751);
        err=errno;
        
    }
    
    if (fd > 0) {return 1;} else {return 0;}
    
}

void return_check ( void ){
    
    int err;
    err= unlink(PATH);
    if ( err == -1 ) { fprintf(stderr,"Impossibile controllare semaforo dopo sezione critica\n"); exit(-1);}
    
}

int main ( void ) {
    
    if ( check() == 1){
        /*////////////////// sezione critica /////////*/ fprintf(stdout,"Sezione critica eseguita\n");
        return_check();
        
    } else {
        fprintf(stderr,"Impossibile entrare in sezione critica\n");
        exit(-2);
    }
    
    return 0;
}

[os] exam 2 - 3 childer - fibonacci - SIGINT handler

xgiovio — Fri, 17 May 2013 17:44:11 GMT

PHP Code:


#include 
#include 
#include 

/*
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *         Giovanni Di Grezia - 0512101xxx
 *
 *         ////// SECONDA PROVA INTERCORSO //////
 *
 *         Advanced Edition
 *
 *
 *        
 */

int fibonacci ( int i) {
    
    if ( i <= 1){ return 0;} else { if ( i == 2) { return 1; } else {
    
        return (fibonacci( i - 1) + fibonacci ( i - 2));
    
        }  
    }
    
}

void null_action (int signal) {}


void action ( int signal) {
    
    int pid,status; char character;
    pid = fork();
    
    if ( pid == -1) { exit(-2);} else {
        
        if ( pid == 0) {
            
            
            fprintf ( stdout, "Pid padre %d \n", getppid());
            fprintf(stdout, "Terminare?\n");
            fscanf(stdin,"%c",&character);
            
            if (character == 'y'){
                
                kill (getppid(),SIGKILL);
                kill (getpid(),SIGKILL);
                
            } else {
            
               kill ( getppid(),SIGCONT);
                
            }

            exit(0);
        } else {
            kill ( getpid(),SIGSTOP);
            waitpid(-1,&status,0);
          
        }
    }
    
}


int main ( void ){
    
    
    int pid,i,status,err;
    
    struct sigaction sigintaction;
        sigintaction.sa_handler= null_action;
        sigintaction.sa_flags=0;
        
    sigaction (SIGINT, &sigintaction, NULL);
    
    pid=fork();
    
    
    if ( pid == -1 ) { /* errore */ exit(-1);} else {
        
        if ( pid == 0){
            
            sigintaction.sa_handler= action;
            sigaction (SIGINT, &sigintaction, NULL);
            
            struct sigaction sigusr1action;
            sigusr1action.sa_handler= null_action;
            sigusr1action.sa_flags=0;
        
            sigaction (SIGUSR1, &sigusr1action, NULL);
            
            
            for (i=0;i<300;i++){
                
                    fprintf(stdout,"Fib %d\n", fibonacci(i+1));
                
            }
            
        } else {
            err= waitpid(-1,&status,0);
            for (;err != pid;){
                err= waitpid(-1,&status,0);
            }
            fprintf(stdout,"Figlio con pid %d terminato\n",pid);  
        }
                
    }

    return 0;
}

[os] linode - list files in a directory with inode number

xgiovio — Fri, 03 May 2013 13:52:07 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 
#include 
#include 

/*
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/  
 *
 *      List files in a directory with relative inode number
 *      Usage: linode 
 *      v1.0
 *
 */

typedef struct contents {
        
        char name[255];
        int node_number;
        struct contents * next;
        
    } contents_struct;
    
contents_struct * getdata (char * name, int number) {
    
    contents_struct * punt;
    
    punt = (contents_struct *) malloc ( sizeof(contents_struct));
            if ( punt == NULL) {
                    fprintf(stderr, "Errore di allocazione\n");
                    exit(-3);
            }
            strcpy (punt->name, name);
            punt->node_number = number;
            punt->next = NULL;
            
    return punt;
    
}

contents_struct * add_to_list (contents_struct * list, contents_struct * t_list){
    
    if (list==NULL){
                    list = t_list;
                    return list;
                    
                } else {
                    
                    if ( strcmp (list->name, t_list->name ) > 1 ){
                        
                        t_list->next = list;
                        list=t_list;
                        return list;
                        
                    } else{
                        
                        list->next = add_to_list ( list->next, t_list);
                        return list;
                        
                    }
    }
    
    
}
    

int main ( int n_entry , char** name_entry) {

    if ( n_entry < 2){return 0;};
    
    struct stat file_info;
    
    DIR * directory;
    struct dirent  * dir_entry;
    
    int err,i;
    
    char array [1000];
    
    contents_struct * list;
    contents_struct * t_list;
        list = NULL;
    
    
    directory =  opendir (*(name_entry + 1));
    if ( directory == NULL){ fprintf(stderr, "Impossibile aprire directory\n"); exit(-1);}
    
        for(dir_entry = readdir(directory); \
            dir_entry != NULL;              \
            dir_entry = readdir(directory)){
            
            
            strcpy ( array, *(name_entry + 1));
            for(i=0;*(array+i)!=0;i++){};
            if (*(array+i-1)!='/'){
                strcat ( array, "/");
            }
            strcat ( array, dir_entry->d_name);
                
                
            err = stat (array, &file_info );
                if ( err == -1){ fprintf(stderr,"Errore lettura file\n"); exit(-2);}
            
            t_list=getdata(dir_entry->d_name, (int)(file_info.st_ino));
            list = add_to_list(list, t_list);
            
        }
        
        for(t_list=list;t_list!=NULL;t_list=t_list->next){
            
            fprintf(stdout,"%s - %d\n",t_list->name,t_list->node_number);
                
        }

    return 0;
}

Monetina falsata [giochino]

TheAvenger — Tue, 23 Apr 2013 19:09:08 GMT

PHP Code:


/*
Avendo una monetina falsata riuscire a bilanciare la possibilit� di
uscita di testa(0) e di croce(1).
*/
#include 
#include 
#include 


int monetina_cattiva(){
int indice;
int possibilita[]= {0, 0, 0, 0, 0, 0, 0, 1, 1, 1};

double random_number = rand() / (double)RAND_MAX;
indice =  random_number *= 10;
return possibilita[indice];
}

int monetina_buona(){
int a = monetina_cattiva();
int b = monetina_cattiva();
while(a == b)
{
a = monetina_cattiva();
b = monetina_cattiva();
}
if(a==0)
return 1;
else
return 0;
}



main(){
srand(time(NULL));

int numero_test = 1000;
int teste = 0;

int i;
for(i = 0; i < numero_test; i++){

int risultato = monetina_buona();
if (risultato == 1){
teste++;
}


}
printf("%.2f\n",(float)teste/numero_test);
}

[os] read directory entries

xgiovio — Mon, 22 Apr 2013 22:23:14 GMT

PHP Code:


#include 
#include 
#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *
 *      Utilizzo : directory [nome-directory]
 *          stampa su stdout tutti i file/cartelle contenuti in nome-directory
 *
 *        
 */



int main ( int n_values, char ** values  ) {
      
        
    DIR * directory;
    struct dirent * dir_entry;
    
    
    directory = opendir(*(values + 1));
        if ( directory == NULL ){
            
            fprintf(stderr,"Impossibile leggere directory %s\n",*(values + 1));
            exit (-2);
            
        }
      
       fprintf(stderr,"La directory %s contienre le seguenti entry:\n",*(values + 1));
    for ( dir_entry = readdir(directory); \
          dir_entry != NULL; \
          dir_entry = readdir(directory)){
        
            fprintf(stdout,"-- %s\n",(char *) &(dir_entry->d_name));
        
    }
    
    closedir(directory);
    
    
    return 0;
}

[os] sleep emulated via alarm + pause - makefile

xgiovio — Mon, 22 Apr 2013 07:11:26 GMT

main

PHP Code:


/*
 *
 *
 *  Sample Function
 *
 */

#include 
#include "main_header.h"

int main ( void ) {
    
    for(;-1;){
        
        fprintf(stdout,"Dormo per 2 sec ...\n");
        xsleep(2);
        fprintf(stdout,"Eccomi. Dormo per altri 2 sec ...\n");
        
    }
    
    return 0;
}

main_header

PHP Code:


void xsleep ( int n);

xsleep

PHP Code:


#include 
#include 
#include 


void xsleep_action ( int signal ){}


void xsleep ( int n ) {
    
    
    struct sigaction sigalrm_action;
        sigalrm_action.sa_handler = xsleep_action;
        sigalrm_action.sa_flags= 0;
    
    sigaction(SIGALRM,&sigalrm_action,NULL);
    
    alarm(n);
    pause();
    
}

makefile

PHP Code:


all:main.o xsleep.o
    gcc -o exec main.o xsleep.o
main.o:main.c main_header.h
    gcc -c -o main.o main.c
xsleep.o:xsleep.c
    gcc -c -o xsleep.o xsleep.c

[os] Signal Mangement with sigaction - SINGINT ( CTRL-D ) SAMPLE

xgiovio — Sun, 21 Apr 2013 17:22:53 GMT

PHP Code:


#include 
#include 
#include 

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 *
 *  Alter SIGINT signal from shell. It will ask you if you are sure
 *  to kill the process.
 *
 *  v 1.0
 *
 *
 */


void xflush ( FILE* stream ) {
    
    int temp;
    temp = fgetc ( stream );
    
    for (; temp != '\n' ;temp = fgetc ( stream )){}
    
    
}



void ask ( int signal) {
    
    char * stringa;
    
    stringa = (char *) malloc (20);
    
    if ( stringa == NULL) { fprintf(stderr,"Impossibile completarel'operazione\n");exit(-2);}
    
    fprintf ( stdout, "\nDo you want to quit me? y\\n\n");
    fscanf( stdin, "%19s", stringa);
    xflush (stdin);
    
    for (;(strcmp(stringa,"y") != 0) &&  (strcmp(stringa,"n") != 0);){
    
        fprintf ( stdout, "Wrong Answer \n");
        fscanf( stdin, "%19s", stringa);
        xflush (stdin);
    }
    
        if ( strcmp(stringa,"y") == 0){
            fprintf(stdout,"Signal processed. Goodbye friend. I'm dying ...\n");
            kill (getpid(),SIGKILL);
            fprintf(stderr, "You can't kill me!\n");
        }
    
}



int main ( void ) {
    
    struct sigaction sigint_action;
        sigint_action.sa_handler = ask;
        sigint_action.sa_flags = 0;
        
    
    sigaction ( SIGINT, &sigint_action, NULL);
    
    fprintf(stdout,"Press ctrl-c if you want to kill me....\n");
    
    for(;-1;){
        pause ();
        fprintf(stdout,"Signal processed but i'm still here. Thank you. Press ctrl-c if you want to kill me\n");
    }
      
    
    return 0;
}

[os] Exam 1/2 - Create 2 subprocesses and wait them

xgiovio — Fri, 12 Apr 2013 19:23:38 GMT

PHP Code:


/*
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/
 *
 *         Giovanni Di Grezia - 0512101xxx
 *
 *         ////// PRIMA PROVA INTERCORSO //////
 *
 *         No CHANGES since - Version 1.0
 *
 *         Notes: La traccia non definisce lo scheduling
 *         dei processi figli, quindi è probabile che i
 *         numeri stampati non siano ordinati.
 *         Per evitare questo evento, basterebbe aggiungere
 *         un sleep al 2 processo figlio o attendere la
 *         terminazione del primo figlio prima di efettuare
 *         la seconda fork.
 *
 *        
 */

#include 
#include 
#include 
#include 
#include 
#include 

int main ( void ) {
    
    int a,b,status,child,i; // definizione variabili
    
    
    a=fork(); //creazione primo figlio
    if ( a<0) {
        
        fprintf(stderr,"Fork fallita\n");
        exit(-1);
        
    }else{
       if (a==0){
        
            fprintf(stdout,"Sono il primo figlio, il mio pid è %d\n",getpid()); // pid processo corrente
            
            for ( i=1; i<=0 ; i++){
                
                fprintf(stdout,"Numero %d\n",i); // stamap dei numeri richiesti
                
            }
            
       }else{
            
            b=fork(); // secondo processo creato
            
            if ( b<0 ){
                
               fprintf(stderr,"Fork fallita\n");
               exit(-2);
                
                
            } else {
                
                if ( b== 0){
                    
                    fprintf(stdout,"Sono il secondo figlio, il pid di mio padre è %d\n",getppid()); // pid padre processo corrente
            
                    for ( i=101; i<=150 ; i++){
                
                        fprintf(stdout,"Numero %d\n",i); // stamap dei numeri richiesti
                
                     }  
                    
                    
                } else {
                    
                    // for per attendere il completamento di tutti i processi figli
                    
                    for ( child = waitpid (-1, &status, 0); child > 0 ; child = waitpid(-1,&status,0)){
                        
                        
                        fprintf(stdout,"Figlio con pid %d terminato con errore %d\n", child, status); // stampa con relativo error code
                        
                    }
            
                }
                
            }
        
       }
          
    }
    
    return 0;
}

[os] v2 systems calls - Covert file 1 to file 2 inverting upper/lower cases

xgiovio — Thu, 04 Apr 2013 20:57:33 GMT

PHP Code:


/*
 *
 *
 *  upper to lower ( and viceversa) v2
 *
 *
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 



int main ( int nentry, char ** names ){

    int fd1,fd2,r_bytes,w_bytes,i;
    void * buffer;
    
    buffer = malloc(100);
    
    if (buffer == NULL){
        //impossibile allocare
        exit(-2);
    }
    
    fd1 = open (*(names +1 ),O_RDONLY);
    
    if (fd1 < 0){
        
        fprintf(stderr,"Sorgente non presente\n");
        exit (-3);
    }
    
    fd2 = open (*(names +2 ),O_WRONLY | O_TRUNC);
    
    if ( fd2<0){
        
        fprintf(stdout,"Creazione file destinazione in corso ..\n");
        fd2 = open (*(names +2 ),O_CREAT | O_WRONLY,00700);
        if (fd2<0){
            fprintf(stderr,"Impossibile creare file di destinazione\n");
            exit(-4);
        }
    }
    
    for (r_bytes= read( fd1, buffer, 100); r_bytes>0; r_bytes= read( fd1, buffer, 100)){
        
        for ( i=0;i<r_bytes;i++) {
            if ( islower(*((char *) buffer + i))){
                *((char *) buffer + i) = toupper(*((char *) buffer + i));
            }else{
                *((char *) buffer + i) = tolower(*((char *) buffer + i));
                
            }    
        }
        
        w_bytes = write (fd2,buffer,r_bytes);
        if ( w_bytes != r_bytes){
            
            fprintf(stderr,"Errore in scrittura sul file destinazione\n");
            exit(-5);
        }
        
    }
    
    if ( r_bytes < 0){
        
        fprintf(stderr, "Errore durante la lettura del file sorgente\n");
        exit(-6);
    }
    
   close(fd1);
   close(fd2);
  
   fprintf(stdout,"Operazione completata senza errori\n");
    
    return 0;
}

[os] systems calls - Covert file 1 to file 2 inverting upper/lower cases

xgiovio — Sat, 23 Mar 2013 13:34:22 GMT

PHP Code:


/*
 *
 * copy file 1 to file2 and invert lower with upper ( and viceversa )
 *
 *
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define READBYTES 100


int main ( int numero_arg, char ** nome_arg ) {
    
    int fd,fd2,n,status,i;
    void * buf;
    char * punt;
    
    /////////////////////////// allocazione buffer temporano di swap tra read e write
    buf = malloc (READBYTES);
    if ( buf == NULL){
        
        fprintf(stderr,"Impossibile completare l'operazione\n");
        exit(-6);
    }
    
    
    if ( (fd = open (*(nome_arg + 1),O_RDONLY)) >= 0 ){
        
        fd2 = open (*(nome_arg + 2),O_WRONLY | O_TRUNC); // apertura file
        
        if (fd2 < 0) { // se non presente
            
            fprintf(stdout,"File destinazione non presente. Creazione in corso ..\n"); // crealo
            fd2 = open (*(nome_arg + 2),O_CREAT | O_WRONLY, S_IRWXU);
            
        }
        
        for (n=read (fd, buf, READBYTES);n>0;n=read (fd, buf, READBYTES)) {
        
            punt = (char *) buf;
            ////////////////////////////////////////////// verifica se minuscolo o maiuscolo
            for (i=0;i<n;i++){
                if (islower(*(punt + i))){
                    *(punt + i) = toupper (*(punt + i));
                } else {
                    *(punt + i) = tolower (*(punt + i));
                }
            }
            
            status = write ( fd2, buf, n); /////////////// scrittura valori nel nuovo file
            if ( status < n){
                
                fprintf(stderr, "Errore di scrittura\n");
                exit(-5);
            }
        }
        
        fprintf(stdout,"Conversione completata\n");
        
        
    } else {
        
        fprintf(stdout,"File di origine non esistente\n");
        exit(-2);
        
    }
    
    return 0;
}

File

TheAvenger — Tue, 11 Dec 2012 13:04:11 GMT

PHP Code:


/*
* esempio scrittura/lettura file
*/

#include 
#include 

int main()
{
FILE *fp;
char *nomefile = "pippo.txt";
char *nomefilebinario = "numeri.dat";
char buffer[1024];
int numeri[20] = {1,2,3,4,5,6,7};
int i;
fp = fopen(nomefile, "wb+");


if(fp == NULL)
{
fprintf(stderr, "Non posso aprire file %s per la scrittura\n",nomefile);
exit(-2);
}

fprintf(fp,"Ciao. DALLE!\n");
fprintf(fp,"Aggiungo dati al file.\n");
fprintf(fp,"ho vergogna di te.\n");

rewind(fp); //torno all'inizio o posso fare anche fseek(fp, 0,SEEK_SET) invece per andare alla fine
   //fseek(fp,0,SEEK_AND)

fscanf(fp, "%s", buffer); //leggo una parola
printf("%s\n",buffer); //stampo la parola
fclose(fp);

//SECONDO FILE :D
fp = fopen(nomefilebinario, "rb+");
if(fp == NULL)
{
fprintf(stderr, "Non posso aprire file %s per la scrittura\n",nomefile);
exit(-2);
}
fwrite(numeri,sizeof(int),20,fp);
fclose(fp);
fp = fopen(nomefilebinario, "rb+");
numeri[0] = numeri[1] = numeri[2] = numeri[3] = numeri[4] = numeri[5] = numeri[6]= numeri[7] = -1;
fread(numeri,sizeof(int),20,fp);
for(i=0;i<7;i++)
{
printf("%d",numeri[i]);
}
printf("\n");

return 0;
}

make test

xgiovio — Sun, 09 Dec 2012 18:39:47 GMT

1.c

PHP Code:


#include "header.h"

int main ( void ) {


int a = 2;

funct(a);


return 0;
}

2.c

PHP Code:


void funct ( int number ) {


number=number+1;



}

header.h

PHP Code:


void funct ( int number );

Makefile

PHP Code:


exec: 1gino.o 2gino.o
    gcc -o exec 1gino.o 2gino.o
1gino.o: 1.c header.h
    gcc -c -o 1gino.o 1.c
2gino.o:2.c
    gcc -c -o 2gino.o 2.c

list to vet ( reverse commented )

xgiovio — Sun, 09 Dec 2012 18:03:34 GMT

PHP Code:


/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */

/*

1)lista di strutture ( info,link ), mettere ogni nodo in un vettore
poi da array a lista
(vddi write to disk)

*/

#include 
#include 
#include 


typedef struct element {
    
    char * info;
    int points ;
    struct element * link;
    
} element_struct;

/////////////////////////// prototypes
void * xmalloc (int byte);
element_struct * save_list ( element_struct * lista, int * elements_to_save);

/////////////////////////////////////////////// begin
int main ( void ) {
    
    
    //// sample data
     element_struct data[]={
        
        {"spada", 100, data + 1},
        {"scudi", 230, data + 2},
        {"maronna", 450, data + 3},
        {"prezzemolo", 10, NULL}
        
     };
    //////////////  end sample data
    
    ////////////////////////// declaration
    element_struct * lista; // input list
    element_struct * vet_to_save; // vet returned from function - save this to disk
    int elements_to_save; // number of elements to save
    int i; // used to count
    
    ////////////////////////////// end declaration
    
    ////////////// sample data to list - replace here the source
    lista = data;
    
    
    ///////////////////////////////////// save list to array : next step -> save to disk
    vet_to_save = save_list ( lista, &elements_to_save);
    
    
    
    ///////////////////////////////// print saved array - debug only
    
    for (i=0 ; i<elements_to_save; i++){
        
        printf("%s , %d \n", (vet_to_save + i)-> info , (vet_to_save + i)-> points );
        
    }
    
    
    ///////////////////////////////////////////////////////////////////// array to list
    /*
     *  int numero_elementi;
     *  element_struct vet[leggi numero elementi da file];
     *  element_struct lista;
     *
     *  numero_elementi= leggi da file il numero;
     *  carica_elementi_da_disco (file,vet, numero_elementi, sizeof (element_struct)) // carica da file in vet
     *
     *
     *  ////////////////////////// linkiamo le strutture nel vettore  
     *  
     * for (i=0;i     *      (vet +i)->link = vet + i + 1;
     * }
     * (vet +i)->link = NULL;
     *
     * lista = vet;
     *
     */
    
    return 0;
}



element_struct * save_list ( element_struct * lista, int * elements_to_save){
    
    element_struct * temp_node;
    element_struct * vet_to_save;
    int i;
    
    //////////////////////////////// conto il numero di elementi
    
    for ( temp_node = lista , i=0 ; temp_node != NULL; i++ , temp_node = temp_node ->link){
    }
    
    /////////////////////////////// salvo numero di elementi
    *elements_to_save = i;
    
    
    ///////////////////////////////// alloco spazio per il blocco consecutivo di dati
    vet_to_save = (element_struct *) xmalloc ( i * sizeof(element_struct));
    
    
    for ( temp_node = lista , i = 0 ; temp_node != NULL; i++ , temp_node = temp_node ->link){
        
        memcpy (vet_to_save + i, temp_node , sizeof(element_struct));
        
    }
    
    return vet_to_save;
    
}

void * xmalloc (int byte){
    
    void * punt;
    
    punt = malloc (byte);
    
    if (punt == NULL){
        printf("Spazio non sufficiente\n");
        exit(-1);
    }
    
    return punt;
}

list -> vet -> qsort ( vet ) -> list = vet

xgiovio — Sun, 09 Dec 2012 18:02:09 GMT

PHP Code:


/*

lista non ordinata- vai i array - fai qsort ordinando vettore,
relinca elementi vettore e restituisci il vettore come se fosse una lista ordinata

*/

/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */

#include 
#include 
#include 


typedef struct element {
    
    char * info;
    int points;
    struct element * link;
    
} element_struct;

/////////////////////////// prototypes
void * xmalloc (int byte);
element_struct * save_list ( element_struct * lista, int * elements_to_save);
void relink ( element_struct * vet_to_save , int elements_to_save);
int compara_elementi ( const void *a, const void *b);

/////////////////////////////////////////////// begin
int main ( void ) {
    
    
    //// sample data
     element_struct data[]={
        
        {"spada", 100, data + 1},
        {"scudi", 230, data + 2},
        {"maronna", 450, data + 3},
        {"prezzemolo", 10, NULL}
        
     };
    //////////////  end sample data
    
    ////////////////////////// declaration
    element_struct * lista; // input list
    element_struct * vet_to_save; // vet returned from function - save this to disk
    int elements_to_save; // number of elements to save
    int i; // used to count
    
    ////////////////////////////// end declaration
    
    ////////////// sample data to list - replace here the source
    lista = data;
    
    
    ///////////////////////////////////// save list to array
    vet_to_save = save_list ( lista, &elements_to_save);
    
    ////////////////////// at this point the vet_to_save is ready to be saved to disk, it contains elements_to_save objects
    
    ////////////////////////////////// order array
    qsort (vet_to_save, elements_to_save , sizeof(element_struct), compara_elementi);
    
    ////////////////////// at this point the vet_to_save is ready to be saved to disk, it contains elements_to_save objects ordered by info
    
    
    //////////////////////////////////// relink array to create a new list ordered
    relink ( vet_to_save, elements_to_save);
    lista = vet_to_save;
    
    ///////////////////////////////// print saved array - debug only
    
    for (i=0 ; i<elements_to_save; i++){
        
        printf("%s , %d \n", (vet_to_save + i)-> info , (vet_to_save + i)-> points );
        
    }
    
    
    return 0;
}



/////////////////////////////////////////////////////////////////// functions
void relink ( element_struct * vet_to_save , int elements_to_save){
    int i;
    
    for (i=0;i< elements_to_save-1;i++){
        
        (vet_to_save +i ) -> link = (vet_to_save + i + 1);
        
    }
    (vet_to_save +i ) -> link = NULL;
}

int compara_elementi ( const void *a, const void *b) {
    
    element_struct * ele1;
    element_struct * ele2;
    
    ele1 = (element_struct *) a;
    ele2 = (element_struct *) b;
    
    return strcasecmp ( ele1->info , ele2->info);
    
}


element_struct * save_list ( element_struct * lista, int * elements_to_save){
    
    element_struct * temp_node;
    element_struct * vet_to_save;
    int i;
    
    //////////////////////////////// conto il numero di elementi
    
    for ( temp_node = lista , i=0 ; temp_node != NULL; i++ , temp_node = temp_node ->link){
    }
    
    /////////////////////////////// salvo numero di elementi
    *elements_to_save = i;
    
    
    ///////////////////////////////// alloco spazio per il blocco consecutivo di dati
    vet_to_save = (element_struct *) xmalloc ( i * sizeof(element_struct));
    
    
    for ( temp_node = lista , i = 0 ; temp_node != NULL; i++ , temp_node = temp_node ->link){
        
        memcpy (vet_to_save + i, temp_node , sizeof(element_struct));
        
    }
    
    return vet_to_save;
    
}

////////////////////////////////////////////////////////// xmalloc = malloc + error control
void * xmalloc (int byte){
    
    void * punt;
    
    punt = malloc (byte);
    
    if (punt == NULL){
        printf("Spazio non sufficiente\n");
        exit(-1);
    }
    
    return punt;
}

Matrice Dinamica - NO Realloc

xgiovio — Sun, 09 Dec 2012 17:49:57 GMT

PHP Code:


/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */


#include 
#include 

///////////////////////////////// function xmalloc = malloc + NULL control
void * xmalloc (int byte){
    
    void * punt;
    
    punt = malloc (byte);
    
    if (punt == NULL){
        printf("Spazio non sufficiente\n");
        exit(-1);
    }
    
    return punt;
}

//////////////////////////////////// function crea_matrice = malloc data and return pointer to data block begin address
float **  crea_matrice ( unsigned int righe, unsigned int colonne){
    
        float * data;
        float ** index;
        int i;
    
        data = (float *) xmalloc ( righe * colonne * sizeof(float));
        index = (float **) xmalloc (righe * sizeof(float *));
        
        for (i=0;i<righe;i++){
            
            *(index + i) = data + ( i * colonne);
            
        };
        
        return index;
    
}

AllPrefixSum - Senator Style - Es2 - Exam

xgiovio — Sun, 09 Dec 2012 17:48:27 GMT

PHP Code:


/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */

#include 
#include 
#include 

typedef struct lista {
         int *indirizzo;
         struct lista * prossimo;
} lista_struct;

//////////////////////////////////////////// prototypes
lista_struct *new_node ( int * address);
lista_struct * add_node(lista_struct * nodo ,lista_struct * lista);
void allprefixsums ( int * a, int n);

int main (void){
    
    int i;
    int vet[10]={2,5,1,3,2,6,0,4};
    lista_struct *list;
    lista_struct *temp_node;
    
    //////////////////////////
    
    list= NULL;
    
    for (i=0;i<8;i++){
        printf ("%d ", *(vet +i));
    }
    printf ("\n");
    
    allprefixsums ( vet, 8);
    
    for (i=0;i<8;i++){
        printf ("%d ", *(vet +i));
    }
    printf ("\n");
    
    
    for (i=0;i<8;i++){
        
        temp_node = new_node (vet +i);
        list = add_node(temp_node,list);
    }
    
    
    for(temp_node = list;temp_node != NULL; temp_node = temp_node->prossimo){
        
        printf("Indirizzo nodo %p\n",temp_node->indirizzo);
        
    }
    return 0;
}

///////////////////////////////////////////////////////////////////////////////////////////////functions



void allprefixsums ( int * a, int n){
    
    int i;
    for (i=1;i<8;i++){
        
        *(a+i)= *(a+i)+ (*(a+i-1));
        
    }
}

lista_struct *new_node ( int * address){
    
    lista_struct * node;
    
    node = (lista_struct *) malloc (sizeof(lista_struct));
    
    node->indirizzo = address;
    node->prossimo = NULL;
    
}

lista_struct * add_node(lista_struct * nodo ,lista_struct * lista){
    
    if ( lista == NULL){
        return nodo;  
    }
    
    lista->prossimo = add_node(nodo,lista->prossimo);
    return lista;
    
}

Vettore puntato ordinato - Senator Exam 1

xgiovio — Sun, 09 Dec 2012 17:46:32 GMT

PHP Code:


/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */
#include 
#include 
#include 


int ** vet_puntato_ordinato ( int * source);
int compara_numeri ( const void * a, const void * b);


int main (void){
    
    int i;
    int ** vet_ordinato;
    int vet[10]={1,4,2,7,3,6,9,3,5,34};
    
    for (i=0;i<10;i++){
        printf ("%d ", *(vet +i));
    }
    printf ("\n");
    
    vet_ordinato = vet_puntato_ordinato (vet);
    
    for (i=0;i<10;i++){
        printf ("%d ", **(vet_ordinato +i));
    }
    printf ("\n");
    
    return 0;
}


int ** vet_puntato_ordinato ( int * source){
    
    int ** new_vet;
    int i;
    
    new_vet = (int **) malloc (10 * sizeof(int *));
    
    if (new_vet == NULL ){
        
        printf("Spazio non disponibile\n");
        exit(-1);
    }else{
        
        for (i=0;i<10;i++){
            *(new_vet +i) = (source + i);
        }
        
        qsort (new_vet,10,sizeof( int *),compara_numeri);
        
        return new_vet;
        
    }
    
}

int compara_numeri ( const void * a, const void * b){
    
    int ** num1 = (int **) a;
    int ** num2 = (int **) b;
    
    if ( **num1 <= **num2){
        return -1;
    }else{
        return 1;
    }
    
}

Struct Delete - Count and Scan

xgiovio — Wed, 05 Dec 2012 23:29:32 GMT

PHP Code:


/***
 *               _            _                          
 *              (_)          (_)                          
 *    __  ____ _ _  _____   ___  ___   ___ ___  _ __ ___  
 *    \ \/ / _` | |/ _ \ \ / / |/ _ \ / __/ _ \| '_ ` _ \
 *     >  < (_| | | (_) \ V /| | (_) | (_| (_) | | | | | |
 *    /_/\_\__, |_|\___/ \_/ |_|\___(_)___\___/|_| |_| |_|
 *          __/ |                                        
 *         |___/                                          
 */


#include 
#include 
#include 


typedef struct member {
    
    char* name;
    char* surname;
    struct member * next;
    
}member_struct;

member_struct * loop_delete_node_from_and_count (char * keyword, member_struct * members, int *count, int * all_list);
member_struct * delete_node_from_and_count (char * keyword, member_struct * members, int *count, int * all_list);


///////////////////////////////////////////////////////////////// begin
int main (void){
    
    
    char * keyword;
    int count =0;
    int all_list= 0;
    member_struct members[10]={
        
        {"gino","carol",(members+1)},
        {"mario","fonz",(members+2)},
        {"fonzo","cristina",(members+3)},
        {"alberto","marcopolo",(members+4)},
        {"ndonio","paolo",(members+5)},
        {"fonzetto","paolone",(members+6)},
        {"mario","paolino",(members+7)},
        {"assunta","paols",(members+8)},
        {"giovanni","mario",(members+9)},
        {"ann","ponzio",NULL}  

    };
    member_struct *list;

    ////////////////////////////////////////////////////////////// end of init
    list = members;
    keyword="mario";
    
    //////////////////////// loop delete until all list scanned
    list = loop_delete_node_from_and_count (keyword,members,&count,&all_list);
                        // keyword is the string to compare
                        // members is the list name
                        // &count is the return address to write delete actions number
                        // &all_list is the return address to confirm a complete list scan
    
    
    //////////////////////// print
    if (count){
        printf("Nodo eliminato %d volte\n",count);
    }else{
        printf("Nodo non trovato");
    }


}



////////////////////////////////////////////////// functions


////////////////////////////////////////////////////////////////////////loop wrapper for delete_node_from_and_count
member_struct * loop_delete_node_from_and_count (char * keyword, member_struct * members, int *count, int * all_list){
    
    for(;*all_list==0;){
        
        delete_node_from_and_count (keyword,members,count,all_list);
    }
    
}
    
  

///////////////////////////////////////////////////////////////////// delete a node and return the new list
member_struct * delete_node_from_and_count (char * keyword, member_struct * members, int *count, int * all_list){
    
    if (members==NULL){
        *all_list=1;
        return NULL;
    
    }
    
    if (keyword == members->name || keyword == members->surname){
        *count+=1;
        return members->next;
    }
    
    members->next = delete_node_from_and_count (keyword,members->next,count,all_list);
    return members;
    
    
}

Lista - Conteggio Parole e Stampe senza ripetizioni

xgiovio — Sun, 02 Dec 2012 15:52:43 GMT

PHP Code:


/*
 *
 *
 * input:parole
 * output: lista ordinata per nome senza ripetizioni + conteggio ripetizioni
 *
 *
 */


#include 
#include 
#include 

#define WORD_SIZE 100

typedef struct string {
    
    char * word;
    unsigned int counter;
    struct string * next;
    
} word_struct;


word_struct * new_word_struct ( char * input_word , unsigned int input_counter );
word_struct * add_to_word_struct_list (word_struct * node, word_struct * list );
void convert_lower_case (char * buffer, int k);

//////////////////////////////////////////////////////////////////////////////////////////////////begin

int main (void ) {
    
    char a;
    char buff[WORD_SIZE]; // buf temporaneo per le parole da input
    int i;
    word_struct * list_word_struct = NULL ; // Lista vuota di tipo word_struct
    word_struct * temp_word_struct; // Node temporaneo di tipo word_struct
    
    
    a=fgetc(stdin);
    
    for (; a!=EOF ; a=fgetc(stdin) ){
        
        ///////////////////////////////////////////////////////////////// parole nel buff
    
        for (i=0 ; a!= ' ' && a!= '\n' && a!= '\t' ; i++){
            
            buff[i]=a;
            a=fgetc(stdin);
            
        }
        buff[i]=0;
        
        convert_lower_case (buff,i);  

        if (buff[0] != 0){
        
            temp_word_struct = new_word_struct (buff,1); // nuovo elemento di tipo word_struct
            
            list_word_struct = add_to_word_struct_list (temp_word_struct, list_word_struct ); // aggiunta di un elemento word_struct a lista word_struct
        }
    
    }
    
    
    ///////////////////////////////////////////////////////////////////////////// stampa parole e numero inserimenti
    
    printf ("\nParole Inserite e ripetizioni :\n");
    
    for (temp_word_struct = list_word_struct ; temp_word_struct != NULL; temp_word_struct = (*temp_word_struct).next){
        
        printf("%s , %u\n",(*temp_word_struct).word,(*temp_word_struct).counter);
    }
    
 return 0;  
}





///////////////////////////////////////////////////////////////////////////////// functions



/////////////////////////////////////////////////////////////////////convert to lowercase
void convert_lower_case (char * buffer, int k){
    
    int i;
    
    for (i=0;i<k;i++){
        
        if (buffer[i] >= 'A' && buffer[i] <= 'Z'){
            
            buffer[i] = buffer[i] + ('a'-'A');
        }
        
    }
    
}



//////////////////////////////////////////////////////////////////// new node
word_struct * new_word_struct ( char * input_word , unsigned int input_counter ){
    
    word_struct * pointer;
    pointer = ( word_struct * ) malloc ( sizeof(word_struct));
    
    (*pointer).word = strdup(input_word);
    (*pointer).counter = input_counter;
    (*pointer).next = NULL;
    
    
    return pointer;
    
}

///////////////////////////////////////////////////////////////////////////////// insert node
word_struct * add_to_word_struct_list (word_struct * node, word_struct * list ){
    
      
    //////////////////////////////////// I caso : Lista Nulla
    if (list == NULL){
        return node;
    }
    
    
    //////////////////////////////////// II caso : Inserimento in testa
    
    if (strcmp((*node).word,(*list).word) <0){
        
        (*node).next = list ;
            return node;
    }
    
    if (strcmp((*node).word,(*list).word)==0){
        
            (*list).counter += 1;
            free((*node).word);
            return list;
    }
    
  
    //////////////////////////////////////III caso Inserimento nel mezzo
  
    (*list).next = add_to_word_struct_list (node, (*list).next );
    return list;
    
  
}

Realloc

xgiovio — Sat, 01 Dec 2012 18:33:02 GMT

PHP Code:


#include 
#include 


int main ( void ) {

int n;
int i,j;
int * dati=NULL;

printf("Inserire Numero\n");
    scanf("%d",&n);

for (i=1;n!=(-1);i++){
    
    dati = realloc ( dati,i * sizeof(int));
    
    *(dati +(i-1))=n;
    
    printf("Inserire Numero\n");
    scanf("%d",&n);

}
i--;

for (j=0;j<i;j++){
    printf("%d\n",*(dati + j));
}


 return 0;
}

Strutture ordinate

xgiovio — Sat, 01 Dec 2012 18:31:30 GMT

PHP Code:


#include 
#include 
#include 

#define ELEMENTS(array) (sizeof(array)/sizeof(array[0]))
#define NUMBER 2


typedef struct {
 
    char * nome;
    char * cognome;
    unsigned int esami;
    float media;
    
} studente_struct;

int compara_struct_nome (const void * a , const void * b);
void stampa_struct ( studente_struct * a);



int main ( void ) {
    
char buffer[50];
int i;

studente_struct studente[NUMBER];

for (i=0;i<NUMBER;i++){

    printf ("Nome\n");
    scanf ("%49s",buffer);
    (*(studente +i)).nome= strdup(buffer);
    
    printf ("Cognome\n");
    scanf ("%49s",buffer);
    (*(studente +i)).cognome= strdup(buffer);
    
    printf ("Esami\n");
    scanf ("%u",&((*(studente+i)).esami) );
    
    printf ("Media\n");
    scanf ("%f",&((*(studente+i)).media) );
    
}

////////////////////////////// ordina per nome
    
    qsort(studente , ELEMENTS(studente) , sizeof(studente[0]), compara_struct_nome);
    stampa_struct (studente);

/////////////////////////////////

 return 0;
}


int compara_struct_nome (const void * a , const void * b){
    
    studente_struct * dat1 = ( studente_struct *) a;
    studente_struct * dat2 = (studente_struct *) b;
    
    return strcmp ( (*(dat1)).nome , (*(dat2)).nome );
    
}

void stampa_struct ( studente_struct * a){
    
    int i;
    
    for(i=0;i<NUMBER;i++){
        
        printf ("%s\n", (*(a + i)).nome);
        printf ("%s\n", (*(a + i)).cognome);
        printf ("%u\n", (*(a + i)).esami);
        printf ("%f\n", (*(a + i)).media);
        
    }
    
}

Qsort - Array Dinamico - Error Control - Headers- Objects - Readme

xgiovio — Wed, 28 Nov 2012 21:10:43 GMT

main

PHP Code:


/*
 *
 * Qsort
 *
 * Require: compara_stringhe_c.o
 *
 */

#include 
#include 
#include 

#include "main_header.h" // prototypes

#define MAX_NUM "20" // numero cifre di input
#define MAX_INPUT_S "99" // lunghezza massima stringa input per vettore buffer
#define MAX_INPUT 100 // grande vettore buffer


int main (void) {
    
    int n; // numero elementi
    int i,j; // contatore di appoggio
    char **vet_s; // base_address dei char *
    char array [MAX_INPUT]; // buffer di chars
    char * p_temp; // puntatore temp  a char
    
    ///////////////////////////////////////////////// grandezza array
    printf("Numero di stringhe da inserire\n");
    scanf("%"MAX_NUM"d",&n);
    
    for(;n<0;){
        printf("Mi prendi in giro? Inserisci un numero intero positivo\n");
        scanf("%"MAX_NUM"d",&n);
    }
    
    ///////////////////////////////// inizio trattamento dati
    if (n==0){
        
        printf("Lei � un betatester pigro\n");
        
    }else{
        //////////////////////////// allocazioni spazio per gli n elementi
        vet_s= (char **)malloc (n * sizeof(void *));
        ////////////////////////// verifica spazio sufficiente
        if (vet_s == NULL) {
            
            printf("Spazio disponibile non sufficiente per l'allocazione\n");
        }else{
            
            for (i=0;i<n;i++){
                ////////////////////////// input stringa
                printf("Inserire la %d stringa :\n",i+1);
                scanf("%" MAX_INPUT_S "s",array);
                
                ///////////////////////// conteggio stringa
                for (j=0; (j!=MAX_INPUT)  && (array[j]!=0) ;j++){
                }
                ////////////////////////////verifica della presenza del tappo
                if (j==MAX_INPUT){
                    
                    printf ("La stringa in input non � formattata correttamente");
                    array[j-1]=0;
                    j--;
                    
                }
                
                ///////////////////////////////// alloco lo spazio per la stringa
                p_temp = ( char *) malloc ((j+1) * sizeof(char *));
                
                if( p_temp == NULL){
                    
                    printf("Spazio disponibile non sufficiente per l'allocazione\n");
                    exit(-1);
                    
                }
                
                
                /////////////////////////////// trasferisco i valori
                for (j=0; array[j]!=0 ;j++){
                    
                    *(p_temp + j) = array [j];
                    
                }
                *(p_temp + j) = array [j]; // aggiungo il tappo
                
                *(vet_s + i) = p_temp;
                
            }
            
            ////////////// fine inserimento valori /////
            
            ////////////stampo stringhe inserite
            printf ("\nStringhe inserite : \n\n");
            
            for(i=0;i<n;i++){
                                
                printf ("%s\n",*(vet_s + i));
            }
            
            ////sorting delle stringhe
            qsort (vet_s, n , sizeof(void *) , compara_stringhe);
            
            // stampa delle stringhe
            printf ("\nStringhe ordinate : \n\n");
            for(i=0;i<n;i++){
                                
                printf ("%s\n",*(vet_s + i));
                /////////////////// libero le allocazioni delle singole stringhe
                free(*(vet_s + i));
                *(vet_s + i)=NULL;
            }
            //////////////////// libero l'allocazione degli n elementi
            free(vet_s);
            vet_s=NULL;
            
        }
        
    }

    return 0;
}

main header

PHP Code:


int compara_stringhe ( const void * a, const void * b);

function

PHP Code:


/*
 *
 * Funzione di comparazione stringhe
 *
 * Closed
 */

int compara_stringhe ( const void * a, const void * b){
    
    char ** str1 = ( char **) a;
    char ** str2 = ( char **) b;
    int i , diff;
    ///////////////////////////////////// controllo le stringhe ed esco solo se trovo un tappo
    for (i=0; *(*(str1) + i)!= 0 && *(*(str2) + i)!= 0  ;i++){
        diff = *(*(str1) + i) - *(*(str2) + i);
        if (diff != 0){
            return diff;
        }
    }
    ///////////////////////////////////rieffettuo la differenza e restituisco
    diff = *(*(str1) + i) - *(*(str2) + i);
    return diff;  
    
}

lista di matrici per la soluzione al problema di di stasi [non funziona]

Broke31 — Wed, 28 Nov 2012 17:41:54 GMT

salve ragazzi ho pensato che una possibile soluzione al problema della stampa di tutti i dati anagrafici dei ragazzi di una classe la si potesse risolvere con una lista(argomento non trattato ancora all'uni) ma qualcosina mi sfugge ancora vi posto il sorgente credo sia la miglior soluzione perch� non mi vincolerebbe in nessuna maniera dal farla crescere in maniera vertiginosa ecco tutto per voi:

PHP Code:


#include 
#include 
#include 
struct studenti
{  char *nome;
    char *cognome;
    char matricola[15];
    struct studenti*next;
};


void stampa(struct studenti*);
void inserisci(struct studenti*);
int main()
{   int scelta;
    struct studenti *alunni ;
  
    alunni=(struct studenti*)malloc(sizeof(struct studenti));
    
      alunni->next=NULL;
    do{
    printf(" _________________________\n");
    printf("|1: inserisci i dati------|\n");
    printf("|2: stampa----------------|\n");
    printf("|3: exit------------------|\n");
    printf("|-------------------------|\n");
    scanf("%d",&scelta);
    
    
    if(scelta==1)
    {
        inserisci(alunni);
    
    }
          if(scelta==2)
        
        {
        stampa(alunni);
    
        }
    
    
    
    }while(scelta!=3);
    
    alunni=NULL;
    
    return 0;
}



void inserisci(struct studenti *alunno)
{

    char *nome,*cognome,*matricola;
    
    cognome=nome=matricola=(char*)malloc(4);
        
    while(alunno->next!=NULL){
    
        alunno=alunno->next;  // vado avanti nella lista fino a che non trovo l'ultimo
    
    
    }
        printf("inserisci un nome\n");
    scanf("%s",nome);
    
    alunno->nome=(char*)malloc(strlen(nome+1)*sizeof(char*));// prendo memoria lo stretto indispensabile
    strcpy(alunno->nome,nome);// copia del dato nella struttura
    
    printf("inserisci il cognome\n");
    scanf("%s",cognome);
    alunno->cognome=(char*)malloc(strlen(cognome+1)*sizeof(char*));
    strcpy(alunno->cognome,cognome);
    
    
    printf("inserisci la matricola\n");
    scanf("%s",matricola);
    alunno->matricola[0]=*(char*)malloc(strlen(matricola+1)*sizeof(char*));
    strcpy(alunno->matricola,matricola);
    
    

}

void stampa(struct studenti *alunno){
    while(alunno->next!=NULL){  // scorro fino all'ultimo elemento e mentre lo faccio stampo
    printf("_________________________________\n");
    puts(alunno->nome);
    puts(alunno->cognome);
    puts(alunno->matricola);
    printf("_________________________________\n");
        alunno=alunno->next;
    }

}

buon divertimento!!

Allocazione Spazio per Matrice Dynamica

xgiovio — Tue, 27 Nov 2012 23:24:42 GMT

PHP Code:


/*
 *
 *  Matrice Dinamica / only space allocation
 *
 *
 */

#include 
#include 

 int main ( void){
    
    int **vet;
    unsigned int r,c;
    int i;
    
    printf("Numero righe\n");
    scanf("%u",&r);
    vet= (int**) malloc ( r * sizeof(int *));
    printf("Numero colonne\n");
    scanf("%u",&c);    
    
    for (i=0;i<r;i++){
        
        *(vet + i) = ( int *) malloc ( c * sizeof(int));
    }
    
    return 0;
 }

Array Stringhe e Stampa di sole vocali ( Senator Style )

xgiovio — Tue, 27 Nov 2012 22:35:30 GMT

PHP Code:


/*
*
*array w di puntatori a stringhe.
*definire una funzione con il seguente prototipo char * getVocali (chat * ).
*prende come parametro il puntatore alla stringa s e
*restituisce un puntatore a una nuova stringa composta da solo le vocali
*in s al vettore originario
*applicate tale funzione a ogni elemento array
*
*/

PHP Code:



#include 
#include 
#include 

#define INPUT 100
#define INPUT_S "99"

char * getvocali (char * a); // prototype

int main(void){

unsigned int n;
char ** vet_s; // vet a char
char buf[INPUT]; // buffer temporaneo
int i; // indice

////////////////////////////////////////////////////////// numero stringhe
printf("Numero elementi:\n");
scanf("%u",&n);
vet_s = (char **) malloc ( n * sizeof(char *));
////////////////////////////////////////////////////// inserimento dati
for (i=0;i<n;i++){

printf("Inserire la %d stringa\n",i+1);
scanf("%" INPUT_S "s",buf);
*(vet_s + i) =strdup(buf);
}
////////////////////////////////////////////////////// fine inserimento dati


////////////////////////////////////////////////////// stampa dati
printf("\nStringhe inserite:\n");
for(i=0;i<n;i++){
printf("%s\n",*(vet_s + i));
}

////////////////////////////////////////////////////// chiamata a getvocali
for (i=0;i<n;i++){
*(vet_s + i) = getvocali (*(vet_s + i));
}

////////////////////////////////////////////////////// stampa stringhe e free dei dati
printf("\nStringhe con solo le vocali:\n");
for(i=0;i<n;i++){
printf("%s\n",*(vet_s + i));
free(*(vet_s + i));
}
free(vet_s);

return 0;

}

char * getvocali (char * a){

int i; // indice
int j=-1; // indice vocali
char buffer[INPUT]; // buffer

////////////////////////////////////////////////////// verifica presenza vocali e inserimento tappi
for(i=0;*(a+i)!=0;i++){

if(*(a+i)=='a' || *(a+i)=='e' || *(a+i)=='i' || *(a+i)=='o' || *(a+i)=='u'){

j++;
*(buffer + j) = *(a+i);

}

}

*(buffer + j + 1) = 0;
////////////////////////////////////////////////////// free dei vecchi dati prima di restituire e perdere il puntatore
free(a);
return strdup (buffer);
}

Il pc sceglie un numero e voi lo dovete indovinare

xgiovio — Tue, 27 Nov 2012 18:48:27 GMT

PHP Code:


#include 
#include 



int main (void){
    
    int n;
    int scelta;
    int i=0;
    
    srand(time(NULL));
    n=rand()%1000;
    printf("Indovina il numero tra 0 e 1000\n");
    scanf("%d",&scelta);
    i++;
    for (;scelta != n;){
        if (scelta<n){
            printf ("Scegli un numero piu grande\n");
            scanf("%d",&scelta);
            i++;
        }else{
            printf ("Scegli un numero piu piccolo\n");
            scanf("%d",&scelta);
            i++;
        }
        
    }
    printf ("Bravo! Hai impiegato %d tentativi\n",i);
    return 0;
}

Il pc che indovina un numero tra 0 e 1000 - Voi lo pensate soltanto

xgiovio — Tue, 27 Nov 2012 18:47:24 GMT

PHP Code:


#include 
#include 



int main (void){
    
    int scelta;
    int sugg;
    int i=0;
    int min = 0;
    int max = 1000;
    int calc;
    
    printf("Pensa un numero tra 0 e 1000\n");
    srand(time(NULL));
    scelta= rand()%1000;
    i++;
    printf("E' per caso %d ?\n",scelta);
    printf("1 se pi� piccolo\n");
    printf("2 se ho fatto centro\n");
    printf("3 se pi� grande\n");
    scanf("%d",&sugg);
    for (;sugg != 2;){
        if (sugg==1){
            max=scelta;
            srand(time(NULL));
            calc=(scelta-2)-min;
            if (calc == 0){
                calc=1;
            }
            scelta= (rand()%calc)+min+1;
            printf("E' per caso %d ?\n",scelta);
            scanf("%d",&sugg);
            i++;
        }else{
            min=scelta;
            srand(time(NULL));
            calc=(max-2)-scelta;
            if (calc == 0){
                calc=1;
            }
            scelta= (rand()% calc)+scelta+1;
            printf("E' per caso %d ?\n",scelta);
            scanf("%d",&sugg);
            i++;
        }
        
    }
    printf ("Aleee! Ho impiegato %d tentativi\n",i);
    return 0;
}

Tab to Spaces

xgiovio — Tue, 27 Nov 2012 17:04:39 GMT

Prima versione, sembra essere funzionante.

PHP Code:


/*
 *
 * Tab to Spaces
 *
 *
 */

#include 

int main ( void ) {
    
    char c;
    int i,j,k;
    
    
    c= fgetc(stdin);
    
        for (i=0;c!=EOF;i++){  // condizione di uscita
            
            if (c == '\t'){ //se il carattere � tab
                
                j=8-(i%8); // modulo rispetto all'indice
                
                for (k=0;k<j;k++){
                    
                    fputc(32,stdout); // stampa degli spazi
                    i++;
                    
                }
                i--;
                
                if (c==10){ // verifica se bisgona resettare tutto
                    i=-1;
                }
                
                c= fgetc(stdin); // richiesta nuovo carattere
                
            }else{
                
                fputc(c,stdout); // stampa carattare non tab
                
                
                if (c==10){ // verifica condizione di reset
                    i=-1;
                }
                
                c= fgetc(stdin); // richiesta di nuovo carattere
            }
    
        }
 
    return 0;  
}

Qsort - Array Dinamico - Error Control

xgiovio — Sun, 25 Nov 2012 19:34:09 GMT

PHP Code:


/*
 *
 * Qsort
 *
 * Require: compara_stringhe_c.o
 *
 */

#include 
#include 
#include 


#define MAX_NUM "20" // numero cifre di input
#define MAX_INPUT_S "99" // lunghezza massima stringa input per vettore buffer
#define MAX_INPUT 100 // grande vettore buffer

int compara_stringhe ( const void * a, const void * b){

    char ** str1=(char **)a;
    char ** str2=(char **)b;
    return strcmp(*str1,*str2);

}

int main (void) {
    
    int n; // numero elementi
    int i,j; // contatore di appoggio
    char **vet_s; // base_address dei char *
    char array [MAX_INPUT]; // buffer di chars
    char * p_temp; // puntatore temp  a char
    
    ///////////////////////////////////////////////// grandezza array
    printf("Numero di stringhe da inserire\n");
    scanf("%"MAX_NUM"d",&n);
    
    for(;n<0;){
        printf("Mi prendi in giro? Inserisci un numero intero positivo\n");
        scanf("%"MAX_NUM"d",&n);
    }
    
    ///////////////////////////////// inizio trattamento dati
    if (n==0){
        
        printf("Lei � un betatester pigro\n");
        
    }else{
        //////////////////////////// allocazioni spazio per gli n elementi
        vet_s= (char **)malloc (n * sizeof(void *));
        ////////////////////////// verifica spazio sufficiente
        if (vet_s == NULL) {
            
            printf("Spazio disponibile non sufficiente per l'allocazione\n");
        }else{
            
            for (i=0;i<n;i++){
                ////////////////////////// input stringa
                printf("Inserire la %d stringa :\n",i+1);
                scanf("%" MAX_INPUT_S "s",array);
                
                ///////////////////////// conteggio stringa
                for (j=0; (j!=MAX_INPUT)  && (array[j]!=0) ;j++){
                }
                ////////////////////////////verifica della presenza del tappo
                if (j==MAX_INPUT){
                    
                    printf ("La stringa in input non � formattata correttamente");
                    array[j-1]=0;
                    j--;
                    
                }
                
                ///////////////////////////////// alloco lo spazio per la stringa
                p_temp = ( char *) malloc ((j+1) * sizeof(char *));
                
                if( p_temp == NULL){
                    
                    printf("Spazio disponibile non sufficiente per l'allocazione\n");
                    exit(-1);
                    
                }
                
                
                /////////////////////////////// trasferisco i valori
                for (j=0; array[j]!=0 ;j++){
                    
                    *(p_temp + j) = array [j];
                    
                }
                *(p_temp + j) = array [j]; // aggiungo il tappo
                
                *(vet_s + i) = p_temp;
                
            }
            
            ////////////// fine inserimento valori /////
            
            ////////////stampo stringhe inserite
            printf ("\nStringhe inserite : \n\n");
            
            for(i=0;i<n;i++){
                                
                printf ("%s\n",*(vet_s + i));
            }
            
            ////sorting delle stringhe
            qsort (vet_s, n , sizeof(void *) , compara_stringhe);
            
            // stampa delle stringhe
            printf ("\nStringhe ordinate : \n\n");
            for(i=0;i<n;i++){
                                
                printf ("%s\n",*(vet_s + i));
                /////////////////// libero le allocazioni delle singole stringhe
                free(*(vet_s + i));
                *(vet_s + i)=NULL;
            }
            //////////////////// libero l'allocazione degli n elementi
            free(vet_s);
            vet_s=NULL;
            
        }
        
    }

    return 0;
}

Sostituzione spazio ai tab :d (non funzionante)

TheAvenger — Sun, 25 Nov 2012 17:05:58 GMT

Vi ricordo che il nome del file � "string.txt"

PHP Code:


#include 
#include 
#include 
#define dim 100
main()
{
FILE * pFile;
int c; //carattere assunto dalla funzione fgetc
char vet[dim]; //vettore che conterr� la stringa
int mod; //mod /tabulazione
int a;
int i=0;int j=0;//INDICI

for(i=0;i<dim;i++)
{
vet[i] = ' ';
}
i=0;
  pFile=fopen ("stringa.txt","r"); //apertura file
  if (pFile==NULL) {
perror ("Error opening file"); //controllo file :)
} // FINE OPERAZIONI APERTURA FILE

  else  {
printf("Il contenuto del file e': ");
do{
c = fgetc (pFile);//assunzione del carattere attraverso la funzione fgetc
vet[i] = c; //assegna a vet[i] c
printf("%c",c); //STAMPA CARATTERE PER CARATTERE
mod=i%4;

if(vet[i] == '\t')
{
for(j=0;j!=(4-mod)+1;j++)
{
vet[i] = ' '; //vettore risultato :D
i++;
}//fine for

}//fine if

i++;
}while (c != EOF); //FINE CICLO

fclose (pFile); //CHIUSURA FILE
printf("seconda parte\n");
printf("il contenuto del file e': ");
i=0;
while(vet[i] != EOF)
{
printf("%c",vet[i]);
i++;
}
   }//chiusura else :)
printf("\n");

  return 0;
}

ricerca con sentinella

Broke31 — Sun, 25 Nov 2012 16:50:41 GMT

raga questo � il mio algoritmo della ricerca con sentinella ecco a voi:

PHP Code:


//ricerca con sentinella
#include 
int ricerca(int[],int,int);
void acquis(int[],int);



int main()
{
    int vet[10],size,mister_x,ris;
    
    
    size=10;
    
    acquis(vet,size-1);// la ricerca con sentinella riempio fino a size -1 e in posizione size ho la sentinella
    
        printf("inserisci il numero da cercare\n");
        scanf("%d",&mister_x);
    
    ris=ricerca(vet,size,mister_x);
    
                if(ris<0)
                {
        
                    printf("elemento non trovato\n");
    
                }
    
    
    
                            else
                                printf("numero presente in posizione %d\n",ris);
    
      
    


    return 0;
}

void acquis(int vet[],int size){

    int *p_vet,i=0;
    
    
    p_vet=vet;
    
    for(i=0;i<=size;i++){
    
        printf("inserisci l'elemento %d\n",i);
        scanf("%d",(p_vet+i));
    
    
    }
}







int ricerca(int vet[],int size,int sei_davvero_tu){

    int i;
    
    
    vet[size]=sei_davvero_tu;// piazzo la sentinella
    
    
    for(i=0;i<size;i++){
    if(vet[i]==sei_davvero_tu)
        return i+1;//ho trovato l'elemento e lo restituisco
    
    }
    
    
    return -1; // non c'� l'elemento :-(

}

Vettore Dinamico con Stringhe

xgiovio — Sun, 25 Nov 2012 11:15:14 GMT

PHP Code:


/*
 *
 * Allocazione dinamica di stringhe in un vettore dinamico
 *
 */
#include 
#include 
#define BUFF_SIZE 100
#define BUFF_SIZE_S "99"

int main (void) {
    
    int n,i,j;
    char * p_temp;
    char ** vet;
    char vet_char[BUFF_SIZE];
    
/////////////////////////////////////////////////// contiamo gli elmenti e allochiamo spazio
    printf("Numero elementi array :\n");
    scanf("%d",&n);
    vet = (char **) malloc (n * sizeof(void *));
    
    for(i=0;i<n;i++){
        ////////////////////////////////////////////inseriamo la stringa nel buffer
        printf ("Inserire la %d stringa :\n",i+1);
        scanf("%" BUFF_SIZE_S "s",vet_char);
        ///////////////////////////////////////////// determino lunghezza stringa buffer
        for (j=0;vet_char[j]!=0;j++){
        }
        ///////////////////////////////////////////// alloco lo spazio necessario per cp in memoria
        p_temp= (char *) malloc ( (i+1) * sizeof(char));
        //////////////////////////////////////////// copia in corso
        for (j=0;vet_char[j]!=0;j++){
            *(p_temp + j) = vet_char[j];
        }
        *(p_temp + j) = vet_char[j];
        //////////////////////////////////////////link del puntatore vet alla stringa allocata
        *(vet+i)=p_temp;
        
    }
    
    printf("Stringhe inserite :\n");
    if (n==0){
        printf("Nessun dato inserito\n");
    }else{
        for(i=0;i<n;i++){
        printf("%s\n",*(vet+i));
        }
    }
        
    return 0;
}

Macro Expanded - temp solution

xgiovio — Sun, 25 Nov 2012 10:41:56 GMT

PHP Code:


/*
 *
 * You loved me and i frozen time
 *
 * Soluzione temporanea finch� non capisco per bene le macro
 *
 */

#include 
#include 
#define BUFF_SIZE_S "100"
#define BUFF_SIZE 100
int main (void) {
    
    char array[BUFF_SIZE];
    
printf("x" BUFF_SIZE_S "x");
    
    return 0;
}

Input Stringhe E Malloc

xgiovio — Sat, 24 Nov 2012 10:58:44 GMT

PHP Code:


#include 
#include 


int main (void) {
    
    int i,j;
    char array [100] ;
    char *vet_s[5];
    char *punt;
    
    for (j=0;j<5;j++){
    
        scanf("%99s",array); // stringhe input
        
        for (i=0;*(array +i)!=0;i++){ // conteggio caratteri stringa compreso 0
        }
        
        punt= (char * ) malloc ((i+1)*sizeof(char)); // allocazione spazio per la stringa
        
        for (i=0;*(array +i)!=0;i++){ // copia da buffer ad allocazione
            *(punt + i)= *(array +i);
        }
        *(punt + i)= *(array +i);
        
        *(vet_s + j)= punt; // array di stringhe di j punta alla string in input
    }
    
    printf("Stampa valori inseriti\n");
    
    for(i=0;i<5;i++){
        printf("%s\n",*(vet_s + i));
    }

    return 0;
}

90 numeri senza ripetizione - Supporto con Array

xgiovio — Sat, 24 Nov 2012 09:36:23 GMT

PHP Code:


/*
*
* Premettendo che questo algoritmo � applicabile solo per *piccoli range di interi, non mi piace!
*
*/

#include 
#include 


int main ( void ) {

    int vet[90]; // creazione array da 90
    int i;
    int index;
    int temp;
    int num;
    
    for (i=0;i<90;i++){ // arrey rimepito di num da 1 a 90
        vet[i]=i+1;
    }
    
    for (i=0;i<90;i++){
        index=(rand() % (90-i)); // calcolo numero tra 90 - i
        num= vet[index]; // identificazione indice vet
        printf("Numero uscito %d\n",num); // stampa num vet[i]
        temp=vet[89-i]; // salvataggio last num vet
        vet[89 - i] =num; // swap dei due
        vet[index]=temp;
    }
    
    
}

Stringa piu lunga

xgiovio — Mon, 19 Nov 2012 00:15:50 GMT

Passare alla funzione due stringhe e l'indirizzo di un puntatore.

PHP Code:


/*
 * nella funzione chiamante, fa puntare p alla stringa pi� corta
 *
 */


#include 
#include 

  void longest_string ( char * a, char *b, char **p){
    if (a==NULL || b==NULL){
        printf ("Invalid strings\n");
        exit(-1);
    }
    char * o_a = a;
    char * o_b = b;
    
    for (;*a!=0 && *b!=0;a++,b++){
    }
    if (*a>*b){
        *p=o_b;
    }else{
        *p=o_a;
    }
}

String Compare + Main

xgiovio — Sun, 18 Nov 2012 14:58:26 GMT

ecco una versione di string compare con controllo sui puntatori nulli

PHP Code:


/*
 * Qual � il parassita pi� resistente? Un batterio? Un virus? Una tenia intestinale?
 * Un'idea
 *
 *ps _ algoritmo di comparazione stringhe + main
 */

#include 

int string_compare (char a[],char b[]);


int main (void){
    char a[]="ciao";
    char b[]="gio";
    printf("%d\n",string_compare(a,b));

    return 0;
}

int string_compare (char a[],char b[]){
    if (a==NULL || b==NULL) {
        return 0;
    }
    for (;*a!=0 && *b!=0;a++,b++){
        if ((*a-*b)!=0){
            return (*a-*b);
        }
    }
    return (*a-*b);
}

Stampare elementi pari e dispari di un vettore - Arit Punt

xgiovio — Sun, 18 Nov 2012 14:28:53 GMT

Ecco due versioni, la prima usando puntatori e indici, la seconda sfruttando pienaemnte l'aritmetica dei puntatori

PHP Code:


/*
 * Un anelli per domarli
 * Un anello per trovarli
 * un anello per ghermirli
 * e nell'oscurit� .. incatenarli
 *
 * ps questo programma stampa i numeri pari e dispari in un array
 *
 */

#include 

void print_p( int vet[], int size);
void print_d( int vet[], int size);

int main(void){
    int vet[7] ={1,2,3,4,5,6,7};
    
    print_p(vet,7);
    print_d(vet,7);
    
    return 0;
}

void print_p( int vet[], int size){
    int i;
    
    for (i=0;i<size;i++){
        if ((*(vet+i))%2==0){
            printf("%d ",*(vet+i));
        }
    }
    printf("\n");
}

void print_d( int vet[], int size){
    int i;
    
    for (i=0;i<size;i++){
        if ((*(vet+i))%2!=0){
            printf("%d ",*(vet+i));
        }
    }
    printf("\n");
}

PHP Code:


/*
 * Un sogno nel sogno
 *
 *ps questo algoritmo stampa i numeri pari e dispari sfruttando l'artimetica dei puntatori
 */


#include 

void print_p( int vet[], int size);
void print_d( int vet[], int size);

int main(void){
    int vet[7] ={1,2,3,4,5,6,7};
    
    print_p(vet,7);
    print_d(vet,7);
    
    return 0;
}

void print_p( int vet[], int size){
    int *init=vet;
    
    for (;vet-init<size;vet++){
        if ((*vet)%2==0){
            printf("%d ",*vet);
        }
    }
    printf("\n");
}

void print_d( int vet[], int size){
    int *init=vet;
    
    for (;vet-init<size;vet++){
        if ((*vet)%2!=0){
            printf("%d ",*vet);
        }
    }
    printf("\n");
}

creare uno stack

Broke31 — Fri, 16 Nov 2012 18:32:48 GMT

questo � il mio codice per la creazione di uno stack( si parla di strtture argomento ancora non trattato all'uni) vi posto il codice e vi avviso che NON FUNZIONA quindi chiunque voglia vederlo e "aggiustarlo"
� gradito

alcuni dettagli il top indica l'ultimo elemento inserito non la prima locazione dove inserire

PHP Code:




#include 

struct stack
{
    int vet[10];                                  
    int top;
};

void  inizializza(struct stack*);
int pop(struct stack*);
void push(struct stack*, int);
void stampa(struct stack*);
int contr(struct stack*);

int main()
{
    struct stack *stack1=NULL;// Per annullare eventuali worring
    int scelta, elemento, controllo;
    
    inizializza(stack1); //inizializza il top a 0;
    
    do
    {
        printf("1:inserisci elemento\n");
        printf("2:preleva elemento\n");
        printf("3:stampa elemento\n");
        printf("4: esci\n");
        
        scanf("%d",&scelta);
    
        switch(scelta)
        {
            case 1:
                controllo = contr(stack1);
                if(controllo)                // se il top � minore di 10 posso inserire!
                {
                    printf("Inserisci l'elemento: ");
                    scanf("%d", &elemento);
                    push(stack1,elemento);
                }
                else
                    printf("error\n");        //top >=10   non posso inserire :-(
                break;
                        
            case 2:
                if(!controllo)                            //se top � maggiore di 0 posso prelevare !
                {
                    elemento = pop(stack1);
                    printf("%d",elemento);
                }
                else                                // � impossibile prelevare con top =0   !
                    printf("error\n");
                break;
                        
            case 3:
                if(controllo)                     //qui mi basta sapere che ho 1 elemento nel mio stack se � cos� posso stamparlo
                    stampa(stack1);
                else
                    printf("stack vuoto\n");
                break;
                        
            case 4:
                printf("arrivederci\n");
                break;
                        
            default:
                printf("error");
        }
    } while (scelta != 4);
    
    return 0;
}

void inizializza(struct stack *stack1)
{
    stack1->top=0;      // Metto nella parte della struttura top puntata dalla variabile stack 0 questo per far partire lo stack da 1 situazione pulita
}

int pop(struct stack *stack1)
{                                                    
    int x;
  
    x = stack1->vet[stack1->top]; //inserisci in x il valore ottenuto da vet[top] sintatticamente va                            
                                                                scritto cos�  
  
    stack1->top--;     //ho prelevato decremento il top!
    
    return x;
}

void push(struct stack *stack1,int x)//devo inserire un valore nuovo
{
    stack1->top++;//faccio spazio aumentando di 1 il top
    stack1->vet[stack1->top] = x;// mi copio il valore nella locazione

}


void stampa(struct stack *stack1)
{
    int i;

    for(i = 0; i < stack1->top; i++)
    {
        printf("%d", stack1->vet[stack1->top]);//stampa alemento indicato dal top
    }
}

int contr(struct stack *stack1)
{
    if(stack1->top >=9)// occorre studiare come si comporta quando viene chiamato nei casi limiti con    
                                   top ==0 e con top =-=9
        return 0;
    else
        return 1;
}

creare una matrice

Broke31 — Thu, 15 Nov 2012 16:24:49 GMT

questo � il mio sorgente sulla creazione della matrice ve lo posto:

PHP Code:


#include 
int flag;//variabile che viene controllata non consente la stampa se non si inizializza o si aquisisce una matrice altenatva a diciararla globale passarla come parametro sempre!
void acquis(int[5][5],int,int,int);
void inizializza(int[5][5],int,int,int);
void stampa(int[5][5],int,int,int);

int main(int argc, const char * argv[])
{
       int mat[5][5],scelta,size;
       int i,j;
    
    
    flag=0;
    size=5;
    i=j=0;
    do
   {
        
        printf("1:inizializza.\n");
        printf("2:acquisisci.\n");
        printf("3:stampa.\n");
        printf("4:esci\n");
        scanf("%d",&scelta);
        switch(scelta)
      {
                
            case 1: inizializza(mat, i, j,size);
                break;
            case 2:  acquis(mat, i, j,size);
                break;
            case 3: stampa(mat,i,j,size);
                break;
                
            case 4: printf("arrivederci\n");
            default: printf("scelta errata\n");
                
                
        }
    }while(scelta!=4);
    
    
    return 0;
}



void acquis(int mat[5][5],int i,int j,int size){
    flag=1;
    for(i=0;i<size;i++){
        for(j=0;j<size;j++){
            printf("inserisci l'elemento(%d,%d)\n",i,j);
            scanf("%d ",&mat[i][j]);
        }
    }
    
}


void inizializza(int mat[5][5],int i,int j,int size){
    flag=1;
    for(i=0;i<size;i++){
        for(j=0 ;j<size;j++)
            mat[i][j]=0;
    }
    
}


void stampa(int mat[5][5],int i,int j,int size){
    if(flag){// if senza condizione valuta solamente se vale vero o falso(0 o diverso da 0
    for(i=0;i<size;i++){
        
        for(j=0;j<size;j++){
            printf("%d ",mat[i][j]);
        }
        printf("\n");
    }}
        else printf("inizializza o acquisisci la matrice\n");
    
}

creazione e uso di una struttura semplice

Broke31 — Thu, 15 Nov 2012 16:13:20 GMT

salve a tutti ho creato una semplice struttura capace di immagazinare dei nomi cognomi e numeri di tel e stamparli nulla di complicato vi posto il sorgente non guardate tanto i for servivano a me come prove !!

PHP Code:


#include 
struct agenda{
    char nome[10];
    char cognome[10];
    char n_cell[10];
}agenda1[5];

int main()
{   int i,scelta,j;
    
    
    i=0;

    for( ;i<2;i++)
   {
          printf("inserisci il nome \n");
          gets((agenda1+i)->nome);

          printf("inserisci il cognome\n");
          gets((agenda1+i)->cognome);

          printf("inserisci il numero di cell \n");
          gets((agenda1+i)->n_cell);
    }
    
    for(j=0;j<3;j++)
   {
      printf("1:stampa nome.\n2:stampa cognome.\n3:stampa n_cell.\n");
      scanf("%d",&scelta);

         printf("inserisci un numero da 1 a 3n");
         scanf("%d",&i);

          (scelta==1)?puts((agenda1+(i-1))->nome):scelta; //if else abreviati

          (scelta==2)?puts((agenda1+(i-1))->cognome):scelta;

    (scelta==3)?puts((agenda1+(i-1))->n_cell):scelta;
  
   }//ultima parentesi del for



}

Lunghezza di una stringa

federicocozza — Tue, 13 Nov 2012 19:26:02 GMT

Il programma, data in input una stringa, ne restituisce la sua lunghezza.

PHP Code:


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

*

* Il programma stabilisce la lunghezza di una stringa

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include 

void lunghezza_stringa(char *stringa, int *lunghezza);

int main (void)

{
char *stringa;
int lunghezza = 0;

printf("Inserisci una stringa:");
scanf("%s", stringa);

lunghezza_stringa(stringa, &lunghezza); // Calcolo lunghezza della stringa

printf("La lunghezza della stringa inserita � uguale a %d.\n", lunghezza);

return 0;
}

void lunghezza_stringa(char *stringa, int *lunghezza)

{
int i = 0; // Contatore

while (*(stringa+i) != '\0') { // Calcolo lunghezza
i++;
}

*lunghezza = i;
}

Comparazione di due stringhe

federicocozza — Tue, 13 Nov 2012 19:22:50 GMT

Il programma compara due stringhe immesse dall'utente e verifica se esse sono uguali o meno.

PHP Code:


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
 * Il programma verifica se due stringhe sono uguali o meno
 
 *
 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 

#include 

int stringhe_uguali(char *str1, char *str2);
int main (void)

{
char str_1[20];
char str_2[20];

printf("Inserisci la prima stringa:");
scanf("%s", str_1);

printf("Inserisci la seconda stringa:");
scanf("%s", str_2);

if (stringhe_uguali(str_1, str_2)==1) {
printf("Uguali!!\n");
}

if (stringhe_uguali(str_1, str_2)==2) {
printf("Disuguali!!\n");
}
    
return 0;
}

int stringhe_uguali(char *str1, char *str2)

{
int i; // Contatore

for (i=0; *(str1+i)!='\0' || *(str2+i)!='\0'; i++) { // Comparo stringhe
if (*(str1+i)!=*(str2+i)) {  // Caratteri diversi!
return 2;
}
}

return 1;

}

Min Max Puntatori a Vettore -> Puntatori di Puntatori

xgiovio — Mon, 12 Nov 2012 20:44:13 GMT

PHP Code:


#include 
#define A 4

void min_max_vet(int a[],int size,int **min,int **max);
void riempi_vet(int vet[],int size);

int main(void){
    int a[A];
    int *pmin;
    int *pmax;
    riempi_vet(a,A);
    min_max_vet(a,A,&pmin,&pmax);
    printf("min :%d\n",*pmin);
    printf("max :%d\n",*pmax);
    return 0;
}
void min_max_vet(int a[],int size,int **min,int **max){
    int i;
    int k=0;
    int *minvet;
    int *maxvet;
    
    for (i=0;i<size;i++){
        if (k==0){
            k=1;
            minvet=a+i;
            maxvet=a+i;
        }else{
            if (a[i]<(*minvet)){
                minvet=a+i;
            }
            if (a[i]>(*maxvet)){
                maxvet=a+i;
            }
        }
    }
    *min=minvet;
    *max=maxvet;
}

void riempi_vet(int vet[],int size){
    int i;
    for (i=0;i<size;i++){
        scanf("%d",(vet+i));
    }
}

Merge Vettori con Funzione

xgiovio — Mon, 12 Nov 2012 20:43:12 GMT

PHP Code:


//dati 2 vettori a,b di interi ordinati, fare il merge di entrambi in un vettore c ordinato
#include 
#define A 5
//elementi di A
#define B 7
//elementi di B
#define C (A+B)
//elementi di C

void stampa_vet(int vettore[],int size);
void merge_vet_ord(int a[],int b[],int sizea, int sizeb, int c[], int sizec);
void riempi_vet(int a[], int sizea);
void ordina_vet (int vet[],int sizea);

int main(void){
    int a[A];
    int b[B];
    int c[C];
    printf("Dai valori interi per vettore A\n");
    riempi_vet(a,A);
    ordina_vet(a,A);
    printf("Dai valori interi per vettore B\n");
    riempi_vet(b,B);
    ordina_vet(b,B);
    merge_vet_ord(a,b,A,B,c,C);
    stampa_vet(c,C);
    return 0;
}

void merge_vet_ord(int a[],int b[],int sizea, int sizeb, int c[], int sizec){
    int *p;
    int *p1;
    int sizep;
    int sizep1;
    int i,j,k;
    
    if (a[0]<=b[0]){
        sizep1= sizea-1;
        sizep=sizeb;
        c[0]=a[0];
        p=b;
        p1=a;
    }else{
        sizep1=sizeb-1;
        sizep=sizea;
        c[0]=b[0];
        p=a;
        p1=b;
    }
    k=0;
    j=0;
    for(i=0;(i<sizep1) && (k<(sizec-1));i++){
        for(;(p[j]<=p1[i+1]) && (j<sizep) && (k<(sizec-1));j++){
                k++;
                c[k]=p[j];
        }
        if (k<(sizec-1)){
            k++;
            c[k]=p1[i+1];
        }else{
            break;
        }
    }
    for(;(j<sizep) && (k<(sizec-1));j++){
        k++;
        c[k]=p[j];
    }
}

void stampa_vet(int vettore[],int size){
    int i;
    i=0;
    
    for(i=0;i<size;i++){
        printf("%d ",vettore[i]);
    }
    printf("\n");
}

void riempi_vet(int a[], int sizea){
    int i;
    for (i=0;i<sizea;i++){
        scanf("%d",a+i);
    }
}

void ordina_vet (int vet[],int sizea){
    int i,c,temp;
    for (i=0;i<(sizea-1);i++){
        for (c=(i+1);c<sizea;c++){
            if (vet[i]>vet[c]){
                temp=vet[i];
                vet[i]=vet[c];
                vet[c]=temp;
            }
        }
    }
}

Inizializzazione mesh x,y,z,n - Primo test con strutture e typedef

xgiovio — Sun, 11 Nov 2012 12:32:15 GMT

considero la crazione di un array di tipo struct, composto da 4 variabili intere, le prime tre per coordinate in uno spazio tridimensionale, la quarta per l'indice.
Ogni elemento dell'array rappresenta un punto della mesh nello spazio.

PHP Code:


#include 
#define MESH_SIZE 100
typedef struct punti_mesh{
        int x; //coordinata x
        int y; //coordianta y
        int z; //coordianta z
        int n; //indice del punto
    }mesh_point;

void init_mesh(mesh_point a[],int size_mesh);

int main (void){
    mesh_point mesh[MESH_SIZE]; // definiamo una mesh di tipo struct punti_mesh grande mesh_size
    init_mesh(mesh,MESH_SIZE); // inizializziamo una mesh
    return 0;
}

void init_mesh(mesh_point a[],int size_mesh){
    int i;
    for (i=0; i<size_mesh; i++){
        a[i].x=0;
        a[i].y=0;
        a[i].z=0;
        a[i].n=i;
    }
}

Fibonacci - Lineare e Procedurale ricorsivo

xgiovio — Sat, 03 Nov 2012 20:07:10 GMT

Il Lineare � nettamente pi� veloce. Poco spazio in memoria occupato e stack ridotto.
Lineare

PHP Code:


#include 
int main(void){
    int i,n;
    long int a,b,c;
    
    a=0;
    b=1;
    printf("Dare Numero di Fibonacci\n");
    scanf("%d",&n);
    if (n==0){
        printf("0\n");
    }else{
        if (n==1){
            printf("1\n");
        }else{
            for (i=2;i<=n;i++){
                c=a+b;
                a=b;
                b=c;
            }
            printf ("%lu\n",c);
        }
    }
    return 0;
}

Ricorsivo

PHP Code:


#include 
long int fib(int n);
int main(void){
    int n;
    
    printf("Dare Numero di Fibonacci\n");
    scanf("%d",&n);
    printf("%lu\n",(fib(n)));
    return 0;
}
long int fib(int n){
    if (n==0){
        return 0;
    }else{
        if (n==1){
            return 1;
        }else{
            return (fib(n-1)+fib(n-2));
        }
    }
}

Numeri Primi - Fast Alpha

xgiovio — Sat, 03 Nov 2012 20:04:46 GMT

Algoritmo in loop per trovare i numeri primi. Si testano i numeri fino alla radice del numero preso in esame e se un numero non � divisibile per 2, i fattori pari non vengono testati

PHP Code:


#include 
void main(void){
    int n,a,p,i;
    n=4;
    
    while(1){
        a=1;
        p=0;
        for (i=2;(i*i)<=n;i+=a){
            if ((n%i)==0){
                    p=1;
                    break;
            }else{
                if (i==2){
                    i--;
                    a=2;
                }
            }
        }
        if (p==0){
            printf("%d\n",n);
        }
    n++;
    }
}

Scomposizione in fattori primi

xgiovio — Thu, 11 Oct 2012 22:39:39 GMT

Il seguente codice, permette di ottenere la scomposizione in fattori primi di un numero intero dato in input.
I numeri vengono testati fino alla met� del numero sorgente, soglia oltre la quale un numero non pu� essere divisibile interamente.
Chiaramente il codice potrebbe essere ottimizzato per evitare calcoli inutili, per ora quindi siamo in una versione iniziale.

PHP Code:


//testing c#include 
int main(void){
    int n,norig,a,k;
    printf("Dammi un numero intero positivo\n");
    scanf("%d",&n);
    norig=n;
    printf("Numero originale: %d\n",norig);
    a=1;
    k=0;
    while (a<=(norig/2)){
        a++;
        while (n%a==0){
            if (k==0){
                printf("I fattori primi sono: ");
                k++;
            }
            printf("%d ",a);
            n=n/a;
        }
    }
    if (n==norig){
        printf("Il numero � primo\n");
    }else{
        printf("\n");        
    }
    return 0;
}

Decimale -> Binario - 2 metodi

xgiovio — Thu, 11 Oct 2012 22:34:59 GMT

Conversione decimale in binario.
Un metodo utilizza solo variabili senza alcun operatore booleano, � pi� costoso in termine di programmazione e di esecuzione ma .... funziona.
Il secondo utilizza un intero come se fosse uno stack e gli operatori booleani permettono di calcoli bit a bit

PHP Code:


#include int main (void){
    /* n � il numero originale,norig � una copia di n, a conta il numero di divisioni di n per 2 in andata,i conta le divisioni di n in ritorno
     *conoscendo a,k � un incremento associato a i per dividere n tot volte diviso 2 in ritorno.*/
    int n,norig,a,i,k;
    i=0;
    printf("Dare un numero intero positivo\n");
    scanf("%d",&n);
    while (n<=0){
        printf("Dare un numero intero positivo\n");
        scanf("%d",&n);
    }
    norig=n;
    /* inizio calcolo ultimo resto in andata in a */
    while (n!=0){
        a=n%2;
        n/=2;
        i++;
    }
    /* fine calcolo ultimo resto in andata in a */
    printf("%d",a);
    i--; // ultimo resto gi� stampato quindi tolgo una divisione
    while(i!=0){
        n=norig;
        k=0;
        while(k!=(i-1)){ // il resto � uguale al modulo del dividendo per il divisore, il dividendo � un ordine pi� grande e quindi i-1
            k++;
            n/=2;
        }
        a=n%2;
        printf("%d",a);
        i--;
    }
    printf("\n");
    return 0;
}

PHP Code:


#include int main (void){
    unsigned int a=0;
    unsigned int b=0;    
    int n,r,i,k;
    printf("Dare un numero intero positivo\n");
    scanf("%d",&n);
    while (n<=0){
        printf("Dare un numero intero positivo\n");
        scanf("%d",&n);
    }
    i=0;
    while(n!=0){
        a<<=1;
        i++;
        r=n%2;
        n/=2;
        a|=r;
    }
    k=0;
    while(k<i){
        k=k+1;
        b=a&1;
        printf("%d",b);
        a>>=1;
    }
    printf("\n");
    return 0;
}

Giovanni Di Grezia - VFX Artist Forum - C

Bitbucket Source

[os] sync 4 processes ( n ) with shared memory and mutex locking ( atomic access )

[os] Different results - Fork with and without Peterson syncronization

[os] sincronizzazione di 2 processi ( fork) usando shared memory e Peterson

[os] sezione critica tra padre e figlio ( fork ) usando shared memory

[os] sezione critica mediante file

[os] exam 2 - 3 childer - fibonacci - SIGINT handler

[os] linode - list files in a directory with inode number

Monetina falsata [giochino]

[os] read directory entries

[os] sleep emulated via alarm + pause - makefile

[os] Signal Mangement with sigaction - SINGINT ( CTRL-D ) SAMPLE

[os] Exam 1/2 - Create 2 subprocesses and wait them

[os] v2 systems calls - Covert file 1 to file 2 inverting upper/lower cases

[os] systems calls - Covert file 1 to file 2 inverting upper/lower cases

File

make test

list to vet ( reverse commented )

list -&gt; vet -&gt; qsort ( vet ) -&gt; list = vet

Matrice Dinamica - NO Realloc

AllPrefixSum - Senator Style - Es2 - Exam

Vettore puntato ordinato - Senator Exam 1

Struct Delete - Count and Scan

Lista - Conteggio Parole e Stampe senza ripetizioni

Realloc

Strutture ordinate

Qsort - Array Dinamico - Error Control - Headers- Objects - Readme

lista di matrici per la soluzione al problema di di stasi [non funziona]

Allocazione Spazio per Matrice Dynamica

Array Stringhe e Stampa di sole vocali ( Senator Style )

Il pc sceglie un numero e voi lo dovete indovinare

Il pc che indovina un numero tra 0 e 1000 - Voi lo pensate soltanto

Tab to Spaces

Qsort - Array Dinamico - Error Control

Sostituzione spazio ai tab :d (non funzionante)

ricerca con sentinella

Vettore Dinamico con Stringhe

Macro Expanded - temp solution

Input Stringhe E Malloc

90 numeri senza ripetizione - Supporto con Array

Stringa piu lunga

String Compare + Main

Stampare elementi pari e dispari di un vettore - Arit Punt

creare uno stack

creare una matrice

creazione e uso di una struttura semplice

Lunghezza di una stringa

Comparazione di due stringhe

Min Max Puntatori a Vettore -&gt; Puntatori di Puntatori

Merge Vettori con Funzione

Inizializzazione mesh x,y,z,n - Primo test con strutture e typedef

Fibonacci - Lineare e Procedurale ricorsivo

Numeri Primi - Fast Alpha

Scomposizione in fattori primi

Decimale -&gt; Binario - 2 metodi

list -> vet -> qsort ( vet ) -> list = vet

Min Max Puntatori a Vettore -> Puntatori di Puntatori

Decimale -> Binario - 2 metodi