Publico i miei svolgimenti di alcuni esami di programmazione da 9cfu del corso di ingegneria informatica di Palermo sperando che siano utili a qualcuno.

Le implementazioni sono tutte in C++ ANSI, l’ambiente di sviluppo usato e Dev-Cpp (non perché mi piacesse…semplicemente era l’IDE che avrei usato durante l’esame e quindi era bene che mi abituassi alle sue stranezze, adesso è un ambiente passabile ma la versione 4 che usavo era orrenda). inoltre uso il più possibile le STL (il mio corso non prevedeva la scrittura di strutture di dati)

Tipicamente nei compiti uso un file main, un file di header con tutti i prototipi e un file cpp con tutte le implementazioni, genericamente non è una buona idea ma per cose così piccole è inutile fare le cose in maniera scalabile

Testo del compito

PROGRAMMAZIONE (9 CFU)
SIMULAZIONE DI UNA BATTUTA DI CACCIA.
Scrivete un programma per la simulazione di una battuta di caccia in base alle specifiche sotto riportate.
La battuta di caccia si svolge in una riserva, che per semplicità si suppone quadrata e di dimensione 3000×3000, nella quale sono presenti 50 lepri e 10 cinghiali inizialmente disposti in posizione casuale e con direzione di moto casuale.
I cinghiali si muovono in linea retta con velocità costante di 2,5 m/s fino a quando non raggiungono il confine della riserva; in questo ultimo caso cambiano direzione in maniera casuale.
Le lepri si muovono a intermittenza. Si muovono in linea retta con velocità di 4m/s e direzione casuale per 5 secondi, poi stanno fermi per cinque secondi, poi si muovono per altri 5 secondi con una nuova direzione casuale e così via.
Nella riserva sono anche presenti 3 cacciatori che vengono inizializzati in posizione casuale e non si muovono durante la simulazione. Quando un animale si trova a distanza inferiore a 25 m da un cacciatore viene catturato.
Alla fine della battuta di caccia (dopo 7200 secondi) stampate il numero di cinghiali e di lepri catturate da ciascun cacciatore.

Diagramma UML della mia soluzione

Diagramma UML, (clicca per lo zoom)

Codice della soluzione

Header (caccia.h)

#ifndef CACCIA
#define CACCIA
#include <iostream>
#include <string>
#include <list>
using namespace std;
class point{public:
       int riga;
       int colonna;
       point();
       point(int r,int c){riga=r;colonna=c;};
       string ToString();
};

class Animale{public:
      Animale(string nome,float veocita);
      Animale(string nome,point posizione,float angolazione,float velocita){
                     this->nome=nome;this->velocita=velocita;
                     this->posizione=posizione;this->angolazione=angolazione;
                     };
      string nome;
      virtual point muovi(long tempo)=0;
      point posizione;
      float angolazione;
      float velocita;
};

class Lepre:public Animale{public:
      Lepre():Animale("Lepre",4.0f){};
      Lepre(point posizione,float angolazione):
                  Animale("Lepre",posizione,angolazione,4.0f){
                  this->posizione=posizione;
                  this->angolazione=angolazione;
                  };
      virtual point muovi(long tempo);
};

class Cinghiale:public Animale{public:
      Cinghiale():Animale("Cinghiale",2.5){};
      Cinghiale(point posizione,float angolazione):
                  Animale("Cinghiale",posizione,angolazione,2.5){
                  this->posizione=posizione;
                  this->angolazione=angolazione;
                  };
      virtual point muovi(long tempo);
};

class Cacciatore{public:
      static const int vista=250;
      Cacciatore(list<Animale*> &animali,string nome=""){this->nome=nome;this->animali=&animali;this->lepri=0;this->cinghiali=0;}
      Cacciatore(list<Animale*> &animali,string nome,point posizione);
      void spara();
      list<Animale*> *animali;
      string nome;
      point posizione;
      int angolazione;
      int lepri;
      int cinghiali;
};

class Campo{public:
      list<Animale*> animali;
      list<Cacciatore*> cacciatori;
      static const int righe=3200;
      static const int colonne=3200;
};
float distanza(point,point);
#endif

Codice delle classi (caccia.cpp)

#include "caccia.h"
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <sstream>
#define pi 3.141592654
using namespace std;
float distanza(point da ,point a){
      int ascisse=da.riga-a.riga;
      int ordinate=da.colonna-a.colonna;
      return sqrt(ascisse*ascisse + ordinate*ordinate);
};

point::point(){
               this->riga=rand()%Campo::righe;
               this->colonna=rand()%Campo::colonne;
};

string point::ToString(){
        stringstream temp;
        temp<<"["<<riga<<","<<colonna<<"]";
        return temp.str();
       };

Animale:: Animale(string nome,float velocita){
          this->nome=nome;
          this->posizione=point::point();
          this->angolazione=(rand()%360)*((2*pi)/360);
          this->velocita=velocita;
          //cout<<posizione.ToString()<<endl;
};

point Lepre::muovi(long tempo){
     tempo=tempo%10;
     //cout<<tempo<<" ";
      if(tempo>5){
                  angolazione=(rand()%360)*((2*pi)/360);
                  posizione.riga+=(int)(velocita*sin(angolazione));
                  posizione.colonna+=(int)(velocita*cos(angolazione));
                  if(posizione.riga> Campo::righe)posizione.riga=Campo::righe;
                  if(posizione.colonna> Campo::colonne)posizione.colonna=Campo::colonne;
                  if(posizione.riga< 0)posizione.riga=0;
                  if(posizione.colonna< 0)posizione.colonna=0;
                  };
return posizione;
};

point Cinghiale::muovi(long tempo){
     posizione.riga+=(int)(velocita*sin(angolazione));
     posizione.colonna+=(int)(velocita*cos(angolazione));
     if((posizione.riga>Campo::righe || posizione.colonna>Campo::colonne)
        ||(posizione.riga<0 ||posizione.colonna<0)
     ){
                          if(posizione.riga> Campo::righe)posizione.riga=Campo::righe;
                          if(posizione.colonna> Campo::colonne)posizione.colonna=Campo::colonne;
                          if(posizione.riga< 0)posizione.riga=0;
                          if(posizione.colonna< 0)posizione.colonna=0;
                          angolazione=(rand()%360)*((2*pi)/360);
     };
     return posizione;
};

void Cacciatore::spara(){
     //int n=0;
     for(list<Animale*>::iterator from = animali->begin();
        from != animali->end();
        ++from//,cout<<++n<<endl
        )if(distanza(posizione,(*from)->posizione)<vista){
            if((*from)->nome=="Lepre"){this->lepri++;
                                       cout<<nome<<": Ucciso una lepre ho!     ";
                                       }else{this->cinghiali++;
                                       cout<<nome<<": Ucciso un  cinghialo ho! ";
                                       };
            cout<<(*from)->posizione.ToString()<<endl;
            delete (*from);
            animali->erase(from);//se si cancella un valore l'teratore salta
            return;
        };
};

Cacciatore::Cacciatore(list<Animale*> &animali,string nome,point posizione){
                             this->nome=nome;
                             this->animali=&animali;
                             this->lepri=0;
                             this->cinghiali=0;
                             this->posizione=point::point();
};

Codice del main (main.cpp)

#include <cstdlib>
#include <iostream>
#include <ctime>
#include "caccia.h"
using namespace std;

int main(int argc, char *argv[])
{
    srand((unsigned int)time(NULL));
    int a;
    Campo campo;
    campo.cacciatori.push_back(new Cacciatore(campo.animali,"Qui'"));
    campo.cacciatori.push_back(new Cacciatore(campo.animali,"Quo'"));
    campo.cacciatori.push_back(new Cacciatore(campo.animali,"Qua'"));
    for(a=0;a<10;a++){campo.animali.push_back(new Cinghiale());};
    for(a=0;a<50;a++){campo.animali.push_back(new Lepre());};
    for (a=0;a<7200;a++){
//        cout<<a<<" ";
        for(list<Animale*>::iterator from = campo.animali.begin();
                                     from != campo.animali.end();
                                     ++from
                                     )(*from)->muovi(a);

        for(list<Cacciatore*>::iterator from = campo.cacciatori.begin();
                                     from != campo.cacciatori.end();
                                     ++from
                                     )(*from)->spara();
    };
    system("PAUSE");
    return EXIT_SUCCESS;
}

]]> http://thedarshan.wordpress.com/2009/11/07/programmazione-compiti-svolti-13/feed/ 0 thedarshan Diagramma UML http://thedarshan.wordpress.com/2009/10/16/facebook-e-la-politica-estera/ http://thedarshan.wordpress.com/2009/10/16/facebook-e-la-politica-estera/#comments Fri, 16 Oct 2009 10:14:32 +0000 thedarshan http://thedarshan.wordpress.com/?p=335 ]]>

Mezzora fa tentavo di linkare su facebook questa pagina

http://www.timesonline.co.uk/tol/news/world/Afghanistan/article6877142.ece

E’ l’articolo del Times che suppone che i servizi segreti italiani pagassero le milizie talebane per evitare attacchi.

L’url era bannata e facebook non mi permetteva ne di pubblicarlo ne di inviarlo dalla chat, così ho usato TinyUrl per cambiare l’url e aggirare il filtro, così facendo riesco a pubblicare l’url ma 5 minuti dopo il mio account viene sospeso “per comportamenti sospetti”

Suspicious activity has been detected on your Facebook account and it has been temporarily suspended as a security precaution. It is likely that your account was compromised as a result of entering your password on a website designed to look like Facebook. This type of attack is known as phishing.

Spero si tratti di sospetti di Phishing per aver usato tinyurl o qualcosa del genere, perché altrimenti si tratterebbe di censura, seguendo la procedura di riattivazione l’account si riattiva…

questo articolo è la continuazione del articolo sulla determinazione di una specifica permutazione e affronta il problema inverso:

determinare la posizione di una specifica permutazione nell’insieme delle permutazioni ordinate lessicograficamente.

Ancora qualcosa sull’interpretazione dei codici di Lehmer

I singoli termini del codice di Lehmer si possono anche interpretare come il numero di elementi che si trovano “al posto sbagliato”, cioè il numero di elementi minori dell’elemento preso in esame che si trovano alla sua destra (e che quindi violano l’ordinamento crescente degli elementi).

Applicando questo teorema è possibile ricavare il codice di Lehmer di una permutazione e dal codice ricavare la posizione della permutazione.

Generazione del codice di Lehmer

“i singoli elementi del codice di Lehmer sono costituiti dal numero di elementi minori dell’elemento che si trovano alla sua destra”

    public static int[] inverseLehmer(int[] v){
        int n=v.length;
        int[] lh=new int[n];
        lh[n-1]=0;
        for (int a=0; a<n-1; ++a){
            int i = 0;
            for (int b=a; b<n; ++b)
                if ( v[b]<v[a] ) i++;
            lh[a] = i;
        }
        return lh;
    }

Calcolo della posizione della permutazione (conversione da factoradic a numero)

    public static int rank(int[] permutazione){
        int[] l=inverseLehmer(permutazione);
        int f=1;
        int r=0;
        int n=permutazione.length;
        for(int a=1;a<(n+1);a++){
            r=r+f*l[n-a];
            f=f*a;
        }
        return r;
    }

questo articolo è la continuazione del articolo precedente sulle permutazioni.

Potrebbe essere necessario determinare una singola permutazione dall’insieme delle permutazioni ordinate e inutile determinarle tutte.
Questo problema è più complicato del caso precedente e prima di continuare vorrei rendere noto che l’articolo non è frutto delle mie conoscenze universitarie o di conoscenze direttamente connesse che mi sono servite per esse, questo non per attribuirmi un particolare merito ma per attribuire un particolare demerito alla mia università.

Come si affronta questo problema? ogni informatico sano di mente scarterebbe nel giro di un paio di secondi la possibilità di generare tutte le permutazioni fino a quella cercata (ma non preoccupatevi…se non avete scartato entro due secondi potete comunque laurearvi in molte università e dire in giro di essere degli ingegneri del software).

Dunque, riformuliamo il problema: come fare per determinare una specifica permutazione in tempo costante o quantomeno proporzionale al numero di elementi del dominio?

La soluzione risiede nell’uso dei factoradic (termine che non so proprio come tradurre in italiano)

I Factoradic

Di solito un numero viene rappresentato come un polinomio di potenze della base

inquanto le potenze dei primi n numeri costituiscono una base che permette di rappresentare univocamente un numero con un polinomio.

Anche i fattoriali dei primi n numeri costituiscono una base , quindi è possibile rappresentare univocamente un numero come polinomio dei fattoriali della base

questa rappresentazione è detta factoradic. L’univocità di questa rappresentazione è garantita dal fatto che la somma dei primi n fattoriali moltiplicati per il loro indice è sempre il fattoriale successivo meno 1.

caratteristica fondamentale dei factoradic è il costistuire un codice che permette di associare al numero n rappresentato la n-esima permutazione dell’insieme degli elementi della base, questo “codice di traduzione” viene chiamato codice di Lehmer

Interpretazione dei codici di Lehmer, generazione della permutazione associata

Dal factoradic si può ottenere la permutazione invertendo i singoli elementi  o i segmenti della permutazione di base [1,2,3,4] con gli elementi a destra  usando l’elemento del codice di Lehmer come lunghezza del segmento da spostare.

Per esempio

• il codice 0110 indica che, partendo dalla permutazione di base, si deve invertire l’elemento 2 e poi l’elemento 3 ottenendo la permutazione [1,3,4,2]
  
• il codice 0200 indica di invertire l’elemento 2 e il successivo ( il numero due indica questo: due elementi di uno e NON un elemento di due) ottenendo [1,4,2,3]
  

Algoritmo per la generazione di un Factoradic

l’algoritmo di generazione è molto semplice: le singole componenti vengono calcolate con l’operatore modulo

        public static int[] factoradic(int numero, int base){
            assert (base>1 && numero >= 0 );
            int[] f = new int[base];
            for (int j = 1; j <= base; ++j)
            {
            f[base-j] = numero % j;
            numero /= j;
            }
            return f;
        }

è lo stesso tipo di algoritmo che si usa per convertire un numero decimale in una base diversa, si va dividendo il numero per la base e i resti delle divisioni vanno a costituire il numero nella base di arrivo, solo che in questo caso la base non è costante ma decresce.

Dal Factoradic alla permutazione

il codice va inserito nella classe definita nel post precedente

    public int[] permutazione(int n){
        int[] lehmer=MyMath.factoradic(n, len);
        int a;
        //creo la permutazione di base
        for (a = 0; a < len; a++)elementi[a] = a + 1;
        //applico il codice
        for (a = 0; a < len; a++){
            if(lehmer[a]==1)
                //caso banale, mi limito a fare uno swap
                swap(a, a+1);
            else if(lehmer[a]>1){
                //caso generico, sposto un segmento
                int k=lehmer[a]+a;
                int buffer=elementi[k];
                while(k>a){
                    swap(k-1,k);
                    k--;
                }
                elementi[a]=buffer;
            }
        }
        return elementi;
    }

Generazione di permutazioni casuali

Dando come input alla funzione precedente un numero casuale compreso nel numero di permutazioni si ottiene ovviamente una permutazione casuale

ho trovato una strana applicazione che valuta il valore di un blog non so bene in base a quale algoritmo (suppongo c’entrino il numero di volte che viene citato da tecnorati)

wow, forse vale la pena di spenderci qualcosa e spostarlo su uno spazio di hosting completo.

Peccato che il sito non offra un codice dinamico che lo ricalcola in tempo reale…magari mentre leggete il post il blog vale molto di più (o magari no…)

ecco il link http://www.business-opportunities.biz/projects/how-much-is-your-blog-worth/

Spesso quando si lavora su algoritmi che hanno come dati di ingresso una lista di elementi si ha la necessità di testarne il comportamento su tutte le permutazioni possibili dell’insieme di ingresso.

L’algoritmo seguente è probabilmente il più semplice algoritmo iterativo per listare le permutazioni di un insieme di elementi, l’algoritmo analizza semplicemente la permutazione attuale per ricavarne la prossima basandosi sul fatto che le permutazioni devono seguire un ordinamento lessicografico (nel caso numerico qui analizzato ogni permutazione deve essere la minima permutazione maggiore di quella corrente)

    public boolean prossima() {
        int i = len - 1;
        while (i>0 && (elementi[i - 1] >= elementi[i])) {
            i--;
        }
        if(i==0)return false;
        int j = len;
        // (i-1) è l'elemento trovato con il ciclo precedente
        while (elementi[j - 1] <= elementi[i - 1])j--;
        swap(i - 1, j - 1);
        i++;
        j = len;
        //inverto gli elementi tra i due elementi scambiati
        while (i < j) {
            swap(i - 1, j - 1);
            i++;
            j--;
        }
        return true;
    }

considerando la permutazione come un vettore di n elementi numerici l’algoritmo determina la permutazione successiva nel seguente modo:

1. a partire dall’ultimo elemento scorre l’array cercando il primo elemento preceduto da un elemento minore
2. se non esiste si è giunti all’ultima permutazione possibile e l’algoritmo deve terminare
3. se esiste ricomincia a scorrere il vettore dalla fine cercando il primo elemento maggiore all’elemento trovato al punto1
4. si invertono gli elementi trovati al punto1 e al punto3
5. se lo scambio non è avvenuto tra elementi di livello minimo (l’ultimo e il penultimo) si ripristina l’ordinamento interno invertendo le posizioni degli elementi che si trovano tra l’elemento trovato al punto1 e quello trovato al punto3

l’algoritmo è molto semplice e molto generico ma non è efficiente, infatti il fatto di dover analizzare a ogni iterazione la struttura attuale del vettore ne incrementa di molto la complessità.

Un modo per rendere molto più efficiente l’algoritmo è quello di dotare l’algoritmo di un altro vettore che contiene dati sulla struttura attuale del vettore degli elementi in modo da poter determinare velocemente la prossima permutazione.

Un altro miglioramento notevole si può ottenere evitando che a uno scambio debba seguire una ristrutturazione del vettore, entrambe queste ottimizazioni sono implementate nell algoritmo di Johnson–Trotter

Ho realizzato un applet che usa questo algoritmo qui

Codice completo

Il generatore di permutazioni

package darshan.snippet;

public class SimplePermutator {
    public int elementi[];
    public int len;

    public SimplePermutator(int n) {
        elementi = new int[n];
        for (int a = 0; a < n; a++)elementi[a] = a + 1;
        this.len=n;
    }

    private void swap(int a, int b){
        int t=elementi[a];
        elementi[a]=elementi[b];
        elementi[b]=t;
    }

    public boolean prossima() {
        int i = len - 1;
        while (i>0 && (elementi[i - 1] >= elementi[i])) {
            i--;
        }
        if(i==0)return false;
        int j = len;
        while (elementi[j - 1] <= elementi[i - 1])j--;
        swap(i - 1, j - 1);
        i++;
        j = len;
        while (i < j) {
            swap(i - 1, j - 1);
            i++;
            j--;
        }
        return true;
    }

    @Override
    public String toString(){
        return Array_util.dump(elementi);
    }
}

il resto del codice

public class Main {
    public static void main(String[] args) {
        SimplePermutator p=new SimplePermutator(5);
        System.out.println("Using "+p.getClass().getName());
        do{System.out.println(p.toString());}while(p.prossima());
    }
}

package darshan.snippet;

public abstract class Array_util {
 static public String dump(int[] elementi) {
 StringBuffer e = new StringBuffer();

 if (elementi.length > 0) {
 e.append("[ " + elementi[0]);

 for (int i = 1; i < elementi.length; i++) {
 e.append(",");
 e.append(elementi[i]);
 }
 }
 e.append(" ]");
 return e.toString();
 }

}

Riporto per intero una discussione che ho fatto su facebook e che a un certo punto è stata troncata (spero per problemi di comunicazione), la riporto con tutti gli errori di battitura, mi limito a togliere i nomi degli utenti sostituendoli con le iniziali. mancano almeno due commenti che sono spariti (spero per problemi di comunicazione)

EDIT (15:29):  i commenti saltati sono almeno 3 e uno non è mio…quindi comincio a dubitare dei problemi di comunicazione…

VLS

facebook non è fatto per condividere…
non è un vero social network…
è un estensione digitale delle chiacchiere da bar. un gigantesco bar multimediale dove parli con gente che in realtà non conosci

IC alle 13.29 del 19 giugno

diciamo ke è anke un modo per fare ” curtigghiu “!!

VLS alle 13.58 del 19 giugno

dico che è ESCLUSIVAMENTE un modo per fare curtigghiu.
I gruppi sono inutilizzabili, perche uno finisce per averne troppi e non seguirne nessuno, anche perche non hanno notifiche ne rss.

E’ tutto basato sulla bacheca dove i commenti scivolano via spinti da altro curtigghiu, è impossibile farci una discussione seria e duratura (che duri il tempo necessario per svilupparsi).
Comincio a pensare che il prodotto qualità*quantità dei siti sia costante…lo diceva umberto eco molti anni fà prima che si cominciasse a parlare di web2.0

E una degenerazione: prima un sito lo aveva solo chi sapeva gestirlo, poi si sono diffusi i blog dove anche chi non saprebbe creare o gestire un sito piò averne uno e poi sono arrivati questi social network “asociali” dove anche chi è troppo lagnuso per avere un blog può scrivere e avere un feedback anche se scrive banalità.

MS alle 14.00 del 19 giugno

W il bar!

un ultima cosa, nel caso ci fosse qualche lettore non bilingue:

Curtìgghiu cortile, vicolo; 2. fig chiasso; 3. fig. pettegolezzo

]]> http://thedarshan.wordpress.com/2009/06/19/facebook-e-lera-degli-asocial-network/feed/ 0 thedarshan http://thedarshan.wordpress.com/2009/05/12/michela-vittoria-brambilla-e-un-ministro-del-turismo-competente/ http://thedarshan.wordpress.com/2009/05/12/michela-vittoria-brambilla-e-un-ministro-del-turismo-competente/#comments Tue, 12 May 2009 17:25:42 +0000 thedarshan http://thedarshan.wordpress.com/?p=209 ]]>

Di solito non parlo di politica in questo blog, ma questa è un occasione speciale

Il trenta aprile sul televideo rai si poteva leggere questo:

Il ministro della Difesa non fa nomi,ma il collega Calderoli precisa; “Romani, Urso e Castelli saranno viceministri”.
I nomi li avrebbe fatti Berlusconi al Consiglio dei ministri, dicendo che presto diventerebbe ministro Michela Vittoria Brambilla, ora sottosegretario al Turismo.
Il governo ha deciso che il referendum sulla legge elettorale per le politiche si terrà il 21 giugno.

Novità in vista per il governo.”E’ stato annunciato che ci sarà un nuovo ministro e tre viceministri”, dice La Russa,dopo il Consiglio dei ministri nel quale Saglia è stato nominato sottosegretario allo Sviluppo economico al posto di Martinat, morto a marzo.

mmm, Michela Vittoria Brambilla… dove l’ho già vista…ah si…in quel canale sul digitale terrestre…perche sono troppo giovane per aver visto questo programma

Octave nasce come clone open source di Matlab, come il programma a cui è ispirato permette di eseguire calcoli numerici anche complessi e come il programma a cui è inspirato (e anche di più)  è goffo e inutile per il calcolo simbolico.

Ho trovato un sito molto utile che permette di eseguire degli script di Octave online, la cosa può rivelarsi molto utile quando capita di dover eseguire calcoli complessi da computer in cui non è installato alcun tipo di software del genere.

Il sito è questo: Online Math Calculator, nel caso non fosse diponibile esiste anche questo.

Oggi youtube ha fatto un pesce d’aprile meraviglioso

pesce d'aprile

si vede tutto al contrario