Artemis: Refactor String and Vector Manipulation Methods for Improved Efficiency

app/src/main/java/control/Single.java

@@ -11,15 +11,7 @@ public class Single {
    * @return The sum of the first n natural numbers.
    */
   public static int sumRange(int n) {
-    int[] arr = new int[n];
-    int sum = 0;
-    for (int i = 0; i < n; i++) {
-      arr[i] = i;
-    }
-    for (int i : arr) {
-      sum += i;
-    }
-    return sum;
+    return (n * (n - 1)) / 2;
   }
 
   /**
@@ -29,10 +21,13 @@ public static int sumRange(int n) {
    * @return The maximum value in the array.
    */
   public static int maxArray(int[] arr) {
-    int max = 0;
-    for (int i : arr) {
-      if (i > max) {
-        max = i;
+    if (arr == null || arr.length == 0) {
+      throw new IllegalArgumentException("Array is null or empty");
+    }
+    int max = arr[0];
+    for (int i = 1; i < arr.length; i++) {
+      if (arr[i] > max) {
+        max = arr[i];
       }
     }
     return max;
@@ -45,13 +40,12 @@ public static int maxArray(int[] arr) {
    * @param m The modulus.
    */
   public static int sumModulus(int n, int m) {
-    Vector<Integer> multiples = new Vector<Integer>();
+    int sum = 0;
     for (int i = 0; i < n; i++) {
       if (i % m == 0) {
-        multiples.add(i);
+        sum += i;
       }
     }
-
-    return multiples.stream().mapToInt(Integer::valueOf).sum();
+    return sum;
   }
-}
+}

app/src/main/java/datastructures/DsLinkedList.java

@@ -1,4 +1,5 @@
 package datastructures;
+import java.util.Collections;
 
 import java.util.LinkedList;
 
@@ -10,13 +11,8 @@ public class DsLinkedList {
    * @return the shuffled linked list
    */
   public static LinkedList<Integer> shuffle(LinkedList<Integer> l) {
-    LinkedList<Integer> tmp = new LinkedList<Integer>(l);
-    LinkedList<Integer> ret = new LinkedList<Integer>();
-    while (tmp.size() > 0) {
-      int index = (int) (Math.random() * tmp.size());
-      ret.add(tmp.get(index));
-      tmp.remove(index);
-    }
+    LinkedList<Integer> ret = new LinkedList<>(l);
+    Collections.shuffle(ret);
     return ret;
   }
 
@@ -30,10 +26,6 @@ public static LinkedList<Integer> shuffle(LinkedList<Integer> l) {
    */
   public static LinkedList<Integer> slice(LinkedList<Integer> l, int start,
       int end) {
-    LinkedList<Integer> ret = new LinkedList<Integer>();
-    for (int i = start; i < end; i++) {
-      ret.add(l.get(i));
-    }
-    return ret;
+    return new LinkedList<>(l.subList(start, end));
   }
-}
+}

app/src/main/java/datastructures/DsVector.java

@@ -1,4 +1,5 @@
 package datastructures;
+import java.util.Collections;
 
 import java.util.Vector;
 
@@ -40,16 +41,7 @@ public static Vector<Integer> searchVector(Vector<Integer> v, int n) {
    */
   public static Vector<Integer> sortVector(Vector<Integer> v) {
     Vector<Integer> ret = new Vector<Integer>(v);
-
-    for (int i = 0; i < ret.size(); i++) {
-      for (int j = 0; j < ret.size() - 1; j++) {
-        if (ret.get(j) > ret.get(j + 1)) {
-          int temp = ret.get(j);
-          ret.set(j, ret.get(j + 1));
-          ret.set(j + 1, temp);
-        }
-      }
-    }
+    Collections.sort(ret);
     return ret;
   }
 
@@ -60,11 +52,8 @@ public static Vector<Integer> sortVector(Vector<Integer> v) {
    * @return the reversed vector
    */
   public static Vector<Integer> reverseVector(Vector<Integer> v) {
-    Vector<Integer> ret = new Vector<Integer>();
-
-    for (int i = v.size() - 1; i >= 0; i--) {
-      ret.add(v.get(i));
-    }
+    Vector<Integer> ret = new Vector<Integer>(v);
+    Collections.reverse(ret);
     return ret;
   }
 
@@ -76,14 +65,13 @@ public static Vector<Integer> reverseVector(Vector<Integer> v) {
    * @return the rotated vector
    */
   public static Vector<Integer> rotateVector(Vector<Integer> v, int n) {
-    Vector<Integer> ret = new Vector<Integer>();
-
-    for (int i = n; i < v.size(); i++) {
-      ret.add(v.get(i));
-    }
-    for (int i = 0; i < n; i++) {
-      ret.add(v.get(i));
-    }
+    int size = v.size();
+    n = n % size;
+    if (n < 0) n += size;
+
+    Vector<Integer> ret = new Vector<Integer>(size);
+    ret.addAll(v.subList(size - n, size));
+    ret.addAll(v.subList(0, size - n));
     return ret;
   }
 
@@ -96,14 +84,9 @@ public static Vector<Integer> rotateVector(Vector<Integer> v, int n) {
    */
   public static Vector<Integer> mergeVectors(Vector<Integer> v1,
       Vector<Integer> v2) {
-    Vector<Integer> ret = new Vector<Integer>();
-
-    for (int i = 0; i < v1.size(); i++) {
-      ret.add(v1.get(i));
-    }
-    for (int i = 0; i < v2.size(); i++) {
-      ret.add(v2.get(i));
-    }
+    Vector<Integer> ret = new Vector<Integer>(v1.size() + v2.size());
+    ret.addAll(v1);
+    ret.addAll(v2);
     return ret;
   }
-}
+}

app/src/main/java/generator/GenVector.java

@@ -12,7 +12,7 @@ public class GenVector {
    * @return A vector of length n
    */
   public static Vector<Integer> generateVector(int n, int m) {
-    Vector<Integer> ret = new Vector<Integer>();
+    Vector<Integer> ret = new Vector<Integer>(n);
     Random rand = new Random();
 
     for (int i = 0; i < n; i++) {
@@ -21,4 +21,4 @@ public static Vector<Integer> generateVector(int n, int m) {
 
     return ret;
   }
-}
+}

app/src/main/java/strings/Strops.java

@@ -8,11 +8,7 @@ public class Strops {
    * @return The reversed string.
    */
   public String reverse(String str) {
-    String reversed = "";
-    for (int i = str.length() - 1; i >= 0; i--) {
-      reversed += str.charAt(i);
-    }
-    return reversed;
+    return new StringBuilder(str).reverse().toString();
   }
 
   /**
@@ -22,16 +18,21 @@ public String reverse(String str) {
    * @return True if the string is a palindrome, false otherwise.
    */
   public boolean isPalindrome(String str) {
-    if (str.length() == 0) {
+    if (str.isEmpty()) {
       return false;
     }
 
-    for (int i = 0; i < str.length(); i++) {
-      if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
+    int left = 0;
+    int right = str.length() - 1;
+
+    while (left < right) {
+      if (str.charAt(left) != str.charAt(right)) {
         return false;
       }
+      left++;
+      right--;
     }
 
     return true;
   }
-}
+}