kolokviumska Poraki AIPS vtor kolovium 2020

/*
se cita broj N koj pretstavuva br na poraki koi se vnesuvaat vo hash
se vnesuvaat poraki od vlez vo format: ime vreme datum status
 - statusot moze da e READ, UNREAD ili TRASH.
*faktor na popolnetost na hashot mora da e 0.5

se cita broj M koj pretstavuva br na poraki na koi treba da im se promeni statusot
se vnesuvaat poraki od vlez vo format: ime vreme datum operacija
na porakata treba da i se smeni statusot soodvetno so operacijata sto se izvrsuva

operacija   status
READ        READ
UNREAD      UNREAD
DELETE      TRASH
RECOVER     READ

za sekoja poraka se cuva kolku pati bil promenet statusot

se cita broj K koj pretstavuva br na poraki za koi treba da se ispecati statusot i kolku pati toj bil promenet
se vnesuvaat poraki od vlez vo format: ime vreme datum
treba da se ispecati: status br_na_promeni

primeri:

pr1.
3
poraka1 12:35 07.06.2020 READ
poraka2 13:40 09.07.2012 TRASH
poraka3 01:09 12.12.1999 UNREAD
3
poraka1 12:35 07.06.2020 DELETE
poraka2 13:40 09.07.2012 RECOVER
poraka3 01:09 12.12.1999 READ
3
poraka1 12:35 07.06.2020
poraka2 13:40 09.07.2012
poraka3 01:09 12.12.1999

pr2.
3
poraka1 12:35 07.06.2020 READ
poraka2 13:40 09.07.2012 TRASH
poraka3 01:09 12.12.1999 UNREAD
6
poraka1 12:35 07.06.2020 DELETE
poraka2 13:40 09.07.2012 RECOVER
poraka3 01:09 12.12.1999 READ
poraka1 12:35 07.06.2020 RECOVER
poraka2 13:40 09.07.2012 READ
poraka3 01:09 12.12.1999 DELETE
3
poraka1 12:35 07.06.2020
poraka2 13:40 09.07.2012
poraka3 01:09 12.12.1999

 */


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

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 + ">";
    }
}

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];
    }

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

    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;
    }
}

class Status1{ // se cuva par od status i kolku pati toj bil promenet

    private String status;
    private  int brojac;

    public Status1( String st ){

        status = st;
        brojac = 0;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
        brojac++;
    }

    public void pecatiStatus1(){

        System.out.println( status + " " + brojac );
    }

}

public class Poraki {

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

        BufferedReader br = new BufferedReader( new InputStreamReader( System.in ));
        String read = br.readLine();
        int N = Integer.parseInt( read ); // br na poraki

        OBHT< String, Status1 > table = new OBHT<>( 2*N );

        for ( int i = 0; i < N; i++ ){

            read= br.readLine();
            String[] niza = read.split( " " );
            String key = niza[0] + " " + niza[1] + " " + niza[2];
            Status1 value = new Status1( niza[3] );

            table.insert( key, value );
        } // vnesuvam poraki vo hash

        read = br.readLine();
        int M = Integer.parseInt( read ); // broj na operacii vrz porakite

        for ( int i = 0; i < M; i++ ){

            read= br.readLine();
            String[] niza = read.split( " " );
            String key = niza[0] + " " + niza[1] + " " + niza[2];
            // niza[3] e operacija so treba da se izvrsi
            String operation = niza[3]; // operations: READ UNREAD DELETE RECOVER
            int b = table.search( key );
            if( b < 0 ){
                System.out.println( "Ne postoi porakata 1" );
                continue;
            }

            MapEntry< String, Status1 > temp = table.getMapEntry( b );

            if( operation.equals( "READ" ) ){

                temp.value.setStatus( "READ" );
            }
            if( operation.equals( "UNREAD" ) ){

                temp.value.setStatus( "UNREAD" );
            }
            if( operation.equals( "DELETE" ) ){

                temp.value.setStatus( "TRASH" );
            }
            if( operation.equals( "RECOVER" ) ){

                temp.value.setStatus( "READ" );
            }

        }

        read = br.readLine();
        int K = Integer.parseInt( read ); // broj na poraki za da se vrati ststus

        for ( int i = 0; i < K; i++ ){

            read= br.readLine();
            String[] niza = read.split( " " );
            String key = niza[0] + " " + niza[1] + " " + niza[2];

            int b = table.search( key );
            if( b < 0 ){
                System.out.println( "Ne postoi porakata" );
                continue;
            }

            MapEntry< String, Status1 > temp = table.getMapEntry( b );
            temp.value.pecatiStatus1();

        }

    }
}