Appello svolto esame programmazione orientata ad oggetti 9-12 CFU

STORE SLOAD# WADD ISTORE WILOAD# ZADD ISTORE ZILOAD SSUB@ WIJNZ ELSELOAD# 1STORE@ ZIJUMP FINEIFELSE:LOAD# 0STORE@ ZIFINEIF:LOAD IADD# 1STORE IJUMP FORROF:LOAD# 0STORE IFORZ:LOAD ISUB LENGTHJZ FINEFORZLOAD# ZADD ISTORE ZI; z[i]WRITE@ ZI; scrivi z[i]LOAD IADD# 1STORE IJUMP FORZFINEFORZ:HALT 4

Esercizio 3 bis.Leggere un array di 10 interi, ordinarlo con il metodo selection sort e scrivere su output il vettore ordinato.Progettare prima l'algoritmo in Java e quindi derivare sistematicamente una sua versione RASP.

int[] a=new int[10];
leggi a;
for( int j=a.length-1; j>0; j-- ){
  int iMax=0;
  for( int i=1; i<=j; i++ ){
    if( a[i]>a[iMax] ) iMax=i;
  }
  //scambia a[j] con a[iMax]
  int park=a[j];
  a[j]=a[iMax];
  a[iMax]=park;
}
//for esterno
scrivi a;

A: RES 10
LOAD# 10
STORE LENGTH
lettura di A
LOAD# 0
STORE ILA
LOAD I ;qui inizia il ciclo Lettura di A
SUB LENGTHJZ AL
LOAD# A
ADD I
STORE AIREAD@ AI
LOAD IADD# 1
STORE IJUMP LA
AL: ;qui finisce la lettura di A
LOAD LENGTH
SUB# 1
STORE JFORE:

;FOREsterno
<FOR>
    <LOAD> JJZ
    <EROFLLOAD> # 0</EROFLLOAD>
    <STORE> IMAX
    <LOAD> # 1</LOAD>
    <STORE> IFOR
    <I: ;FORInterno>
        <LOAD> ISUB
        <JJGZ> IROF
    </I: ;FORInterno>
</FOR>

<LOAD> # A
<ADD> IMAX
<STORE> AIMAX
<LOAD> # A
<ADD> 5
<ADD> I
<STORE> AI
<LOAD@> AI
<ISUB@> AIMAX
<JLEZ> AVANTI
<LOAD> I
<STORE> IMAX
<AVANTI:LOAD> I
<ADD> # 1
<STORE> I
<JUMP> FORIIROF

<LOAD> # A
<ADD> J
<STORE> AJ
<LOAD> # A
<ADD> IMAX
<STORE> AIMAX
<LOAD@> AJ
<STORE> PARK
<LOAD@> AIMAX
<STORE@> AJ
<LOAD> PARK
<STORE@> AIMAX
<LOAD> J
<SUB> # 1
<STORE> J
<JUMP> FOREEROF

<LOAD> # A
<ADD> I
<STORE> AI
<WRITE@> AI
<LOAD> I
<ADD> # 1
<STORE> I
<JUMP> SAAS

<HALT> 6

[-14,-1,-2,4,3,5,7,14,10,12]

[-2,-1,5,4,3,12,7,14,10]

package poo.indice;
import java.util.*;

public class Parola implements Comparable<Parola>{
    private String ortografia;
    private Set<Integer> elenco=new TreeSet<Integer>(); // numeri di linea su cui ortografia compare

    public Parola(String ortografia){
        this.ortografia=ortografia;
    }

    public void add(int nr){
        elenco.add(nr);
    }

    public int size(){
        return elenco.size();
    }

    public String getOrtografia(){
        return ortografia;
    }

    public boolean equals(Object o){
        if(!(o instanceof Parola))
            return false;
        if(o==this)
            return true;
        Parola p=(Parola)o;
        return ortografia.equals(p.ortografia);
    }
}

public class Parola implements Comparable<Parola> {
    private String ortografia;
    private List<Integer> elenco;
    
    public Parola(String ortografia) {
        this.ortografia = ortografia;
        this.elenco = new ArrayList<>();
    }
    
    public void addOccorrenza(int numeroRiga) {
        elenco.add(numeroRiga);
    }
    
    public int compareTo(Parola p) {
        if (ortografia.length() < p.ortografia.length() || ortografia.length() == p.ortografia.length() && ortografia.compareTo(p.ortografia) < 0)
            return -1;
        if (this.equals(p))
            return 0;
        return +1;
    }
    
    public String toString() {
        String s = ortografia + "\n";
        Iterator<Integer> i = elenco.iterator();
        while (i.hasNext()) {
            s += i.next() + " ";
        }
        s += "\n";
        return s;
    }
    
    public int hashCode() {
        return ortografia.hashCode();
    }
}

public interface Indice extends Iterable<Parola> {
    int size();
    int occorrenze(String ortografia);
    void add(String ortografia, int numeroRiga);
}

public abstract class IndiceAstratto implements Indice {
    public int size() {
        int c = 0;
        for (Iterator<Parola> it = this.iterator(); it.hasNext(); it.next(), c++);
        return c;
    }
    
    public int occorrenze(String ortografia) {
        int count = 0;
        for (Parola p : this) {
            if (p.getOrtografia().equals(ortografia)) {
                count += p.getElenco().size();
            }
        }
        return count;
    }
}

{Parola orto=new Parola( ortografia );
for( Parola p: this ){
    if( p.equals(orto) ) return p.size();
    if( p.compareTo(orto)>0 ) return 0;
}
return 0;
}//occorrenze

public String toString(){
    StringBuilder sb=new StringBuilder( 400 );
    for( Parola p: this )
        sb.append(p);
    return sb.toString();
}//toString

public boolean equals( Object o ){
    if( !(o instanceof Indice) ) return false;
    if( o==this ) return true;
    Indice ix=(Indice)o;
    if( this.size()!=ix.size() ) return false;
    Iterator<Parola> i1=this.iterator(), i2=ix.iterator();
    while( i1.hasNext() ){
        Parola p1=i1.next(), p2=i2.next();
        if( !p1.equals(p2) ) return false;
    }
    return true;
}//equals

public int hashCode(){
    final int MOLT=43;
    int h=0;
    for( Parola p: this )
        h=h*MOLT+p.hashCode();
    return h;
}//hashCode
}//IndiceAstratto 8

package poo.indice;
import java.util.*;

public class IndiceLinkato extends IndiceAstratto{
    private LinkedList<Parola> indice=new LinkedList<Parola>();
    
    public Iterator<Parola> iterator(){
        return indice.iterator();
    }
    
    public int

size(){ return indice.size(); }

public void add( String ortografia, int nr ){
    Parola p = new Parola( ortografia );
    p.add( nr ); //provvisorio
    ListIterator<Parola> li = indice.listIterator();
    boolean flag = false;
    while( li.hasNext() ){
        Parola q = li.next();
        if( q.equals(p) ){
            q.add( nr );
            return;
        }
        if( q.compareTo(p)>0 ){
            li.previous();
            li.add( p );
            flag=true;
            break;
        }
    }
    if( !flag ) li.add( p );
}//add

public class IndiceMappato extends IndiceAstratto{
    private Map<String,Parola> indice=new TreeMap<String,Parola>();
    
    public Iterator<Parola> iterator(){
        return indice.values().iterator();
    }
    
    public int size(){
        return indice.size();
    }
    
    public int occorrenze( String ortografia ){
        Parola p = indice.get( ortografia );
        if( p == null ) return 0;
        return p.size();
    }//occorrenze
    
    public void add( String ortografia, int nr ){
        Parola p=indice.get( ortografia );
        if( p==null ){
            p=new Parola( ortografia );
            p.add( nr );
            indice.put( ortografia, p );
        }else{
            p.add( nr );
        }
    }//add
}

<!-- IndiceMappatoUtilizzando la classe AlberoBinarioDiRicerca (presente in poo.util) studiata a lezione, è possibile ottenere rapidamente un'altra implementazione di indice concreto come segue. Si ipotizza che AlberoBinarioDiRicerca sia provvisto di struttura di iterazione (come spiegato a lezione). -->
<pre>
<code>
package poo.indice;
import poo.util.*;
import java.util.*;

public class IndiceSuAlbero extends IndiceAstratto {
    private AlberoBinarioDiRicerca<Parola> indice = new AlberoBinarioDiRicerca<Parola>();

    public int occorrenze(String ortografia) {
        Parola p = new Parola(ortografia);
        p = indice.get(p);
        if (p == null) return 0;
        return p.size();
    }//occorrenze

    public void add(String ortografia, int nr) {
        Parola p = new Parola(ortografia);
        if (!indice.contains(p)) {
            p.add(nr);
            indice.add(p);
        } else {
            p = indice.get(p);
            p.add(nr);
        }
    }//add

    public Iterator<Parola> iterator() {
        return indice.iterator();
    }//iterator
}
</code>
</pre>

<pre>
<code>
public class CrossIndex {
    public static void main(String[] args) {
        // Codice del main
    }
}
</code>
</pre>

package poo.indice;
import java.io.*;
import java.util.*;
import poo.testo.*;

public class CrossIndex {
    public static void main(String[] args) throws IOException {
        System.out.println("Indice dei riferimenti incrociati");
        Scanner s = new Scanner(System.in);
        String nomeFile = null;
        File f = null;
        do {
            System.out.print("Nome file testo = ");
            nomeFile = s.nextLine();
            f = new File(nomeFile);
            if (!f.exists())
                System.out.println("File inesistente. Ridarlo!");
        } while (!f.exists());
        
        GestoreTesto gt = new GestoreTesto(f, "\\W+"); // ogni carattere non di word è delimitatore
        Indice indice = new IndiceSuAlbero();
        String word = null;
        int numLinea = 0;
        GestoreTesto.Simbolo simbolo = null;
        
        for (;;) {
            simbolo = gt.prossimoSimbolo();
            if (simbolo == GestoreTesto.Simbolo.EOF)
                break;
            word = gt.getString().toUpperCase();
            numLinea = gt.getNumeroLinea();
            indice.add(word, numLinea);
        }
        
        s.close(); // chiudi scanner su
    }
}

tastieraSystem.out.println();
System.out.println("Contenuto dell'indice");
System.out.println(indice);
}//main}//CrossIndexSi mostra, infine, la classe GestoreTesto (supposta collocata per generalità nel package poo.testo) che si interfaccia con il file testo da elaborare e nasconde i problemi relativi all'ottenimento delle varie parole.
GestoreTesto è un (minimo) analizzatore lessicale (si veda anche l'implementazione della macchina RASP sul libro di testo).
package poo.testo;
import java.io.*;
import java.util.*;
GestoreTestopublic class {
public enum Simbolo{ WORD, EOF }
private boolean EOF=false;
private String linea=null;
private Scanner input, scan;
private int numeroLineaCorrente=0;
private String word, delim;
public GestoreTesto( File f, String delim ) throws IOException{
input=new Scanner( f );
this.delim=delim;
}//costruttore
private void avanza(){
try{
if( linea==null || !scan.hasNext() ){
linea=input.nextLine();
numeroLineaCorrente++;
//echo su output

della lineaSystem.out.println(numeroLineaCorrente+": "+linea);scan=new Scanner( linea );scan.useDelimiter( delim );}}catch( Exception ioe ){EOF=true; input.close();}}//avanzapublic Simbolo prossimoSimbolo() throws IOException{do{avanza()