[APS] Kumanovski Dijalekt

Кумановски дијалект Problem 1 (3 / 6)

Даден ви е речник на зборови на кумановски дијалект и како тие се пишуваат на македонски јазик. Потоа даден ви е текст којшто е напишан на кумановски дијалект. Потребно е да ги замените сите појавувања на зборовите на кумановскиот дијалект кои се дадени во речникот со соодветни зборови на македонски јазик.

Забелешка: Треба да се игнорираат интерпункциските знаци точка (.) , запирка (,), извичник(!) и прашалник (?). Исто така зборовите во текстот можат да се појават и со прва голема буква и во тој случај неговиот синоним на македонски јазик исто така треба да се отпечати со прва голема буква.

Име на класата (Java): KumanovskiDijalekt.

=========================================================================================================================================

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class KumanovskiDijalekt {

   static class MapEntry<K extends Comparable<K>,E> implements Comparable<K> {

        // Each MapEntry object is a pair consisting of a key (a Comparable
        // object) and a value (an arbitrary object).
        K key;
        E value;

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

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

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


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

        // An object of class OBHT is an open-bucket hash table, containing entries
        // of class MapEntry.
        private MapEntry<K,E>[] buckets;

        // buckets[b] is null if bucket b has never been occupied.
        // buckets[b] is former if bucket b is formerly-occupied
        // by an entry that has since been deleted (and not yet replaced).

        static final int NONE = -1; // ... distinct from any bucket index.

        private static final MapEntry former = new MapEntry(null, null);
        // This guarantees that, for any genuine entry e,
        // e.key.equals(former.key) returns false.

        private int occupancy = 0;
        // ... number of occupied or formerly-occupied buckets in this OBHT.

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


        private int hash (K key) {
            // Translate key to an index of the array buckets.
            return Math.abs(key.hashCode()) % buckets.length;
        }


        public int search (K targetKey) {
            // Find which if any bucket of this OBHT is occupied by an entry whose key
            // is equal to targetKey. Return the index of that bucket.
            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) {
            // Insert the entry <key, val> into this OBHT.
            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) {
            // Delete the entry (if any) whose key is equal to key from this OBHT.
            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;//(MapEntry<K,E>)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;
        }


        public OBHT<K,E> clone () {
            OBHT<K,E> copy = new OBHT<K,E>(buckets.length);
            for (int i = 0; i < buckets.length; i++) {
                MapEntry<K,E> e = buckets[i];
                if (e != null&&e != former)
                    copy.buckets[i] = new MapEntry<K,E>(e.key, e.value);
                else
                    copy.buckets[i] = e;
            }
            return copy;
        }
    }


    public static void main(String[] args) throws IOException {


        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(in.readLine());

        OBHT<String, String> ht = new OBHT<String, String>(n+n+1);
        for(int i = 0; i < n;i++){
            String line = in.readLine();
            String pom[] = line.split(" ");

            ht.insert(pom[0], pom[1]);
        }

        String rez= "";
        String tekst = in.readLine();
        String pom[] = tekst.split(" ");
        for(int i = 0; i < pom.length;i++){

        String zbor = pom[i];

        // dali ima karakter na posledna bukva
         boolean last = Character.isAlphabetic(zbor.charAt(zbor.length()-1));
         boolean first = Character.isUpperCase(zbor.charAt(0));
         char lastChar = zbor.charAt(zbor.length()-1);
         if(!last){
             // izostavi go posledniot karakter
              zbor = zbor.substring(0,zbor.length()-1);
         }
        // dali ima prva golema bukva
        if(first)
            zbor = Character.toLowerCase(zbor.charAt(0)) + zbor.substring(1);



        // dali go ima vo ht
        if(ht.search(zbor)>=0){
            // 1. go ima
            int key = ht.search(zbor);
            String sk = ht.buckets[key].value;
            if(first){
                sk = Character.toUpperCase(sk.charAt(0)) + sk.substring(1);
            }
            if(!last){
                sk += lastChar;
            }
            System.out.print(sk + " ");

        }else{
            // 2. go nema vo ht

            if(!last){
                zbor += lastChar;
            }

            if(first){
                zbor = Character.toUpperCase(zbor.charAt(0)) + zbor.substring(1);
            }

            System.out.print(zbor+" ");
        }
    }


    }

}






/*



            String zbor = pom[i];
            char last = zbor.charAt(zbor.length() -1);
            boolean first = Character.isUpperCase(zbor.charAt(0));
            // ako e karakter
            if(Character.isLetter(last)){
                if(first){
                    zbor = zbor.toLowerCase();
                }
                int key = ht.search(zbor);
                String novZbor = ht.buckets[key].value;
                if(first){
                    char c = Character.toUpperCase(zbor.charAt(0));
                    String tmp = c+novZbor.substring(1);
                    novZbor = tmp;
                }
                zbor.

            }
            // ako ne e karakter




 */