> int find(T[] array, T value) {
- for (int i = 0; i < array.length ; i++) {
- if (array[i].compareTo(value) == 0) {
- return i;
- }
- }
- return -1;
- }
-
-
- public static void main(String[] args) {
- //just generate data
- Random r = new Random();
- int size = 200;
- int maxElement = 100;
- Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)).limit(size).toArray(Integer[]::new);
-
-
- //the element that should be found
- Integer shouldBeFound = integers[r.nextInt(size - 1)];
-
- LinearSearch search = new LinearSearch();
- int atIndex = search.find(integers, shouldBeFound);
-
- System.out.println(String.format("Should be found: %d. Found %d at index %d. An array length %d"
- , shouldBeFound, integers[atIndex], atIndex, size));
- }
-
-}
diff --git a/Searches/src/search/SaddlebackSearch.java b/Searches/src/search/SaddlebackSearch.java
deleted file mode 100644
index 68779db..0000000
--- a/Searches/src/search/SaddlebackSearch.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package search;
-
-import java.util.Scanner;
-
-/**
- * Program to perform Saddleback Search
- * Given a sorted 2D array(elements are sorted across every row and column, assuming ascending order)
- * of size n*m we can search a given element in O(n+m)
- *
- * we start from bottom left corner
- * if the current element is greater than the given element then we move up
- * else we move right
- * Sample Input:
- * 5 5 ->Dimensions
- * -10 -5 -3 4 9
- * -6 -2 0 5 10
- * -4 -1 1 6 12
- * 2 3 7 8 13
- * 100 120 130 140 150
- * 140 ->element to be searched
- * output: 4 3 // first value is row, second one is column
- *
- * @author Nishita Aggarwal
- */
-public class SaddlebackSearch {
-
- /**
- * This method performs Saddleback Search
- *
- * @param arr The **Sorted** array in which we will search the element.
- * @param row the current row.
- * @param col the current column.
- * @param key the element that we want to search for.
- * @return The index(row and column) of the element if found.
- * Else returns -1 -1.
- */
- private static int[] find(int arr[][], int row, int col, int key) {
-
- //array to store the answer row and column
- int ans[] = {-1, -1};
- if (row < 0 || col >= arr[row].length) {
- return ans;
- }
- if (arr[row][col] == key) {
- ans[0] = row;
- ans[1] = col;
- return ans;
- }
- //if the current element is greater than the given element then we move up
- else if (arr[row][col] > key) {
- return find(arr, row - 1, col, key);
- }
- //else we move right
- return find(arr, row, col + 1, key);
- }
-
- /**
- * Main method
- *
- * @param args Command line arguments
- */
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Scanner sc = new Scanner(System.in);
- int arr[][];
- int i, j, rows = sc.nextInt(), col = sc.nextInt();
- arr = new int[rows][col];
- for (i = 0; i < rows; i++) {
- for (j = 0; j < col; j++) {
- arr[i][j] = sc.nextInt();
- }
- }
- int ele = sc.nextInt();
- //we start from bottom left corner
- int ans[] = find(arr, rows - 1, 0, ele);
- System.out.println(ans[0] + " " + ans[1]);
- sc.close();
- }
-
-}
diff --git a/Searches/src/search/SearchAlgorithm.java b/Searches/src/search/SearchAlgorithm.java
deleted file mode 100644
index ca3bf59..0000000
--- a/Searches/src/search/SearchAlgorithm.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package search;
-
-/**
- * The common interface of most searching algorithms
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- **/
-public interface SearchAlgorithm {
-
- /**
- *
- * @param key is an element which should be found
- * @param array is an array where the element should be found
- * @param Comparable type
- * @return first found index of the element
- */
- > int find(T array[], T key);
-
-}
diff --git a/Searches/src/search/TernarySearch.java b/Searches/src/search/TernarySearch.java
deleted file mode 100644
index 7e60edf..0000000
--- a/Searches/src/search/TernarySearch.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package search;
-
-
-import java.util.Arrays;
-import java.util.Random;
-import java.util.stream.Stream;
-
-import static java.lang.String.format;
-
-/**
- *
- *
- *
- * A ternary search algorithm is a technique in computer science for finding the minimum or maximum of a unimodal function
- * The algorithm determines either that the minimum or maximum cannot be in the first third of the domain
- * or that it cannot be in the last third of the domain, then repeats on the remaining third.
- *
- * Worst-case performance Θ(log3(N))
- * Best-case performance O(1)
- * Average performance Θ(log3(N))
- * Worst-case space complexity O(1)
- *
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- * @see SearchAlgorithm
- * @see IterativeBinarySearch
- *
- */
-
-public class TernarySearch implements SearchAlgorithm{
-
- /**
- * @param arr The **Sorted** array in which we will search the element.
- * @param value The value that we want to search for.
- * @return The index of the element if found.
- * Else returns -1.
- */
- @Override
- public > int find(T[] arr, T value){
- return ternarySearch(arr, value, 0, arr.length - 1);
- }
-
- /**
- * @param arr The **Sorted** array in which we will search the element.
- * @param key The value that we want to search for.
- * @param start The starting index from which we will start Searching.
- * @param end The ending index till which we will Search.
- * @return Returns the index of the Element if found.
- * Else returns -1.
- */
- private > int ternarySearch(T[] arr, T key, int start, int end) {
- if (start > end){
- return -1;
- }
- /* First boundary: add 1/3 of length to start */
- int mid1 = start + (end - start) / 3;
- /* Second boundary: add 2/3 of length to start */
- int mid2 = start + 2 * (end - start) / 3;
-
- if (key.compareTo(arr[mid1]) == 0) {
- return mid1;
- }
- else if (key.compareTo(arr[mid2]) == 0) {
- return mid2;
- }
-
- /* Search the first (1/3) rd part of the array.*/
-
- else if (key.compareTo(arr[mid1]) < 0) {
- return ternarySearch(arr, key, start, --mid1);
- }
- /* Search 3rd (1/3)rd part of the array */
-
- else if (key.compareTo(arr[mid2]) > 0) {
- return ternarySearch(arr, key, ++mid2, end);
- }
- /* Search middle (1/3)rd part of the array */
-
- else {
- return ternarySearch(arr, key, mid1, mid2);
- }
- }
-
- public static void main(String[] args) {
- //just generate data
- Random r = new Random();
- int size = 100;
- int maxElement = 100000;
- Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().toArray(Integer[]::new);
-
-
- //the element that should be found
- Integer shouldBeFound = integers[r.nextInt(size - 1)];
-
- TernarySearch search = new TernarySearch();
- int atIndex = search.find(integers, shouldBeFound);
-
- System.out.println(format("Should be found: %d. Found %d at index %d. An array length %d"
- , shouldBeFound, integers[atIndex], atIndex, size));
-
- int toCheck = Arrays.binarySearch(integers, shouldBeFound);
- System.out.println(format("Found by system method at an index: %d. Is equal: %b", toCheck, toCheck == atIndex));
-
- }
-}
\ No newline at end of file
diff --git a/SkylineProblem/SkylineProblem.java b/SkylineProblem/SkylineProblem.java
deleted file mode 100644
index a0b7063..0000000
--- a/SkylineProblem/SkylineProblem.java
+++ /dev/null
@@ -1,131 +0,0 @@
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Scanner;
-
-public class SkylineProblem {
- Building[] building;
- int count;
-
- public void run() {
- Scanner sc = new Scanner(System.in);
-
- int num = sc.nextInt();
- this.building = new Building[num];
-
- for(int i = 0; i < num; i++) {
- String input = sc.next();
- String[] data = input.split(",");
- this.add(Integer.parseInt(data[0]), Integer.parseInt(data[1]), Integer.parseInt(data[2]));
- }
- this.print(this.findSkyline(0, num - 1));
-
- sc.close();
- }
-
- public void add(int left, int height, int right) {
- building[count++] = new Building(left, height, right);
- }
-
- public void print(ArrayList skyline) {
- Iterator it = skyline.iterator();
-
- while(it.hasNext()) {
- Skyline temp = it.next();
- System.out.print(temp.coordinates + "," + temp.height);
- if(it.hasNext()) {
- System.out.print(",");
- }
- }
-
- }
-
- public ArrayList findSkyline(int start, int end) {
- if(start == end) {
- ArrayList list = new ArrayList<>();
- list.add(new Skyline(building[start].left, building[start].height));
- list.add(new Skyline(building[end].right, 0));
-
- return list;
- }
-
- int mid = (start + end) / 2;
-
- ArrayList sky1 = this.findSkyline(start, mid);
- ArrayList sky2 = this.findSkyline(mid + 1, end);
-
- return this.mergeSkyline(sky1, sky2);
- }
-
- public ArrayList mergeSkyline(ArrayList sky1, ArrayList sky2) {
- int currentH1 = 0, currentH2 = 0;
- ArrayList skyline = new ArrayList<>();
- int maxH = 0;
-
- while(!sky1.isEmpty() && !sky2.isEmpty()) {
- if(sky1.get(0).coordinates < sky2.get(0).coordinates) {
- int currentX = sky1.get(0).coordinates;
- currentH1 = sky1.get(0).height;
-
- if(currentH1 < currentH2) {
- sky1.remove(0);
- if(maxH != currentH2) skyline.add(new Skyline(currentX, currentH2));
- } else {
- maxH = currentH1;
- sky1.remove(0);
- skyline.add(new Skyline(currentX, currentH1));
- }
- } else {
- int currentX = sky2.get(0).coordinates;
- currentH2 = sky2.get(0).height;
-
- if(currentH2 < currentH1) {
- sky2.remove(0);
- if(maxH != currentH1) skyline.add(new Skyline(currentX, currentH1));
- } else {
- maxH = currentH2;
- sky2.remove(0);
- skyline.add(new Skyline(currentX, currentH2));
- }
- }
- }
-
- while(!sky1.isEmpty()) {
- skyline.add(sky1.get(0));
- sky1.remove(0);
- }
-
- while(!sky2.isEmpty()) {
- skyline.add(sky2.get(0));
- sky2.remove(0);
- }
-
- return skyline;
- }
-
- public class Skyline {
- public int coordinates;
- public int height;
-
- public Skyline(int coordinates, int height) {
- this.coordinates = coordinates;
- this.height = height;
- }
- }
-
- public class Building {
- public int left;
- public int height;
- public int right;
-
- public Building(int left, int height, int right) {
- this.left = left;
- this.height = height;
- this.right = right;
- }
- }
-
- public static void main(String[] args) {
- SkylineProblem skylineProblem = new SkylineProblem();
- skylineProblem.run();
- }
-}
diff --git a/Sorts/src/sort/BinaryTreeSort.java b/Sorts/src/sort/BinaryTreeSort.java
deleted file mode 100644
index 59d58ab..0000000
--- a/Sorts/src/sort/BinaryTreeSort.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package sort;
-
-import static sort.SortUtils.less;
-import static sort.SortUtils.print;
-
-/**
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- * @see SortAlgorithm
- *
- */
-public class BinaryTreeSort implements SortAlgorithm {
-
- interface TreeVisitor> {
- void visit(Node node);
- }
-
- private static class SortVisitor> implements TreeVisitor {
-
- private final T[] array;
- private int counter;
-
- SortVisitor(T[] array) {
- this.array = array;
- }
-
- @Override
- public void visit(Node node) {
- array[counter++] = node.value;
- }
- }
-
- private static class Node>{
- private T value;
- private Node left;
- private Node right;
-
- Node(T value) {
- this.value = value;
- }
-
- void insert(Node node) {
- if (less(node.value, value)){
- if (left != null) left.insert(node);
- else left = node;
- }
- else {
- if (right != null) right.insert(node);
- else right = node;
- }
- }
-
- void traverse(TreeVisitor visitor) {
- if ( left != null)
- left.traverse(visitor);
-
- visitor.visit(this);
-
- if ( right != null )
- right.traverse(visitor );
- }
-
- }
-
-
- @Override
- public > T[] sort(T[] array) {
-
- Node root = new Node<>(array[0]);
- for (int i = 1; i < array.length; i++) {
- root.insert(new Node<>(array[i]));
- }
-
- root.traverse(new SortVisitor<>(array));
-
- return array;
- }
-
-
- public static void main(String args[]) {
-
- Integer[] intArray = {12, 40, 9, 3, 19, 74, 7, 31, 23, 54, 26, 81, 12};
- BinaryTreeSort treeSort = new BinaryTreeSort();
- Integer[] sorted = treeSort.sort(intArray);
- print(sorted);
-
- Double[] decimalArray = {8.2, 1.5, 3.14159265, 9.3, 5.1, 4.8, 2.6};
- print(treeSort.sort(decimalArray));
-
- String[] stringArray = {"c", "a", "e", "b","d", "dd","da","zz", "AA", "aa","aB","Hb", "Z"};
- print(treeSort.sort(stringArray));
- }
-
-}
-
diff --git a/Sorts/src/sort/BogoSort.java b/Sorts/src/sort/BogoSort.java
deleted file mode 100644
index 1079ca2..0000000
--- a/Sorts/src/sort/BogoSort.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package sort;
-
-import java.util.Random;
-
-import static sort.SortUtils.*;
-
-
-/**
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- * @see SortAlgorithm
- *
- */
-public class BogoSort implements SortAlgorithm {
-
- private static final Random random = new Random();
-
-
- private static > boolean isSorted(T array[]){
- for(int i = 0; i void nextPermutation(T array[]){
- int length = array.length;
-
- for (int i = 0; i < array.length; i++) {
- int randomIndex = i + random.nextInt(length - i);
- swap(array, randomIndex, i);
- }
- }
-
- public > T[] sort(T array[]) {
- while(!isSorted(array)){
- nextPermutation(array);
- }
- return array;
- }
-
- // Driver Program
- public static void main(String[] args) {
- // Integer Input
- Integer[] integers = {4, 23, 6, 78, 1, 54, 231, 9, 12};
-
- BogoSort bogoSort = new BogoSort();
-
- // print a sorted array
- print(bogoSort.sort(integers));
-
- // String Input
- String[] strings = {"c", "a", "e", "b","d"};
-
- print(bogoSort.sort(strings));
- }
-}
diff --git a/Sorts/src/sort/BubbleSort.java b/Sorts/src/sort/BubbleSort.java
deleted file mode 100644
index 1173245..0000000
--- a/Sorts/src/sort/BubbleSort.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-/**
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- * @see SortAlgorithm
- */
-
-class BubbleSort implements SortAlgorithm {
- /**
- * This method implements the Generic Bubble Sort
- *
- * @param array The array to be sorted
- * Sorts the array in increasing order
- **/
-
- @Override
- public > T[] sort(T array[]) {
- int last = array.length;
- //Sorting
- boolean swap;
- do {
- swap = false;
- for (int count = 0; count < last-1; count++) {
- if (less(array[count], array[count + 1])) {
- swap = swap(array, count, count + 1);
- }
- }
- last--;
- } while (swap);
- return array;
- }
-
- // Driver Program
- public static void main(String[] args) {
-
- // Integer Input
- Integer[] integers = {4, 23, 6, 78, 1, 54, 231, 9, 12};
- BubbleSort bubbleSort = new BubbleSort();
- bubbleSort.sort(integers);
-
- // Output => 231, 78, 54, 23, 12, 9, 6, 4, 1
- print(integers);
-
- // String Input
- String[] strings = {"c", "a", "e", "b","d"};
- //Output => e, d, c, b, a
- print(bubbleSort.sort(strings));
-
- }
-}
diff --git a/Sorts/src/sort/CocktailShakerSort.java b/Sorts/src/sort/CocktailShakerSort.java
deleted file mode 100644
index 7982b8f..0000000
--- a/Sorts/src/sort/CocktailShakerSort.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-/**
- *
- * @author Mateus Bizzo (https://github.com/MattBizzo)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- */
-
-class CocktailShakerSort implements SortAlgorithm {
-
- /**
- * This method implements the Generic Cocktail Shaker Sort
- *
- * @param array The array to be sorted
- * Sorts the array in increasing order
- **/
-
- @Override
- public > T[] sort(T[] array) {
-
- int length = array.length;
- int left = 0;
- int right = length - 1;
- int swappedLeft, swappedRight;
- while (left < right) {
- // front
- swappedRight = 0;
- for (int i = left; i < right; i++) {
- if (less(array[i + 1], array[i])) {
- swap(array, i, i + 1);
- swappedRight = i;
- }
- }
- // back
- right = swappedRight;
- swappedLeft = length - 1;
- for (int j = right; j > left; j--) {
- if (less(array[j], array[j - 1])) {
- swap(array, j - 1, j);
- swappedLeft = j;
- }
- }
- left = swappedLeft;
- }
- return array;
-
- }
-
- // Driver Program
- public static void main(String[] args) {
- // Integer Input
- Integer[] integers = { 4, 23, 6, 78, 1, 54, 231, 9, 12 };
- CocktailShakerSort shakerSort = new CocktailShakerSort();
-
- // Output => 1 4 6 9 12 23 54 78 231
- print(shakerSort.sort(integers));
-
- // String Input
- String[] strings = { "c", "a", "e", "b", "d" };
- print(shakerSort.sort(strings));
- }
-
-
-}
diff --git a/Sorts/src/sort/CombSort.java b/Sorts/src/sort/CombSort.java
deleted file mode 100644
index 492605c..0000000
--- a/Sorts/src/sort/CombSort.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-
-/**
- *
- * Comb Sort algorithm implementation
- *
- * Best-case performance O(n * log(n))
- * Worst-case performance O(n ^ 2)
- * Worst-case space complexity O(1)
- *
- * Comb sort improves on bubble sort.
- *
- *
- * @see BubbleSort
- * @see SortAlgorithm
- *
- * @author Sandeep Roy (https://github.com/sandeeproy99)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- */
-class CombSort implements SortAlgorithm {
-
- // To find gap between elements
- private int nextGap(int gap) {
- // Shrink gap by Shrink factor
- gap = ( gap * 10 ) / 13;
- return ( gap < 1 ) ? 1 : gap;
- }
-
- /**
- * Function to sort arr[] using Comb
- * @param arr - an array should be sorted
- * @return sorted array
- */
- @Override
- public > T[] sort(T arr[]) {
- int size = arr.length;
-
- // initialize gap
- int gap = size;
-
- // Initialize swapped as true to make sure that loop runs
- boolean swapped = true;
-
- // Keep running while gap is more than 1 and last iteration caused a swap
- while (gap != 1 || swapped) {
- // Find next gap
- gap = nextGap(gap);
-
- // Initialize swapped as false so that we can check if swap happened or not
- swapped = false;
-
- // Compare all elements with current gap
- for (int i = 0; i < size - gap ; i++) {
- if (less(arr[i + gap], arr[i])) {
- // Swap arr[i] and arr[i+gap]
- swapped = swap(arr, i, i + gap);
- }
- }
- }
- return arr;
- }
-
- // Driver method
- public static void main(String args[]) {
- CombSort ob = new CombSort();
- Integer arr[] = {8, 4, 1, 56, 3, -44, -1 , 0 , 36, 34, 8, 12 , -66, - 78, 23, -6, 28, 0};
- ob.sort(arr);
-
- System.out.println("sorted array");
- print(arr);
- }
-}
diff --git a/Sorts/src/sort/CountingSort.java b/Sorts/src/sort/CountingSort.java
deleted file mode 100644
index 39442a0..0000000
--- a/Sorts/src/sort/CountingSort.java
+++ /dev/null
@@ -1,102 +0,0 @@
-package sort;
-
-import java.util.*;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
-
-import static java.util.stream.Collectors.toList;
-import static java.util.stream.Collectors.toMap;
-import static sort.SortUtils.print;
-
-/**
- *
- * @author Youssef Ali (https://github.com/youssefAli11997)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- */
-class CountingSort implements SortAlgorithm {
-
-
-
- @Override
- public > T[] sort(T[] unsorted) {
- return sort(Arrays.asList(unsorted)).toArray(unsorted);
- }
-
- /**
- * This method implements the Generic Counting Sort
- *
- * @param list The list to be sorted
- *
- * Sorts the list in increasing order
- * The method uses list elements as keys in the frequency map
- **/
- @Override
- public > List sort(List list) {
-
- Map frequency = new TreeMap<>();
- // The final output array
- List sortedArray = new ArrayList<>(list.size());
-
- // Counting the frequency of @param array elements
- list.forEach(v -> frequency.put(v, frequency.getOrDefault(v, 0) + 1));
-
- // Filling the sortedArray
- for(Map.Entry element : frequency.entrySet()) {
- for(int j=0; j> List streamSort(List list) {
- return list.stream()
- .collect(toMap(k -> k, v -> 1, (v1, v2) -> v1 + v2, TreeMap::new))
- .entrySet()
- .stream()
- .flatMap(entry -> IntStream.rangeClosed(1, entry.getValue()).mapToObj(t -> entry.getKey()))
- .collect(toList());
- }
-
- // Driver Program
- public static void main(String[] args) {
- // Integer Input
- List unsortedInts = Stream.of(4, 23, 6, 78, 1, 54, 23, 1, 9, 231, 9, 12).collect(toList());
- CountingSort countingSort = new CountingSort();
-
- System.out.println("Before Sorting:");
- print(unsortedInts);
-
- // Output => 1 1 4 6 9 9 12 23 23 54 78 231
- System.out.println("After Sorting:");
- print(countingSort.sort(unsortedInts));
- System.out.println("After Sorting By Streams:");
- print(streamSort(unsortedInts));
-
- System.out.println("\n------------------------------\n");
-
- // String Input
- List unsortedStrings = Stream.of("c", "a", "e", "b","d", "a", "f", "g", "c").collect(toList());
-
- System.out.println("Before Sorting:");
- print(unsortedStrings);
-
- //Output => a a b c c d e f g
- System.out.println("After Sorting:");
- print(countingSort.sort(unsortedStrings));
-
- System.out.println("After Sorting By Streams:");
- print(streamSort(unsortedStrings));
-
- }
-}
diff --git a/Sorts/src/sort/CycleSort.java b/Sorts/src/sort/CycleSort.java
deleted file mode 100644
index ea4f055..0000000
--- a/Sorts/src/sort/CycleSort.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package sort;
-
-import static sort.SortUtils.less;
-import static sort.SortUtils.print;
-
-/**
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- */
-class CycleSort implements SortAlgorithm {
-
-
- @Override
- public > T[] sort(T[] arr) {
- int n = arr.length;
-
- // traverse array elements
- for (int j = 0; j <= n - 2; j++) {
- // initialize item as starting point
- T item = arr[j];
-
- // Find position where we put the item.
- int pos = j;
- for (int i = j + 1; i < n; i++)
- if (less(arr[i], item)) pos++;
-
- // If item is already in correct position
- if (pos == j) continue;
-
- // ignore all duplicate elements
- while (item.compareTo(arr[pos]) == 0)
- pos += 1;
-
- // put the item to it's right position
- if (pos != j) {
- item = replace(arr, pos, item);
- }
-
- // Rotate rest of the cycle
- while (pos != j) {
- pos = j;
-
- // Find position where we put the element
- for (int i = j + 1; i < n; i++)
- if (less(arr[i], item)){
- pos += 1;
- }
-
-
- // ignore all duplicate elements
- while (item.compareTo(arr[pos]) == 0)
- pos += 1;
-
- // put the item to it's right position
- if (item != arr[pos]) {
- item = replace(arr, pos, item);
- }
- }
- }
-
- return arr;
- }
-
- private > T replace(T[] arr, int pos, T item){
- T temp = item;
- item = arr[pos];
- arr[pos] = temp;
- return item;
- }
-
-
-
- public static void main(String[] args) {
- Integer arr[] = { 4, 23, 6, 78, 1, 26, 11, 23 , 0, -6, 3, 54, 231, 9, 12 };
- CycleSort cycleSort = new CycleSort();
- cycleSort.sort(arr);
-
- System.out.println("After sort : ");
- print(arr);
- }
-
-}
diff --git a/Sorts/src/sort/GnomeSort.java b/Sorts/src/sort/GnomeSort.java
deleted file mode 100644
index 14af67c..0000000
--- a/Sorts/src/sort/GnomeSort.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-/**
- * Implementation of gnome sort
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- * @since 2018-04-10
- *
- **/
-public class GnomeSort implements SortAlgorithm{
-
- @Override
- public > T[] sort(T[] arr) {
- int i = 1;
- int j = 2;
- while (i < arr.length){
- if ( less(arr[i - 1], arr[i]) ) i = j++;
- else {
- swap(arr, i - 1, i);
- if (--i == 0){ i = j++; }
- }
- }
-
- return null;
- }
-
- public static void main(String[] args) {
- Integer[] integers = { 4, 23, 6, 78, 1, 26, 11, 23 , 0, -6, 3, 54, 231, 9, 12 };
- String[] strings = {"c", "a", "e", "b","d", "dd","da","zz", "AA", "aa","aB","Hb", "Z"};
- GnomeSort gnomeSort = new GnomeSort();
-
- gnomeSort.sort(integers);
- gnomeSort.sort(strings);
-
- System.out.println("After sort : ");
- print(integers);
- print(strings);
-
-
- }
-
-}
diff --git a/Sorts/src/sort/InsertionSort.java b/Sorts/src/sort/InsertionSort.java
deleted file mode 100644
index 5936143..0000000
--- a/Sorts/src/sort/InsertionSort.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package sort;
-
-import static sort.SortUtils.less;
-import static sort.SortUtils.print;
-
-/**
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- */
-
-class InsertionSort implements SortAlgorithm {
-
- /**
- * This method implements the Generic Insertion Sort
- * Sorts the array in increasing order
- *
- * @param array The array to be sorted
- *
- **/
-
- @Override
- public > T[] sort(T[] array) {
- for (int j = 1; j < array.length; j++) {
-
- // Picking up the key(Card)
- T key = array[j];
- int i = j - 1;
-
- while (i >= 0 && less(key, array[i])) {
- array[i + 1] = array[i];
- i--;
- }
- // Placing the key (Card) at its correct position in the sorted subarray
- array[i + 1] = key;
- }
- return array;
- }
-
- // Driver Program
- public static void main(String[] args) {
- // Integer Input
- Integer[] integers = {4, 23, 6, 78, 1, 54, 231, 9, 12};
-
- InsertionSort sort = new InsertionSort();
-
- sort.sort(integers);
-
- // Output => 1 4 6 9 12 23 54 78 231
- print(integers);
-
- // String Input
- String[] strings = {"c", "a", "e", "b","d"};
-
- sort.sort(strings);
-
- //Output => a b c d e
- print(strings);
- }
-}
diff --git a/Sorts/src/sort/MergeSort.java b/Sorts/src/sort/MergeSort.java
deleted file mode 100644
index 2c7a141..0000000
--- a/Sorts/src/sort/MergeSort.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package sort;
-
-import static sort.SortUtils.print;
-
-/**
- * This method implements the Generic Merge Sort
- *
- *
- * @author Varun Upadhyay (https://github.com/varunu28)
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- *
- * @see SortAlgorithm
- *
- */
-
-class MergeSort implements SortAlgorithm {
-
-
- /**
- * This method implements the Generic Merge Sort
- * @param unsorted the array which should be sorted
- * @param Comparable class
- * @return sorted array
- */
- @Override
- @SuppressWarnings("unchecked")
- public > T[] sort(T[] unsorted) {
- T[] tmp = (T[]) new Comparable[unsorted.length];
- doSort(unsorted, tmp, 0, unsorted.length - 1);
- return unsorted;
- }
-
- /**
- *
- * @param arr The array to be sorted
- * @param temp The copy of the actual array
- * @param left The first index of the array
- * @param right The last index of the array
- * Recursively sorts the array in increasing order
- **/
- private static > void doSort(T[] arr, T[] temp, int left, int right) {
- if (left < right) {
- int mid = left + (right - left) / 2;
- doSort(arr, temp, left, mid);
- doSort(arr, temp,mid + 1, right);
- merge(arr, temp, left, mid, right);
- }
-
- }
-
- /**
- * This method implements the merge step of the merge sort
- *
- * @param arr The array to be sorted
- * @param temp The copy of the actual array
- * @param left The first index of the array
- * @param mid The middle index of the array
- * @param right The last index of the array
- * merges two parts of an array in increasing order
- **/
-
- private static > void merge(T[] arr, T[] temp, int left, int mid, int right) {
- System.arraycopy(arr, left, temp, left, right - left + 1);
-
-
- int i= left;
- int j = mid + 1;
- int k = left;
-
- while (i <= mid && j <= right) {
- if (temp[i].compareTo(temp[j]) <= 0) {
- arr[k] = temp[i];
- i++;
- }
- else {
- arr[k] = temp[j];
- j++;
- }
- k++;
- }
-
- while (i <= mid) {
- arr[k] = temp[i];
- i++;
- k++;
- }
-
- while (j <= right) {
- arr[k] = temp[j];
- j++;
- k++;
- }
- }
-
- // Driver program
- public static void main(String[] args) {
-
- // Integer Input
- Integer[] arr = {4, 23, 6, 78, 1, 54, 231, 9, 12};
- MergeSort mergeSort = new MergeSort();
- mergeSort.sort(arr);
-
- // Output => 1 4 6 9 12 23 54 78 231
- print(arr);
-
- // String Inpu
- String[] stringArray = {"c", "a", "e", "b","d"};
- mergeSort.sort(stringArray);
- //Output => a b c d e
- print(stringArray);
- }
-}
diff --git a/Sorts/src/sort/PancakeSort.java b/Sorts/src/sort/PancakeSort.java
deleted file mode 100644
index 902db4b..0000000
--- a/Sorts/src/sort/PancakeSort.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-/**
- * Implementation of gnome sort
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- * @since 2018-04-10
- *
- **/
-public class PancakeSort implements SortAlgorithm {
-
-
- @Override
- public > T[] sort(T[] array){
- int size = array.length;
-
- for (int i = 0; i < size; i++) {
- T max = array[0];
- int index = 0;
- for (int j = 0; j < size - i; j++) {
- if ( less(max, array[j]) ) {
- max = array[j];
- index = j;
- }
- }
- flip(array, index, array.length - 1 - i);
- }
- return array;
- }
-
-
- public static void main(String[] args) {
-
- Integer[] arr = {10, 9, 8, 7, 6, 15, 14, 7, 4, 3, 8, 6, 3, 1 ,2, -2, -5, -8, -3, -1, 13, 12, 11, 5, 4, 3, 2, 1};
- PancakeSort pancakeSort = new PancakeSort();
- System.out.println("After sorting:");
- pancakeSort.sort(arr);
- print(arr);
- }
-
-
-
-
-
-}
diff --git a/Sorts/src/sort/RadixSort.java b/Sorts/src/sort/RadixSort.java
deleted file mode 100644
index 0d1e696..0000000
--- a/Sorts/src/sort/RadixSort.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package sort;
-
-import java.util.Arrays;
-
-class RadixSort {
-
-
- private static int getMax(int arr[], int n) {
- int mx = arr[0];
- for (int i = 1; i < n; i++)
- if (arr[i] > mx)
- mx = arr[i];
- return mx;
- }
-
- private static void countSort(int arr[], int n, int exp)
- {
- int output[] = new int[n];
- int i;
- int count[] = new int[10];
- Arrays.fill(count,0);
-
- for (i = 0; i < n; i++)
- count[ (arr[i]/exp)%10 ]++;
-
- for (i = 1; i < 10; i++)
- count[i] += count[i - 1];
-
- for (i = n - 1; i >= 0; i--)
- {
- output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
- count[ (arr[i]/exp)%10 ]--;
- }
-
- for (i = 0; i < n; i++)
- arr[i] = output[i];
- }
-
- private static void radixsort(int arr[], int n) {
-
- int m = getMax(arr, n);
-
-
- for (int exp = 1; m/exp > 0; exp *= 10)
- countSort(arr, n, exp);
- }
-
-
- static void print(int arr[], int n)
- {
- for (int i=0; i> T[] sort(T[] arr) {
- int n = arr.length;
- for (int i = 0; i < n - 1; i++) {
- // Initial index of min
- int min = i;
-
- for (int j = i +1 ; j < n; j++) {
- if (less(arr[j], arr[min])) {
- min = j;
- }
- }
-
- // Swapping if index of min is changed
- if (min != i) {
- swap(arr, i , min);
- }
- }
-
- return arr;
- }
-
- // Driver Program
- public static void main(String[] args) {
-
- Integer[] arr = {4, 23, 6, 78, 1, 54, 231, 9, 12};
-
- SelectionSort selectionSort = new SelectionSort();
-
- Integer[] sorted = selectionSort.sort(arr);
-
- // Output => 1 4 6 9 12 23 54 78 231
- print(sorted);
-
- // String Input
- String[] strings = {"c", "a", "e", "b","d"};
- String[] sortedStrings = selectionSort.sort(strings);
-
- //Output => a b c d e
- print(sortedStrings);
- }
-}
diff --git a/Sorts/src/sort/ShellSort.java b/Sorts/src/sort/ShellSort.java
deleted file mode 100644
index bafd19b..0000000
--- a/Sorts/src/sort/ShellSort.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package sort;
-
-import static sort.SortUtils.*;
-
-
-/**
- * @author dpunosevac
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- * @see SortAlgorithm
- *
- */
-public class ShellSort implements SortAlgorithm {
-
- /**
- * This method implements Generic Shell Sort.
- * @param array The array to be sorted
- */
- @Override
- public > T[] sort(T[] array) {
- int N = array.length;
- int h = 1;
-
- while (h < N/3) {
- h = 3 * h + 1;
- }
-
- while (h >= 1) {
- for (int i = h; i < N; i++) {
- for (int j = i; j >= h && less(array[j], array[j-h]); j -= h) {
- swap(array, j, j - h);
- }
- }
-
- h /= 3;
- }
-
- return array;
- }
-
- public static void main(String[] args) {
- Integer[] toSort = {4, 23, 6, 78, 1, 54, 231, 9, 12};
-
- ShellSort sort = new ShellSort();
- Integer[] sorted = sort.sort(toSort);
-
- print(sorted);
-
- }
-}
diff --git a/Sorts/src/sort/SortAlgorithm.java b/Sorts/src/sort/SortAlgorithm.java
deleted file mode 100644
index 46b1f58..0000000
--- a/Sorts/src/sort/SortAlgorithm.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package sort;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * The common interface of most sorting algorithms
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- **/
-public interface SortAlgorithm {
-
- /**
- * Main method arrays sorting algorithms
- * @param unsorted - an array should be sorted
- * @return a sorted array
- */
- > T[] sort(T[] unsorted);
-
- /**
- * Auxiliary method for algorithms what wanted to work with lists from JCF
- * @param unsorted - a list should be sorted
- * @return a sorted list
- */
- @SuppressWarnings("unchecked")
- default > List sort(List unsorted){
- return Arrays.asList(sort(unsorted.toArray((T[]) new Comparable[unsorted.size()])));
- }
-
-}
diff --git a/Sorts/src/sort/SortUtils.java b/Sorts/src/sort/SortUtils.java
deleted file mode 100644
index 8766e9d..0000000
--- a/Sorts/src/sort/SortUtils.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package sort;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * The class contains util methods
- *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
- *
- **/
-final class SortUtils {
-
-
- /**
- * Helper method for swapping places in array
- * @param array The array which elements we want to swap
- * @param idx index of the first element
- * @param idy index of the second element
- */
- static boolean swap(T[] array, int idx, int idy){
- T swap = array[idx];
- array[idx] = array[idy];
- array[idy] = swap;
- return true;
- }
-
-
- /**
- * This method checks if first element is less then the other element
- * @param v first element
- * @param w second element
- * @return true if the first element is less then the second element
- */
- static > boolean less(T v, T w) {
- return v.compareTo(w) < 0;
- }
-
-
- /**
- * Just print list
- * @param toPrint - a list which should be printed
- */
- static void print(List toPrint){
- toPrint.stream()
- .map(Object::toString)
- .map(str -> str + " ")
- .forEach(System.out::print);
-
- System.out.println();
- }
-
-
- /**
- * Prints an array
- * @param toPrint - the array which should be printed
- */
- static void print(Object[] toPrint){
- System.out.println(Arrays.toString(toPrint));
- }
-
-
-
- /**
- * Swaps all position from {@param left} to @{@param right} for {@param array}
- * @param array is an array
- * @param left is a left flip border of the array
- * @param right is a right flip border of the array
- */
- static > void flip(T[] array, int left, int right) {
- while (left <= right) {
- swap(array, left++ , right--);
- }
- }
-}
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..04d375e
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,27 @@
+plugins {
+ id 'java'
+}
+
+repositories {
+ mavenLocal()
+ maven {
+ url = 'http://repo.maven.apache.org/maven2'
+ }
+}
+
+dependencies {
+ testImplementation('org.junit.jupiter:junit-jupiter-api:5.5.0')
+ testRuntime('org.junit.jupiter:junit-jupiter-engine:5.5.0')
+}
+
+test {
+ useJUnitPlatform()
+ testLogging {
+ events "passed", "skipped", "failed", "standardOut", "standardError"
+ }
+}
+
+group = 'algorithm'
+version = '1.0-SNAPSHOT'
+description = 'java-algorithm'
+sourceCompatibility = '1.8'
diff --git a/ciphers/AES.java b/ciphers/AES.java
deleted file mode 100644
index 75ae8db..0000000
--- a/ciphers/AES.java
+++ /dev/null
@@ -1,605 +0,0 @@
-package ciphers;
-
-import java.math.BigInteger;
-import java.util.Scanner;
-
-/**
- * This class is build to demonstrate the application of the AES-algorithm on a
- * single 128-Bit block of data.
- *
- * @see khalil2535
- */
-public class AES {
-
- /**
- * Precalculated values for x to the power of 2 in Rijndaels galois field. Used
- * as 'RCON' during the key expansion.
- */
- private static final int[] RCON = { 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
- 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91,
- 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74,
- 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
- 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4,
- 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d,
- 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc,
- 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61,
- 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
- 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97,
- 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25,
- 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
- 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4,
- 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33,
- 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d };
-
- /**
- * Rijndael S-box Substitution table used for encryption in the subBytes step,
- * as well as the key expansion.
- */
- private static final int[] SBOX = { 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE,
- 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72,
- 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x04,
- 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83, 0x2C,
- 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20,
- 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33,
- 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC,
- 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E,
- 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE,
- 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4,
- 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 0xBA,
- 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5,
- 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69,
- 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42,
- 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 };
-
- /**
- * Inverse Rijndael S-box Substitution table used for decryption in the
- * subBytesDec step.
- */
- private static final int[] INVERSE_SBOX = { 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E,
- 0x81, 0xF3, 0xD7, 0xFB, 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE,
- 0xE9, 0xCB, 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
- 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 0x72, 0xF8,
- 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92, 0x6C, 0x70, 0x48, 0x50,
- 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC,
- 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06, 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
- 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2,
- 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73, 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8,
- 0x1C, 0x75, 0xDF, 0x6E, 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18,
- 0xBE, 0x1B, 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
- 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F, 0x60, 0x51,
- 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, 0xA0, 0xE0, 0x3B, 0x4D,
- 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77,
- 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D };
-
- /**
- * Precalculated lookup table for galois field multiplication by 2 used in the
- * MixColums step during encryption.
- */
- private static final int[] MULT2 = { 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18,
- 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c,
- 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60,
- 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84,
- 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 0xa8,
- 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc,
- 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0,
- 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f,
- 0x0d, 0x03, 0x01, 0x07, 0x05, 0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23,
- 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47,
- 0x45, 0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65, 0x9b,
- 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf,
- 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd, 0xd3,
- 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5, 0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7,
- 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5 };
-
- /**
- * Precalculated lookup table for galois field multiplication by 3 used in the
- * MixColums step during encryption.
- */
- private static final int[] MULT3 = { 0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14,
- 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22,
- 0x21, 0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71, 0x50,
- 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6,
- 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5, 0xfc,
- 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1, 0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa,
- 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88,
- 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85,
- 0x86, 0x8f, 0x8c, 0x89, 0x8a, 0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf,
- 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9,
- 0xea, 0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda, 0x5b,
- 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d,
- 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e, 0x37,
- 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a, 0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01,
- 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a };
-
- /**
- * Precalculated lookup table for galois field multiplication by 9 used in the
- * MixColums step during decryption.
- */
- private static final int[] MULT9 = { 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c,
- 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee,
- 0xe7, 0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c, 0xab,
- 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64,
- 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd, 0xc2,
- 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91, 0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b,
- 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95,
- 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6,
- 0xbf, 0x80, 0x89, 0x92, 0x9b, 0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10,
- 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9,
- 0xa0, 0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30, 0x9a,
- 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18,
- 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba, 0x85,
- 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6, 0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07,
- 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46 };
-
- /**
- * Precalculated lookup table for galois field multiplication by 11 used in the
- * MixColums step during decryption.
- */
- private static final int[] MULT11 = { 0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74,
- 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2,
- 0xd9, 0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12, 0xcb,
- 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0,
- 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b, 0x6a,
- 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f, 0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7,
- 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65,
- 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9,
- 0xb2, 0x83, 0x88, 0x95, 0x9e, 0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33,
- 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee,
- 0xe5, 0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55, 0x01,
- 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7,
- 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67, 0x56,
- 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13, 0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0,
- 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3 };
-
- /**
- * Precalculated lookup table for galois field multiplication by 13 used in the
- * MixColums step during decryption.
- */
- private static final int[] MULT13 = { 0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c,
- 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96,
- 0x9b, 0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0, 0x6b,
- 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77,
- 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa, 0x89,
- 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6, 0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8,
- 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e,
- 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8,
- 0xa5, 0x86, 0x8b, 0x9c, 0x91, 0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56,
- 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27,
- 0x2a, 0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa, 0xb7,
- 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d,
- 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b, 0x38,
- 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47, 0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2,
- 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97 };
-
- /**
- * Precalculated lookup table for galois field multiplication by 14 used in the
- * MixColums step during decryption.
- */
- private static final int[] MULT14 = { 0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48,
- 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4,
- 0xba, 0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81, 0x3b,
- 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1,
- 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f, 0x75,
- 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17, 0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52,
- 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6,
- 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d,
- 0x23, 0x09, 0x07, 0x15, 0x1b, 0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9,
- 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce,
- 0xc0, 0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20, 0xec,
- 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10,
- 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25, 0x0f,
- 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d, 0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3,
- 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d };
-
- /**
- * Subroutine of the Rijndael key expansion.
- *
- * @param t
- * @param rconCounter
- * @return
- */
- public static BigInteger scheduleCore(BigInteger t, int rconCounter) {
- String rBytes = t.toString(16);
-
- // Add zero padding
- int rBytesLength = rBytes.length();
- while (rBytesLength < 8) {
- rBytes = "0" + rBytes;
- }
-
- // rotate the first 16 bits to the back
- String rotatingBytes = rBytes.substring(0, 2);
- String fixedBytes = rBytes.substring(2);
-
- rBytes = fixedBytes + rotatingBytes;
-
- // apply S-Box to all 8-Bit Substrings
- for (int i = 0; i < 4; i++) {
- String currentByteBits = rBytes.substring(i * 2, (i + 1) * 2);
-
- int currentByte = Integer.parseInt(currentByteBits, 16);
- currentByte = SBOX[currentByte];
-
- // add the current RCON value to the first byte
- if (i == 0) {
- currentByte = currentByte ^ RCON[rconCounter];
- }
-
- currentByteBits = Integer.toHexString(currentByte);
-
- // Add zero padding
- int currentByteBitsLength = currentByteBits.length();
- while (currentByteBitsLength < 2) {
- currentByteBits = '0' + currentByteBits;
- }
-
- // replace bytes in original string
- rBytes = rBytes.substring(0, i * 2) + currentByteBits + rBytes.substring((i + 1) * 2);
- }
-
- // t = new BigInteger(rBytes, 16);
- // return t;
- return new BigInteger(rBytes, 16);
- }
-
- /**
- *
- * Returns an array of 10 + 1 round keys that are calculated by using Rijndael
- * key schedule
- *
- * @param initialKey
- * @return array of 10 + 1 round keys
- */
- public static BigInteger[] keyExpansion(BigInteger initialKey) {
- BigInteger[] roundKeys = { initialKey, new BigInteger("0"), new BigInteger("0"), new BigInteger("0"),
- new BigInteger("0"), new BigInteger("0"), new BigInteger("0"), new BigInteger("0"), new BigInteger("0"),
- new BigInteger("0"), new BigInteger("0"), };
-
- // initialize rcon iteration
- int rconCounter = 1;
-
- for (int i = 1; i < 11; i++) {
-
- // get the previous 32 bits the key
- BigInteger t = roundKeys[i - 1].remainder(new BigInteger("100000000", 16));
-
- // split previous key into 8-bit segments
- BigInteger[] prevKey = { roundKeys[i - 1].remainder(new BigInteger("100000000", 16)),
- roundKeys[i - 1].remainder(new BigInteger("10000000000000000", 16))
- .divide(new BigInteger("100000000", 16)),
- roundKeys[i - 1].remainder(new BigInteger("1000000000000000000000000", 16))
- .divide(new BigInteger("10000000000000000", 16)),
- roundKeys[i - 1].divide(new BigInteger("1000000000000000000000000", 16)), };
-
- // run schedule core
- t = scheduleCore(t, rconCounter);
- rconCounter += 1;
-
- // Calculate partial round key
- BigInteger t0 = t.xor(prevKey[3]);
- BigInteger t1 = t0.xor(prevKey[2]);
- BigInteger t2 = t1.xor(prevKey[1]);
- BigInteger t3 = t2.xor(prevKey[0]);
-
- // Join round key segments
- t2 = t2.multiply(new BigInteger("100000000", 16));
- t1 = t1.multiply(new BigInteger("10000000000000000", 16));
- t0 = t0.multiply(new BigInteger("1000000000000000000000000", 16));
- roundKeys[i] = t0.add(t1).add(t2).add(t3);
-
- }
- return roundKeys;
- }
-
- /**
- * representation of the input 128-bit block as an array of 8-bit integers.
- *
- * @param block
- * of 128-bit integers
- * @return array of 8-bit integers
- */
- public static int[] splitBlockIntoCells(BigInteger block) {
-
- int[] cells = new int[16];
- String blockBits = block.toString(2);
-
- // Append leading 0 for full "128-bit" string
- int blockBitsLength = blockBits.length();
- while (blockBitsLength < 128) {
- blockBits = '0' + blockBits;
- }
-
- // split 128 to 8 bit cells
- for (int i = 0; i < cells.length; i++) {
- String cellBits = blockBits.substring(8 * i, 8 * (i + 1));
- cells[i] = Integer.parseInt(cellBits, 2);
- }
-
- return cells;
- }
-
- /**
- * Returns the 128-bit BigInteger representation of the input of an array of
- * 8-bit integers.
- *
- * @param cells
- * that we need to merge
- * @return block of merged cells
- */
- public static BigInteger mergeCellsIntoBlock(int[] cells) {
-
- String blockBits = "";
- for (int i = 0; i < 16; i++) {
- String cellBits = Integer.toBinaryString(cells[i]);
-
- // Append leading 0 for full "8-bit" strings
- int cellBitsLength = cellBits.length();
- while (cellBitsLength < 8) {
- cellBits = '0' + cellBits;
- }
-
- blockBits += cellBits;
- }
-
- return new BigInteger(blockBits, 2);
- }
-
- /**
- *
- * @param ciphertext
- * @param key
- * @return ciphertext XOR key
- */
- public static BigInteger addRoundKey(BigInteger ciphertext, BigInteger key) {
- return ciphertext.xor(key);
- }
-
- /**
- * substitutes 8-Bit long substrings of the input using the S-Box and returns
- * the result.
- *
- * @param ciphertext
- * @return subtraction Output
- */
- public static BigInteger subBytes(BigInteger ciphertext) {
-
- int[] cells = splitBlockIntoCells(ciphertext);
-
- for (int i = 0; i < 16; i++) {
- cells[i] = SBOX[cells[i]];
- }
-
- return mergeCellsIntoBlock(cells);
- }
-
- /**
- * substitutes 8-Bit long substrings of the input using the inverse S-Box for
- * decryption and returns the result.
- *
- * @param ciphertext
- * @return subtraction Output
- */
- public static BigInteger subBytesDec(BigInteger ciphertext) {
-
- int[] cells = splitBlockIntoCells(ciphertext);
-
- for (int i = 0; i < 16; i++) {
- cells[i] = INVERSE_SBOX[cells[i]];
- }
-
- return mergeCellsIntoBlock(cells);
- }
-
- /**
- * Cell permutation step. Shifts cells within the rows of the input and returns
- * the result.
- *
- * @param ciphertext
- */
- public static BigInteger shiftRows(BigInteger ciphertext) {
- int[] cells = splitBlockIntoCells(ciphertext);
- int[] output = new int[16];
-
- // do nothing in the first row
- output[0] = cells[0];
- output[4] = cells[4];
- output[8] = cells[8];
- output[12] = cells[12];
-
- // shift the second row backwards by one cell
- output[1] = cells[5];
- output[5] = cells[9];
- output[9] = cells[13];
- output[13] = cells[1];
-
- // shift the third row backwards by two cell
- output[2] = cells[10];
- output[6] = cells[14];
- output[10] = cells[2];
- output[14] = cells[6];
-
- // shift the forth row backwards by tree cell
- output[3] = cells[15];
- output[7] = cells[3];
- output[11] = cells[7];
- output[15] = cells[11];
-
- return mergeCellsIntoBlock(output);
- }
-
- /**
- * Cell permutation step for decryption . Shifts cells within the rows of the
- * input and returns the result.
- *
- * @param ciphertext
- */
- public static BigInteger shiftRowsDec(BigInteger ciphertext) {
- int[] cells = splitBlockIntoCells(ciphertext);
- int[] output = new int[16];
-
- // do nothing in the first row
- output[0] = cells[0];
- output[4] = cells[4];
- output[8] = cells[8];
- output[12] = cells[12];
-
- // shift the second row forwards by one cell
- output[1] = cells[13];
- output[5] = cells[1];
- output[9] = cells[5];
- output[13] = cells[9];
-
- // shift the third row forwards by two cell
- output[2] = cells[10];
- output[6] = cells[14];
- output[10] = cells[2];
- output[14] = cells[6];
-
- // shift the forth row forwards by tree cell
- output[3] = cells[7];
- output[7] = cells[11];
- output[11] = cells[15];
- output[15] = cells[3];
-
- return mergeCellsIntoBlock(output);
- }
-
- /**
- * Applies the Rijndael MixColumns to the input and returns the result.
- *
- * @param ciphertext
- */
- public static BigInteger mixColumns(BigInteger ciphertext) {
-
- int[] cells = splitBlockIntoCells(ciphertext);
- int[] outputCells = new int[16];
-
- for (int i = 0; i < 4; i++) {
- int[] row = { cells[i * 4], cells[i * 4 + 1], cells[i * 4 + 2], cells[i * 4 + 3] };
-
- outputCells[i * 4] = MULT2[row[0]] ^ MULT3[row[1]] ^ row[2] ^ row[3];
- outputCells[i * 4 + 1] = row[0] ^ MULT2[row[1]] ^ MULT3[row[2]] ^ row[3];
- outputCells[i * 4 + 2] = row[0] ^ row[1] ^ MULT2[row[2]] ^ MULT3[row[3]];
- outputCells[i * 4 + 3] = MULT3[row[0]] ^ row[1] ^ row[2] ^ MULT2[row[3]];
- }
- return mergeCellsIntoBlock(outputCells);
- }
-
- /**
- * Applies the inverse Rijndael MixColumns for decryption to the input and
- * returns the result.
- *
- * @param ciphertext
- */
- public static BigInteger mixColumnsDec(BigInteger ciphertext) {
-
- int[] cells = splitBlockIntoCells(ciphertext);
- int[] outputCells = new int[16];
-
- for (int i = 0; i < 4; i++) {
- int[] row = { cells[i * 4], cells[i * 4 + 1], cells[i * 4 + 2], cells[i * 4 + 3] };
-
- outputCells[i * 4] = MULT14[row[0]] ^ MULT11[row[1]] ^ MULT13[row[2]] ^ MULT9[row[3]];
- outputCells[i * 4 + 1] = MULT9[row[0]] ^ MULT14[row[1]] ^ MULT11[row[2]] ^ MULT13[row[3]];
- outputCells[i * 4 + 2] = MULT13[row[0]] ^ MULT9[row[1]] ^ MULT14[row[2]] ^ MULT11[row[3]];
- outputCells[i * 4 + 3] = MULT11[row[0]] ^ MULT13[row[1]] ^ MULT9[row[2]] ^ MULT14[row[3]];
- }
- return mergeCellsIntoBlock(outputCells);
- }
-
- /**
- * Encrypts the plaintext with the key and returns the result
- *
- * @param plainText
- * which we want to encrypt
- * @param key
- * the key for encrypt
- * @return EncryptedText
- */
- public static BigInteger encrypt(BigInteger plainText, BigInteger key) {
- BigInteger[] roundKeys = keyExpansion(key);
-
- // Initial round
- plainText = addRoundKey(plainText, roundKeys[0]);
-
- // Main rounds
- for (int i = 1; i < 10; i++) {
- plainText = subBytes(plainText);
- plainText = shiftRows(plainText);
- plainText = mixColumns(plainText);
- plainText = addRoundKey(plainText, roundKeys[i]);
- }
-
- // Final round
- plainText = subBytes(plainText);
- plainText = shiftRows(plainText);
- plainText = addRoundKey(plainText, roundKeys[10]);
-
- return plainText;
- }
-
- /**
- * Decrypts the ciphertext with the key and returns the result
- *
- * @param cipherText
- * The Encrypted text which we want to decrypt
- * @param key
- * @return decryptedText
- */
- public static BigInteger decrypt(BigInteger cipherText, BigInteger key) {
-
- BigInteger[] roundKeys = keyExpansion(key);
-
- // Invert final round
- cipherText = addRoundKey(cipherText, roundKeys[10]);
- cipherText = shiftRowsDec(cipherText);
- cipherText = subBytesDec(cipherText);
-
- // Invert main rounds
- for (int i = 9; i > 0; i--) {
- cipherText = addRoundKey(cipherText, roundKeys[i]);
- cipherText = mixColumnsDec(cipherText);
- cipherText = shiftRowsDec(cipherText);
- cipherText = subBytesDec(cipherText);
- }
-
- // Invert initial round
- cipherText = addRoundKey(cipherText, roundKeys[0]);
-
- return cipherText;
- }
-
- public static void main(String[] args) {
-
- try (Scanner input = new Scanner(System.in)) {
- System.out.println("Enter (e) letter for encrpyt or (d) letter for decrypt :");
- char choice = input.nextLine().charAt(0);
- String in;
- switch (choice) {
- case 'E':
- case 'e':
- System.out.println("Choose a plaintext block (128-Bit Integer in base 16):");
- in = input.nextLine();
- BigInteger plaintext = new BigInteger(in, 16);
- System.out.println("Choose a Key (128-Bit Integer in base 16):");
- in = input.nextLine();
- BigInteger encryptionKey = new BigInteger(in, 16);
- System.out.println("The encrypted message is: \n" + encrypt(plaintext, encryptionKey).toString(16));
- break;
- case 'D':
- case 'd':
- System.out.println("Enter your ciphertext block (128-Bit Integer in base 16):");
- in = input.nextLine();
- BigInteger ciphertext = new BigInteger(in, 16);
- System.out.println("Choose a Key (128-Bit Integer in base 16):");
- in = input.nextLine();
- BigInteger decryptionKey = new BigInteger(in, 16);
- System.out.println("The deciphered message is:\n" + decrypt(ciphertext, decryptionKey).toString(16));
- break;
- default:
- System.out.println("** End **");
- }
- }
-
- }
-}
diff --git a/ciphers/AESEncryption.java b/ciphers/AESEncryption.java
deleted file mode 100644
index 871bd52..0000000
--- a/ciphers/AESEncryption.java
+++ /dev/null
@@ -1,114 +0,0 @@
-package ciphers;
-
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import javax.crypto.BadPaddingException;
-import javax.crypto.Cipher;
-import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.KeyGenerator;
-import javax.crypto.NoSuchPaddingException;
-import javax.crypto.SecretKey;
-import javax.xml.bind.DatatypeConverter;
-
-/**
- * This example program shows how AES encryption and decryption can be done in
- * Java. Please note that secret key and encrypted text is unreadable binary and
- * hence in the following program we display it in hexadecimal format of the
- * underlying bytes.
- *
- */
-public class AESEncryption {
-
- /**
- * 1. Generate a plain text for encryption 2. Get a secret key (printed in
- * hexadecimal form). In actual use this must by encrypted and kept safe. The
- * same key is required for decryption.
- *
- */
- public static void main(String[] args) throws Exception {
- String plainText = "Hello World";
- SecretKey secKey = getSecretEncryptionKey();
- byte[] cipherText = encryptText(plainText, secKey);
- String decryptedText = decryptText(cipherText, secKey);
-
- System.out.println("Original Text:" + plainText);
- System.out.println("AES Key (Hex Form):" + bytesToHex(secKey.getEncoded()));
- System.out.println("Encrypted Text (Hex Form):" + bytesToHex(cipherText));
- System.out.println("Descrypted Text:" + decryptedText);
-
- }
-
- /**
- * gets the AES encryption key. In your actual programs, this should be safely
- * stored.
- *
- * @return secKey (Secret key that we encrypt using it)
- * @throws NoSuchAlgorithmException
- * (from KeyGenrator)
- *
- */
- public static SecretKey getSecretEncryptionKey() throws NoSuchAlgorithmException {
- KeyGenerator aesKeyGenerator = KeyGenerator.getInstance("AES");
- aesKeyGenerator.init(128); // The AES key size in number of bits
- SecretKey secKey = aesKeyGenerator.generateKey();
- return secKey;
- }
-
- /**
- * Encrypts plainText in AES using the secret key
- *
- * @param plainText
- * @param secKey
- * @return byteCipherText (The encrypted text)
- * @throws NoSuchPaddingException
- * (from Cipher)
- * @throws NoSuchAlgorithmException
- * (from Cipher)
- * @throws InvalidKeyException
- * (from Cipher)
- * @throws BadPaddingException
- * (from Cipher)
- * @throws IllegalBlockSizeException
- * (from Cipher)
- */
- public static byte[] encryptText(String plainText, SecretKey secKey) throws NoSuchAlgorithmException,
- NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
- // AES defaults to AES/ECB/PKCS5Padding in Java 7
- Cipher aesCipher = Cipher.getInstance("AES");
- aesCipher.init(Cipher.ENCRYPT_MODE, secKey);
- byte[] byteCipherText = aesCipher.doFinal(plainText.getBytes());
- return byteCipherText;
- }
-
- /**
- * Decrypts encrypted byte array using the key used for encryption.
- *
- * @param byteCipherText
- * @param secKey
- * @return plainText
- * @throws NoSuchPaddingException
- * @throws NoSuchAlgorithmException
- * @throws InvalidKeyException
- * @throws BadPaddingException
- * @throws IllegalBlockSizeException
- */
- public static String decryptText(byte[] byteCipherText, SecretKey secKey) throws NoSuchAlgorithmException,
- NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
- // AES defaults to AES/ECB/PKCS5Padding in Java 7
- Cipher aesCipher = Cipher.getInstance("AES");
- aesCipher.init(Cipher.DECRYPT_MODE, secKey);
- byte[] bytePlainText = aesCipher.doFinal(byteCipherText);
- return new String(bytePlainText);
- }
-
- /**
- * Convert a binary byte array into readable hex form
- *
- * @param hash
- * (in binary)
- * @return hexHash
- */
- private static String bytesToHex(byte[] hash) {
- return DatatypeConverter.printHexBinary(hash);
- }
-}
diff --git a/ciphers/Caesar.java b/ciphers/Caesar.java
deleted file mode 100644
index 77cd5b9..0000000
--- a/ciphers/Caesar.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package ciphers;
-
-import java.util.Scanner;
-
-/**
- *
- * A Java implementation of Caesar Cipher. /It is a type of substitution cipher
- * in which each letter in the plaintext is replaced by a letter some fixed
- * number of positions down the alphabet. /
- *
- * @author FAHRI YARDIMCI
- * @author khalil2535
- */
-public class Caesar {
-
- /**
- * Encrypt text by shifting every Latin char by add number shift for ASCII
- * Example : A + 1 -> B
- *
- * @param message
- * @param shift
- * @return Encrypted message
- */
- public static String encode(String message, int shift) {
- String encoded = "";
-
- while (shift >= 26) { // 26 = number of latin letters
- shift -= 26;
- }
-
- final int length = message.length();
- for (int i = 0; i < length; i++) {
-
-// int current = message.charAt(i); //using char to shift characters because ascii is in-order latin alphabet
- char current = message.charAt(i); // Java law : char + int = char
-
- if (IsCapitalLatinLetter(current)) {
-
- current += shift;
- encoded += (char) (current > 'Z' ? current - 26 : current); // 26 = number of latin letters
-
- } else if (IsSmallLatinLetter(current)) {
-
- current += shift;
- encoded += (char) (current > 'z' ? current - 26 : current); // 26 = number of latin letters
-
- } else {
- encoded += current;
- }
- }
- return encoded;
- }
-
- /**
- * Decrypt message by shifting back every Latin char to previous the ASCII
- * Example : B - 1 -> A
- *
- * @param encryptedMessage
- * @param shift
- * @return message
- */
- public static String decode(String encryptedMessage, int shift) {
- String decoded = "";
-
- while (shift >= 26) { // 26 = number of latin letters
- shift -= 26;
- }
-
- final int length = encryptedMessage.length();
- for (int i = 0; i < length; i++) {
- char current = encryptedMessage.charAt(i);
- if (IsCapitalLatinLetter(current)) {
-
- current -= shift;
- decoded += (char) (current < 'A' ? current + 26 : current);// 26 = number of latin letters
-
- } else if (IsSmallLatinLetter(current)) {
-
- current -= shift;
- decoded += (char) (current < 'a' ? current + 26 : current);// 26 = number of latin letters
-
- } else {
- decoded += current;
- }
- }
- return decoded;
- }
-
- /**
- *
- * @param c
- * @return true if character is capital Latin letter or false for others
- */
- private static boolean IsCapitalLatinLetter(char c) {
- return c >= 'A' && c <= 'Z';
- }
-
- /**
- *
- * @param c
- * @return true if character is small Latin letter or false for others
- */
- private static boolean IsSmallLatinLetter(char c) {
- return c >= 'a' && c <= 'z';
- }
-
- /**
- *
- * @deprecated TODO remove main and make JUnit Testing
- */
- public static void main(String[] args) {
- Scanner input = new Scanner(System.in);
- System.out.println("Please enter the message (Latin Alphabet)");
- String message = input.nextLine();
- System.out.println(message);
- System.out.println("Please enter the shift number");
- int shift = input.nextInt() % 26;
- System.out.println("(E)ncode or (D)ecode ?");
- char choice = input.next().charAt(0);
- switch (choice) {
- case 'E':
- case 'e':
- System.out.println("ENCODED MESSAGE IS \n" + encode(message, shift)); //send our function to handle
- break;
- case 'D':
- case 'd':
- System.out.println("DECODED MESSAGE IS \n" + decode(message, shift));
- }
- }
-
-}
diff --git a/ciphers/ColumnarTranspositionCipher.java b/ciphers/ColumnarTranspositionCipher.java
deleted file mode 100644
index 26acc62..0000000
--- a/ciphers/ColumnarTranspositionCipher.java
+++ /dev/null
@@ -1,224 +0,0 @@
-package ciphers;
-
-/**
- * Columnar Transposition Cipher Encryption and Decryption.
- *
- * @author