dzocesrce

[APS] Pharmacy

Aug 31st, 2023
331
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 11.30 KB | None | 0 0
  1. // lugje sho uchat hash > lugje sho ne uchat hash
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.util.Iterator;
  5. import java.util.NoSuchElementException;
  6. import java.io.InputStreamReader;
  7. import java.util.Scanner;
  8. class SLL<E> {
  9.     private SLLNode<E> first;
  10.  
  11.     public SLL() {
  12.         // Construct an empty SLL
  13.         this.first = null;
  14.     }
  15.  
  16.     public void deleteList() {
  17.         first = null;
  18.     }
  19.  
  20.     public int length() {
  21.         int ret;
  22.         if (first != null) {
  23.             SLLNode<E> tmp = first;
  24.             ret = 1;
  25.             while (tmp.succ != null) {
  26.                 tmp = tmp.succ;
  27.                 ret++;
  28.             }
  29.             return ret;
  30.         } else
  31.             return 0;
  32.  
  33.     }
  34.  
  35.     @Override
  36.     public String toString() {
  37.         String ret = new String();
  38.         if (first != null) {
  39.             SLLNode<E> tmp = first;
  40.             ret += tmp + "->";
  41.             while (tmp.succ != null) {
  42.                 tmp = tmp.succ;
  43.                 ret += tmp + "->";
  44.             }
  45.         } else
  46.             ret = "Prazna lista!!!";
  47.         return ret;
  48.     }
  49.  
  50.     public void insertFirst(E o) {
  51.         SLLNode<E> ins = new SLLNode<E>(o, first);
  52.         first = ins;
  53.     }
  54.  
  55.     public void insertAfter(E o, SLLNode<E> node) {
  56.         if (node != null) {
  57.             SLLNode<E> ins = new SLLNode<E>(o, node.succ);
  58.             node.succ = ins;
  59.         } else {
  60.             System.out.println("Dadenot jazol e null");
  61.         }
  62.     }
  63.  
  64.     public void insertBefore(E o, SLLNode<E> before) {
  65.  
  66.         if (first != null) {
  67.             SLLNode<E> tmp = first;
  68.             if(first==before){
  69.                 this.insertFirst(o);
  70.                 return;
  71.             }
  72.             //ako first!=before
  73.             while (tmp.succ != before)
  74.                 tmp = tmp.succ;
  75.             if (tmp.succ == before) {
  76.                 SLLNode<E> ins = new SLLNode<E>(o, before);
  77.                 tmp.succ = ins;
  78.             } else {
  79.                 System.out.println("Elementot ne postoi vo listata");
  80.             }
  81.         } else {
  82.             System.out.println("Listata e prazna");
  83.         }
  84.     }
  85.  
  86.     public void insertLast(E o) {
  87.         if (first != null) {
  88.             SLLNode<E> tmp = first;
  89.             while (tmp.succ != null)
  90.                 tmp = tmp.succ;
  91.             SLLNode<E> ins = new SLLNode<E>(o, null);
  92.             tmp.succ = ins;
  93.         } else {
  94.             insertFirst(o);
  95.         }
  96.     }
  97.  
  98.     public E deleteFirst() {
  99.         if (first != null) {
  100.             SLLNode<E> tmp = first;
  101.             first = first.succ;
  102.             return tmp.element;
  103.         } else {
  104.             System.out.println("Listata e prazna");
  105.             return null;
  106.         }
  107.     }
  108.  
  109.     public E delete(SLLNode<E> node) {
  110.         if (first != null) {
  111.             SLLNode<E> tmp = first;
  112.             if(first ==node){
  113.                 return this.deleteFirst();
  114.             }
  115.             while (tmp.succ != node && tmp.succ.succ != null)
  116.                 tmp = tmp.succ;
  117.             if (tmp.succ == node) {
  118.                 tmp.succ = tmp.succ.succ;
  119.                 return node.element;
  120.             } else {
  121.                 System.out.println("Elementot ne postoi vo listata");
  122.                 return null;
  123.             }
  124.         } else {
  125.             System.out.println("Listata e prazna");
  126.             return null;
  127.         }
  128.  
  129.     }
  130.  
  131.     public SLLNode<E> getFirst() {
  132.         return first;
  133.     }
  134.  
  135.     public SLLNode<E> find(E o) {
  136.         if (first != null) {
  137.             SLLNode<E> tmp = first;
  138.             while (tmp.element != o && tmp.succ != null)
  139.                 tmp = tmp.succ;
  140.             if (tmp.element == o) {
  141.                 return tmp;
  142.             } else {
  143.                 System.out.println("Elementot ne postoi vo listata");
  144.             }
  145.         } else {
  146.             System.out.println("Listata e prazna");
  147.         }
  148.         return first;
  149.     }
  150.  
  151.     public Iterator<E> iterator () {
  152.         // Return an iterator that visits all elements of this list, in left-to-right order.
  153.         return new LRIterator<E>();
  154.     }
  155.  
  156.     // //////////Inner class ////////////
  157.  
  158.     private class LRIterator<E> implements Iterator<E> {
  159.  
  160.         private SLLNode<E> place, curr;
  161.  
  162.         private LRIterator() {
  163.             place = (SLLNode<E>) first;
  164.             curr = null;
  165.         }
  166.  
  167.         public boolean hasNext() {
  168.             return (place != null);
  169.         }
  170.  
  171.         public E next() {
  172.             if (place == null)
  173.                 throw new NoSuchElementException();
  174.             E nextElem = place.element;
  175.             curr = place;
  176.             place = place.succ;
  177.             return nextElem;
  178.         }
  179.  
  180.         public void remove() {
  181.             //Not implemented
  182.         }
  183.     }
  184.  
  185.     public void mirror(){
  186.         if (first != null) {
  187.             //m=nextsucc, p=tmp,q=next
  188.             SLLNode<E> tmp = first;
  189.             SLLNode<E> newsucc = null;
  190.             SLLNode<E> next;
  191.  
  192.             while(tmp != null){
  193.                 next = tmp.succ;
  194.                 tmp.succ = newsucc;
  195.                 newsucc = tmp;
  196.                 tmp = next;
  197.             }
  198.             first = newsucc;
  199.         }
  200.  
  201.     }
  202.  
  203.     public void merge (SLL<E> in){
  204.         if (first != null) {
  205.             SLLNode<E> tmp = first;
  206.             while(tmp.succ != null)
  207.                 tmp = tmp.succ;
  208.             tmp.succ = in.getFirst();
  209.         }
  210.         else{
  211.             first = in.getFirst();
  212.         }
  213.     }
  214. }
  215. class MapEntry<K extends Comparable<K>,E> implements Comparable<K> {
  216.  
  217.     // Each MapEntry object is a pair consisting of a key (a Comparable
  218.     // object) and a value (an arbitrary object).
  219.     K key;
  220.     E value;
  221.  
  222.     public MapEntry (K key, E val) {
  223.         this.key = key;
  224.         this.value = val;
  225.     }
  226.  
  227.     public int compareTo (K that) {
  228.         // Compare this map entry to that map entry.
  229.         @SuppressWarnings("unchecked")
  230.         MapEntry<K,E> other = (MapEntry<K,E>) that;
  231.         return this.key.compareTo(other.key);
  232.     }
  233.  
  234.     public String toString () {
  235.         return "<" + key + "," + value + ">";
  236.     }
  237. }
  238.  
  239. class SLLNode<E> {
  240.     protected E element;
  241.     protected SLLNode<E> succ;
  242.  
  243.     public SLLNode(E elem, SLLNode<E> succ) {
  244.         this.element = elem;
  245.         this.succ = succ;
  246.     }
  247.  
  248.     @Override
  249.     public String toString() {
  250.         return element.toString();
  251.     }
  252. }
  253.  
  254. class CBHT<K extends Comparable<K>, E> {
  255.  
  256.     // An object of class CBHT is a closed-bucket hash table, containing
  257.     // entries of class MapEntry.
  258.     private SLLNode<MapEntry<K,E>>[] buckets;
  259.  
  260.     @SuppressWarnings("unchecked")
  261.     public CBHT(int m) {
  262.         // Construct an empty CBHT with m buckets.
  263.         buckets = (SLLNode<MapEntry<K,E>>[]) new SLLNode[m];
  264.     }
  265.  
  266.     private int hash(K key) {
  267.         // Napishete ja vie HASH FUNKCIJATA
  268.         return Math.abs(hashCode()) % buckets.length;
  269.     }
  270.  
  271.     public SLLNode<MapEntry<K,E>> search(K targetKey) {
  272.         // Find which if any node of this CBHT contains an entry whose key is
  273.         // equal
  274.         // to targetKey. Return a link to that node (or null if there is none).
  275.         int b = hash(targetKey);
  276.         for (SLLNode<MapEntry<K,E>> curr = buckets[b]; curr != null; curr = curr.succ) {
  277.             if (targetKey.equals(((MapEntry<K, E>) curr.element).key))
  278.                 return curr;
  279.         }
  280.         return null;
  281.     }
  282.  
  283.     public void insert(K key, E val) {      // Insert the entry <key, val> into this CBHT.
  284.         MapEntry<K, E> newEntry = new MapEntry<K, E>(key, val);
  285.         int b = hash(key);
  286.         for (SLLNode<MapEntry<K,E>> curr = buckets[b]; curr != null; curr = curr.succ) {
  287.             if (key.equals(((MapEntry<K, E>) curr.element).key)) {
  288.                 // Make newEntry replace the existing entry ...
  289.                 curr.element = newEntry;
  290.                 return;
  291.             }
  292.         }
  293.         // Insert newEntry at the front of the 1WLL in bucket b ...
  294.         buckets[b] = new SLLNode<MapEntry<K,E>>(newEntry, buckets[b]);
  295.     }
  296.  
  297.     public void delete(K key) {
  298.         // Delete the entry (if any) whose key is equal to key from this CBHT.
  299.         int b = hash(key);
  300.         for (SLLNode<MapEntry<K,E>> pred = null, curr = buckets[b]; curr != null; pred = curr, curr = curr.succ) {
  301.             if (key.equals(((MapEntry<K,E>) curr.element).key)) {
  302.                 if (pred == null)
  303.                     buckets[b] = curr.succ;
  304.                 else
  305.                     pred.succ = curr.succ;
  306.                 return;
  307.             }
  308.         }
  309.     }
  310.  
  311.     public String toString() {
  312.         String temp = "";
  313.         for (int i = 0; i < buckets.length; i++) {
  314.             temp += i + ":";
  315.             for (SLLNode<MapEntry<K,E>> curr = buckets[i]; curr != null; curr = curr.succ) {
  316.                 temp += curr.element.toString() + " ";
  317.             }
  318.             temp += "\n";
  319.         }
  320.         return temp;
  321.     }
  322.  
  323. }
  324. class Drug{
  325.     public String ime;
  326.     public String bolest;
  327.     public int cena;
  328.  
  329.     public Drug(String ime, String bolest, int cena) {
  330.         this.ime = ime;
  331.         this.bolest = bolest;
  332.         this.cena = cena;
  333.     }
  334. }
  335. public class Apteka {
  336.     public static void main(String[] args) {
  337.         Scanner input= new Scanner(System.in);
  338.         int numDrugs= Integer.parseInt(input.nextLine());
  339.         CBHT<String,SLL<Drug>> drugs= new CBHT<>(499);
  340.         for(int i=0;i<numDrugs;i++){
  341.             String[] info_drug= input.nextLine().split("\\s+");
  342.             if(drugs.search(info_drug[1])==null){
  343.                 SLL<Drug> lista = new SLL<Drug>();
  344.                 lista.insertLast(new Drug(info_drug[0],info_drug[1],Integer.parseInt(info_drug[2])));
  345.                 drugs.insert(info_drug[1],lista);
  346.             }
  347.             else{
  348.                 drugs.search(info_drug[1]).element.value.insertLast(new Drug(info_drug[0],info_drug[1],Integer.parseInt(info_drug[2])));
  349.             }
  350.         }
  351.         String sickness= input.nextLine();
  352.         if(drugs.search(sickness)!=null){
  353.             SLLNode<Drug> temp= drugs.search(sickness).element.value.getFirst();
  354.             int lowest_price= temp.element.cena;
  355.             String best_drug= temp.element.ime;
  356.             temp=temp.succ;
  357.             while(temp!=null){
  358.                 if(temp.element.cena<lowest_price) {
  359.                     best_drug= temp.element.ime;
  360.                     lowest_price = temp.element.cena;
  361.                 }
  362.                     temp=temp.succ;
  363.             }
  364.             System.out.println(best_drug);
  365.         }
  366.         else{
  367.             System.out.println("Samo dobar seks mu e lekot...");
  368.         }
  369.     }
  370. }
  371. /*
  372. 5
  373. Analgin Glavobolka 80
  374. Daleron Glavobolka 90
  375. Lineks Bolki_vo_stomak 150
  376. Spazmeks Bolki_vo_stomak 150
  377. Loratadin Alergija 150
  378. Glavobolka
  379. --------------------------
  380. Analgin
  381.  
  382. 6
  383. Analgin Glavobolka 80
  384. Daleron Glavobolka 70
  385. Lineks Bolki_vo_stomak 150
  386. Spazmeks Bolki_vo_stomak 150
  387. Loratadin Alergija 150
  388. Paracetamol Glavobolka 100
  389. Glavobolka
  390. --------------------------
  391. Daleron
  392.  
  393. 7
  394. Viagra Erektilna_Disfunkcija 80
  395. Lineks Bolki_vo_stomak 150
  396. Spazmeks Bolki_vo_stomak 150
  397. Loratadin Alergija 150
  398. Amoxiclav Bolki_vo_grlo 100
  399. AngiSept Bolki_vo_grlo 69
  400. Caffetin Zabobolka 75
  401. Glavobolka
  402. --------------------------
  403. Samo dobar seks mu e lekot...
  404.  */
Add Comment
Please, Sign In to add comment