Initial Commit

Author: ananay22

.gitignore

@@ -0,0 +1,5 @@
+build/**/*
+**/*.class
+**/*.exe
+**/*.obj
+**/*.pdb

cli.py

@@ -0,0 +1,98 @@
+import argparse
+import os
+import subprocess
+import shutil
+
+__ITEM_LOCATION = lambda item, lang, pref="", suff="": f"{pref}{item}/{lang}{suff}"
+__ITEM_PATH = lambda item, lang, pref="", suff="": __ITEM_LOCATION(item, lang, pref, "/" + item + suff)
+
+__SUPPORTED_LANGS = {
+    "zig": {
+        "ext": ".zig", 
+        "build": "zig build-exe {0}.zig",
+    }, 
+    "java": {
+        "ext": ".java", 
+        "build": "javac -d . {0}.java",
+    }, 
+    "c++": {
+        "ext": ".cpp", 
+        "build": "g++ {0}.cpp",
+    }
+}
+
+# create
+def _create_dir(dirname):
+    print("Making directory:", dirname)
+    if os.path.exists(dirname):
+        print(f"Path '{dirname}' already exists")
+        exit(1)
+    os.mkdir(dirname)
+
+def _create_file(filename):
+    print("Making file:", filename)
+    if os.path.exists(filename):
+        print(f"Path '{filename}' already exists")
+        exit(1)
+    with open(filename, "w"):
+        pass
+
+def _create_supported_langs_dirs(item_name):
+    _create_dir(f"src/{item_name}")
+    for lang in __SUPPORTED_LANGS:
+        _create_dir(f"src/{item_name}/{lang}")
+        _create_file(f"src/{item_name}/{lang}/{item_name}{__SUPPORTED_LANGS[lang]['ext']}")
+
+# build 
+def _get_items_in_src():
+    return [f.name for f in os.scandir("./src/") if f.is_dir()]
+
+def _run_build_command(lang, item):
+    start_dir = os.getcwd()
+
+    try:
+        print("Building %s in language %s" % (item, lang))
+        os.chdir(f"{start_dir}/build/")
+        subprocess.run(__SUPPORTED_LANGS[lang]["build"].format(__ITEM_PATH(item, lang, "../src/")).split(), shell=True, check=True)
+        for i in [f.name for f in os.scandir(".") if f.is_file()]:
+            if i.endswith(__SUPPORTED_LANGS[lang]["ext"]):
+                continue
+            try:
+                shutil.copy("./" + i, __ITEM_LOCATION(item, lang, "../build/", "/" + i))
+            except IOError:
+                os.makedirs(os.path.dirname(__ITEM_LOCATION(item, lang, "../build/", "/" + i)))                
+                shutil.copy("./" + i, __ITEM_LOCATION(item, lang, "../build/", "/" + i))
+
+            os.remove("./" + i)
+        os.chdir(start_dir)
+        print("Success.")
+    except Exception as e:
+        print(e)
+        os.chdir(start_dir)
+        print("Failed to build: %s for language %s\nFull command was %s\n" % (item, lang, __SUPPORTED_LANGS[lang]["build"].format(__ITEM_PATH(item, lang, "./src/"))))
+
+def _build_supported_langs(item_name):
+    for lang in __SUPPORTED_LANGS:
+        _run_build_command(lang, item_name)
+
+def _build_items_in_src():
+    if not os.path.exists("./build/"):
+        os.mkdir("./build/")
+    for item in _get_items_in_src():
+        _build_supported_langs(item)
+
+
+# args
+argParser = argparse.ArgumentParser()
+argParser.add_argument("-c", "--create", type=str, help="Create a directory structure with all supported programming languages.")
+argParser.add_argument("-b", "--build", action='store_true', help="Build all the files in the src directory and places them in a separate build directory structure. Builds all supported programming languages.")
+
+# main
+if __name__ == "__main__":
+    args = argParser.parse_args()
+
+    if args.create:
+        _create_supported_langs_dirs(args.create)
+    if args.build:
+        _build_items_in_src()
+    

src/binary_search/c++/binary_search.cpp

@@ -0,0 +1,16 @@
+template <typename T>
+int binary_search(T arr[], T key, int length) {
+    int left = 0;
+    int right = length;
+    while (left < right) {
+        int mid = (left + right) / 2;
+        if (arr[mid] == key) return mid;
+        if (arr[mid] < key) left = mid;
+        if (arr[mid] > key) right = mid;
+    }
+    return -1;
+}
+
+int main() {
+    return 0;
+}

src/binary_search/java/binary_search.java

@@ -0,0 +1,13 @@
+class BinarySearch {
+    public static <T extends Comparable<T>> int search(T[] arr, T key) {
+        int left = 0;
+        int right = arr.length;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (arr[mid].compareTo(key) == 0) return mid;
+            if (arr[mid].compareTo(key) < 0) left = mid;
+            if (arr[mid].compareTo(key) > 0) right = mid;
+        }
+        return -1;
+    }
+}

src/binary_search/zig/binary_search.zig

@@ -0,0 +1,13 @@
+pub fn binary(comptime T: type, arr: []T, key: T) i32 {
+    var left: u32 = 0;
+    var right: u32 = @intCast(u32, arr.len);
+    while (left < right) {
+        var mid = (left + right) / 2;
+        if (arr[mid] == key) return mid;
+        if (arr[mid] < key) left = mid;
+        if (arr[mid] > key) right = mid;
+    }
+    return -1;
+}
+
+pub fn main() !void {}

src/bubble_sort/c++/bubble_sort.cpp

@@ -0,0 +1,16 @@
+template <typename T>
+void bubble_sort(T arr[], int length) {
+    for (int i = 0; i < length; i++) {
+        for (int j = 0; j < length - i - 1; j++) {
+            if (arr[j] > (arr[j+1])) {
+                T temp = arr[j];
+                arr[j] = arr[j+1];
+                arr[j+1] = temp;
+            }
+        }
+    }
+}
+
+int main() {
+    return 0;
+}

src/bubble_sort/java/bubble_sort.java

@@ -0,0 +1,13 @@
+class BubbleSort {
+    public static <T extends Comparable<T>> void sort(T[] arr) {
+        for (int i = 0; i < arr.length; i++) {
+            for (int j = 0; j < arr.length - i - 1; j++) {
+                if (arr[j].compareTo(arr[j+1]) > 0) {
+                    T temp = arr[j];
+                    arr[j] = arr[j+1];
+                    arr[j+1] = temp;
+                }
+            }
+        }
+    }
+}

src/bubble_sort/zig/bubble_sort.zig

@@ -0,0 +1,15 @@
+pub fn bubble(comptime T: type, arr: []T) void {
+    var i: u32 = 0;
+    while (i < arr.len) : (i += 1) {
+        var j: u32 = 0;
+        while (j < arr.len - i - 1) : (j += 1) {
+            if (arr[j] > arr[j + 1]) {
+                var temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+        }
+    }
+}
+
+pub fn main() !void {}

src/linear_search/c++/linear_search.cpp

@@ -0,0 +1,11 @@
+template <typename T>
+int linear_search(T arr[], T key, int length) {
+    for (int i = 0; i < length; i++) {
+        if (arr[i] == key) return i;
+    }
+    return -1;
+}
+
+int main() {
+    return 0;
+}

src/linear_search/java/linear_search.java

@@ -0,0 +1,8 @@
+class LinearSearch {
+    public static <T extends Comparable<T>> int search(T[] arr, T key) {
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i].compareTo(key) == 0) return i;
+        }
+        return -1;
+    } 
+}

src/linear_search/zig/linear_search.zig

@@ -0,0 +1,10 @@
+pub fn linear_search(comptime T: type, arr: []T, key: T) i32 {
+    for (arr) |e, i| {
+        if (e == key) {
+            return @intCast(i32, i);
+        }
+    }
+    return -1;
+}
+
+pub fn main() !void {}

src/linked_list/c++/linked_list.cpp

@@ -0,0 +1,94 @@
+template <typename T> 
+class Node {
+    T data;
+    Node<T> next;
+    Node<T> prev;
+};
+
+template <typename T>
+class LinkedList {
+private:
+    Node<T> head;
+    Node<T> tail;
+    int _size;
+public:
+    bool is_empty() {return _size == 0;}
+    bool add(T data) {
+        Node<T> curr = new Node<T>();
+        if (_size == 0) {
+            curr.data = data;
+            head = tail = curr;
+        } else {
+            tail.next = curr;
+            curr.prev = tail;
+            tail = curr;
+        }
+        _size++;
+        return true;
+    }
+    T get(int idx) {
+        Node<T> curr = head;
+        while (idx - 1 > 0 && curr != nullptr) {
+            curr = curr.next;
+        }
+        if (idx != 0) return nullptr;
+        return curr.data;
+    }
+    bool insert(int idx, T data) {
+        if (idx < 0 || idx >= this._size) return false;
+        Node<T> curr = head;
+        while (idx - 1 > 0 && curr != nullptr) {
+            curr = curr.next;
+        }
+        if (idx != 0) return false;
+        Node<T> temp = curr.next;
+        Node<T> next = new Node<T>();
+        next.data = data;
+        curr.next = next;
+        next.prev = curr;
+
+        next.next = temp;
+        temp.prev = next;
+        return true;
+    }
+    T remove(int idx) {
+        if (idx < 0 || idx >= this._size) return nullptr;
+        Node<T> curr = head;
+        while (idx - 1 > 0 && curr != nullptr) {
+            curr = curr.next;
+        }
+        if (idx != 0) return nullptr;
+        Node<T> temp = curr.next;
+        
+        T ret = curr.data;
+        curr.prev.next = curr.next;
+        curr.next.prev = curr.prev;
+        return ret;
+    }
+    bool replace(int idx, T data) {
+        if (this.remove(idx) != nullptr) {
+            return this.insert(idx, data);
+        }
+        return false;
+    }
+    int size() {
+        return this._size;
+    }
+    // void print() {
+    //     if (this._size < 1) {
+    //         printf("[]\n");
+    //         return;
+    //     }
+    //     var curr = head;
+    //     printf("[");
+    //     while (curr != nullptr) {
+    //         printf("%s, ", curr.data);
+    //         curr = curr.next;
+    //     }
+    //     System.out.println("]");
+    // }
+};
+
+int main() {
+    return 0;
+}