From ad72c28d91989460f61917b28545f4f33c2771d4 Mon Sep 17 00:00:00 2001 From: Saurabh Rahate <55960054+saurabh-rahate@users.noreply.github.com> Date: Mon, 3 Apr 2023 20:05:59 +0530 Subject: [PATCH] Remove unnecessary code (#4141) --- .../com/thealgorithms/ciphers/Blowfish.java | 2 +- .../com/thealgorithms/ciphers/HillCipher.java | 1 - .../conversions/AnyBaseToAnyBase.java | 2 +- .../conversions/OctalToDecimal.java | 3 +-- .../datastructures/graphs/BellmanFord.java | 4 ++-- .../graphs/BipartiteGrapfDFS.java | 2 +- .../graphs/DIJSKSTRAS_ALGORITHM.java | 2 +- .../datastructures/graphs/MatrixGraphs.java | 12 ++++------ .../datastructures/graphs/PrimMST.java | 4 ++-- .../graphs/TarjansAlgorithm.java | 2 +- .../datastructures/heaps/FibonacciHeap.java | 1 - .../heaps/MinPriorityQueue.java | 10 ++------ .../lists/CursorLinkedList.java | 3 +-- .../lists/SinglyLinkedList.java | 4 ++-- .../datastructures/queues/CircularQueue.java | 12 ++-------- .../datastructures/queues/Deques.java | 3 +-- .../datastructures/queues/Queues.java | 2 +- .../datastructures/trees/AVLSimple.java | 3 +-- .../datastructures/trees/AVLTree.java | 17 +++++-------- .../datastructures/trees/BinaryTree.java | 8 ++----- .../datastructures/trees/GenericTree.java | 1 - .../datastructures/trees/RedBlackBST.java | 23 ++++++++---------- .../datastructures/trees/TrieImp.java | 2 +- .../BruteForceKnapsack.java | 10 +------- .../DyanamicProgrammingKnapsack.java | 8 +------ .../dynamicprogramming/EditDistance.java | 7 +++--- .../LongestCommonSubsequence.java | 5 +--- .../LongestPalindromicSubstring.java | 14 ++--------- .../MatrixChainMultiplication.java | 2 +- .../PalindromicPartitioning.java | 14 ++++------- .../dynamicprogramming/RegexMatching.java | 4 ++-- .../dynamicprogramming/WineProblem.java | 4 +--- .../thealgorithms/maths/AmicableNumber.java | 2 +- .../com/thealgorithms/maths/Combinations.java | 3 +-- .../thealgorithms/maths/DistanceFormula.java | 6 ++--- .../com/thealgorithms/maths/EulerMethod.java | 24 ++++--------------- .../thealgorithms/maths/FastInverseSqrt.java | 2 +- .../maths/KrishnamurthyNumber.java | 6 +---- .../thealgorithms/maths/StandardScore.java | 3 +-- .../others/BankersAlgorithm.java | 4 ++-- .../com/thealgorithms/others/Dijkstra.java | 10 +------- ...g_auto_completing_features_using_trie.java | 2 +- .../others/LowestBasePalindrome.java | 2 +- .../others/MiniMaxAlgorithm.java | 8 +++---- .../com/thealgorithms/others/PageRank.java | 4 ++-- .../others/RemoveDuplicateFromString.java | 2 +- .../thealgorithms/searches/BinarySearch.java | 16 +++---------- .../searches/ExponentalSearch.java | 16 +++---------- .../searches/InterpolationSearch.java | 18 ++++---------- .../searches/IterativeBinarySearch.java | 16 +++---------- .../searches/IterativeTernarySearch.java | 16 +++---------- .../thealgorithms/searches/LinearSearch.java | 6 ++--- .../thealgorithms/searches/LowerBound.java | 16 +++---------- .../searches/MonteCarloTreeSearch.java | 6 ++--- .../thealgorithms/searches/TernarySearch.java | 16 +++---------- .../thealgorithms/searches/UpperBound.java | 16 +++---------- .../com/thealgorithms/sorts/BeadSort.java | 2 +- .../com/thealgorithms/sorts/CircleSort.java | 2 +- .../com/thealgorithms/sorts/CombSort.java | 2 +- .../sorts/MergeSortRecursive.java | 3 +-- .../com/thealgorithms/sorts/TreeSort.java | 16 ++++++------- .../com/thealgorithms/sorts/WiggleSort.java | 2 +- .../strings/LongestPalindromicSubstring.java | 2 +- .../com/thealgorithms/strings/MyAtoi.java | 7 +----- 64 files changed, 125 insertions(+), 322 deletions(-) diff --git a/src/main/java/com/thealgorithms/ciphers/Blowfish.java b/src/main/java/com/thealgorithms/ciphers/Blowfish.java index 7e74cc6da..b60cf7c7a 100644 --- a/src/main/java/com/thealgorithms/ciphers/Blowfish.java +++ b/src/main/java/com/thealgorithms/ciphers/Blowfish.java @@ -1079,7 +1079,7 @@ public class Blowfish { */ private String hexToBin(String hex) { String binary = ""; - Long num; + long num; String binary4B; int n = hex.length(); for (int i = 0; i < n; i++) { diff --git a/src/main/java/com/thealgorithms/ciphers/HillCipher.java b/src/main/java/com/thealgorithms/ciphers/HillCipher.java index f989502ed..102d760d1 100644 --- a/src/main/java/com/thealgorithms/ciphers/HillCipher.java +++ b/src/main/java/com/thealgorithms/ciphers/HillCipher.java @@ -160,7 +160,6 @@ public class HillCipher { System.out.println( "Invalid key, as determinant = 0. Program Terminated" ); - return; } } diff --git a/src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java b/src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java index 25d9ded3b..b5974dd65 100644 --- a/src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java +++ b/src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java @@ -175,7 +175,7 @@ public class AnyBaseToAnyBase { // If the remainder is a digit < 10, simply add it to // the left side of the new number. if (decimalValue % b2 < 10) { - output = Integer.toString(decimalValue % b2) + output; + output = decimalValue % b2 + output; } // If the remainder is >= 10, add a character with the // corresponding value to the new number. (A = 10, B = 11, C = 12, ...) else { diff --git a/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java b/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java index be8b43375..782f34883 100644 --- a/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java +++ b/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java @@ -34,8 +34,7 @@ public class OctalToDecimal { public static int convertOctalToDecimal(String inputOctal) { try { // Actual conversion of Octal to Decimal: - Integer outputDecimal = Integer.parseInt(inputOctal, 8); - return outputDecimal; + return Integer.parseInt(inputOctal, 8); } catch (NumberFormatException ne) { // Printing a warning message if the input is not a valid octal // number: diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java b/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java index ac0898e10..b640eeaf5 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java @@ -74,7 +74,7 @@ start vertex, end vertex and weights. Vertices should be labelled with a number for (i = 0; i < v - 1; i++) { for (j = 0; j < e; j++) { if ( - (int) dist[arr[j].u] != Integer.MAX_VALUE && + dist[arr[j].u] != Integer.MAX_VALUE && dist[arr[j].v] > dist[arr[j].u] + arr[j].w ) { dist[arr[j].v] = dist[arr[j].u] + arr[j].w; // Update @@ -85,7 +85,7 @@ start vertex, end vertex and weights. Vertices should be labelled with a number // Final cycle for negative checking for (j = 0; j < e; j++) { if ( - (int) dist[arr[j].u] != Integer.MAX_VALUE && + dist[arr[j].u] != Integer.MAX_VALUE && dist[arr[j].v] > dist[arr[j].u] + arr[j].w ) { neg = 1; diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGrapfDFS.java b/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGrapfDFS.java index 5d484d187..651b3e617 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGrapfDFS.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGrapfDFS.java @@ -28,7 +28,7 @@ public class BipartiteGrapfDFS { for (Integer it : adj.get(node)) { if (color[it] == -1) { color[it] = 1 - color[node]; - if (bipartite(V, adj, color, it) == false) { + if (!bipartite(V, adj, color, it)) { return false; } } else if (color[it] == color[node]) { diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/DIJSKSTRAS_ALGORITHM.java b/src/main/java/com/thealgorithms/datastructures/graphs/DIJSKSTRAS_ALGORITHM.java index 928516d2b..5b8533b8d 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/DIJSKSTRAS_ALGORITHM.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/DIJSKSTRAS_ALGORITHM.java @@ -12,7 +12,7 @@ class dijkstras { int min = Integer.MAX_VALUE, min_index = -1; for (int r = 0; r < k; r++) { - if (Set[r] == false && dist[r] <= min) { + if (!Set[r] && dist[r] <= min) { min = dist[r]; min_index = r; } diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java b/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java index 90386230b..8d382cdde 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java @@ -154,11 +154,7 @@ class AdjacencyMatrixGraph { * @return whether or not the vertex exists */ public boolean vertexDoesExist(int aVertex) { - if (aVertex >= 0 && aVertex < this.numberOfVertices()) { - return true; - } else { - return false; - } + return aVertex >= 0 && aVertex < this.numberOfVertices(); } /** @@ -343,14 +339,14 @@ class AdjacencyMatrixGraph { public String toString() { String s = " "; for (int i = 0; i < this.numberOfVertices(); i++) { - s = s + String.valueOf(i) + " "; + s = s + i + " "; } s = s + " \n"; for (int i = 0; i < this.numberOfVertices(); i++) { - s = s + String.valueOf(i) + " : "; + s = s + i + " : "; for (int j = 0; j < this.numberOfVertices(); j++) { - s = s + String.valueOf(this._adjacency[i][j]) + " "; + s = s + this._adjacency[i][j] + " "; } s = s + "\n"; } diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/PrimMST.java b/src/main/java/com/thealgorithms/datastructures/graphs/PrimMST.java index 4365f7214..75de04713 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/PrimMST.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/PrimMST.java @@ -17,7 +17,7 @@ class PrimMST { int min = Integer.MAX_VALUE, min_index = -1; for (int v = 0; v < V; v++) { - if (mstSet[v] == false && key[v] < min) { + if (!mstSet[v] && key[v] < min) { min = key[v]; min_index = v; } @@ -80,7 +80,7 @@ class PrimMST { { if ( graph[u][v] != 0 && - mstSet[v] == false && + !mstSet[v] && graph[u][v] < key[v] ) { parent[v] = u; diff --git a/src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java b/src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java index 18e43c49d..bb633c4ee 100644 --- a/src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java +++ b/src/main/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithm.java @@ -114,7 +114,7 @@ public class TarjansAlgorithm { stronglyConnCompsUtil(n, lowTime, insertionTime, isInStack, st, graph); //update lowTime for the current node comparing lowtime of adj node lowTime[u] = Math.min(lowTime[u], lowTime[n]); - } else if (isInStack[n] == true) { + } else if (isInStack[n]) { //If adj node is in stack, update low lowTime[u] = Math.min(lowTime[u], insertionTime[n]); } diff --git a/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java b/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java index 3359ccb5e..eeeb591c2 100644 --- a/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java +++ b/src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java @@ -234,7 +234,6 @@ public class FibonacciHeap { if (!curr.isMarked()) { //stop the recursion curr.mark(); if (!curr.isRoot()) this.markedHeapNoodesCounter++; - return; } else { if (curr.isRoot()) { return; diff --git a/src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java b/src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java index 034e32ce9..23ac5d3aa 100644 --- a/src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java +++ b/src/main/java/com/thealgorithms/datastructures/heaps/MinPriorityQueue.java @@ -51,18 +51,12 @@ public class MinPriorityQueue { // returns boolean value whether the heap is empty or not public boolean isEmpty() { - if (0 == this.size) { - return true; - } - return false; + return 0 == this.size; } // returns boolean value whether the heap is full or not public boolean isFull() { - if (this.size == this.capacity) { - return true; - } - return false; + return this.size == this.capacity; } // prints the heap diff --git a/src/main/java/com/thealgorithms/datastructures/lists/CursorLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/CursorLinkedList.java index b3ad535c7..6ed317d6d 100644 --- a/src/main/java/com/thealgorithms/datastructures/lists/CursorLinkedList.java +++ b/src/main/java/com/thealgorithms/datastructures/lists/CursorLinkedList.java @@ -174,8 +174,7 @@ public class CursorLinkedList { } // 2- make the os point to the next of the @var{availableNodeIndex} - int availableNext = cursorSpace[availableNodeIndex].next; - cursorSpace[os].next = availableNext; + cursorSpace[os].next = cursorSpace[availableNodeIndex].next; // this to indicate an end of the list , helpful at testing since any err // would throw an outOfBoundException diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java index 03ce735f2..a4276b021 100644 --- a/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java +++ b/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java @@ -407,7 +407,7 @@ public class SinglyLinkedList extends Node { list.insert(3); list.insertNth(1, 4); assert list.toString().equals("10->7->5->3->1"); - System.out.println(list.toString()); + System.out.println(list); /* Test search function */ assert list.search(10) && list.search(5) && @@ -424,7 +424,7 @@ public class SinglyLinkedList extends Node { list.deleteNth(1); list.delete(); assert list.toString().equals("7->3"); - System.out.println(list.toString()); + System.out.println(list); assert list.size == 2 && list.size() == list.count(); list.clear(); diff --git a/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java b/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java index 18293bffe..e5bedd9be 100644 --- a/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java +++ b/src/main/java/com/thealgorithms/datastructures/queues/CircularQueue.java @@ -17,21 +17,13 @@ public class CircularQueue { } public boolean isEmpty() { - if (beginningOfQueue == -1) { - return true; - } else { - return false; - } + return beginningOfQueue == -1; } public boolean isFull() { if (topOfQueue + 1 == beginningOfQueue) { return true; - } else if (topOfQueue == size - 1 && beginningOfQueue == 0) { - return true; - } else { - return false; - } + } else return topOfQueue == size - 1 && beginningOfQueue == 0; } public void enQueue(int value) { diff --git a/src/main/java/com/thealgorithms/datastructures/queues/Deques.java b/src/main/java/com/thealgorithms/datastructures/queues/Deques.java index 06d7c5995..5c4e9b641 100644 --- a/src/main/java/com/thealgorithms/datastructures/queues/Deques.java +++ b/src/main/java/com/thealgorithms/datastructures/queues/Deques.java @@ -91,13 +91,12 @@ public class Deques { if (tail == null) { // If the deque is empty, add the node as the head and tail head = newNode; - tail = newNode; } else { // If the deque is not empty, insert the node as the new tail newNode.prev = tail; tail.next = newNode; - tail = newNode; } + tail = newNode; size++; } diff --git a/src/main/java/com/thealgorithms/datastructures/queues/Queues.java b/src/main/java/com/thealgorithms/datastructures/queues/Queues.java index 47de89928..bcc292b3e 100644 --- a/src/main/java/com/thealgorithms/datastructures/queues/Queues.java +++ b/src/main/java/com/thealgorithms/datastructures/queues/Queues.java @@ -177,6 +177,6 @@ public class Queues { System.out.println(myQueue.peekFront()); // Will print 2 System.out.println(myQueue.peekRear()); // Will print 7 - System.out.println(myQueue.toString()); // Will print [2, 5, 3, 7] + System.out.println(myQueue); // Will print [2, 5, 3, 7] } } diff --git a/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java b/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java index 72fe7972d..85c44707e 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java @@ -49,8 +49,7 @@ public class AVLSimple { private Node insert(Node node, int item) { if (node == null) { - Node add = new Node(item); - return add; + return new Node(item); } if (node.data > item) { node.left = insert(node.left, item); diff --git a/src/main/java/com/thealgorithms/datastructures/trees/AVLTree.java b/src/main/java/com/thealgorithms/datastructures/trees/AVLTree.java index 5549adbd2..b56a71421 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/AVLTree.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/AVLTree.java @@ -62,21 +62,20 @@ public class AVLTree { } return; } + Node child; if (node.left != null) { - Node child = node.left; + child = node.left; while (child.right != null) { child = child.right; } - node.key = child.key; - delete(child); } else { - Node child = node.right; + child = node.right; while (child.left != null) { child = child.left; } - node.key = child.key; - delete(child); } + node.key = child.key; + delete(child); } public void delete(int delKey) { @@ -216,11 +215,7 @@ public class AVLTree { public boolean search(int key) { Node result = searchHelper(this.root, key); - if (result != null) { - return true; - } - - return false; + return result != null; } private Node searchHelper(Node root, int key) { diff --git a/src/main/java/com/thealgorithms/datastructures/trees/BinaryTree.java b/src/main/java/com/thealgorithms/datastructures/trees/BinaryTree.java index 48dfe9658..fc0db9b8c 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/BinaryTree.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/BinaryTree.java @@ -117,11 +117,9 @@ public class BinaryTree { if (value < parent.data) { parent.left = newNode; parent.left.parent = parent; - return; } else { parent.right = newNode; parent.right.parent = parent; - return; } } } @@ -177,7 +175,6 @@ public class BinaryTree { if (temp == root) { successor.parent = null; root = successor; - return true; } // If you're not deleting the root else { successor.parent = temp.parent; @@ -188,8 +185,8 @@ public class BinaryTree { } else { temp.parent.left = successor; } - return true; } + return true; } // One child else { // If it has a right child @@ -207,7 +204,6 @@ public class BinaryTree { } else { temp.parent.right = temp.right; } - return true; } // If it has a left child else { if (temp == root) { @@ -223,8 +219,8 @@ public class BinaryTree { } else { temp.parent.right = temp.left; } - return true; } + return true; } } diff --git a/src/main/java/com/thealgorithms/datastructures/trees/GenericTree.java b/src/main/java/com/thealgorithms/datastructures/trees/GenericTree.java index 9f776e6d7..c22bdab08 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/GenericTree.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/GenericTree.java @@ -168,7 +168,6 @@ public class GenericTree { for (int i = 0; i < node.child.size(); i++) { depth(node.child.get(i), dep - 1); } - return; } /** diff --git a/src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java b/src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java index d7f34007f..7103a9ead 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/RedBlackBST.java @@ -309,23 +309,20 @@ public class RedBlackBST { public void insertDemo() { Scanner scan = new Scanner(System.in); - while (true) { - System.out.println("Add items"); + System.out.println("Add items"); - int item; - Node node; + int item; + Node node; + item = scan.nextInt(); + while (item != -999) { + node = new Node(item); + insert(node); item = scan.nextInt(); - while (item != -999) { - node = new Node(item); - insert(node); - item = scan.nextInt(); - } - printTree(root); - System.out.println("Pre order"); - printTreepre(root); - break; } + printTree(root); + System.out.println("Pre order"); + printTreepre(root); scan.close(); } diff --git a/src/main/java/com/thealgorithms/datastructures/trees/TrieImp.java b/src/main/java/com/thealgorithms/datastructures/trees/TrieImp.java index a650900a2..5829f920c 100644 --- a/src/main/java/com/thealgorithms/datastructures/trees/TrieImp.java +++ b/src/main/java/com/thealgorithms/datastructures/trees/TrieImp.java @@ -62,7 +62,7 @@ public class TrieImp { } currentNode = node; } - if (currentNode.end == true) { + if (currentNode.end) { currentNode.end = false; return true; } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsack.java b/src/main/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsack.java index 4e2e25484..49031152e 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsack.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/BruteForceKnapsack.java @@ -3,13 +3,6 @@ package com.thealgorithms.dynamicprogramming; /* A Naive recursive implementation of 0-1 Knapsack problem */ public class BruteForceKnapsack { - - // A utility function that returns - // maximum of two integers - static int max(int a, int b) { - return (a > b) ? a : b; - } - // Returns the maximum value that // can be put in a knapsack of // capacity W @@ -29,8 +22,7 @@ public class BruteForceKnapsack { // (1) nth item included // (2) not included else { - return max( - val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), + return Math.max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), knapSack(W, wt, val, n - 1) ); } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/DyanamicProgrammingKnapsack.java b/src/main/java/com/thealgorithms/dynamicprogramming/DyanamicProgrammingKnapsack.java index ffbefd479..445f1e9d0 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/DyanamicProgrammingKnapsack.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/DyanamicProgrammingKnapsack.java @@ -3,11 +3,6 @@ package com.thealgorithms.dynamicprogramming; // A Dynamic Programming based solution // for 0-1 Knapsack problem public class DyanamicProgrammingKnapsack { - - static int max(int a, int b) { - return (a > b) ? a : b; - } - // Returns the maximum value that can // be put in a knapsack of capacity W static int knapSack(int W, int wt[], int val[], int n) { @@ -20,8 +15,7 @@ public class DyanamicProgrammingKnapsack { if (i == 0 || w == 0) { K[i][w] = 0; } else if (wt[i - 1] <= w) { - K[i][w] = - max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]); + K[i][w] = Math.max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]); } else { K[i][w] = K[i - 1][w]; } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/EditDistance.java b/src/main/java/com/thealgorithms/dynamicprogramming/EditDistance.java index 0f27ba0bc..5141e12db 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/EditDistance.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/EditDistance.java @@ -57,8 +57,8 @@ public class EditDistance { int insert = dp[i][j + 1] + 1; int delete = dp[i + 1][j] + 1; - int min = replace > insert ? insert : replace; - min = delete > min ? min : delete; + int min = Math.min(replace, insert); + min = Math.min(delete, min); dp[i + 1][j + 1] = min; } } @@ -110,13 +110,12 @@ public class EditDistance { if (s1.charAt(0) == s2.charAt(0)) { storage[m][n] = editDistance(s1.substring(1), s2.substring(1), storage); - return storage[m][n]; } else { int op1 = editDistance(s1, s2.substring(1), storage); int op2 = editDistance(s1.substring(1), s2, storage); int op3 = editDistance(s1.substring(1), s2.substring(1), storage); storage[m][n] = 1 + Math.min(op1, Math.min(op2, op3)); - return storage[m][n]; } + return storage[m][n]; } } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java b/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java index b74942364..a2711a810 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java @@ -30,10 +30,7 @@ class LongestCommonSubsequence { if (arr1[i - 1].equals(arr2[j - 1])) { lcsMatrix[i][j] = lcsMatrix[i - 1][j - 1] + 1; } else { - lcsMatrix[i][j] = - lcsMatrix[i - 1][j] > lcsMatrix[i][j - 1] - ? lcsMatrix[i - 1][j] - : lcsMatrix[i][j - 1]; + lcsMatrix[i][j] = Math.max(lcsMatrix[i - 1][j], lcsMatrix[i][j - 1]); } } } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstring.java b/src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstring.java index 1d7bbe438..824bce085 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstring.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstring.java @@ -27,19 +27,9 @@ public class LongestPalindromicSubstring { if (g == 0) { arr[i][j] = true; } else if (g == 1) { - if (input.charAt(i) == input.charAt(j)) { - arr[i][j] = true; - } else { - arr[i][j] = false; - } + arr[i][j] = input.charAt(i) == input.charAt(j); } else { - if ( - input.charAt(i) == input.charAt(j) && arr[i + 1][j - 1] - ) { - arr[i][j] = true; - } else { - arr[i][j] = false; - } + arr[i][j] = input.charAt(i) == input.charAt(j) && arr[i + 1][j - 1]; } if (arr[i][j]) { diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplication.java b/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplication.java index 5c4be18e3..7a3213558 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplication.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplication.java @@ -87,7 +87,7 @@ public class MatrixChainMultiplication { private static void printArray(int[][] array) { for (int i = 1; i < size + 1; i++) { for (int j = 1; j < size + 1; j++) { - System.out.print(String.format("%7d", array[i][j])); + System.out.printf("%7d", array[i][j]); } System.out.println(); } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioning.java b/src/main/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioning.java index e1218fefc..98b9d1631 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioning.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioning.java @@ -48,27 +48,21 @@ public class PalindromicPartitioning { if (L == 2) { isPalindrome[i][j] = (word.charAt(i) == word.charAt(j)); } else { - if ( - (word.charAt(i) == word.charAt(j)) && - isPalindrome[i + 1][j - 1] - ) { - isPalindrome[i][j] = true; - } else { - isPalindrome[i][j] = false; - } + isPalindrome[i][j] = (word.charAt(i) == word.charAt(j)) && + isPalindrome[i + 1][j - 1]; } } } //We find the minimum for each index for (i = 0; i < len; i++) { - if (isPalindrome[0][i] == true) { + if (isPalindrome[0][i]) { minCuts[i] = 0; } else { minCuts[i] = Integer.MAX_VALUE; for (j = 0; j < i; j++) { if ( - isPalindrome[j + 1][i] == true && + isPalindrome[j + 1][i] && 1 + minCuts[j] < minCuts[i] ) { minCuts[i] = 1 + minCuts[j]; diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/RegexMatching.java b/src/main/java/com/thealgorithms/dynamicprogramming/RegexMatching.java index 238d8abcd..5994ffe8d 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/RegexMatching.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/RegexMatching.java @@ -112,7 +112,7 @@ public class RegexMatching { return true; } if (strg[svidx][pvidx] != 0) { - return strg[svidx][pvidx] == 1 ? false : true; + return strg[svidx][pvidx] != 1; } char chs = src.charAt(svidx); char chp = pat.charAt(pvidx); @@ -127,7 +127,7 @@ public class RegexMatching { } else { ans = false; } - strg[svidx][pvidx] = ans == false ? 1 : 2; + strg[svidx][pvidx] = ans ? 2 : 1; return ans; } diff --git a/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java b/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java index ce8836ee6..8e4821806 100644 --- a/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java +++ b/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java @@ -24,9 +24,7 @@ public class WineProblem { int start = WPRecursion(arr, si + 1, ei) + arr[si] * year; int end = WPRecursion(arr, si, ei - 1) + arr[ei] * year; - int ans = Math.max(start, end); - - return ans; + return Math.max(start, end); } // Method 2: Top-Down DP(Memoization) diff --git a/src/main/java/com/thealgorithms/maths/AmicableNumber.java b/src/main/java/com/thealgorithms/maths/AmicableNumber.java index 4b49e21c7..3efea0e16 100644 --- a/src/main/java/com/thealgorithms/maths/AmicableNumber.java +++ b/src/main/java/com/thealgorithms/maths/AmicableNumber.java @@ -58,7 +58,7 @@ public class AmicableNumber { countofRes + " Amicable_numbers.These are \n " ); - System.out.println(res.toString()); + System.out.println(res); } /** diff --git a/src/main/java/com/thealgorithms/maths/Combinations.java b/src/main/java/com/thealgorithms/maths/Combinations.java index 34b324466..68d653229 100644 --- a/src/main/java/com/thealgorithms/maths/Combinations.java +++ b/src/main/java/com/thealgorithms/maths/Combinations.java @@ -52,8 +52,7 @@ public class Combinations { // nC0 is always 1 long solution = 1; for (int i = 0; i < k; i++) { - long next = (n - i) * solution / (i + 1); - solution = next; + solution = (n - i) * solution / (i + 1); } return solution; } diff --git a/src/main/java/com/thealgorithms/maths/DistanceFormula.java b/src/main/java/com/thealgorithms/maths/DistanceFormula.java index 96f8e6969..89f9b4298 100644 --- a/src/main/java/com/thealgorithms/maths/DistanceFormula.java +++ b/src/main/java/com/thealgorithms/maths/DistanceFormula.java @@ -10,8 +10,7 @@ public class DistanceFormula { ) { double dX = Math.pow(x2 - x1, 2); double dY = Math.pow(y2 - x1, 2); - double d = Math.sqrt(dX + dY); - return d; + return Math.sqrt(dX + dY); } public static double manhattanDistance( @@ -20,8 +19,7 @@ public class DistanceFormula { double x2, double y2 ) { - double d = Math.abs(x1 - x2) + Math.abs(y1 - y2); - return d; + return Math.abs(x1 - x2) + Math.abs(y1 - y2); } public static int hammingDistance(int[] b1, int[] b2) { diff --git a/src/main/java/com/thealgorithms/maths/EulerMethod.java b/src/main/java/com/thealgorithms/maths/EulerMethod.java index 4904c5038..eca400765 100644 --- a/src/main/java/com/thealgorithms/maths/EulerMethod.java +++ b/src/main/java/com/thealgorithms/maths/EulerMethod.java @@ -26,22 +26,14 @@ public class EulerMethod { BiFunction exampleEquation1 = (x, y) -> x; ArrayList points1 = eulerFull(0, 4, 0.1, 0, exampleEquation1); assert points1.get(points1.size() - 1)[1] == 7.800000000000003; - points1.forEach(point -> - System.out.println( - String.format("x: %1$f; y: %2$f", point[0], point[1]) - ) - ); + points1.forEach(point -> System.out.printf("x: %1$f; y: %2$f%n", point[0], point[1])); // example from https://en.wikipedia.org/wiki/Euler_method System.out.println("\n\nexample 2:"); BiFunction exampleEquation2 = (x, y) -> y; ArrayList points2 = eulerFull(0, 4, 0.1, 1, exampleEquation2); assert points2.get(points2.size() - 1)[1] == 45.25925556817596; - points2.forEach(point -> - System.out.println( - String.format("x: %1$f; y: %2$f", point[0], point[1]) - ) - ); + points2.forEach(point -> System.out.printf("x: %1$f; y: %2$f%n", point[0], point[1])); // example from https://www.geeksforgeeks.org/euler-method-solving-differential-equation/ System.out.println("\n\nexample 3:"); @@ -55,11 +47,7 @@ public class EulerMethod { exampleEquation3 ); assert points3.get(points3.size() - 1)[1] == 1.1116729841674804; - points3.forEach(point -> - System.out.println( - String.format("x: %1$f; y: %2$f", point[0], point[1]) - ) - ); + points3.forEach(point -> System.out.printf("x: %1$f; y: %2$f%n", point[0], point[1])); } /** @@ -83,11 +71,7 @@ public class EulerMethod { "stepSize should be greater than zero" ); } - double yNext = - yCurrent + - stepSize * - differentialEquation.apply(xCurrent, yCurrent); - return yNext; + return yCurrent + stepSize * differentialEquation.apply(xCurrent, yCurrent); } /** diff --git a/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java b/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java index c8ba532b2..1e30374e5 100644 --- a/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java +++ b/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java @@ -17,7 +17,7 @@ public class FastInverseSqrt { i = 0x5f3759df - (i >> 1); x = Float.intBitsToFloat(i); x = x * (1.5f - xhalf * x * x); - return x == (float) ((float) 1 / (float) Math.sqrt(number)); + return x == ((float) 1 / (float) Math.sqrt(number)); } /** diff --git a/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java b/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java index 64569be4b..28fe772ed 100644 --- a/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java +++ b/src/main/java/com/thealgorithms/maths/KrishnamurthyNumber.java @@ -36,11 +36,7 @@ public class KrishnamurthyNumber { } //evaluating if sum of the factorials of the digits equals the number itself - if (tmp == s) { - return true; - } else { - return false; - } + return tmp == s; } } diff --git a/src/main/java/com/thealgorithms/maths/StandardScore.java b/src/main/java/com/thealgorithms/maths/StandardScore.java index 42a41f3cb..dcedf458b 100644 --- a/src/main/java/com/thealgorithms/maths/StandardScore.java +++ b/src/main/java/com/thealgorithms/maths/StandardScore.java @@ -3,7 +3,6 @@ package com.thealgorithms.maths; public class StandardScore { public static double zScore(double num, double mean, double stdDev) { - double z = (num - mean) / stdDev; - return z; + return (num - mean) / stdDev; } } diff --git a/src/main/java/com/thealgorithms/others/BankersAlgorithm.java b/src/main/java/com/thealgorithms/others/BankersAlgorithm.java index f6d683a22..1c7870e05 100644 --- a/src/main/java/com/thealgorithms/others/BankersAlgorithm.java +++ b/src/main/java/com/thealgorithms/others/BankersAlgorithm.java @@ -88,7 +88,7 @@ public class BankersAlgorithm { while (count < totalProcess) { boolean foundSafeSystem = false; for (int m = 0; m < totalProcess; m++) { - if (finishProcesses[m] == false) { + if (!finishProcesses[m]) { int j; for (j = 0; j < totalResources; j++) { @@ -112,7 +112,7 @@ public class BankersAlgorithm { } // If we could not find a next process in safe sequence. - if (foundSafeSystem == false) { + if (!foundSafeSystem) { System.out.print( "The system is not in the safe state because lack of resources" ); diff --git a/src/main/java/com/thealgorithms/others/Dijkstra.java b/src/main/java/com/thealgorithms/others/Dijkstra.java index 8f5a5f570..e2cd2630d 100644 --- a/src/main/java/com/thealgorithms/others/Dijkstra.java +++ b/src/main/java/com/thealgorithms/others/Dijkstra.java @@ -131,15 +131,7 @@ class Graph { ) { return false; } - if ( - neighbours != null - ? !neighbours.equals(vertex.neighbours) - : vertex.neighbours != null - ) { - return false; - } - - return true; + return neighbours != null ? neighbours.equals(vertex.neighbours) : vertex.neighbours == null; } @Override diff --git a/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java b/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java index 6364c5cd3..08cdd44fb 100644 --- a/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java +++ b/src/main/java/com/thealgorithms/others/Implementing_auto_completing_features_using_trie.java @@ -120,7 +120,7 @@ class Trieac { } // If prefix is present as a word. - boolean isWord = (pCrawl.isWordEnd == true); + boolean isWord = (pCrawl.isWordEnd); // If prefix is last node of tree (has no // children) diff --git a/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java b/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java index 95fffd41c..3d50b4840 100644 --- a/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java +++ b/src/main/java/com/thealgorithms/others/LowestBasePalindrome.java @@ -139,7 +139,7 @@ public class LowestBasePalindrome { // If the remainder is a digit < 10, simply add it to // the left side of the new number. if (decimalValue % b2 < 10) { - output = Integer.toString(decimalValue % b2) + output; + output = decimalValue % b2 + output; } // If the remainder is >= 10, add a character with the // corresponding value to the new number. (A = 10, B = 11, C = 12, ...) else { diff --git a/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java b/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java index 87ecd8594..f05d19389 100644 --- a/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java +++ b/src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java @@ -46,7 +46,7 @@ public class MiniMaxAlgorithm { "The best score for " + (isMaximizer ? "Maximizer" : "Minimizer") + " is " + - String.valueOf(bestScore) + bestScore ); } @@ -88,14 +88,12 @@ public class MiniMaxAlgorithm { // (1 x 2) = 2; ((1 x 2) + 1) = 3 // (2 x 2) = 4; ((2 x 2) + 1) = 5 ... if (verbose) { - System.out.println( - String.format( - "From %02d and %02d, %s chooses %02d", + System.out.printf( + "From %02d and %02d, %s chooses %02d%n", score1, score2, (isMaximizer ? "Maximizer" : "Minimizer"), bestScore - ) ); } diff --git a/src/main/java/com/thealgorithms/others/PageRank.java b/src/main/java/com/thealgorithms/others/PageRank.java index b25ca3e3f..8d67ff8f9 100644 --- a/src/main/java/com/thealgorithms/others/PageRank.java +++ b/src/main/java/com/thealgorithms/others/PageRank.java @@ -49,7 +49,7 @@ class PageRank { for (k = 1; k <= totalNodes; k++) { this.pagerank[k] = InitialPageRank; } - System.out.printf("\n Initial PageRank Values , 0th Step \n"); + System.out.print("\n Initial PageRank Values , 0th Step \n"); for (k = 1; k <= totalNodes; k++) { System.out.printf( @@ -113,7 +113,7 @@ class PageRank { } // Display PageRank - System.out.printf("\n Final Page Rank : \n"); + System.out.print("\n Final Page Rank : \n"); for (k = 1; k <= totalNodes; k++) { System.out.printf( " Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n" diff --git a/src/main/java/com/thealgorithms/others/RemoveDuplicateFromString.java b/src/main/java/com/thealgorithms/others/RemoveDuplicateFromString.java index b1e13816d..0b410a9d5 100644 --- a/src/main/java/com/thealgorithms/others/RemoveDuplicateFromString.java +++ b/src/main/java/com/thealgorithms/others/RemoveDuplicateFromString.java @@ -40,7 +40,7 @@ public class RemoveDuplicateFromString { for (int i = 0; i < n; i++) { if (sb.toString().indexOf(s.charAt(i)) == -1) { - sb.append(String.valueOf(s.charAt(i))); + sb.append(s.charAt(i)); } } diff --git a/src/main/java/com/thealgorithms/searches/BinarySearch.java b/src/main/java/com/thealgorithms/searches/BinarySearch.java index 18ec2c0c4..bc5b41580 100644 --- a/src/main/java/com/thealgorithms/searches/BinarySearch.java +++ b/src/main/java/com/thealgorithms/searches/BinarySearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Arrays; import java.util.Random; @@ -86,23 +84,15 @@ class BinarySearch implements SearchAlgorithm { BinarySearch search = new BinarySearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } } diff --git a/src/main/java/com/thealgorithms/searches/ExponentalSearch.java b/src/main/java/com/thealgorithms/searches/ExponentalSearch.java index f1fc7705f..1b9accdca 100644 --- a/src/main/java/com/thealgorithms/searches/ExponentalSearch.java +++ b/src/main/java/com/thealgorithms/searches/ExponentalSearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Arrays; import java.util.Random; @@ -29,24 +27,16 @@ class ExponentialSearch implements SearchAlgorithm { ExponentialSearch search = new ExponentialSearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } @Override diff --git a/src/main/java/com/thealgorithms/searches/InterpolationSearch.java b/src/main/java/com/thealgorithms/searches/InterpolationSearch.java index bb53389a1..0632971b7 100644 --- a/src/main/java/com/thealgorithms/searches/InterpolationSearch.java +++ b/src/main/java/com/thealgorithms/searches/InterpolationSearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import java.util.Arrays; import java.util.Random; import java.util.stream.IntStream; @@ -67,28 +65,20 @@ class InterpolationSearch { .toArray(); // the element that should be found - Integer shouldBeFound = integers[r.nextInt(size - 1)]; + int shouldBeFound = integers[r.nextInt(size - 1)]; InterpolationSearch search = new InterpolationSearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - String.format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } } diff --git a/src/main/java/com/thealgorithms/searches/IterativeBinarySearch.java b/src/main/java/com/thealgorithms/searches/IterativeBinarySearch.java index 7f71ba3dd..cec8703be 100644 --- a/src/main/java/com/thealgorithms/searches/IterativeBinarySearch.java +++ b/src/main/java/com/thealgorithms/searches/IterativeBinarySearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Arrays; import java.util.Random; @@ -72,23 +70,15 @@ public final class IterativeBinarySearch implements SearchAlgorithm { IterativeBinarySearch search = new IterativeBinarySearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - String.format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } } diff --git a/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java b/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java index 176091229..933056987 100644 --- a/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java +++ b/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Arrays; import java.util.Random; @@ -70,23 +68,15 @@ public class IterativeTernarySearch implements SearchAlgorithm { IterativeTernarySearch search = new IterativeTernarySearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } } diff --git a/src/main/java/com/thealgorithms/searches/LinearSearch.java b/src/main/java/com/thealgorithms/searches/LinearSearch.java index bd97d0a9c..350cfc6e8 100644 --- a/src/main/java/com/thealgorithms/searches/LinearSearch.java +++ b/src/main/java/com/thealgorithms/searches/LinearSearch.java @@ -53,14 +53,12 @@ public class LinearSearch implements SearchAlgorithm { LinearSearch search = new LinearSearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - String.format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); } } diff --git a/src/main/java/com/thealgorithms/searches/LowerBound.java b/src/main/java/com/thealgorithms/searches/LowerBound.java index 0822ae6df..d800a6cc1 100644 --- a/src/main/java/com/thealgorithms/searches/LowerBound.java +++ b/src/main/java/com/thealgorithms/searches/LowerBound.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Random; import java.util.concurrent.ThreadLocalRandom; @@ -48,24 +46,16 @@ class LowerBound implements SearchAlgorithm { LowerBound search = new LowerBound(); int atIndex = search.find(integers, val); - System.out.println( - format( - "Val: %d. Lower Bound Found %d at index %d. An array length %d", + System.out.printf( + "Val: %d. Lower Bound Found %d at index %d. An array length %d%n", val, integers[atIndex], atIndex, size - ) ); boolean toCheck = integers[atIndex] >= val || integers[size - 1] < val; - System.out.println( - format( - "Lower Bound found at an index: %d. Is greater or max element: %b", - atIndex, - toCheck - ) - ); + System.out.printf("Lower Bound found at an index: %d. Is greater or max element: %b%n", atIndex, toCheck); } /** diff --git a/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java b/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java index 3765d871b..88c097b03 100644 --- a/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java +++ b/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java @@ -187,13 +187,11 @@ public class MonteCarloTreeSearch { System.out.println("N.\tScore\t\tVisits"); for (int i = 0; i < rootNode.childNodes.size(); i++) { - System.out.println( - String.format( - "%02d\t%d\t\t%d", + System.out.printf( + "%02d\t%d\t\t%d%n", i + 1, rootNode.childNodes.get(i).score, rootNode.childNodes.get(i).visitCount - ) ); } } diff --git a/src/main/java/com/thealgorithms/searches/TernarySearch.java b/src/main/java/com/thealgorithms/searches/TernarySearch.java index 170b3e104..5b447fa49 100644 --- a/src/main/java/com/thealgorithms/searches/TernarySearch.java +++ b/src/main/java/com/thealgorithms/searches/TernarySearch.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Arrays; import java.util.Random; @@ -89,23 +87,15 @@ public class TernarySearch implements SearchAlgorithm { TernarySearch search = new TernarySearch(); int atIndex = search.find(integers, shouldBeFound); - System.out.println( - format( - "Should be found: %d. Found %d at index %d. An array length %d", + System.out.printf( + "Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size - ) ); int toCheck = Arrays.binarySearch(integers, shouldBeFound); - System.out.println( - format( - "Found by system method at an index: %d. Is equal: %b", - toCheck, - toCheck == atIndex - ) - ); + System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex); } } diff --git a/src/main/java/com/thealgorithms/searches/UpperBound.java b/src/main/java/com/thealgorithms/searches/UpperBound.java index 0b5cfa090..1c842fbcc 100644 --- a/src/main/java/com/thealgorithms/searches/UpperBound.java +++ b/src/main/java/com/thealgorithms/searches/UpperBound.java @@ -1,7 +1,5 @@ package com.thealgorithms.searches; -import static java.lang.String.format; - import com.thealgorithms.devutils.searches.SearchAlgorithm; import java.util.Random; import java.util.concurrent.ThreadLocalRandom; @@ -48,24 +46,16 @@ class UpperBound implements SearchAlgorithm { UpperBound search = new UpperBound(); int atIndex = search.find(integers, val); - System.out.println( - format( - "Val: %d. Upper Bound Found %d at index %d. An array length %d", + System.out.printf( + "Val: %d. Upper Bound Found %d at index %d. An array length %d%n", val, integers[atIndex], atIndex, size - ) ); boolean toCheck = integers[atIndex] > val || integers[size - 1] < val; - System.out.println( - format( - "Upper Bound found at an index: %d. Is greater or max element: %b", - atIndex, - toCheck - ) - ); + System.out.printf("Upper Bound found at an index: %d. Is greater or max element: %b%n", atIndex, toCheck); } /** diff --git a/src/main/java/com/thealgorithms/sorts/BeadSort.java b/src/main/java/com/thealgorithms/sorts/BeadSort.java index dd064b4fe..cd60ab0b5 100644 --- a/src/main/java/com/thealgorithms/sorts/BeadSort.java +++ b/src/main/java/com/thealgorithms/sorts/BeadSort.java @@ -27,7 +27,7 @@ public class BeadSort { for(int i = 0; i < unsorted.length; i++) { int k = 0; - for(int j = 0; j < (int) unsorted[i] ; j++) { + for(int j = 0; j < unsorted[i]; j++) { grid[count[max - k - 1]++][k] = '*'; k++; } diff --git a/src/main/java/com/thealgorithms/sorts/CircleSort.java b/src/main/java/com/thealgorithms/sorts/CircleSort.java index 2ad09d15b..3d013c88e 100644 --- a/src/main/java/com/thealgorithms/sorts/CircleSort.java +++ b/src/main/java/com/thealgorithms/sorts/CircleSort.java @@ -24,7 +24,7 @@ public class CircleSort implements SortAlgorithm { int left, int right ) { - Boolean swapped = false; + boolean swapped = false; if (left == right) { return false; diff --git a/src/main/java/com/thealgorithms/sorts/CombSort.java b/src/main/java/com/thealgorithms/sorts/CombSort.java index 78951fb3c..2341ac652 100644 --- a/src/main/java/com/thealgorithms/sorts/CombSort.java +++ b/src/main/java/com/thealgorithms/sorts/CombSort.java @@ -23,7 +23,7 @@ class CombSort implements SortAlgorithm { private int nextGap(int gap) { // Shrink gap by Shrink factor gap = (gap * 10) / 13; - return (gap < 1) ? 1 : gap; + return Math.max(gap, 1); } /** diff --git a/src/main/java/com/thealgorithms/sorts/MergeSortRecursive.java b/src/main/java/com/thealgorithms/sorts/MergeSortRecursive.java index 57f1d9be3..902507abc 100644 --- a/src/main/java/com/thealgorithms/sorts/MergeSortRecursive.java +++ b/src/main/java/com/thealgorithms/sorts/MergeSortRecursive.java @@ -13,8 +13,7 @@ public class MergeSortRecursive { } public List mergeSort() { - List arrSorted = merge(arr); - return arrSorted; + return merge(arr); } private static List merge(List arr) { diff --git a/src/main/java/com/thealgorithms/sorts/TreeSort.java b/src/main/java/com/thealgorithms/sorts/TreeSort.java index ca9d4c80c..78f233783 100644 --- a/src/main/java/com/thealgorithms/sorts/TreeSort.java +++ b/src/main/java/com/thealgorithms/sorts/TreeSort.java @@ -72,20 +72,20 @@ public class TreeSort implements SortAlgorithm { // ==== Integer Array ======= System.out.println("Testing for Integer Array...."); Integer[] a = { 3, -7, 45, 1, 343, -5, 2, 9 }; - System.out.print(String.format("%-10s", "unsorted: ")); + System.out.printf("%-10s", "unsorted: "); print(a); a = treeSort.sort(a); - System.out.print(String.format("%-10s", "sorted: ")); + System.out.printf("%-10s", "sorted: "); print(a); System.out.println(); // ==== Integer List ======= System.out.println("Testing for Integer List...."); List intList = List.of(3, -7, 45, 1, 343, -5, 2, 9); - System.out.print(String.format("%-10s", "unsorted: ")); + System.out.printf("%-10s", "unsorted: "); print(intList); intList = treeSort.sort(intList); - System.out.print(String.format("%-10s", "sorted: ")); + System.out.printf("%-10s", "sorted: "); print(intList); System.out.println(); @@ -101,10 +101,10 @@ public class TreeSort implements SortAlgorithm { "apple", "pineapple", }; - System.out.print(String.format("%-10s", "unsorted: ")); + System.out.printf("%-10s", "unsorted: "); print(b); b = treeSort.sort(b); - System.out.print(String.format("%-10s", "sorted: ")); + System.out.printf("%-10s", "sorted: "); print(b); System.out.println(); @@ -120,10 +120,10 @@ public class TreeSort implements SortAlgorithm { "apple", "pineapple" ); - System.out.print(String.format("%-10s", "unsorted: ")); + System.out.printf("%-10s", "unsorted: "); print(stringList); stringList = treeSort.sort(stringList); - System.out.print(String.format("%-10s", "sorted: ")); + System.out.printf("%-10s", "sorted: "); print(stringList); } } diff --git a/src/main/java/com/thealgorithms/sorts/WiggleSort.java b/src/main/java/com/thealgorithms/sorts/WiggleSort.java index c69fcdbe9..dc05de43c 100644 --- a/src/main/java/com/thealgorithms/sorts/WiggleSort.java +++ b/src/main/java/com/thealgorithms/sorts/WiggleSort.java @@ -59,7 +59,7 @@ public class WiggleSort implements SortAlgorithm { median = select( - Arrays.asList(sortThis), + Arrays.asList(sortThis), (int) floor(sortThis.length / 2.0) ); diff --git a/src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java b/src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java index e2c7d9078..8ebff8576 100644 --- a/src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java +++ b/src/main/java/com/thealgorithms/strings/LongestPalindromicSubstring.java @@ -27,7 +27,7 @@ class Solution { String maxStr = ""; for (int i = 0; i < n; ++i) { for (int j = i; j < n; ++j) { - if (isValid(s, i, j) == true) { + if (isValid(s, i, j)) { if (j - i + 1 > maxStr.length()) { // update maxStr maxStr = s.substring(i, j + 1); } diff --git a/src/main/java/com/thealgorithms/strings/MyAtoi.java b/src/main/java/com/thealgorithms/strings/MyAtoi.java index a68a5fd39..0770f66c7 100644 --- a/src/main/java/com/thealgorithms/strings/MyAtoi.java +++ b/src/main/java/com/thealgorithms/strings/MyAtoi.java @@ -72,13 +72,8 @@ public static int myAtoi(String s) { if (db1 > (2147483647)) { return 2147483647; } - }else if (number.length() == 10 && negative) { - double db1 = Double.parseDouble(number); - if (db1 >= 2147483648d) { - return -2147483648; - } } - + if(negative){ return Integer.parseInt(number)*-1; }