1 files changed, 104 insertions, 0 deletions
diff --git a/graphs/java/classics/src/main/java/fr/epita/assistants/classics/Classics.java b/graphs/java/classics/src/main/java/fr/epita/assistants/classics/Classics.java
new file mode 100644
index 0000000..9be12e2
--- /dev/null
+++ b/graphs/java/classics/src/main/java/fr/epita/assistants/classics/Classics.java
@@ -0,0 +1,104 @@
+package fr.epita.assistants.classics;
+
+public class Classics {
+    /**
+     * Computes the factorial of n.
+     *
+     * @param n the nth value to compute, negative values should return -1
+     * @return the long value of n!
+     */
+    public static long factorial(int n) {
+        if (n < 0) return -1;
+        if (n == 0) return 1;
+        return n * factorial(n - 1);
+    }
+
+    /**
+     * Computes the nth value of the tribonacci suite.
+     * f(0) = 0, f(1) = 1, f(2) = 1, f(n+3) = f(n) + f(n+1) + f(n+2)
+     *
+     * @param n the nth sequence to compute
+     */
+    public static long tribonacci(int n) {
+        if (n < 0)
+            return -1;
+        if (n == 0) {
+            return 0;
+        }
+        long fst = 0;
+        if (n < 3) return 1;
+        long sec = 1;
+        long thd = 1;
+        while (n >= 3) {
+            long t = fst + sec + thd;
+            fst = sec;
+            sec = thd;
+            thd = t;
+            n--;
+        }
+        return thd;
+    }
+
+    /**
+     * Checks if a word is a palindrome.
+     *
+     * @param word the string to check
+     * @return true if the word is a palindrome, false otherwise.
+     */
+    public static boolean isPalindrome(String word) {
+        if (word == null) return false;
+        word = word.toLowerCase().strip();
+        if (word.isEmpty()) return true;
+        for (int i = 0, j = word.length() - 1; i < j; i++, j--) {
+            while (word.charAt(i) == ' ') {
+                i++;
+            }
+            while (word.charAt(j) == ' ') {
+                j--;
+            }
+            if (word.charAt(i) != word.charAt(j)) return false;
+        }
+        return true;
+    }
+
+    /**
+     * Sorts an array using an insertion sort.
+     *
+     * @param array the array to sort in place
+     */
+    public static void insertionSort(int[] array) {
+        if (array.length == 0) {
+            return;
+        }
+        for (int i = 1; i < array.length; i++) {
+            for (int j = i; j > 0 && array[j - 1] > array[j]; j--) {
+                int tmp = array[j];
+                array[j] = array[j - 1];
+                array[j - 1] = tmp;
+            }
+        }
+    }
+
+    /**
+     * Combines two strings by alternating their characters. Must use a StringBuilder.
+     * If the strings do not have the same length, appends the remaining characters at the end of the result.
+     * For instance, combine("abc", "def") returns "adbecf"
+     */
+    public static String combine(String a, String b) {
+        if (a.isEmpty())
+            return b;
+        if (b.isEmpty())
+            return a;
+        StringBuilder sb = new StringBuilder();
+        int i;
+        for (i = 0; i < Math.min(a.length(), b.length()); i++) {
+            sb.append(a.charAt(i));
+            sb.append(b.charAt(i));
+        }
+        if (b.length() > a.length()) {
+            for (; i < b.length(); i++)
+                sb.append(b.charAt(i));
+        }
+        return new String(sb);
+    }
+}
+\ No newline at end of file