From 41cb6d55f815e42be1dd886508461f3ea7a95573 Mon Sep 17 00:00:00 2001
From: Nimrod Abramovich <grumpydormin@gmail.com>
Date: Sun, 22 Mar 2020 22:30:35 +0000
Subject: [PATCH] grid values & cage generator added
---
bin/coursework/RandomGenerator.class | Bin 0 -> 7268 bytes
src/coursework/RandomGenerator.java | 317 +++++++++++++++++++++++++++
2 files changed, 317 insertions(+)
create mode 100644 bin/coursework/RandomGenerator.class
create mode 100644 src/coursework/RandomGenerator.java
diff --git a/bin/coursework/RandomGenerator.class b/bin/coursework/RandomGenerator.class
new file mode 100644
index 0000000000000000000000000000000000000000..3ffd12084d130765e78aa78c13730b35777c3487
GIT binary patch
literal 7268
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
literal 0
HcmV?d00001
diff --git a/src/coursework/RandomGenerator.java b/src/coursework/RandomGenerator.java
new file mode 100644
index 0000000..d0d26ac
--- /dev/null
+++ b/src/coursework/RandomGenerator.java
@@ -0,0 +1,317 @@
+package coursework;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+
+public class RandomGenerator {
+
+ private static int N = 6;
+ private static int[][] grid = new int[N][N];
+
+ private static List<Integer> uncagedGrids = new ArrayList<Integer>();
+ private static List<Integer> possibleMoves;
+
+ public static void main(String[] args) {
+ generate();
+ }
+
+ private static void generate() {
+ generateGridValues();
+ shuffleGridValues();
+ generateCages();
+ }
+
+ private static void generateCages() {
+ Random random = new Random();
+ addAllGrids();
+ while (uncagedGrids.size() > 0) {
+ int cageProbability = random.nextInt(100);
+ int cageSize;
+
+ if (cageProbability < 50) {
+ cageSize = 2;
+ }
+ else if (cageProbability < 85) {
+ cageSize = 3;
+ }
+ else {
+ cageSize = 4;
+ }
+
+ if (uncagedGrids.size() <= cageSize) {
+ cageSize = uncagedGrids.size();
+ }
+ if (cageSize == 0) {
+ break;
+ }
+
+ int[] cageIds = new int[cageSize];
+ int id = uncagedGrids.get(0);
+ cageIds[0] = id;
+ uncagedGrids.remove(0);
+ for (int i = 0; i < cageSize - 1; i++) {
+ int cornerGrid = isCornerGrid(id);
+ int edgeGrid = isEdgeGrid(id);
+
+ possibleMoves = new ArrayList<Integer>();
+ possibleMoves.add(id + 1);
+ possibleMoves.add(id - 1);
+ possibleMoves.add(id + N);
+ possibleMoves.add(id - N);
+
+ if (cornerGrid != -1) {
+ if (cornerGrid == 0) {
+ topLeftCorner(id);
+ }
+ else if (cornerGrid == 1) {
+ topRightCorner(id);
+ }
+ else if (cornerGrid == 2) {
+ bottomRightCorner(id);
+ }
+ else if (cornerGrid == 3) {
+ bottomLeftCorner(id);
+ }
+ }
+ else if (edgeGrid != -1) {
+ if (edgeGrid == 0) {
+ leftEdge(id);
+ }
+ else if (edgeGrid == 1) {
+ rightEdge(id);
+ }
+ else if (edgeGrid == 2) {
+ topEdge(id);
+ }
+ else if (edgeGrid == 3) {
+ bottomEdge(id);
+ }
+ }
+ else {
+ centre(id);
+ }
+
+
+ if (possibleMoves.size() >= 1) {
+ id = possibleMoves.get(random.nextInt(possibleMoves.size()));
+ }
+ cageIds[i + 1] = id;
+ if (uncagedGrids.contains(id)) {
+ uncagedGrids.remove(uncagedGrids.indexOf(id));
+ }
+ }
+
+ String operator = "+";
+ int value = 0;
+
+ //Cage cage = new Cage(cageIds, value, operator);
+ }
+ }
+
+
+ private static void centre(int id) {
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ }
+
+ private static void topLeftCorner(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ }
+
+ private static void topRightCorner(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ }
+
+ private static void bottomRightCorner(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ }
+
+ private static void bottomLeftCorner(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ }
+
+ private static void leftEdge(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ }
+
+ private static void topEdge(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ }
+
+ private static void rightEdge(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id + N))
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ }
+
+ private static void bottomEdge(int id) {
+ possibleMoves.remove(possibleMoves.indexOf(id + N));
+ if (!uncagedGrids.contains(id - N))
+ possibleMoves.remove(possibleMoves.indexOf(id - N));
+ if (!uncagedGrids.contains(id - 1))
+ possibleMoves.remove(possibleMoves.indexOf(id - 1));
+ if (!uncagedGrids.contains(id + 1))
+ possibleMoves.remove(possibleMoves.indexOf(id + 1));
+ }
+
+ private static void addAllGrids() {
+ for (int i = 0; i < N*N; i++) {
+ uncagedGrids.add(i);
+ }
+ }
+
+ private static int isEdgeGrid(int gridId) {
+ if (gridId % N == 0) // left edge
+ return 0;
+ if (gridId % N == N - 1) // right edge
+ return 1;
+ if ((int) gridId / N == 0) // top edge
+ return 2;
+ if ((int) gridId / N == N - 1) // bottom edge
+ return 3;
+ return -1; // not an edge grid
+ }
+
+ private static int isCornerGrid(int gridId) {
+ if ((int) gridId / N == 0 && gridId % N == 0) // top left corner
+ return 0;
+ if ((int) gridId / N == N - 1 && gridId % N == N - 1) // bottom right corner
+ return 2;
+ if ((int) gridId / N == 0 && gridId % N == N - 1) // top right corner
+ return 1;
+ if ((int) gridId / N == N - 1 && gridId % N == 0) // bottom left corner
+ return 3;
+ return -1; // not a corner
+ }
+
+ private static void generateGridValues() {
+ int counter = 1;
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ grid[i][j] = counter;
+ counter++;
+ if (counter == N + 1) {
+ counter = 1;
+ }
+ }
+ counter--;
+ if (counter == 0) {
+ counter = N;
+ }
+ }
+ }
+
+ private static void shuffleGridValues() {
+ Random random = new Random();
+ for (int i = 0; i < 15; i++) {
+ int[] colsSwap = new int[2];
+ int[] rowsSwap = new int[2];
+ if (colsSwap[0] == colsSwap[1]) {
+ colsSwap = generateValues(random);
+ }
+ if (rowsSwap[0] == rowsSwap[1]) {
+ rowsSwap = generateValues(random);
+ }
+
+ swapColumns(colsSwap[0], colsSwap[1]);
+ swapRows(rowsSwap[0], rowsSwap[1]);
+
+ if (i == 7) {
+ transpose();
+ }
+ }
+ }
+
+ private static int[] generateValues(Random random) {
+ return new int[] { random.nextInt(N), random.nextInt(N) };
+ }
+
+ private static void swapColumns(int colA, int colB) {
+ int[][] columns = new int[N][2];
+ for (int i = 0; i < N; i++) {
+ columns[i][0] = grid[i][colA];
+ columns[i][1] = grid[i][colB];
+ }
+ for (int i = 0; i < N; i++) {
+ grid[i][colA] = columns[i][1];
+ grid[i][colB] = columns[i][0];
+ }
+ }
+
+ private static void swapRows(int rowA, int rowB) {
+ int[][] rows = new int[N][2];
+ for (int i = 0; i < N; i++) {
+ rows[i][0] = grid[rowA][i];
+ rows[i][1] = grid[rowB][i];
+ }
+ for (int i = 0; i < N; i++) {
+ grid[rowA][i] = rows[i][1];
+ grid[rowB][i] = rows[i][0];
+ }
+ }
+
+ private static void transpose() {
+ int[][] temp = new int[N][N];
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ temp[j][i] = grid[i][j];
+ }
+ }
+ grid = temp;
+ }
+
+ private static void output() {
+ for (int i = 0; i < N; i++) {
+ for (int j = 0; j < N; j++) {
+ System.out.print(grid[i][j] + " ");
+ }
+ System.out.print("\n");
+ }
+ System.out.print("\n");
+ }
+
+}
\ No newline at end of file
--
GitLab