update,

gitUpdate.bat

@@ -0,0 +1,7 @@
+git status .
+
+@pause
+
+git add .
+git commit -m"update jacksonyeet,"
+start git push

java-assignment/README.md

@@ -0,0 +1,34 @@
+1. This assignment should be written by individual student. All downloaded materials are not　allowed.
+2. Plagiarism will be treated seriously. 
+  - All assignments that have been found involved wholly or 
+    partly in plagiarism (no matter these assignments are from the original authors or from
+    the plagiarists) will score ZERO marks.
+3. Your program must use Java JDK7 or above to develop.
+4. Your program must be structured and well commented.
+
+The first few lines in the source file must be comments stating the name of the source file,
+student name, student ID, course name, course code, and brief description of your
+program.
+
+```
+/********************************************************
+Name of Source File: xxxxx.java
+Student Name (ID): Chan Tai Man (141414141)
+Course Name (Code): HD in MAD (IT114112)
+Program Description:
+This program is . . . . . . .
+. . . . .
+. . . . .
+********************************************************/
+```
+
+Marks will be deducted if such comments are not included.
+
+5. Write down your test cases and the reason(s) for them. 
+  - Test your program by using your test cases.
+
+6. You are required to hand a zip file containing the following 2 items via the assignment link in Moodle:
+  - a. Program code of your java file, including detailed comments
+  - b. Input file to show your test cases
+
+8. Weight of this assignment is 20% of the module total assessment.

java-assignment/build_delivery.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+# grep -rin TODO src
+
+rm -rf delivery.zip
+rm -rf delivery
+rm -rf _pre_deliver
+
+mkdir -p _pre_deliver
+
+./format.sh
+
+# references
+cp -r _ref _pre_deliver
+
+# sources
+cp -r src/main.java _pre_deliver
+cp -r src/vertices.txt _pre_deliver
+cp -r src/README.md _pre_deliver
+
+# test pattern
+cp -r src/vertices.txt _pre_deliver
+cp -r src/square.txt _pre_deliver
+cp -r src/hsbc.txt _pre_deliver
+cp -r src/entry.sh _pre_deliver
+
+# docs
+cp -r docs _pre_deliver
+
+
+# 7za a -tzip delivery.zip _pre_deliver
+
+# rm -rf _pre_deliver

java-assignment/docker-compose.yml

@@ -0,0 +1,9 @@
+services:
+  openjdk:
+    build:
+      context: .
+    volumes:
+      - $PWD/src:/src
+    command: sleep infinity
+    working_dir: /src
+    

java-assignment/dockerfile

@@ -0,0 +1,4 @@
+FROM openjdk:21-bullseye
+
+RUN apt update && \
+  apt install -qyy entr

java-assignment/format.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -ex
+
+npx prettier --write "**/*.java"

java-assignment/package-lock.json

@@ -0,0 +1,133 @@
+{
+  "name": "java-assignment",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "java-assignment",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "prettier": "^2.8.1",
+        "prettier-plugin-java": "^2.0.0"
+      }
+    },
+    "node_modules/chevrotain": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-6.5.0.tgz",
+      "integrity": "sha512-BwqQ/AgmKJ8jcMEjaSnfMybnKMgGTrtDKowfTP3pX4jwVy0kNjRsT/AP6h+wC3+3NC+X8X15VWBnTCQlX+wQFg==",
+      "dependencies": {
+        "regexp-to-ast": "0.4.0"
+      }
+    },
+    "node_modules/java-parser": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/java-parser/-/java-parser-2.0.3.tgz",
+      "integrity": "sha512-z+ZsqcY3LCN0NPK1KnC7AXFHQxtzlsADJ2OVQmenKS/4gHBQ6SkEQYIMVV/2WrxRBMWXMXW7KeOVmXPLHCMRAQ==",
+      "dependencies": {
+        "chevrotain": "6.5.0",
+        "lodash": "4.17.21"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
+    },
+    "node_modules/prettier": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.1.tgz",
+      "integrity": "sha512-lqGoSJBQNJidqCHE80vqZJHWHRFoNYsSpP9AjFhlhi9ODCJA541svILes/+/1GM3VaL/abZi7cpFzOpdR9UPKg==",
+      "bin": {
+        "prettier": "bin-prettier.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/prettier-plugin-java": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/prettier-plugin-java/-/prettier-plugin-java-2.0.0.tgz",
+      "integrity": "sha512-ct7Zgog2XUpZ+olF3Ed4gPBNU7aWBu0cnpgDX7eqs0IZVH+9ZAduRkaJ0HlreoOm7SdUOc7UoKK1vk3T/coEoQ==",
+      "dependencies": {
+        "java-parser": "2.0.3",
+        "lodash": "4.17.21",
+        "prettier": "2.8.0"
+      }
+    },
+    "node_modules/prettier-plugin-java/node_modules/prettier": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.0.tgz",
+      "integrity": "sha512-9Lmg8hTFZKG0Asr/kW9Bp8tJjRVluO8EJQVfY2T7FMw9T5jy4I/Uvx0Rca/XWf50QQ1/SS48+6IJWnrb+2yemA==",
+      "bin": {
+        "prettier": "bin-prettier.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/regexp-to-ast": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/regexp-to-ast/-/regexp-to-ast-0.4.0.tgz",
+      "integrity": "sha512-4qf/7IsIKfSNHQXSwial1IFmfM1Cc/whNBQqRwe0V2stPe7KmN1U0tWQiIx6JiirgSrisjE0eECdNf7Tav1Ntw=="
+    }
+  },
+  "dependencies": {
+    "chevrotain": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-6.5.0.tgz",
+      "integrity": "sha512-BwqQ/AgmKJ8jcMEjaSnfMybnKMgGTrtDKowfTP3pX4jwVy0kNjRsT/AP6h+wC3+3NC+X8X15VWBnTCQlX+wQFg==",
+      "requires": {
+        "regexp-to-ast": "0.4.0"
+      }
+    },
+    "java-parser": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/java-parser/-/java-parser-2.0.3.tgz",
+      "integrity": "sha512-z+ZsqcY3LCN0NPK1KnC7AXFHQxtzlsADJ2OVQmenKS/4gHBQ6SkEQYIMVV/2WrxRBMWXMXW7KeOVmXPLHCMRAQ==",
+      "requires": {
+        "chevrotain": "6.5.0",
+        "lodash": "4.17.21"
+      }
+    },
+    "lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
+    },
+    "prettier": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.1.tgz",
+      "integrity": "sha512-lqGoSJBQNJidqCHE80vqZJHWHRFoNYsSpP9AjFhlhi9ODCJA541svILes/+/1GM3VaL/abZi7cpFzOpdR9UPKg=="
+    },
+    "prettier-plugin-java": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/prettier-plugin-java/-/prettier-plugin-java-2.0.0.tgz",
+      "integrity": "sha512-ct7Zgog2XUpZ+olF3Ed4gPBNU7aWBu0cnpgDX7eqs0IZVH+9ZAduRkaJ0HlreoOm7SdUOc7UoKK1vk3T/coEoQ==",
+      "requires": {
+        "java-parser": "2.0.3",
+        "lodash": "4.17.21",
+        "prettier": "2.8.0"
+      },
+      "dependencies": {
+        "prettier": {
+          "version": "2.8.0",
+          "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.0.tgz",
+          "integrity": "sha512-9Lmg8hTFZKG0Asr/kW9Bp8tJjRVluO8EJQVfY2T7FMw9T5jy4I/Uvx0Rca/XWf50QQ1/SS48+6IJWnrb+2yemA=="
+        }
+      }
+    },
+    "regexp-to-ast": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/regexp-to-ast/-/regexp-to-ast-0.4.0.tgz",
+      "integrity": "sha512-4qf/7IsIKfSNHQXSwial1IFmfM1Cc/whNBQqRwe0V2stPe7KmN1U0tWQiIx6JiirgSrisjE0eECdNf7Tav1Ntw=="
+    }
+  }
+}

java-assignment/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "java-assignment",
+  "version": "1.0.0",
+  "description": "1. This assignment should be written by individual student. All downloaded materials are not　allowed. 2. Plagiarism will be treated seriously.    - All assignments that have been found involved wholly or      partly in plagiarism (no matter these assignments are from the original authors or from     the plagiarists) will score ZERO marks. 3. Your program must use Java JDK7 or above to develop. 4. Your program must be structured and well commented.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "format": "prettier --write '**/*.java'"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "prettier": "^2.8.1",
+    "prettier-plugin-java": "^2.0.0"
+  }
+}

java-assignment/retest.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -ex
+
+
+docker compose up -d --build
+
+docker compose exec -it openjdk bash

java-assignment/src/README.md

@@ -0,0 +1,26 @@
+# Program code of your java file, including detailed comments
+```
+./main.java
+```
+
+# Input file to show your test cases
+```
+./single.txt
+./two_line.txt
+./three_line.txt
+./square.txt
+./hsbc.txt
+```
+
+
+```bash
+# test
+# java main.java single.txt
+# java main.java two_line.txt
+# java main.java three_line.txt
+# java main.java square.txt
+# java main.java hsbc.txt
+
+# formal run
+java main.java vertices.txt
+```

java-assignment/src/ReadFile.java

@@ -0,0 +1,70 @@
+import java.io.*;
+import java.io.File; // Import the File class
+import java.io.FileNotFoundException; // Import this class to handle errors
+import java.nio.file.*;
+import java.nio.file.Files;
+import java.util.Scanner; // Import the Scanner class to read text files
+
+public class ReadFile {
+
+  public static int[][] ReadVerticsFile(String file_in) {
+    int number_of_lines = 0;
+    int temp[][] = new int[999][2];
+
+    int end_pattern[] = { 999, 999 };
+    for (int i = 0; i < temp.length; i++) {
+      temp[i] = end_pattern;
+    }
+
+    try {
+      File myObj = new File(file_in);
+
+      Scanner myReader = new Scanner(myObj);
+
+      while (myReader.hasNextLine()) {
+        String data = myReader.nextLine();
+
+        String s[] = data.split(" ", 2);
+
+        // System.out.println(s[0]);
+
+        int test_t[] = { Integer.parseInt(s[0]), Integer.parseInt(s[1]) };
+        temp[number_of_lines] = test_t;
+
+        number_of_lines += 1;
+      }
+
+      myReader.close();
+
+      System.out.println("done");
+    } catch (FileNotFoundException e) {
+      System.out.println("An error occurred.");
+
+      e.printStackTrace();
+    }
+
+    return temp;
+  }
+
+  public static int countVertics(int[][] test_vertics) {
+    int i = 0;
+
+    while (test_vertics[i][0] != 999 && test_vertics[i][1] != 999) {
+      System.out.print(test_vertics[i][0]);
+      System.out.print(",");
+      System.out.print(test_vertics[i][1]);
+      System.out.println();
+      i += 1;
+    }
+    return i;
+  }
+
+  public static void main(String[] args) {
+    String file_in = "vertices.txt";
+    int test_vertics[][] = new int[999][];
+    test_vertics = ReadVerticsFile(file_in);
+    int num_of_vertics = countVertics(test_vertics);
+
+    System.out.println(num_of_vertics);
+  }
+}

java-assignment/src/array.java

@@ -0,0 +1,30 @@
+// Java Program to illustrate Reading from FileReader
+// using BufferedReader Class
+
+// Importing input output classes
+import java.io.*;
+
+public class Main {
+
+  public static void main(String[] args) {
+    int[] numbers = { 2, -9, 0, 5, 12, -25, 22, 9, 8, 12 };
+    int sum = 0;
+    Double average;
+
+    // access all elements using for each loop
+    // add each element in sum
+    for (int number : numbers) {
+      sum += number;
+    }
+
+    // get the total number of elements
+    int arrayLength = numbers.length;
+
+    // calculate the average
+    // convert the average from int to double
+    average = ((double) sum / (double) arrayLength);
+
+    System.out.println("Sum = " + sum);
+    System.out.println("Average = " + average);
+  }
+}

java-assignment/src/entry.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+# set -ex
+
+sleep 1
+
+# test
+# java main.java single.txt
+# java main.java two_line.txt
+# java main.java three_line.txt
+# java main.java square.txt
+# java main.java hsbc.txt
+
+# formal run
+# java main.java vertices.txt

java-assignment/src/filename.txt

@@ -0,0 +1,7 @@
+-5 2
+0 2
+8 2
+8 -11
+4 2
+4 5
+999 999

java-assignment/src/hsbc.txt

@@ -0,0 +1,7 @@
+20 0
+40 0
+60 20
+40 40
+20 40
+0 20
+999 999

java-assignment/src/main copy.java

@@ -0,0 +1,12 @@
+// Java Program to illustrate Reading from FileReader
+// using BufferedReader Class
+
+// Importing input output classes
+import java.io.*;
+
+public class Main {
+
+  public static void main(String[] args) {
+    System.out.println("Hello World 123321");
+  }
+}

java-assignment/src/main.java

@@ -0,0 +1,706 @@
+/********************************************************
+    Name of Source File: xxxxx.java
+    
+    Student Name (ID): Chan Tai Man (141414141)
+    Course Name (Code): HD in MAD (IT114112)
+
+    Program Description:
+    This program try to extract the triangle embedded in
+    a complex polygon. It will try to define triangle's
+    properties and it's areas.
+********************************************************/
+
+import java.io.*;
+import java.io.File; // Import the File class
+import java.io.FileNotFoundException; // Import this class to handle errors
+import java.nio.file.*;
+import java.nio.file.Files;
+import java.util.*;
+import java.util.Arrays;
+import java.util.Scanner; // Import the Scanner class to read text files
+
+public class Main {
+
+  static double COMPARE_NOT_DEFINED = -3;
+  static double AREA_NOT_VALID = -2;
+
+  static int INVALID_TRIANGLE = -1;
+  static int VALID_TRIANGLE = -2;
+
+  static int RIGHT_ANGLED_TRIANGLE = -1;
+  static int INVALID_RIGHT_ANGLED_TRIANGLE = -2;
+
+  static int SCALENE = -1;
+  static int INVALID_SCALENE = -2;
+
+  static int ISOSCELES = -1;
+  static int INVALID_ISOSCELES = -2;
+
+  static int MAX_AREA = 1;
+  static int MIN_AREA = 0;
+
+  // main table length
+  static int LIST_LENGTH = 999;
+  static int NOT_FOUND = -1;
+
+  static double[] length_a = new double[LIST_LENGTH];
+  static double[] length_b = new double[LIST_LENGTH];
+  static double[] length_c = new double[LIST_LENGTH];
+
+  public static int CountVertics(double[][] test_vertics) {
+    // count length of input vertics
+    // input : list of input vertics
+    // output: number of valid vertics
+
+    int i = 0;
+    while (test_vertics[i][0] != 999 && test_vertics[i][1] != 999) {
+      i += 1;
+    }
+    return i;
+  }
+
+  public static boolean VerticsCalculatedBefore(double[][] test_vertics) {
+    // to check if the input vertics calculated in the past
+    // if not calculated before, add them into the cache
+    // input : list of input vertics
+    // output:
+    //    true if test_vertics calculated in the past
+    //    false if test_vertics is a fresh input
+
+    String x0 = Double.toString(test_vertics[0][0]);
+    String y0 = Double.toString(test_vertics[0][1]);
+    String p0 = x0 + y0;
+
+    String x1 = Double.toString(test_vertics[1][0]);
+    String y1 = Double.toString(test_vertics[1][1]);
+    String p1 = x1 + y1;
+
+    String x2 = Double.toString(test_vertics[2][0]);
+    String y2 = Double.toString(test_vertics[2][1]);
+    String p2 = x2 + y2;
+
+    String[] a = { p0, p1, p2 };
+    Arrays.sort(a);
+
+    String test = (a[0] + "," + a[1] + "," + a[2]);
+    for (int i = 0; i < calculated_length; i++) {
+      if (calculated[i].equals(test)) {
+        return true;
+      }
+    }
+
+    calculated[calculated_length] = test;
+    calculated_length += 1;
+    return false;
+  }
+
+  public static boolean ContainsTrue(boolean[] array) {
+    // check if true value found in a boolean array
+    // input : boolean array
+    // output: true if any element true, false if all element are false
+
+    for (boolean val : array) {
+      if (val) return true;
+    }
+    return false;
+  }
+
+  public static boolean ContainsFalse(boolean[] array) {
+    // check if false value found in a boolean array
+    // input : boolean array
+    // output: true if any element false, false if all element are true
+
+    for (boolean val : array) {
+      if (!val) return true;
+    }
+    return false;
+  }
+
+  public static void PrintLine(int line_length) {
+    // print a dash "-" with defined length
+    // input : line_length to define the length wanted
+
+    for (int i = 0; i < line_length; i++) {
+      System.out.print("-");
+    }
+    System.out.println();
+    return;
+  }
+
+  public static double AreaOfTriangle(double a, double b, double c) {
+    // to get the area of the triangle by its side length :
+    //    Area = √𝑠(𝑠 − 𝑎)(𝑠 − 𝑏)(𝑠 − 𝑐) and s = (a+b+c)/2
+    // constrains:
+    //    the sum of either two sides cannot be the same as the rest side:
+    //    i.e.:
+    //        a = 1, b = 2, c = 3, 1+2=3 => is a invalid input
+    //        a = 2, b = 2, c = 3, 2+2 > 3 => is a valid input
+    // input :
+    //    a => length of side a
+    //    b => length of side b
+    //    c => length of side c
+    // output:
+    //    area of triangle by formula
+
+    double var_s = (a + b + c) / 2;
+    double s_minus_a = var_s - a;
+    double s_minus_b = var_s - b;
+    double s_minus_c = var_s - c;
+
+    // constrain: the sum of first 2 side has to be greater than the third side
+    if (s_minus_a == 0 || s_minus_b == 0 || s_minus_c == 0) {
+      return AREA_NOT_VALID;
+    }
+
+    return Math.sqrt(var_s * s_minus_a * s_minus_b * s_minus_c);
+  }
+
+  public static boolean TestRightAngledTriangle(double a, double b, double c) {
+    // to see if the parameters can form a right angle triangle
+    // input :
+    //    a => length of side a
+    //    b => length of side b
+    //    c => length of side c
+    // output:
+    //  true => right angled triangle,
+    //  false => not right angled triangle
+
+    double[] sorted_input = { a, b, c };
+
+    Arrays.sort(sorted_input);
+
+    double a_square = sorted_input[0] * sorted_input[0];
+    double b_square = sorted_input[1] * sorted_input[1];
+    double c_square = sorted_input[2] * sorted_input[2];
+    double a_and_b_square = a_square + b_square;
+
+    // NOTE: loosen maths to relax right-angle triangle checking
+    return Math.abs(c_square - a_and_b_square) < 0.000001;
+    // return c_square == a_and_b_square;
+  }
+
+  public static boolean TestValidIsoscelesTriangle(
+    double a,
+    double b,
+    double c
+  ) {
+    // to see if the parameters form a isosceles triangle
+    // definition:
+    //    a = b or b = c or c = a
+    // input :
+    //    a => length of side a
+    //    b => length of side b
+    //    c => length of side c
+    // output:
+    //  true => isosceles triangle,
+    //  false => not isosceles triangle
+
+    boolean a_equal_b = a == b;
+    boolean b_equal_c = b == c;
+    boolean c_equal_a = c == a;
+    boolean[] test_array = { a_equal_b, b_equal_c, c_equal_a };
+
+    return ContainsTrue(test_array);
+  }
+
+  public static boolean TestValidScaleneTriangle(double a, double b, double c) {
+    // to see if the parameters form a scalene triangle
+    // definition:
+    //    a ≠ b ≠ c
+    // input :
+    //    a => length of side a
+    //    b => length of side b
+    //    c => length of side c
+    // output:
+    //  true => scalene triangle,
+    //  false => not scalene triangle
+
+    boolean a_equal_b = a != b;
+    boolean b_equal_c = b != c;
+    boolean c_equal_a = c != a;
+    boolean[] test_array = { a_equal_b, b_equal_c, c_equal_a };
+
+    // output valid only if no false found => thus valid scalene triangle
+    return !ContainsFalse(test_array);
+  }
+
+  public static String formatPoint(double[] point_in) {
+    // prepare string to print for point input
+    // input :
+    //    point_in => {x, y}
+    // output:
+    //    formatted string
+    return String.format("(%1$3s,%2$3s)", point_in[0], point_in[1]);
+  }
+
+  public static String formatTriangleArea(double area_in) {
+    // prepare string to print for area output
+    // input :
+    //    area_in => 1
+    // output:
+    //    formatted string 1.00
+    return String.format("%.2f", area_in);
+  }
+
+  public static double TestLengthOfEachSide(double[] x1_y1, double[] x2_y2) {
+    // to get the length by 2 points
+    // input :
+    //    x1_y1 => point start
+    //    x2_y2 => point end
+    // output:
+    //    length
+
+    double x1 = x1_y1[0];
+    double x2 = x2_y2[0];
+    double y1 = x1_y1[1];
+    double y2 = x2_y2[1];
+    double x_length = x2 - x1;
+    double y_length = y2 - y1;
+    double x_square = x_length * x_length;
+    double y_square = y_length * y_length;
+    double length = Math.sqrt(x_square + y_square);
+
+    return Math.abs(length);
+  }
+
+  public static boolean TestValidTriangle(double a, double b, double c) {
+    // check if triangle valid
+    // definition:
+    //  a > 0, b > 0, c > 0
+    //    a + b > c
+    //    b + c > a
+    //    c + a > b
+    // input :
+    //    a,b,c => point input i.e. {x,y}
+    // output:
+    //    true if points a,b,c found valid triangle, false if not invalid
+
+    double a_and_b = a + b;
+    double b_and_c = b + c;
+    double c_and_a = c + a;
+
+    // rule set
+    boolean a_gt_zero = a > 0;
+    boolean b_gt_zero = b > 0;
+    boolean c_gt_zero = c > 0;
+    boolean a_and_b_gtc = a_and_b > c;
+    boolean b_and_c_gta = b_and_c > a;
+    boolean c_and_a_gtc = c_and_a > b;
+
+    boolean[] test_arrays = {
+      a_gt_zero,
+      b_gt_zero,
+      c_gt_zero,
+      a_and_b_gtc,
+      b_and_c_gta,
+      c_and_a_gtc,
+    };
+
+    return !ContainsFalse(test_arrays);
+  }
+
+  public static int[] GetExtremeTriangleArea(
+    double[] area_list,
+    int extreme_type,
+    int area_list_length
+  ) {
+    // get the max/min (depends) area from area_list
+    // input :
+    //    area_list: list of area of triangle
+    //    extreme_type: the extreme wanted MAX_AREA/MINAREA
+    //    area_list_length: length of area list
+    // output:
+    //    list containing the extreme found
+
+    double compare = COMPARE_NOT_DEFINED;
+    int out[] = new int[LIST_LENGTH];
+    int cursor = 0;
+
+    // init list before search
+    for (int i = 0; i < LIST_LENGTH; i++) {
+      out[i] = NOT_FOUND;
+    }
+
+    if (extreme_type == MIN_AREA) {
+      double min_value = COMPARE_NOT_DEFINED;
+      // get min area from list
+      for (int i = 0; i < area_list_length; i++) {
+        double tested_value = area_list[i];
+
+        if (min_value == COMPARE_NOT_DEFINED) {
+          if (tested_value != AREA_NOT_VALID) {
+            min_value = tested_value;
+          } else {
+            // invalid area, skipping
+          }
+        } else {
+          if (tested_value != AREA_NOT_VALID) {
+            if (tested_value < min_value) {
+              min_value = tested_value;
+            }
+          }
+        }
+      }
+
+      for (int i = 0; i < area_list_length; i++) {
+        double tested_value = area_list[i];
+        if (tested_value == min_value) {
+          out[cursor] = i;
+          cursor += 1;
+        }
+      }
+    } else {
+      double max_value = 0;
+
+      for (int i = 0; i < area_list_length; i++) {
+        double tested_value = area_list[i];
+        if (tested_value > max_value) {
+          max_value = tested_value;
+        }
+      }
+
+      // literate the list by the value
+      for (int i = 0; i < area_list_length; i++) {
+        double tested_value = area_list[i];
+        if (tested_value == max_value) {
+          out[cursor] = i;
+          cursor += 1;
+        }
+      }
+    }
+
+    return out;
+  }
+
+  public static void PrintOutput(
+    double[][][] point_set,
+    double[] area_list,
+    int point_length,
+    int[] max_area_idx,
+    int[] min_area_idx,
+    int[] valid_triangle,
+    int[] right_angle_triangle,
+    int[] scalene_triangle,
+    int[] isosceles_triangle
+  ) {
+    // main printing function
+    // input :
+    //    point_set: point list forming triangle
+    //    area_list: area referring the point
+    //    point_length: length of valid data
+    //    max_area_idx: list contain index with max area
+    //    min_area_idx: list contain index with min area
+    //    valid_triangle: list with result of valid triangle check
+    //    right_angle_triangle: list with result of right angle triangle check
+    //    scalene_triangle: list with result of scalene triangle check
+    //    isosceles_triangle: list with result of isosceles triangle check
+
+    double max_area = NOT_FOUND;
+    double min_area = NOT_FOUND;
+
+    if (max_area_idx[0] != NOT_FOUND) {
+      max_area = area_list[max_area_idx[0]];
+    }
+    if (min_area_idx[0] != NOT_FOUND) {
+      min_area = area_list[min_area_idx[0]];
+    }
+
+    PrintLine(120);
+    System.out.println(String.format("%1$60s", "Types of Triangles"));
+    PrintLine(120);
+    System.out.println(
+      String.format(
+        "%1$-15s %2$-15s %3$-15s %4$-33s %5$-10s",
+        "Point 1",
+        "Point 2",
+        "Point 3",
+        "Types of Triangle",
+        "area"
+      )
+    );
+    PrintLine(120);
+
+    for (int y = 0; y < point_length; y++) {
+      double[] point_x = point_set[y][0];
+      double[] point_y = point_set[y][1];
+      double[] point_z = point_set[y][2];
+      length_a[y] = TestLengthOfEachSide(point_x, point_y);
+      length_b[y] = TestLengthOfEachSide(point_y, point_z);
+      length_c[y] = TestLengthOfEachSide(point_z, point_x);
+
+      String type_of_triangle = "";
+      boolean test_valid_triangle = TestValidTriangle(
+        length_a[y],
+        length_b[y],
+        length_c[y]
+      );
+
+      if (valid_triangle[y] == VALID_TRIANGLE) {
+        // triangle, test properties
+        type_of_triangle +=
+          right_angle_triangle[y] == RIGHT_ANGLED_TRIANGLE
+            ? "Right-angled "
+            : "";
+
+        type_of_triangle += scalene_triangle[y] == SCALENE ? "Scalene " : "";
+
+        // TestValidIsoscelesTriangle
+        type_of_triangle +=
+          isosceles_triangle[y] == ISOSCELES ? "Isosceles " : "";
+      } else {
+        // non-triangle, no need test the rest
+        type_of_triangle += "Non-triangle ";
+      }
+
+      System.out.print(
+        String.format(
+          "%1$-15s %2$-15s %3$-15s %4$-33s %5$-10s",
+          formatPoint(point_set[y][0]),
+          formatPoint(point_set[y][1]),
+          formatPoint(point_set[y][2]),
+          type_of_triangle,
+          valid_triangle[y] == VALID_TRIANGLE
+            ? area_list[y]
+            : "no area calculated"
+        )
+      );
+
+      System.out.println();
+    }
+
+    System.out.println();
+
+    // NOTE:
+    // The format of the maximum and minimum area is having 2 decimal places only.
+    double[] t = { 1, 2 };
+
+    System.out.println();
+    PrintLine(120);
+    System.out.println();
+
+    if (max_area != min_area) {
+      if (max_area == NOT_FOUND) {
+        System.out.println("cannot find a valid max area");
+      } else {
+        System.out.println(
+          String.format("Maximum area %1$10s", formatTriangleArea(max_area))
+        );
+      }
+      for (int i : max_area_idx) {
+        if (i != NOT_FOUND) {
+          System.out.println(
+            String.format(
+              "points: %1$10s %2$10s %3$10s",
+              formatPoint(point_set[i][0]),
+              formatPoint(point_set[i][1]),
+              formatPoint(point_set[i][2])
+            )
+          );
+        }
+      }
+
+      System.out.println();
+      PrintLine(120);
+      System.out.println();
+
+      if (min_area == NOT_FOUND) {
+        System.out.println("cannot find a valid min area");
+      } else {
+        System.out.println(
+          String.format("Minimum area %1$10s", formatTriangleArea(min_area))
+        );
+      }
+      for (int i : min_area_idx) {
+        if (i != NOT_FOUND) {
+          System.out.println(
+            String.format(
+              "points: %1$10s %2$10s %3$10s",
+              formatPoint(point_set[i][0]),
+              formatPoint(point_set[i][1]),
+              formatPoint(point_set[i][2])
+            )
+          );
+        }
+      }
+    } else {
+      System.out.println("sorry but the area are the same");
+      System.out.println();
+    }
+
+    PrintLine(120);
+  }
+
+  public static void PrintError(String error) {
+    System.out.println();
+    System.out.println(error);
+    System.out.println();
+  }
+
+  public static double[][] ReadVerticsFile(String file_in) {
+    int number_of_lines = 0;
+    double temp[][] = new double[999][2];
+
+    double end_pattern[] = { 999, 999 };
+    for (int i = 0; i < temp.length; i++) {
+      temp[i] = end_pattern;
+    }
+
+    try {
+      System.out.println();
+      System.out.println("file input: " + file_in);
+      System.out.println();
+
+      File myObj = new File(file_in);
+
+      Scanner myReader = new Scanner(myObj);
+
+      while (myReader.hasNextLine()) {
+        String data = myReader.nextLine();
+
+        String s[] = data.split(" ", 2);
+
+        double test_t[] = {
+          Double.parseDouble(s[0]),
+          Double.parseDouble(s[1]),
+        };
+        temp[number_of_lines] = test_t;
+
+        number_of_lines += 1;
+      }
+
+      myReader.close();
+    } catch (FileNotFoundException e) {
+      PrintError("An error occurred during reading points list");
+      System.exit(-1);
+    }
+
+    return temp;
+  }
+
+  static String[] calculated = new String[999];
+  static int calculated_length = 0;
+
+  public static void main(String[] args) {
+    String file_in = args[0];
+    double point_list[][] = new double[LIST_LENGTH][];
+
+    point_list = ReadVerticsFile(file_in);
+    int num_of_vertics = CountVertics(point_list);
+
+    if (num_of_vertics < 3) {
+      System.out.println("number of vertics: " + num_of_vertics);
+      PrintError("sorry, at least 3 points to carry on");
+      System.exit(-1);
+    }
+
+    double vertics_list[][][] = new double[LIST_LENGTH][3][2];
+    int vertics_list_length = 0;
+
+    for (int i_a = 0; i_a < num_of_vertics; i_a++) {
+      for (int i_b = 0; i_b < num_of_vertics; i_b++) {
+        double[] xy_a = point_list[i_a];
+        double[] xy_b = point_list[i_b];
+
+        double[][] list = { xy_a, xy_b };
+        long t = Arrays.stream(list).distinct().count();
+
+        if (t >= 2) {
+          for (int i_c = 0; i_c < num_of_vertics; i_c++) {
+            double[] xy_c = point_list[i_c];
+            double[][] list_3 = { xy_a, xy_b, xy_c };
+            long t_3 = Arrays.stream(list_3).distinct().count();
+
+            if (t_3 >= 3 && !VerticsCalculatedBefore(list_3)) {
+              vertics_list[vertics_list_length] = list_3;
+              vertics_list_length += 1;
+            } else {
+              // System.out.println("a and b and c are same");
+            }
+          }
+        } else {
+          // System.out.println("a and b are same");
+        }
+      }
+    }
+
+    double[] area_of_triangle = new double[LIST_LENGTH];
+    // sorted the list to be calculated
+    for (int j = 0; j < vertics_list_length; j++) {
+      double[] point_x = vertics_list[j][0];
+      double[] point_y = vertics_list[j][1];
+      double[] point_z = vertics_list[j][2];
+
+      double length_a = TestLengthOfEachSide(point_x, point_y);
+      double length_b = TestLengthOfEachSide(point_y, point_z);
+      double length_c = TestLengthOfEachSide(point_z, point_x);
+
+      area_of_triangle[j] = AreaOfTriangle(length_a, length_b, length_c);
+    }
+
+    int max_area_idx[] = GetExtremeTriangleArea(
+      area_of_triangle,
+      MAX_AREA,
+      vertics_list_length
+    );
+    int min_area_idx[] = GetExtremeTriangleArea(
+      area_of_triangle,
+      MIN_AREA,
+      vertics_list_length
+    );
+
+    // prepare output list
+    int[] valid_triangle = new int[LIST_LENGTH];
+    int[] right_angle_triangle = new int[LIST_LENGTH];
+    int[] scalene_triangle = new int[LIST_LENGTH];
+    int[] isosceles_triangle = new int[LIST_LENGTH];
+
+    for (int i = 0; i < LIST_LENGTH; i++) {
+      valid_triangle[i] = INVALID_TRIANGLE;
+      right_angle_triangle[i] = INVALID_RIGHT_ANGLED_TRIANGLE;
+      scalene_triangle[i] = INVALID_SCALENE;
+      isosceles_triangle[i] = INVALID_ISOSCELES;
+    }
+
+    for (int y = 0; y < vertics_list_length; y++) {
+      double[] point_x = vertics_list[y][0];
+      double[] point_y = vertics_list[y][1];
+      double[] point_z = vertics_list[y][2];
+
+      length_a[y] = TestLengthOfEachSide(point_x, point_y);
+      length_b[y] = TestLengthOfEachSide(point_y, point_z);
+      length_c[y] = TestLengthOfEachSide(point_z, point_x);
+
+      valid_triangle[y] =
+        TestValidTriangle(length_a[y], length_b[y], length_c[y])
+          ? VALID_TRIANGLE
+          : INVALID_TRIANGLE;
+
+      right_angle_triangle[y] =
+        TestRightAngledTriangle(length_a[y], length_b[y], length_c[y])
+          ? RIGHT_ANGLED_TRIANGLE
+          : INVALID_RIGHT_ANGLED_TRIANGLE;
+
+      scalene_triangle[y] =
+        TestValidScaleneTriangle(length_a[y], length_b[y], length_c[y])
+          ? SCALENE
+          : INVALID_SCALENE;
+
+      isosceles_triangle[y] =
+        TestValidIsoscelesTriangle(length_a[y], length_b[y], length_c[y])
+          ? ISOSCELES
+          : INVALID_ISOSCELES;
+    }
+
+    PrintOutput(
+      vertics_list,
+      area_of_triangle,
+      vertics_list_length,
+      max_area_idx,
+      min_area_idx,
+      valid_triangle,
+      right_angle_triangle,
+      scalene_triangle,
+      isosceles_triangle
+    );
+  }
+}

java-assignment/src/md_array.java

@@ -0,0 +1,46 @@
+// Java Program to illustrate Reading from FileReader
+// using BufferedReader Class
+
+// Importing input output classes
+import java.io.*;
+
+public class Main {
+
+  public static void main(String[] args) {
+    // int[] numbers = {2, -9, 0, 5, 12, -25, 22, 9, 8, 12};
+    // int sum = 0;
+    // Double average;
+
+    // // access all elements using for each loop
+    // // add each element in sum
+    // for (int number: numbers) {
+    //   sum += number;
+    // }
+
+    // // get the total number of elements
+    // int arrayLength = numbers.length;
+
+    // // calculate the average
+    // // convert the average from int to double
+    // average =  ((double)sum / (double)arrayLength);
+
+    // System.out.println("Sum = " + sum);
+    // System.out.println("Average = " + average);
+
+    double[][] matrix = {
+      { -5, 2 },
+      { 0, 2 },
+      { 8, 2 },
+      { 8, -11 },
+      { 4, 2 },
+      { 4, 5 },
+    };
+
+    for (double[] test : matrix) {
+      for (double tt : test) {
+        System.out.print(tt);
+      }
+      System.out.println("");
+    }
+  }
+}

java-assignment/src/single.txt

@@ -0,0 +1,2 @@
+20 0
+999 999

java-assignment/src/square.txt

@@ -0,0 +1,5 @@
+0 0
+10 0
+0 10
+10 10
+999 999

java-assignment/src/test_iterate.java

@@ -0,0 +1,74 @@
+// Java Program to illustrate Reading from FileReader
+// using BufferedReader Class
+
+// Importing input output classes
+import java.io.*;
+import java.util.Arrays;
+
+public class Main {
+
+  public static boolean containsTrue(boolean[] array) {
+    for (boolean val : array) {
+      if (val) return true;
+    }
+    return false;
+  }
+
+  public static boolean checkAnySamePoint(double[] a, double[] b, double[] c) {
+    boolean a_bSame = a == b;
+    boolean a_cSame = a == c;
+    boolean b_cSame = b == c;
+    boolean[] testArray = { a_bSame, a_cSame, b_cSame };
+
+    return containsTrue(testArray);
+  }
+
+  public static void main(String[] args) {
+    System.out.println("test_iterate");
+
+    double[][] point_list = {
+      { -5, 2 },
+      { 0, 2 },
+      { 8, 2 },
+      { 8, -11 },
+      { 4, 2 },
+      { 4, 5 },
+    };
+
+    double[] test_d = { 1, 2, 3 };
+
+    for (double d : test_d) {
+      System.out.println(d);
+    }
+
+    // 1
+    for (double[] xy_a : point_list) {
+      for (double[] xy_b : point_list) {
+        // test if same point
+        double[][] list = { xy_a, xy_b };
+        long t = Arrays.stream(list).distinct().count();
+
+        // if a and b is not the same point
+        if (t == 2) {
+          for (double[] xy_c : point_list) {
+            // if a and b and c is not the same point
+            double[][] list_t = { xy_a, xy_b, xy_c };
+            long tt = Arrays.stream(list_t).distinct().count();
+
+            if (tt == 3) {
+              System.out.print(xy_a[0] + "/" + xy_a[1]);
+              System.out.print("," + xy_b[0] + "/" + xy_b[1]);
+              System.out.print("," + xy_c[0] + "/" + xy_c[1]);
+              System.out.print("==" + checkAnySamePoint(xy_a, xy_b, xy_c));
+              System.out.println("");
+            } else {
+              // skip if a and b and c is same
+            }
+          }
+        } else {
+          // skip if a and b is same
+        }
+      }
+    }
+  }
+}

java-assignment/src/three_line.txt

@@ -0,0 +1,4 @@
+20 0
+20 0
+20 0
+999 999

java-assignment/src/triangle_rules.java

@@ -0,0 +1,141 @@
+// Java Program to illustrate Reading from FileReader
+// using BufferedReader Class
+
+// Importing input output classes
+import java.io.*;
+import java.lang.Math;
+import java.util.Arrays;
+
+public class Main {
+
+  public static double TestLengthOfEachSide(double[] x1y1, double[] x2y2) {
+    System.out.println("TestLengthOfEachSide");
+
+    System.out.println(x1y1[0] + "," + x1y1[1]);
+    System.out.println(x2y2[0] + "," + x2y2[1]);
+
+    double x1 = x1y1[0];
+    double x2 = x2y2[0];
+    double y1 = x1y1[1];
+    double y2 = x2y2[1];
+    double x_length = x2 - x1;
+    double y_length = y2 - y1;
+    double x_square = x_length * x_length;
+    double y_square = y_length * y_length;
+    double length = Math.sqrt(x_square + y_square);
+
+    return length;
+  }
+
+  public static boolean containsTrue(boolean[] array) {
+    for (boolean val : array) {
+      if (val) return true;
+    }
+    return false;
+  }
+
+  public static boolean containsFalse(boolean[] array) {
+    for (boolean val : array) {
+      if (!val) return true;
+    }
+
+    return false;
+  }
+
+  public static boolean TestValidTriangle(double a, double b, double c) {
+    // true = valid triangle, false = invalid triangle
+    System.out.println("TestValidTriangle");
+    // a > 0
+    boolean aGtZero = a > 0;
+    boolean bGtZero = b > 0;
+    boolean cGtZero = c > 0;
+    double aAndb = a + b;
+    double bAndc = b + c;
+    double cAnda = c + a;
+    boolean aAndbGtc = aAndb > c;
+    boolean bAndcGta = bAndc > a;
+    boolean cAndaGtc = cAnda > b;
+
+    boolean[] bArrays = {
+      aGtZero,
+      bGtZero,
+      cGtZero,
+      aAndbGtc,
+      bAndcGta,
+      cAndaGtc,
+    };
+
+    return !containsFalse(bArrays);
+  }
+
+  public static boolean TestRightAngledTriangle(double a, double b, double c) {
+    // true => right angled triangle, false => not right angled triangle
+    System.out.println("TestRightAngledTriangle");
+
+    double[] arr = { a, b, c };
+    Arrays.sort(arr);
+
+    double largest_side = arr[2];
+
+    double a_square = arr[0] * arr[0];
+    double b_square = arr[1] * arr[1];
+    double c_square = arr[2] * arr[2];
+    double a_and_b_square = a_square + b_square;
+
+    return Math.abs(c_square - a_and_b_square) < 0.000001;
+  }
+
+  public static boolean TestValidScaleneTriangle(double a, double b, double c) {
+    System.out.println("TestValidScaleneTriangle");
+
+    boolean aEqualb = a != b;
+    boolean bEqualc = b != c;
+    boolean[] testArray = { aEqualb, bEqualc };
+
+    System.out.println(aEqualb);
+    System.out.println(bEqualc);
+
+    // either a equal b or b equal c will found true here
+    return containsTrue(testArray);
+  }
+
+  public static boolean TestValidIsoscelesTriangle(
+    double a,
+    double b,
+    double c
+  ) {
+    boolean aEqualb = a == b;
+    boolean bEqualc = b == c;
+    boolean cEquala = c == a;
+    boolean[] testArray = { aEqualb, bEqualc, cEquala };
+
+    return containsTrue(testArray);
+  }
+
+  public static double AreaOfTriangle(double a, double b, double c) {
+    double var_s = (a + b + c) / 2;
+    double s_minus_a = var_s - a;
+    double s_minus_b = var_s - b;
+    double s_minus_c = var_s - c;
+
+    return Math.sqrt(var_s * s_minus_a * s_minus_b * s_minus_c);
+  }
+
+  public static void main(String[] args) {
+    System.out.println("triangle rules");
+    // i. The length of each side can be calculated via the coordinates of the two vertices (x1, y1)
+    // and (x2, y2) connecting the side by using the formula:
+    double[] a = { 1, 2 };
+    double[] b = { 3, 4 };
+    double[] c = { 5, 6 };
+
+    // System.out.println(TestLengthOfEachSide(a,b));
+    // System.out.println(TestValidTriangle(3,3,3));
+    // System.out.println(TestRightAngledTriangle(1,2,Math.sqrt(5)));
+    // System.out.println(TestValidIsoscelesTriangle(2,2,3));
+    // System.out.println(TestValidScaleneTriangle(2,1,1));
+    // System.out.println(AreaOfTriangle(2,1,1));
+
+    System.out.println("done");
+  }
+}

java-assignment/src/two_line.txt

@@ -0,0 +1,3 @@
+20 0
+20 0
+999 999

java-assignment/src/vertices.txt

@@ -0,0 +1,7 @@
+-5 2
+0 2
+8 2
+8 -11
+4 2
+4 5
+999 999