added: miscellaneous testing

Author: nweniwincs4

nnw_python/MergeSortTest.py

@@ -0,0 +1,40 @@
+def merge(left, right):
+    result = []
+    i = j = 0
+    
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+            
+    result.extend(left[i:])
+    result.extend(right[j:])
+    
+    return result
+
+def mergeSort(arr):
+    step = 1  # Starting with sub-arrays of length 1
+    length = len(arr)
+    
+    while step < length:
+        for i in range(0, length, 2 * step):
+            left = arr[i:i + step]
+            right = arr[i + step:i + 2 * step]
+            
+            merged = merge(left, right)
+            
+            # Place the merged array back into the original array
+            for j, val in enumerate(merged):
+                arr[i + j] = val
+                
+        step *= 2  # Double the sub-array length for the next iteration
+        
+    return arr
+
+# unsortedArr = [3, 7, 6, -10, 15, 23.5, 55, -13]
+unsortedArr = [3, 7, 6, 5]
+sortedArr = mergeSort(unsortedArr)
+print("Sorted array:", sortedArr)

nnw_python/QueueWithLinkedList.py

@@ -0,0 +1,65 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class Queue:
+    def __init__(self):
+        self.front = None
+        self.rear = None
+        self.length = 0
+    
+    def enqueue(self, element):
+        new_node = Node(element)
+        if self.rear is None:
+            self.front = self.rear = new_node
+            self.length += 1
+            return
+        self.rear.next = new_node
+        self.rear = new_node
+        self.length += 1
+    
+    def dequeue(self):
+        if self.isEmpty():
+            return "Queue is empty"
+        temp = self.front
+        self.front = temp.next
+        self.length -= 1
+        if self.front is None:
+            self.rear = None
+        return temp.data
+    
+    def peek(self):
+        if self.isEmpty():
+            return "Queue is empty"
+        return self.front.data
+    
+    def isEmpty(self):
+        return self.length == 0
+    
+    def size(self):
+        return self.length
+
+    def printQueue(self):
+        temp = self.front
+        while temp:
+            print(temp.data, end=" ")
+            temp = temp.next
+        print()
+
+# Create a queue
+myQueue = Queue()
+
+myQueue.enqueue('A')
+myQueue.enqueue('B')
+myQueue.enqueue('C')
+print("Queue: ", end="")
+myQueue.printQueue()
+
+print("Dequeue: ", myQueue.dequeue())
+
+print("Peek: ", myQueue.peek())
+
+print("isEmpty: ", myQueue.isEmpty())
+
+print("Size: ", myQueue.size())

nnw_python/QueueWithList.py

@@ -0,0 +1,38 @@
+class Queue:
+    def __init__(self):
+        self.queue = []
+    
+    def enqueue(self, element):
+        self.queue.append(element)
+    
+    def dequeue(self):
+        if self.isEmpty():
+            return "Queue is empty"
+        return self.queue.pop(0)
+    
+    def peek(self):
+        if self.isEmpty():
+            return "Queue is empty"
+        return self.queue[0]
+    
+    def isEmpty(self):
+        return len(self.queue) == 0
+    
+    def size(self):
+        return len(self.queue)
+
+# Create a queue
+myQueue = Queue()
+
+myQueue.enqueue('A')
+myQueue.enqueue('B')
+myQueue.enqueue('C')
+print("Queue: ", myQueue.queue)
+
+print("Dequeue: ", myQueue.dequeue())
+
+print("Peek: ", myQueue.peek())
+
+print("isEmpty: ", myQueue.isEmpty())
+
+print("Size: ", myQueue.size())

nnw_python/StackTest.py

@@ -0,0 +1,35 @@
+class Stack:
+    def __init__(self):
+        self.stack = []
+        
+    def push(self,item):
+        self.stack.append(item)
+        
+    def pop(self):
+        self.stack.pop()
+        
+    def peek(self):
+        return self.stack[-1]
+    
+    def isEmpyt(self):
+        return len(self.stack)==0
+
+    def size(self):
+        return len(self.stack)
+    
+    
+if __name__=="__main__":
+    stack = Stack()
+    stack.push("A")
+    stack.push("B")
+    stack.push("C")
+    stack.push("D")
+    print(f" Stack's items : {stack.stack}")
+    print(f" Stack Size : {stack.size()}")
+    print(f" Stack's last item : {stack.peek()}")
+    stack.pop()
+    print(f" Stack's items after removing last item: {stack.stack}")
+    print(f" Is Stack empty? : {stack.isEmpyt()}")
+
+
+

src/main/java/com/nnw/AdvancedSortingTest.java

@@ -0,0 +1,47 @@
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class AdvancedSortingTest {
+    static class Car{
+        int year;
+        String name;
+        public Car(int year,String name){
+            this.year=year;
+            this.name=name;
+        }
+    }
+    public static void main(String[] args) {
+        Car c1= new Car(2010,"Mazda");
+        Car c2 = new Car(2012,"Mazda");
+        Car c3 = new Car(2012,"BMW");
+        Car c4 = new Car(2012,"BMW");
+        ArrayList<Car> myCars = new ArrayList<>();
+        myCars.add(c1);
+        myCars.add(c2);
+        myCars.add(c3);
+        myCars.add(c4);
+        // Collections.sort(myCars, (obj1, obj2) -> {
+        //     Car a = (Car) obj1;
+        //     Car b = (Car) obj2;
+        //     if (a.year < b.year) return -1;
+        //     if (a.year > b.year) return 1;
+        //     return 0;
+        //   });
+        
+        Collections.sort(myCars,(obj1,obj2)->{
+        Car c_obj1= (Car)obj1;
+        Car c_obj2= (Car)obj2;
+        if(c_obj1.year<c_obj2.year)
+            return -1;
+        else if(c_obj1.year>c_obj2.year)
+            return 1;
+        // return 0;
+        else
+            return c_obj1.name.compareTo(c_obj2.name); 
+        });
+        myCars.forEach(car->{System.out.printf("Car Brand : %s \t Model Year : %d \n",car.name,car.year);});
+    }
+}
+
+

src/main/java/com/nnw/ArraySortingTest.java

@@ -0,0 +1,23 @@
+import java.util.Arrays;
+
+public class ArraySortingTest {
+  public static void main(String[] args) {
+    String[] cars = {"Volvo", "BMW", "Tesla", "Ford", "Fiat", "Mazda", "Audi"};
+    System.out.println("Ascending order : ");
+    Arrays.sort(cars);
+    for (String i : cars) {
+        System.out.println(i);
+    }
+    System.out.printf("Lowest value : %s \n",cars[0]);
+    System.out.printf("Highest value : %s \n",cars[cars.length-1]);
+    System.out.println("------------------------");
+    System.out.println("Descending order : ");
+    Arrays.sort(cars,(obj1,obj2)->{
+    	int comp = obj1.compareTo(obj2);
+        return comp*-1;
+    });
+    for (String i : cars) {
+      System.out.println(i);
+    }
+  }
+}

src/main/java/com/nnw/CreateFileTest.java

@@ -0,0 +1,100 @@
+
+import java.io.File;  // Import the File class
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Scanner;
+
+public class CreateFileTest {
+
+    public static void main(String[] args) {
+        // try {
+        //     File myFile = new File("filename.txt");
+        //     // windows
+        //     // File myFile = new File("C:\\Users\\MyName\\filename.txt");
+        //     // mac
+        //     // File myFile = new File("..//filename.txt"); // mac: step back to the higher level
+        //     // File myFile = new File("/Users/nweniwin/Documents/Java Study/Algorithms-and-Data-Structures-in-Java/filename.txt");
+        //     if (myFile.createNewFile()){
+        //         System.out.printf("New file : %s is created.",myFile.getName());
+        //         // System.out.printf("The file is created at %s",myFile.getAbsolutePath());
+        //     }else{
+        //         System.out.println("File already exists");
+        //         // System.out.printf("The file is at %s",myFile.getAbsolutePath());
+        //     }
+        // } catch (IOException e) {
+        //     System.out.println("An error occured");
+        //     e.printStackTrace();
+        // }
+
+        try {
+            FileWriter myWriter = new FileWriter("filename.txt");
+            String st = "Files in Java might be tricky, but it is fun enough!!!!!";
+            // for(String w:st.split(" ")){
+            for (char w : st.toCharArray()) {
+                myWriter.write(w + "\n");
+            }
+            myWriter.close();
+            System.out.println("Successfully wrote to the file.");
+        } catch (IOException e) {
+            System.out.println("An error occurred.");
+            e.printStackTrace();
+        }
+        File myFile = new File("filename.txt");
+        if (myFile.exists()) {
+            System.out.printf("File Name : %s \n", myFile.getName());
+            System.out.printf("File Absolute Path : %s \n", myFile.getAbsolutePath());
+            System.out.printf("File Path: %s  \n", myFile.getPath());
+            System.out.printf("File size in bytes : %s \n", myFile.length());
+            System.out.printf("Can Write : %s \n", myFile.canRead());
+            System.out.printf("Can Read : %s \n", myFile.canWrite());
+        }
+        if (myFile.delete()) {
+            System.out.printf("File Name : %s has been deleted", myFile.getName());
+        }
+        // To create a directory
+        try {
+            File myfolder = new File("files");
+            if (myfolder.createNewFile()) {
+                System.out.printf("The folder name : %s has been created.", myfolder.getAbsolutePath());
+            }
+            if (myfolder.delete()) {
+                System.out.printf("The folder name : %s has been deleted.", myfolder.getAbsolutePath());
+            }
+        } catch (IOException e) {
+            System.out.println("An error occured in creating a folder");
+        }
+
+        System.out.println("----------------------");
+        try {
+            FileWriter myWriter = new FileWriter("filename.txt");
+            Scanner myScanner = new Scanner(System.in);
+            for (int i=1;i<=5;i++){
+                String ln = myScanner.nextLine();
+                myWriter.write(ln + "\n");
+                if (i==5){
+                    System.out.println("Do you have anything to say? (Type yes or no)");
+                    String ans = myScanner.nextLine();
+                    if (ans.toLowerCase().equals("yes")){
+                        i=0;
+                    }
+                }
+            }
+            myScanner.close();
+            myWriter.close();
+        } catch (IOException e) {
+            System.out.println("An error occured");
+        }
+
+        try {
+            System.out.println("-----------------");
+            Scanner myScanner1 = new Scanner(new File("filename.txt"));
+            System.out.println("Here is the file content you have saved");
+            while(myScanner1.hasNext()){
+                System.out.println(myScanner1.nextLine());
+            }
+        } catch (FileNotFoundException e) {
+            System.out.println(e.getMessage());
+        } 
+    }
+}

src/main/java/com/nnw/DateTest.java

@@ -0,0 +1,18 @@
+import java.time.LocalDate; // import the LocalDate class
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+
+public class DateTest {
+  public static void main(String[] args) {
+    LocalDate obj1 = LocalDate.now(); // Create a date object
+    System.out.printf("Local Date : %s \n",obj1); // Display the current date
+    LocalTime obj2 = LocalTime.now();
+    System.out.printf("Local Time : %s \n",obj2);
+    LocalDateTime obj3 = LocalDateTime.now();
+    System.out.printf("Local Date Time : %s \n",obj3);
+    DateTimeFormatter df = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
+    String formatted_obj3 = obj3.format(df);
+    System.out.printf("Local Date Time After format : %s \n",formatted_obj3);
+  }
+}