Merge branch 'master' into master

Author: siriak

.github/workflows/update_directory.yml

@@ -18,10 +18,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@master
-      - uses: actions/setup-python@master
+      - uses: actions/setup-python@v4
         with:
-          python-version: '3.9' # Version range or exact version of a Python version to use, using SemVer's version range syntax
-          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+          python-version: '3.10'
       - name: Update Directory
         shell: python
         run: |

DIRECTORY.md

@@ -0,0 +1,147 @@
+package com.thealgorithms.datastructures.caches;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Java program for LFU Cache (https://en.wikipedia.org/wiki/Least_frequently_used)
+ * @author Akshay Dubey (https://github.com/itsAkshayDubey)
+ */
+public class LFUCache<K,V> {
+
+	private class Node {
+		private K key;
+		private V value;
+		private int frequency;
+		private Node previous;
+		private Node next;
+
+		public Node(K key, V value, int frequency) {
+			this.key = key;
+			this.value = value;
+			this.frequency = frequency;
+		}
+	}
+
+	private Node head;
+	private Node tail;
+	private Map<K,Node> map = null;
+	private Integer capacity;
+	private static final int DEFAULT_CAPACITY = 100;
+	
+	public LFUCache() {
+		this.capacity = DEFAULT_CAPACITY;
+	}
+
+	public LFUCache(Integer capacity) {
+		this.capacity = capacity;
+		this.map = new HashMap<>();
+	}
+	
+    /**
+     * This method returns value present in the cache corresponding to the key passed as parameter
+     *
+     * @param <K> key for which value is to be retrieved 
+     * @returns <V> object corresponding to the key passed as parameter, returns null if <K> key is not present in the cache
+     */
+	public V get(K key) {
+		if(this.map.get(key) == null) {
+			return null;
+		}
+
+		Node node = map.get(key);
+		removeNode(node);
+		node.frequency += 1;
+		addNodeWithUpdatedFrequency(node);
+
+		return node.value;
+	}
+
+    /**
+     * This method stores <K> key and <V> value in the cache
+     *
+     * @param <K> key which is to be stored in the cache
+     * @param <V> value which is to be stored in the cache 
+     */
+	public void put(K key, V value) {
+		if(map.containsKey(key)) {
+			Node node =  map.get(key);
+			node.value = value;
+			node.frequency += 1;
+			removeNode(node);
+			addNodeWithUpdatedFrequency(node);
+		}
+		else {
+			if(map.size() >= capacity) {
+				map.remove(this.head.key);
+				removeNode(head);
+			}
+			Node node = new Node(key,value,1);
+			addNodeWithUpdatedFrequency(node);
+			map.put(key, node);
+		}
+	}
+
+    /**
+     * This method stores the node in the cache with updated frequency
+     *
+     * @param Node node which is to be updated in the cache 
+     */
+	private void addNodeWithUpdatedFrequency(Node node) {
+		if(tail != null && head != null) {
+			Node temp = this.head;
+			while(temp != null) {
+				if(temp.frequency > node.frequency) {
+					if(temp==head) {
+						node.next = temp;
+						temp.previous = node;
+						this.head = node;
+						break;
+					}
+					else {
+						node.next = temp;
+						node.previous = temp.previous;
+						temp.previous.next = node;
+						node.previous = temp.previous;
+						break;
+					}
+				}
+				else {
+					temp = temp.next;
+					if(temp == null) {
+						tail.next = node;
+						node.previous = tail;
+						node.next = null;
+						tail = node;
+						break;
+					}
+				}
+			}
+		}
+		else {
+			tail = node;
+			head = tail;
+		}
+	}
+
+    /**
+     * This method removes node from the cache 
+     * 
+     * @param Node node which is to be removed in the cache 
+     */
+	private void removeNode(Node node) {
+		if(node.previous != null) {
+			node.previous.next = node.next;
+		}
+		else {
+			this.head = node.next;
+		}
+
+		if(node.next != null) {
+			node.next.previous = node.previous;
+		}
+		else {
+			this.tail = node.previous;
+		}		
+	}
+}

src/main/java/com/thealgorithms/datastructures/caches/LFUCache.java

@@ -50,7 +50,7 @@ private void swap(int index1, int index2) {
     // Toggle an element up to its right place as long as its key is lower than its parent's
     private void toggleUp(int elementIndex) {
         double key = minHeap.get(elementIndex - 1).getKey();
-        while (getElementKey((int) Math.floor(elementIndex / 2.0)) > key) {
+        while (getElementKey((int) Math.floor(elementIndex / 2.0) + 1) > key) {
             swap(elementIndex, (int) Math.floor(elementIndex / 2.0));
             elementIndex = (int) Math.floor(elementIndex / 2.0);
         }

src/main/java/com/thealgorithms/datastructures/heaps/MinHeap.java

@@ -117,7 +117,9 @@ public void remove(E e) {
         }
         for (int i = 0; i <= layer; i++) {
             current.previous(i).setNext(i, current.next(i));
-            current.next(i).setPrevious(i, current.previous(i));
+            if (current.next(i) != null) {
+                current.next(i).setPrevious(i, current.previous(i));
+            }
         }
         size--;
     }

src/main/java/com/thealgorithms/datastructures/lists/SkipList.java

@@ -76,23 +76,4 @@ private static <T extends Comparable<T>> int partition(T[] array, int left, int
         }
         return left;
     }
-
-    // Driver Program
-    public static void main(String[] args) {
-
-        // For integer input
-        Integer[] array = {3, 4, 1, 32, 0, 1, 5, 12, 2, 5, 7, 8, 9, 2, 44, 111, 5};
-
-        QuickSort quickSort = new QuickSort();
-        quickSort.sort(array);
-
-        // Output => 0 1 1 2 2 3 4 5 5 5 7 8 9 12 32 44 111
-        print(array);
-
-        String[] stringArray = {"c", "a", "e", "b", "d"};
-        quickSort.sort(stringArray);
-
-        // Output => a	b	c	d	e
-        print(stringArray);
-    }
 }

src/main/java/com/thealgorithms/sorts/QuickSort.java

@@ -0,0 +1,32 @@
+package com.thealgorithms.strings;
+
+/* In information theory, the Hamming distance between two strings of equal length 
+is the number of positions at which the corresponding symbols are different. 
+https://en.wikipedia.org/wiki/Hamming_distance
+*/
+public class HammingDistance {
+
+    /**
+     * calculate the hamming distance between two strings of equal length
+     *
+     * @param s1 the first string
+     * @param s2 the second string
+     * @return {@code int} hamming distance
+     * @throws Exception
+     */
+    public static int calculateHammingDistance(String s1, String s2) throws Exception {
+        if (s1.length() != s2.length()) {
+            throw new Exception("String lengths must be equal");
+        }
+        
+        int stringLength = s1.length();
+        int counter = 0;
+        
+        for (int i = 0; i < stringLength; i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                counter++;
+            }
+        }
+        return counter;
+    }
+}

src/main/java/com/thealgorithms/strings/HammingDistance.java

@@ -0,0 +1,67 @@
+package com.thealgorithms.datastructures.caches;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class LFUCacheTest {
+
+	@Test
+	void testLFUCacheWithIntegerValueShouldPass() {
+
+		LFUCache<Integer, Integer> lfuCache = new LFUCache<>(5);
+		lfuCache.put(1, 10);
+		lfuCache.put(2, 20);
+		lfuCache.put(3, 30);
+		lfuCache.put(4, 40);
+		lfuCache.put(5, 50);
+
+		//get method call will increase frequency of key 1 by 1
+		assertEquals(10, lfuCache.get(1));
+
+		//this operation will remove value with key as 2
+		lfuCache.put(6, 60);
+
+		//will return null as value with key 2 is now evicted
+		assertEquals(null, lfuCache.get(2));
+
+		//should return 60
+		assertEquals(60, lfuCache.get(6));
+
+		//this operation will remove value with key as 3
+		lfuCache.put(7, 70);
+
+		assertEquals(null, lfuCache.get(2));
+		assertEquals(70, lfuCache.get(7));
+	}
+
+	@Test
+	void testLFUCacheWithStringValueShouldPass() {
+
+		LFUCache<Integer, String> lfuCache = new LFUCache<>(5);
+		lfuCache.put(1, "Alpha");
+		lfuCache.put(2, "Beta");
+		lfuCache.put(3, "Gamma");
+		lfuCache.put(4, "Delta");
+		lfuCache.put(5, "Eplison");
+
+		//get method call will increase frequency of key 1 by 1
+		assertEquals("Alpha", lfuCache.get(1));
+
+		//this operation will remove value with key as 2
+		lfuCache.put(6, "Digamma");
+
+		//will return null as value with key 2 is now evicted
+		assertEquals(null, lfuCache.get(2));
+
+		//should return string Digamma
+		assertEquals("Digamma", lfuCache.get(6));
+
+		//this operation will remove value with key as 3
+		lfuCache.put(7, "Zeta");
+
+		assertEquals(null, lfuCache.get(2));
+		assertEquals("Zeta", lfuCache.get(7));
+	}
+
+}

src/test/java/com/thealgorithms/datastructures/caches/LFUCacheTest.java

@@ -42,12 +42,26 @@ void contains() {
     }
 
     @Test
-    void remove() {
+    void removeFromHead() {
         SkipList<String> skipList = createSkipList();
+        String mostLeftElement = skipList.get(0);
         int initialSize = skipList.size();
         print(skipList);
 
-        skipList.remove("a");
+        skipList.remove(mostLeftElement);
+
+        print(skipList);
+        assertEquals(initialSize - 1, skipList.size());
+    }
+
+    @Test
+    void removeFromTail() {
+        SkipList<String> skipList = createSkipList();
+        String mostRightValue = skipList.get(skipList.size() - 1);
+        int initialSize = skipList.size();
+        print(skipList);
+
+        skipList.remove(mostRightValue);
 
         print(skipList);
         assertEquals(initialSize - 1, skipList.size());

src/test/java/com/thealgorithms/datastructures/lists/SkipListTest.java

@@ -0,0 +1,37 @@
+package com.thealgorithms.others;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+
+public class PasswordGenTest {
+    @Test 
+    public void failGenerationWithSameMinMaxLengthTest() {
+        int length = 10;
+        assertThrows(IllegalArgumentException.class, ()-> {
+            PasswordGen.generatePassword(length, length);
+        });
+    }
+
+    @Test
+    public void generateOneCharacterPassword() {
+        String tempPassword = PasswordGen.generatePassword(1, 2);
+        assertTrue(tempPassword.length()==1);
+    }
+
+    @Test
+    public void failGenerationWithMinLengthSmallerThanMaxLengthTest() {
+        int minLength = 10;
+        int maxLength = 5;
+        assertThrows(IllegalArgumentException.class, ()-> {
+            PasswordGen.generatePassword(minLength, maxLength);
+        });
+    }
+
+    @Test
+    public void generatePasswordNonEmptyTest() {
+        String tempPassword = PasswordGen.generatePassword(8, 16);
+        assertTrue(tempPassword.length()!=0);
+    }
+}