Un coda una struttura dati molto semplice, segue il principio FIFO, First In First Out, il primo ad entrare il primo ad uscire.. o potremmo dire chi primo arriva meglio alloggia!:P

Oggi non posso spiegarvi tutto, come sempre confido nei vostri commenti e richieste di informazioni specifiche per contribuire al meglio al post. Vediamo subito quali metodi ha l’interfaccia Queue:

• enqueue(e): accoda l’elemento e alla coda, in pratica posiziona dietro l’elemento;
• dequeue(): prende il primo elemento della coda, ovvero il primo ad essere entrato, lancia un’eccezione se vuota;
• front(): simile al pop dello stack, legge il primo elemento della coda senza per toglierlo da essa, lancia un’eccezione se vuota;
• size(): un classico ormai, restituisce la dimensione;
• isEmpty(): booleano per sapere se la coda vuota o occupata da elementi.

Vediamo quindi l’interfaccia:

package queue;

import exception.EmptyQueueException;

public interface Queue<E> {

 public int size();
 public boolean isEmpty();
 public E front() throws EmptyQueueException;
 public void enqueue(E element);
 public E dequeue()throws EmptyQueueException;
}

Questa la classe della nuova eccezione che abbiamo creato:

package exception;

public class EmptyQueueException extends RuntimeException{
 /**
  *
  */
 private static final long serialVersionUID = -6005613600247835251L;

 public EmptyQueueException(String errore) {
  super(errore);
 }

}

Classe ArrayQueue per implementare l’interfaccia con un array:

package queue;

import exception.EmptyQueueException;
import exception.FullQueueException;

public class ArrayQueue<E> implements Queue<E>{
 protected int capacity;
 public static final int CAPACITY = 1000;
 protected E[] Q;
 protected int f, r = 0;

 public ArrayQueue() {
  this(CAPACITY);
 }
 @SuppressWarnings("unchecked")
 public ArrayQueue(int capacity) {
  this.capacity=capacity;
  Q = (E[]) new Object[capacity];
 }
 public boolean isEmpty() {
  return (f==r);
 }
 public E dequeue() throws EmptyQueueException {
  if (isEmpty())
   throw new EmptyQueueException("Queue is empty");
  E element;
  element = Q[f];
  Q[f] = null;
  f = (f+1) % Q.length;
  return element;
 }
 public void enqueue(E element) throws FullQueueException{
  if (size() == Q.length-1)
   throw new FullQueueException("Queue is full");
  Q[r] = element;
  r = (r+1) % Q.length;
 }
 public int size() {
  return ((Q.length-f+r) % Q.length);
 }
 public E front() throws EmptyQueueException {
  if (isEmpty()) throw new EmptyQueueException("Queue is empty");
  return Q[f];
 }

}

Classe dell’altra eccezione:

package exception;

public class FullQueueException extends RuntimeException{
 /**
  *
  */
 private static final long serialVersionUID = -6005613600247835251L;

 public FullQueueException(String errore) {
  super(errore);
 }

}

E infine la classe di test:

package queue;

public class TestArrayQueue {
	public static void main(String[] args) {
		Queue A = new ArrayQueue();
		A.enqueue(5);
		System.out.println("Enqueue 5");
		A.enqueue(3);
		System.out.println("Enqueue 3");
		System.out.println("Dequeue "+A.dequeue());
		A.enqueue(7);
		System.out.println("Enqueue 7");
		System.out.println("Dequeue "+A.dequeue());
		System.out.println("Front "+A.front());
		System.out.println("Dequeue "+A.dequeue());
		if (!A.isEmpty()) A.dequeue();
		A.enqueue(9);
		System.out.println("Enqueue 9");
		A.enqueue(7);
		System.out.println("Enqueue 7");
		System.out.println("Size :"+A.size());
		A.enqueue(3);
		System.out.println("Enqueue 3");
		A.enqueue(5);
		System.out.println("Enqueue 5");
		System.out.println("Dequeue "+A.dequeue());

	}
}

Buonanotte rag!

Prima di cominciare vorrei fare una piccola premessa, utilizzo il linguaggio Java per implementare gli algoritmi (in particolare Java 5.0), si presume (come ho citato nell’articolo precedente) che conosciate almeno in piccola parte il linguaggio Java, in particolare Classi, interfacce, Variabili assegnamenti e operatori/operazioni, cicli, packages e chi pi ne ha pi ne metta. Non vorrei trattare guide riguardanti la normale programmazione in Java in quanto ci sono degli ottimi libri che permettono di superare addirittura un esame universitario (nel mio caso cos stato ), mi permetto quindi di citarvi l’ottimo Java Mattone dopo Mattone, liberamente scaricabile e utilizzabile da tutti, non sar aggiornatissimo ma una volta acquisiti i fondamenti iniziali aggiornarsi alle ultime versioni di Java non sar un problema .

Uno Stack una struttura di dati astratta, all’universit lo chiamiamo TDA (Tipo di Dati Astratto), definizione forse pi azzeccata perch una volta definita questa struttura avremo proprio un nuovo tipo di dato da poter utilizzare per i nostri programmi.

Il principio di funzionamento di uno Stack semplicissimo, immaginate una pila di piatti dove l’ultimo ad essere posizionato il primo ad uscire e cos man mano potremo prendere sempre l’ultimo piatto (elemento/oggetto). Questa tipologia di inserimento/rimozione oggetti prende il nome di last-in first-out (LIFO), in parole povere il primo ad entrare l’ultimo ad uscire.

In uno stack/pila abbiamo principalmente due funzionalit che chiameremo con il nome di metodi:

• push(e): Inserisce l’elemento e, naturalmente in testa allo stack;
• pop(): pop invece non ha bisogno di argomenti/parametri perch prende, o meglio toglie, dal nostro stack l’ultimo elemento e ce lo restituisce. In questo metodo per, nel caso lo stack fosse vuoto, avremo un errore perch pop() non sar capace di prendere elementi dallo stack, gli errori in java vengono comunemente definiti come eccezioni;

Inoltre ai nostri due metodi che definiscono la base di funzionamento dello stack abbiamo anche 3 metodi aggiuntivi, non saranno obbligatori ma ci permettono di gestire al meglio l’intero stack e di gestire alcune eccezioni risparmiando cos anche un po di tempo:

• size(): ritorna il numero degli elementi nello stack;
• isEmpty(): ritorna un valore booleano (vero, falso) per indicare se lo stack vuoto o meno;
• top():top invece un metodo abbastanza simile al pop() soltanto che invece di togliere l’elemento dallo stack per fornircene il contenuto si limita soltanto a leggerlo e restiturci il risultato, in questo modo naturalmente non potremo leggere il contenuto dell’elemento successivo (contenuto sotto) finch non effettueremo il pop(), anche questo metodo lancia un eccezione nel caso lo stack sia vuoto.

Il codice per la rispettiva interfaccia in Java 5.0 sar di questo tipo:

 package stack;

 import exception.EmptyStackException;

 public interface Stack<E> {
  public int size();
  public boolean isEmpty();
  public E top() throws EmptyStackException;
  public void push (E element);
  public E pop() throws EmptyStackException;
 }

Tramite l’interfaccia potremo implementare tutti gli algoritmi e definire la struttura di dati che pi ci piace senza dover per forza fornire dettagli sulle nostre implementazioni semplicemente perch dovremmo soddisfare tutti i requisiti richiesti dall’interfaccia e quindi implementare tutti i metodi. Da notare che importo da un secondo package, exception, la classe EmptyStackException che ci permetter di gestire i nostri errori di tipo Stack Vuoto, il codice il seguente:

package exception;

@SuppressWarnings("serial")
public class EmptyStackException extends RuntimeException{

public EmptyStackException(String exception) {
super(exception);
}

}

In questo articolo implementeremo una rudimentale struttura di dati per lo Stack grazie ad un array, come potrete ben capire da soli avremi dei problemi:

• Dovendo dichiarare l???array avremo una dimensione ben definita e quindi non pi modificabile (con tutti i problemi che naturalmente ne deriveranno);
• Una volta riempito l???array il push, se eseguito ancora, lancer un???eccezione di stack pieno (FullStackException);
• Gli elementi nell???array verranno aggiunti da destra verso sinistra;
• Riempito l???array e quindi il push per effettuare una nuova push dovremmo per forza di cose effettuare una pop;

Vediamo quindi il codice in Java 5.0:

package stack;

import exception.EmptyStackException;
import exception.FullStackException;

public class ArrayStack<E> implements Stack<E>{
 protected int capacity;
 public static final int CAPACITY = 1000;
 protected E[] S;
 protected int top = -1;

 public ArrayStack() {
  this(CAPACITY);
 }
 @SuppressWarnings("unchecked")
 public ArrayStack(int capacity) {
  this.capacity=capacity;
  S = (E[]) new Object[capacity];
 }
 public boolean isEmpty() {
  return (top<0);
 }
 public E pop() throws EmptyStackException {
  E element;
  if (isEmpty())
   throw new EmptyStackException("Lo stack e' vuoto.");
  element = S[top];
  S[top--] = null;
  return element;
 }
 public void push(E element) throws FullStackException{
  if (size() == capacity)
   throw new FullStackException("Lo stack e' pieno.");
  S[++top] = element;
 }
 public int size() {
  return top+1;
 }
 public E top() throws EmptyStackException {
  if (isEmpty()) throw new EmptyStackException("Lo stack e' vuoto.");
  return S[top];
 }
 public String toString() {
  String s;
  s = "[";
  if (size() > 0) s+= S[0];
  if (size() > 1)
   for (int i=1; i<= size()-1; i++)
    s += ", " + S[i];
  return s+"]";
 }
 public void status(String op, Object element) {
  System.out.print("------>" + op);
  System.out.println(", returns " + element);
  System.out.print("result: size = "+size() + ", isEmpty = "+ isEmpty());
  System.out.println(", stack: " + this);
 }
}

Da notare che stata richiamata una nuova classe per le eccezioni di Stack pieno, seguendo l???esempio della prima classe di Exception semplicissimo creare un???altra classe con nome variato, ma gia ce ce l???ho salvata in Eclipse vi copio anche questa parte :

package exception;

@SuppressWarnings("serial")
public class FullStackException extends RuntimeException{

 public FullStackException(String errore) {
  super(errore);
 }

}

Come vedrete ci sono anche alcuni metodi accessori che utilizzeremo per la nostra classe di test:

package stack;

public class TestArrayStack {
 public static void main(String[] args) {
  Object o;
  ArrayStack<Integer> A = new ArrayStack<Integer>();
  A.status("new ArrayStack<Integer> A", null);
  A.push(7);
  A.status("A.push(7)", null);
  o = A.pop();
  A.status("A.pop()", o);
  A.push(9);
  A.status("A.push(9)", null);
  o = A.pop();
  A.status("A.pop()", o);
  ArrayStack<String> B = new ArrayStack<String>();
  B.status("new ArrayStack<String> B", null);
  B.push("Bob");
  B.status("B.push(\"Bob\")", null);
  B.push("Alice");
  B.status("B.push(\"Alice\")", null);
  o = B.pop();
  B.status("B.pop()", o);
  B.push("Eve");
  B.status("B.push(\"Eve\")", null);
 }

}

Perdonatemi se non mi dilungo a spiegare il codice pi di tanto stasera ho perso 4 ore per poter formattare il codice senza perdere validazione W3C e senza perdere alcune parti di codice di Java 5.0 incompatibili con WordPress (mi chiude i tag in automatico) e con il plugin Wp-Syntax che ho dovuto modificare per eliminare il controllo sulle identazioni e su tutti i caratteri speciali html (su quelli il controllo manuale sempre migliore ), poi con l???editor avanzato sempre su ???disattivato??? chiaro

Il libro di riferimento Data Structures and Algorithms in Java, fourth edition.
Di Michael T. Goodrich e Roberto Tamassia (in english naturalmente ehehhe ). L???algoritmo rispecchia lo stesso metodo risolutore riportato nel libro, ma il bello cominceremo a vederlo tra poco quando il libro non riporter pi degli esempi tanto carini, ma io l???anno scorso queste cose le ho fatte fino a met corso???diciamo che sono molto anticipato sul libro e sul programma ehehe

Naturalmente qualsiasi cosa chiedete, nei limiti del possibile prover a darvi una risposta, ma sono dell???idea che questi esercizi dobbiate farveli da soli non vale la pena di copiare questi, si fa una figura di m??? all???interrogazione perch difficilmente si sapr discutere codice non commentato di altre persone ne tantomeno si sapr dove spostarsi esattamente con lo sguardo e con il ditino. Sisi mi stato chiesto addirittura questo in un esame per verificare l???autenticit del mio codice!!!

Vi parler di un corso molto bello riguardante Laboratorio di Algoritmi e Strutture Dati (da ora in poi conosciuto con il tag LASD) nel quale vedremo come implementare in Java e in particolare in Java 5.0 con le classi generiche Algoritmi e Strutture Dati di grande utilit per i programmatori. Ma prima di tutto conosciamo meglio la definizione di Algoritmi e Strutture Dati:

Una struttura dati un’entit usata per organizzare un insieme di dati all’interno della memoria del computer, ed eventualmente per memorizzarli in una memoria di massa. La scelta delle strutture dati da utilizzare strettamente legata a quella degli algoritmi, a tal proposito, solitamente si utilizza il concetto unificato di Algoritmi e Strutture Dati. La scelta della struttura dati influir inevitabilmente sull’efficienza degli algoritmi da utilizzare.

La struttura dati un metodo di organizzazione dei dati, quindi prescinde dai dati effettivamente contenuti. Ciascun linguaggio di programmazione offre strumenti, pi o meno sofisticati, per definire strutture dati, ovvero aggregare dati di tipo omogeneo o eterogeneo. Questi strumenti sono tipicamente componibili.

Pi formalmente, i linguaggi forniscono un insieme predefinito di tipi di dato elementari, e le strutture dati sono strumenti per costruire tipi di dati aggregati pi complessi.

L’operazione di costruire una variabile di un tipo di dato complesso detta “istanziazione”, e pu avvenire sia durante la compilazione del programma (compile time) sia durante la sua esecuzione (runtime).

Le strutture di dati si differenziano prima di tutto in base alle operazioni che si possono effettuare su di esse e alle prestazioni offerte. Questo permette di creare un’astrazione dall’implementazione, dando vita al concetto di Struttura dati astratta o Abstract Data Structure (ADS).

L’articolo stato preso da Wikipedia, per leggere la parte mancante visitate la pagina Struttura dati e seguite un pochino tutti i vari collegamenti per avere maggiori informazioni.

A breve vedremo come implentare la nostra prima struttura dati astratta, una delle pi primitive e semplici ma forse anche una delle pi importanti che ancora oggi alla base di molte applicazioni…

Parler dello Stack e la sua implementazione in Java 5.0 in un ArrayList a dimensione fissa, successivamente tratter un Array di tipo circolare a dimensione fissa e infine dovrei trattare uno Stack immagazzinato tramite una lista di oggetti a dimensione variabile.

Un piccolo avvertimento per chi fosse interessato: sono necessari Java Se JDK 5 o superiore e possibilmente un ide di programmazione java, magari Eclipse 3.2 o superiore (come il nuovo Europa). Per ora tutto comincer tra breve a pubblicare le prime risorse

Continua il mio viaggio di esproprio dal proprio ambiente di lavoro nativo di programmi praticamente perfetti. Oggi ho scoperto Python.

Cosa Python??

Python un linguaggio di programmazione interpretato, interattivo, ad oggetti. Incorpora i moduli, le eccezioni, la tipizzazione dinamica, alcuni tipi di dati dinamici ad altissimo livello e le classi. Python unisce una potenza considerevole ad una sintassi molto pulita e comprensibile. ?? dotato di interfacce a molte chiamate di sistema e librerie, come pure a vari sistemi a finestre, ed estensibile in C o C++. ?? utilizzabile pure come linguaggio di estensione per applicazioni che necessitano di un’interfaccia programmabile. Infine, Python portabile: funziona su molte versioni di UNIX, su Mac, e sui PC sotto MS-DOS, Windows, Windows NT, e OS/2. (Fonte: Python.it)

Conoscevo gia questo linguaggio di programmazione, su [tag]Linux[/tag] mi sono imbattuto pi volte, ma non ne avevo mai approfondito l’uso ne tantomeno sono capace di scrivere una sola riga di codice fin quando non mi sono imbattuto su questo articolo: Come mettere le ultime news del blog in firma con Mozilla Thunderbird.

Lo script creato da questo fantastico ragazzo di cui ora seguir sempre il blog tramite feed [tag]rss[/tag], stato creato in Python con il supporto della libreria Universal Feed Parser di cui tratter dopo l’installazione.

Procediamo con lo scaricare da qui l’installer per [tag]Windows[/tag], l’ultima versione al momento della stesura di questo articolo la Python 2.5.1. Scegliete poi il download a seconda dell’architettura del vostro PC (solitamente X86). Terminato il download scaricate l’installer e seguite le istruzioni a video, non c’ davvero bisogno di spiegar nulla se ci sono riuscito anche io

Bene Python installato, annotate il percorso in cui lo avete installato perch importante.
Facciamo un esempio pratico (il classicissimo Hello World! ).

File “helloworld.py“:
print "Hello World!"

Veramente molto semplice, una sola riga di codice, nessuna chiusura di istruzioni, no tag di apertura o altro, per ora io sono capace di fare soltanto questo, non avevo mai programmato in python in vita mia.

Vediamo come eseguire su Windows questo file con estensione “py”.

File “helloworld.cmd” (oppure .bat uguale):
PATH=%PATH%;"C:\Python25\"
python helloworld.py
pause

Cosa abbiamo fatto? Semplicemente creato un file.cmd di Windows che esegue un file .py, il richiamo avviene settando prima il PATH a “C:\Python25\” (il percorso della vostra installazione) e poi dando il comando python con il percorso del file da eseguire. Baster esegire helloworld.cmd per avviare lo script.

Installazione di Universal Feed Parser
Altro non un modulo aggiuntivo molto famoso per Python che permette l’estrapolazione di dati da un feed rss, serve per far funzionare lo script di cui ho parlato prima.

Andiamo come sempre a scaricare lo script da qui. Al momento la versione in uso “feedparser-4.1.zip“. Salviamolo nel nostro Desktop ed estraiamo l’archivio in una cartella. Noterete certamente che manca di un installer. Infatti uno script python che dovremo eseguire per aggiungere il modulo creando un nuovo file.cmd (chi ha capito prima saprebbe costruirselo anche da solo), sono buono quindi eccovi il file da eseguire:

File “installamodulo.cmd“:
PATH=%PATH%;"C:\Python25\"
python setup.py install
pause

That’s all! Vi saluto ragazzi e vi ringrazio per l’attenzione, corro a imparare questo stupendo linguaggio

Per compilare il gioco visto che ho letto di alcune difficoltà vi descrivo la procedura passo passo da fare in Eclipse 3.2.2.
Una volta scaricato basta estrarlo e aprire la cartella, non necessita di installazione. Troverete all’interno della cartella Eclipse un file chiamato eclipse.exe facendo doppio click sopra potrete avviare (dopo aver selezionato una cartella per il workspace) Eclipse.
Subito dopo andate su File > New > Project e scegliete Java Project poi cliccate su Next.
Apparirà questa schermata:

Assicuratevi che in JRE sia selezionata almeno la versione 1.5.0 oppure come nel mio caso la versione 1.6.0. Poi cliccate sotto su Configure compilance…

Il livello di compilazione deve essere impostato almeno su 5.0 altrimenti non si potranno usare le classi generiche previste da Java 5.0(e superiori). Date OK e alla richiesta successiva rispondete YES. Apparirà la finestra precedente date Next e poi Finish.

Ora vedrete nel Package Explorer la nostra bella cartella Giochi, cliccate su New Java Package (l’icona indicata nell’immagine).

Restate Giochi in source folder e date come nome del package snakeB_04. Questo sarà il risultato finale:

Cliccate ora su New Java Class e date un nome alla vostra classe.

Cliccate su Finish e si aprirà il vostro bel file Snake.java pronto da essere editato.

Cancellate tutto e incollate il codice sorgente contenuto in questo file snake.java. Poi dopo andate nel Package Explorer, cliccate con il destro su Snake.java e scorrete fino alla voce Run As > Java Applet:

Vi verrà chiesto di salvare il programma, date Ok, il tempo di elaborare e codificare in Byte code il codice sorgente e verrà avviata l’applet che potrete testare.

Vi faccio presente che nell’applet ci sono molte imperfezioni e inoltre ho verificato la presenza di un bug abbastanza grave che fa crashare il gioco che non ho avuto tempo di sistemare, quindi se volete potete risolvere i problemi e rielaborare il tutto a vostro piacimento però abbiate l’accortezza di inviarmi indietro la vostra versione modificata perchè così potrò imparare qualcosa da voi. Grazie.

THAT’S ALL!

Ecco qui il link:

java-codice-sorgente-dello-snake-04-di-traffyk

SnakeB 0.3 – Aggiornamento dalla versione precedente e implementazione della MORTE

Molti di voi mi hanno detto che al mio Snake non si moriva mai, che era una palla e che non c’era sfizio..Beh io a tutti vi rispondo che avevo sempre sognato un gioco cos davvero un potente antistress per me! Inoltre visto che non sto mai con le mani in mano vi ho accontentato tutti e ho creato il classico Snake(escluso il fatto che attraversa i muri che mi piace un casino).

Cosa c’ di nuovo? Allora, non potete pi far scontrare il serpente con se stesso, ne fare retromarcia, inoltre stato aggiunto il punteggio con possibilit di memorizzare il Record. Appena possibile rilascer un’ulteriore versione che permetter di salvare i migliori punteggi in un database. Inoltre potete scrivere il vostro nome nella finestra che compare.

È stato inoltre risolto un antipaticissimo Bug, che faceva bloccare Snake che sfociava in un Loop infinito, c’ un altro errore durante il reset in caso di sconfitta meno fastidioso che non sono ancora riuscito a capire in quali casi si crea. Quindi se vi capita ditemi un po in quale situazione o magari mi postate uno screenShot. Grazie RAGAZZI

Per giocare cliccate con il mouse nel riquadro qui sotto, poi muovete i tasti direzionali!

SnakeB 0.2 – Il mio primo giochino cazzuto in Java

Chi di voi non ha giocato al buon vecchio Snake?? Immagino tutti…ah ricordo ancora i megatornei dietro al banco del liceo con i cellulari allo Snake 1 e 2 della Nokia, hihihi quante ne abbiamo combinate(Catap t ricord record?? hiihihhi), naturalmente il sottoscritto li ha battuti tutti, e se si permettono di dire che non vero abbuscano tutti quanti uno ad uno! ihihihi LOL. Ritorniamo a noi, questo Snake un pochino particolare…Stufo di perdere ore ed ore per poi morire e ricominciare da capo ho sempre sognato di crearmene uno dove non si muore mai….AVETE CAPITO BENE! QUI NON SI MUORE MAI! hihihih. Ma non finita qui…elenco brevemente le particolarit di questo gioco:

• Snake attraversa i bordi e ricompare all’altra estremit ;
• Snake si annoda su se stesso, fa le capriole, si attorciglia tutto quanto e non si affoga mai! hihihi;
• Snake, e sentite bene questa, ha la RETROMARCIA! Basta invertire la direzione e il simpatico serpentello prima si contrae e poi va dall’altra parte!
• Mantenendo il tasto premuto di direzione, il serpente raddoppia la velocit di movimento! Nos Inside! (Come soprannominato da Pako! Grande!).

Il gioco per funzionare necessita della Java Virtual Machine, aggiornata alla versione 1,5(o versione 5 la stessa cosa). Tecnicamente parlando questo gioco non si basa sulla classica(e molto dispendiosa) matrice NxN vista qualche post fa, ma su una lista a puntatori che memorizza tutte le posizioni dello Snake(e volendo si pu usare anche il classico ArrayList ma siccome lo sto studiando in Lasd, mi sono creato il TDA, tipo di dato astratto, da solo).

Per giocare cliccate con il mouse nel riquadro qui sotto, poi muovete i tasti direzionali!