[НП] Блоковска структура

/*
Блоковска структура (35 поени) Problem 3 (1 / 2)

Да се имплементира генеричка класа за блок контејнер BlockContainer. Контејнерот треба да има блоковска структура, со тоа што секој блок содржи N елементи. Контејнерот треба да ги задоволува следните услови:
* константно време на пристап до секој блок O(1)
* логаритамско време на пристап до елементите во блокот O(logN)
* елементите во секој блок треба да бидат сортирани.
* Класата треба да ги имплементира следните методи:

public BlockContainer(int n) - конструктор со еден аргумент, максималниот број на елементи во блокот

public void add(T a) - метод за додавање елемент во последниот блок од контејнерот (ако блокот е полн, се додава нов блок)

public boolean remove(T a) - метод за бришње на елемент од последниот блок (ако се избришат сите елементи од еден блок, тогаш и блокот се брише)

public void sort() - метод за сортирање на сите елементи во контејнерот

public String toString() - препокривање на методот да враќа String во следниот формат: пример: [7, 8, 9],[1, 2, 3],[5, 6, 12],[4, 10, 8]

INPUT:
11 2
89 12 54 11 5 1 7 8 2 4 14
abc ccc bcxs abcde fdsr aerdd fdsa fdf etie lidj trdf

OUTPUT:
+++++ Integer Block Container +++++
[12, 89],[11, 54],[1, 5],[7, 8],[2, 4],[14]
+++++ Removing element +++++
+++++ Sorting container +++++
[1, 2],[4, 5],[7, 8],[11, 12],[54, 89]
+++++ String Block Container +++++
[abc, ccc],[abcde, bcxs],[aerdd, fdsr],[fdf, fdsa],[etie, lidj],[trdf]
+++++ Removing element +++++
+++++ Sorting container +++++
[abc, abcde],[aerdd, bcxs],[ccc, etie],[fdf, fdsa],[fdsr, lidj]
*/

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class BlockContainerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int size = scanner.nextInt();
        BlockContainer<Integer> integerBC = new BlockContainer<Integer>(size);
        scanner.nextLine();
        Integer lastInteger = null;
        for(int i = 0; i < n; ++i) {
            int element = scanner.nextInt();
            lastInteger = element;
            integerBC.add(element);
        }
        System.out.println("+++++ Integer Block Container +++++");
        System.out.println(integerBC);
        System.out.println("+++++ Removing element +++++");
        integerBC.remove(lastInteger);
        System.out.println("+++++ Sorting container +++++");
        integerBC.sort();
        System.out.println(integerBC);
        BlockContainer<String> stringBC = new BlockContainer<String>(size);
        String lastString = null;
        for(int i = 0; i < n; ++i) {
            String element = scanner.next();
            lastString = element;
            stringBC.add(element);
        }
        System.out.println("+++++ String Block Container +++++");
        System.out.println(stringBC);
        System.out.println("+++++ Removing element +++++");
        stringBC.remove(lastString);
        System.out.println("+++++ Sorting container +++++");
        stringBC.sort();
        System.out.println(stringBC);
    }
}

// Вашиот код овде
class Block<T extends Comparable<T>> {
    private Set<T> elems;

    public Block(T elem) {
        this.elems = new TreeSet<>();
        this.elems.add(elem);
    }

    public void addElement(T elem) {
        elems.add(elem);
    }

    public boolean removeFromLastBlock(T a) {
        elems.remove(a);
        return elems.size() == 0;
    }

    public boolean isBlockFull(int size) {
        return elems.size() == size;
    }

    public Set<T> getElems() {
        return elems;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        elems.forEach((e) -> sb.append(e.toString()).append(", "));
        sb.setLength(sb.length()-2);
        return sb.toString();
    }
}

class BlockContainer<T extends Comparable<T>> {
    private List<Block<T>> blocks;
    private int blocksNumber;
    private static int maxElementsInBlock;

    public BlockContainer(int size) {
        maxElementsInBlock = size;
        this.blocks = new ArrayList<>();
        this.blocksNumber = -1;
    }

    public void add(T a) {
        if(blocksNumber == -1 || blocks.get(blocksNumber).isBlockFull(maxElementsInBlock)) {
            blocks.add(new Block<>(a));
            blocksNumber++;
        } else blocks.get(blocksNumber).addElement(a);
    }

    public void remove(T a) {
        if(blocks.get(blocksNumber).removeFromLastBlock(a)) {
            blocks.remove(blocksNumber--);
        }
    }

    public void sort() {
        List<T> sortedElems = blocks.stream()
                .flatMap((b) -> b.getElems().stream())
                .sorted(Comparable::compareTo)
                .collect(Collectors.toList());

        this.blocks = new ArrayList<>();
        this.blocksNumber = -1;

        IntStream.range(0, sortedElems.size())
                .forEach((i) -> add(sortedElems.get(i)));
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        blocks.forEach((b) -> sb.append("[").append(b).append("]").append(","));
        sb.setLength(sb.length()-1);
        return sb.toString();
    }
}