1. Definizione della classe base e delle sottoclassi.

   FILE: Ingranaggio.java

   public class Ingranaggio {
       public static class Dimensione {
           public final int altezza, larghezza, profondita;
   
           public Dimensione(int a, int l, int p) {
               altezza = a;
               larghezza = l;
               profondita = p;
           }
       }
   
       private final String codice;
       private final Dimensione dim;
   
       public Ingranaggio(String c, Dimensione d) {
           codice = c;
           dim = d;
       }
   
       public String getCodice() { return codice; }
       public Dimensione getDimensione() { return dim; }
   
       @Override
       public boolean equals(Object o) {
           if (o == null || !(o instanceof Ingranaggio)) return false;
           return codice.equals(((Ingranaggio)o).codice);
       }
   }
   

   FILE: IngrSemplice.java

   import java.util.*;
   
   public class IngrSemplice extends Ingranaggio {
       private final String tipo;
       private Ingranaggio[] compatibili = new Ingranaggio[0];
   
       public IngrSemplice(String c, Dimensione d, String t) {
           super(c, d);
           tipo = t;
       }
   
       public String getTipo() { return tipo; }
       
       public boolean isCompatibile(Ingranaggio ingr) {
           if (ingr == null) return false;
           for (int i = 0 ; i < compatibili.length ; i++)
               if (compatibili[i].equals(ingr))
                   return true;
           return false;
       }
   
       public boolean add(Ingranaggio ingr) {
           if (isCompatibile(ingr)) return false;
           compatibili = Arrays.copyOf(compatibili, compatibili.length + 1);
           compatibili[compatibili.length - 1] = ingr;
           return true;
       }
   }
   

   FILE: IngrComposto.java

   import java.util.*;
   
   public class IngrComposto extends Ingranaggio {
       private Ingranaggio[] componenti = new Ingranaggio[0];
   
       public IngrComposto(String c, Dimensione d) {
           super(c, d);
       }
       
       public int componentCount(Ingranaggio ingr) {
           int cont = 0;
           for (int i = 0 ; i < componenti.length ; i++) {
               if (componenti[i].equals(ingr)) {
                   cont++;
               } else if (componenti[i] instanceof IngrComposto) {
                   cont += ((IngrComposto)componenti[i]).componentCount(ingr);
               }
           }
           return cont;
       }
   
       public void add(Ingranaggio ingr) {
           if (ingr == null)
               throw new IllegalArgumentException();
           if (ingr instanceof IngrComposto) {
               if (((IngrComposto)ingr).componentCount(this) > 0)
                   throw new IllegalArgumentException();
           }
           componenti = Arrays.copyOf(componenti, componenti.length + 1);
           componenti[componenti.length - 1] = ingr;
       }
   }
   

2. Il metodo getCompSemplici() della classe IngrComposto.

       //Metodo ausiliario che aggiunge gli ingranaggi ingr all'array e ritorna
       //l'array modificato.
       private static IngrSemplice[] addIngrS(IngrSemplice[] array, IngrSemplice...ingr) {
           int n = array.length;
           array = Arrays.copyOf(array, n + ingr.length);
           System.arraycopy(ingr, 0, array, n, ingr.length);
           return array;
       }
       
       public IngrSemplice[] getCompSemplici() {
           IngrSemplice[] ps = new IngrSemplice[0];
           for (int i = 0 ; i < componenti.length ; i++) {
               if (componenti[i] instanceof IngrSemplice) {
                   ps = addIngrS(ps, (IngrSemplice)componenti[i]);
               } else if (componenti[i] instanceof IngrComposto) {
                   ps = addIngrS(ps, ((IngrComposto)componenti[i]).getCompSemplici());
               }
           }
           return ps;
       }
   

import java.util.*;

public class ShapeTree<T extends Shape<? super T>> implements Iterable<T> {
    private final Map<T, Set<T>> children = new HashMap<T, Set<T>>();

    public ShapeTree(T root) {
        children.put(root, new HashSet<T>());
    }

    public boolean contains(T u) {
        return children.containsKey(u);
    }

    public void addChild(T par, T u) {
        if (u == null || !contains(par) || contains(u))
            throw new IllegalArgumentException();
        children.get(par).add(u);
        children.put(u, new HashSet<T>());
    }

    public double area(T r) {
        if (!contains(r)) throw new IllegalArgumentException();
        double a = r.area();
        for (T c : children.get(r))
            a += area(c);
        return a;
    }

    public Set<T> covered(T r, Collection<? extends T> coll) {
        if (!contains(r)) throw new IllegalArgumentException();
        Set<T> cov = new HashSet<T>();
        if (r.isCovered(coll)) cov.add(r);
        for (T c : children.get(r))
            cov.addAll(covered(c, coll));
        return cov;
    }
        //Metodo ausiliario che ritorna l'insieme delle forme nel sottoalbero di r
    private Set<T> subtree(T r) {
        Set<T> st = new HashSet<T>();
        st.add(r);
        for (T c : children.get(r))
            st.addAll(subtree(r));
        return st;
    }

    public boolean isCovered(T r, T x) {
        if (!contains(r) || x == null)
            throw new IllegalArgumentException();
        Set<T> st = subtree(r);
        return x.isCovered(st);
    }

    @Override
    public Iterator<T> iterator() {
        return Collections.unmodifiableSet(children.keySet()).iterator();
    }
}

C'è un solo errore.

1. Linea 12: if (p.process(x) > 3) return false;   provoca un errore in compilazione perchè x non è di tipo T.

import java.util.*;

public class Main {
    public static <T> List<Set<T>> InvIndex(Map<T, ? extends Set<Integer>> map) {
        List<Set<T>> list = new ArrayList<Set<T>>();
        for (T k : map.keySet()) {
            Set<Integer> indices = map.get(k);
            for (Integer ind : indices) {
                if (ind >= list.size()) {
                    for (int i = list.size() ; i <= ind ; i++)
                        list.add(null);
                }
                if (list.get(ind) == null)
                    list.set(ind, new HashSet<T>());
                list.get(ind).add(k);
            }
        }
        return list;
    }
}