MINMAX; STACKED CANVAS

=== MINMAX ===

Да се имплемнтира генеричка класа MinMax од два споредливи објекти (минимум/максимум). За класата да се имплементираат:

MinMax()-default конструктор
void update(T element) - метод за ажурирање на тековните минимум/максимум.
T max() - го враќа најголемиот елемент
T min() - го враќа најмалиот елемент
да се преоптовари методот toString() кој враќа стринг составен од минималниот и максималниот елемент и бројот на елементи обработени во методот update кои се различни од тековниот минимум/максимум, разделени со празно место.
Во класата не смеат да се чуваат елементите кои се обработуваат во методот update, освен тековниот минимум/максимум.


import java.util.Scanner;
import java.io.*;
import java.util.*;

class MinMax<E extends Comparable<E>>{
    E maximum;
    E minimum;
    int countMax;
    int countMin;
    int counter;
    public MinMax(){
        maximum = null;
        countMax = 0;
        minimum = null;
        countMin = 0;
        counter = 0;
    }
    public void update(E el){
        if(maximum == null&&minimum == null){
            maximum = el;
            minimum = el;
            countMax++;
            countMin++;
            return;
        }
        if(maximum.equals(el) || minimum.equals(el)){
            if(maximum.equals(el))
                countMax++;
            else countMin++;
            return;
        }
        if(el.compareTo(maximum) < 0 && el.compareTo(minimum) > 0){
            counter++;
            return;
        }
        if(el.compareTo(maximum) > 0){
            if(!maximum.equals(minimum)){
                counter+=countMax;
                countMax = 1;
            }
            maximum = el;
            return;
        }
        if(el.compareTo(minimum) < 0){
            if(!maximum.equals(minimum)){
                counter+=countMin;
                countMin = 1;
            }
            minimum = el;
            return;
        }
    }
    public E max(){
        return maximum;
    }
    public E min(){
        return minimum;
    }
    public String toString(){
        return minimum.toString()+" "+maximum.toString()+" "+counter+"\n";
    }
}

public class MinAndMax {
    public static void main(String[] args) throws ClassNotFoundException {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        MinMax<String> strings = new MinMax<String>();
        for(int i = 0; i < n; ++i) {
            String s = scanner.next();
            strings.update(s);
        }
        System.out.println(strings);
        MinMax<Integer> ints = new MinMax<Integer>();
        for(int i = 0; i < n; ++i) {
            int x = scanner.nextInt();
            ints.update(x);
        }
        System.out.println(ints);
    }
}

=== STACKED CANVAS ===

Да се имплементира класа Canvas на која ќе чуваат различни форми. За секоја форма се чува:

id:String
color:Color (enum дадена)
Притоа сите форми треба да имплментираат два интерфејси:

Scalable - дефиниран со еден метод void scale(float scaleFactor) за соодветно зголемување/намалување на формата за дадениот фактор
Stackable - дефиниран со еден метод float weight() кој враќа тежината на формата (се пресметува како плоштина на соодветната форма)
Во класата Canvas да се имплементираат следните методи:

void add(String id, Color color, float radius) за додавање круг
void add(String id, Color color, float width, float height) за додавање правоаголник
При додавањето на нова форма, во листата со форми таа треба да се смести на соодветното место според нејзината тежина. Елементите постојано се подредени според тежината во опаѓачки редослед.

void scale(String id, float scaleFactor) - метод кој ја скалира формата со даденото id за соодветниот scaleFactor. Притоа ако има потреба, треба да се изврши преместување на соодветните форми, за да се задржи подреденоста на елементите.
Не смее да се користи сортирање на листата.

toString() - враќа стринг составен од сите фигури во нов ред. За секоја фигура се додава:
C: [id:5 места од лево] [color:10 места од десно] [weight:10.2 места од десно] ако е круг
R: [id:5 места од лево] [color:10 места од десно] [weight:10.2 места од десно] ако е правоаголник
Користење на instanceof ќе се смета за неточно решение


import java.util.Scanner;
import java.util.*;

enum Color {
    RED, GREEN, BLUE
}
public class ShapesTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Canvas canvas = new Canvas();
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            int type = Integer.parseInt(parts[0]);
            String id = parts[1];
            if (type == 1) {
                Color color = Color.valueOf(parts[2]);
                float radius = Float.parseFloat(parts[3]);
                canvas.add(id, color, radius);
            } else if (type == 2) {
                Color color = Color.valueOf(parts[2]);
                float width = Float.parseFloat(parts[3]);
                float height = Float.parseFloat(parts[4]);
                canvas.add(id, color, width, height);
            } else if (type == 3) {
                float scaleFactor = Float.parseFloat(parts[2]);
                System.out.println("ORIGNAL:");
                System.out.print(canvas);
                canvas.scale(id, scaleFactor);
                System.out.printf("AFTER SCALING: %s %.2f\n", id, scaleFactor);
                System.out.print(canvas);
            }

        }
    }
}

class Canvas {
    List<Form> forms;
    public Canvas(){
        forms = new ArrayList<Form>();
    }
    void add(String id, Color color, float radius){
        Form ins = new Circle(id,color,radius);
        this.addForm(ins);
    }
    void add(String id, Color color, float width, float height){
        Form ins = new Rectangle(id,color,width, height);
        this.addForm(ins);
    }
    void addForm(Form ins){
        if(forms.size() == 0){
            forms.add(ins);
            return;
        }
        else{
            for(int i = 0; i < forms.size(); i++){
                if( ins.weight() > forms.get(i).weight() ){
                    forms.add(i, ins);
                    return;
                }
            }
        }
        forms.add(ins);
    }
    public void scale(String id, float scaleFactor){
        for(int i = 0; i < forms.size(); i++){
            if(forms.get(i).getId().equals(id)){
                Form move = forms.get(i);
                forms.remove(i);
                move.scale(scaleFactor);
                this.addForm(move);
                return;
            }
        }
    }
    public String toString(){
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < forms.size(); i++){
            sb.append(forms.get(i).toString());
        }
        return sb.toString();
    }
}
class Circle extends Form{
    float radius;
    public Circle(String _id, Color _color, float _radius){
        super(_id, _color);
        radius = _radius;
    }
    @Override
    public float weight() {
        return  (float) (radius*radius*Math.PI);
    }
    @Override
    public void scale(float scaleFactor) {
        radius = radius * scaleFactor;
        //System.out.println("SCALE " + id +" " +radius);
    }
    public String toString(){
        return String.format("C: %-5s%-10s%10.2f\n", id, color, weight());
    }
}
class Rectangle extends Form{
    float width;
    float height;
    public Rectangle(String _id, Color _color, float _width, float _height){
        super(_id, _color);
        width = _width;
        height = _height;
    }
    @Override
    public float weight() {
        return width*height;
    }
    @Override
    public void scale(float scaleFactor) {
        width = width * scaleFactor;
        height = height * scaleFactor;
    }
    public String toString(){
        return String.format("R: %-5s%-10s%10.2f\n", id, color, weight());
    }
}
abstract class Form implements Scalable, Stackable{
    String id;
    Color color;
    public Form (String _id, Color _color){
        id = _id;
        color = _color;
    }
    public String getId(){
        return id;
    }
    abstract public float weight();
    abstract public void scale(float scaleFactor);
}
interface Scalable{
    void scale(float scaleFactor);
}
interface Stackable{
    float weight();
}