[ADSx] - Spell Checking

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

class MapEntry<K extends Comparable<K>, E> implements Comparable<K> {
    K key;
    E value;

    public MapEntry(K key, E val) {
        this.key = key;
        this.value = val;
    }

    public int compareTo(K that) {
        @SuppressWarnings("unchecked")
        MapEntry<K, E> other = (MapEntry<K, E>) that;
        return this.key.compareTo(other.key);
    }

    public String toString() {
        return "(" + key + "," + value + ")";
    }
}


class OBHT<K extends Comparable<K>, E> {

    private MapEntry<K, E>[] buckets;
    static final int NONE = -1; // ... distinct from any bucket index.
    @SuppressWarnings({"rawtypes", "unchecked"})
    private static final MapEntry former = new MapEntry(null, null);
    private int occupancy = 0;

    @SuppressWarnings("unchecked")
    public OBHT(int m) {
        buckets = (MapEntry<K, E>[]) new MapEntry[m];
    }

    private int hash(K key) {
        return Math.abs(key.hashCode()) % buckets.length;
    }

    public MapEntry<K, E> getBucket(int i) {
        return buckets[i];
    }

    public int search(K targetKey) {
        int b = hash(targetKey);
        int n_search = 0;
        for (; ; ) {
            MapEntry<K, E> oldEntry = buckets[b];
            if (oldEntry == null)
                return NONE;
            else if (targetKey.equals(oldEntry.key))
                return b;
            else {
                b = (b + 1) % buckets.length;
                n_search++;
                if (n_search == buckets.length)
                    return NONE;
            }
        }
    }

    public void insert(K key, E val) {
        MapEntry<K, E> newEntry = new MapEntry<K, E>(key, val);
        int b = hash(key);
        int n_search = 0;

        for (; ; ) {
            MapEntry<K, E> oldEntry = buckets[b];
            if (oldEntry == null) {
                if (++occupancy == buckets.length) {
                    System.out.println("Hash tabelata e polna!!!");
                }
                buckets[b] = newEntry;
                return;
            } else if (oldEntry == former
                    || key.equals(oldEntry.key)) {
                buckets[b] = newEntry;
                return;
            } else {
                b = (b + 1) % buckets.length;
                n_search++;
                if (n_search == buckets.length)
                    return;

            }
        }
    }

    @SuppressWarnings("unchecked")
    public void delete(K key) {
        int b = hash(key);
        int n_search = 0;
        for (; ; ) {
            MapEntry<K, E> oldEntry = buckets[b];

            if (oldEntry == null)
                return;
            else if (key.equals(oldEntry.key)) {
                buckets[b] = former;
                return;
            } else {
                b = (b + 1) % buckets.length;
                n_search++;
                if (n_search == buckets.length)
                    return;

            }
        }
    }

    public String toString() {
        String temp = "";
        for (int i = 0; i < buckets.length; i++) {
            temp += i + ":";
            if (buckets[i] == null)
                temp += "\n";
            else if (buckets[i] == former)
                temp += "former\n";
            else
                temp += buckets[i] + "\n";
        }
        return temp;
    }
}


class Zbor implements Comparable<Zbor> {
    String zbor;

    public Zbor(String zbor) {
        this.zbor = zbor;
    }

    @Override
    public boolean equals(Object obj) {
        Zbor pom = (Zbor) obj;
        return this.zbor.equals(pom.zbor);
    }

    @Override
    public int hashCode() {
        /*
        *
        * Vie ja kreirate hesh funkcijata
        *
        */
        return zbor.hashCode();
    }

    @Override
    public String toString() {
        return zbor;
    }

    @Override
    public int compareTo(Zbor arg0) {
        return zbor.compareTo(arg0.zbor);
    }
}

public class Speluvanje {
    public static void main(String[] args) throws IOException {
        OBHT<Zbor, String> obht;
        Scanner scanner = new Scanner(System.in);
        int N = Integer.parseInt(scanner.nextLine());

        //---Vie odluchete za goleminata na hesh tabelata----
        obht = new OBHT<>(N + 1);

        for (int i = 0; i < N; i++) {
            String word = scanner.nextLine().toLowerCase();
            String current = trim(word);
            obht.insert(new Zbor(current), current);
        }

        //System.out.println(obht.toString());

        String text = scanner.nextLine().toLowerCase();
        String split[] = text.split("\\s+");

        /*Matcher matcher= Pattern.compile("\\w+").matcher(text);
        while (matcher.find()){

        }*/

        List<String> wrongWords = new ArrayList<>();

        //System.out.println(Arrays.toString(split));

        for (int i = 0; i < split.length; i++) {
            String current = trim(split[i]);
            int searchIndex = obht.search(new Zbor(current));
            if (searchIndex == -1) {
                //System.out.println(current + " S:" + split[i]);
                if (current.length() != 0) {
                    wrongWords.add(current);
                }
            }
        }
        //System.out.println(wrongWords);
        //System.out.println(wrongWords.size());
        if (wrongWords.size() == 0) System.out.println("Bravo");
        else System.out.println(wrongWords.stream()
                .collect(Collectors.joining("\n")));

    }

    public static String trim(String word) {
        Character last = word.charAt(word.length() - 1);
        if (!Character.isAlphabetic(last))
            return word.substring(0, word.length() - 1);
        return word;
    }
}

/**
 * Write a program to check the spelling of a text. You are given a dictionary of english words, then a text that should be spell-checked. As a result, all incorrectly spelled words, or words not in the dictionary should be printed.
 * <p>
 * Input: First you input the number N, then N lines of english words, then the text to be checked.
 * <p>
 * Output: Print a list of incorrectly spelled words (each on its own line). If all words are correct, print: Bravo.
 * <p>
 * Note: Avoid punctuation marks such as, dot (.), comma (,), exclamation point (!) and question makr (?). Words are case insensitive, i.e. words with first capital letter in the text should be considered correct even if they don't start with capital in the dictionary. Work with open bucket hash table (OBHT). You are left to decide the number of buckets in the table.
 */