-
Notifications
You must be signed in to change notification settings - Fork 4
/
PatternRecognition.java
112 lines (92 loc) · 3.86 KB
/
PatternRecognition.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/*
Textbook Exercise 8.19. Page 314, Pattern Recognition Four consecutive equal numbers
Write the following method that tests whether a two-dimensional array has four consecutive numbers
of the same value, either horizontally, vertically, or diagonally
Write a test program that prompts the user to enter the number of rows and columns of
a two-dimensional array then the values in the array, and displays true if the array contains
four consecutive numbers with the same value. Otherwise, the program displays false.
Here are some examples of the true cases.
// last line has four consecutive 3s.
0 1 0 3 1 6 1
0 1 6 8 6 0 1
5 6 2 1 8 2 9
6 5 6 1 1 9 1
1 3 6 1 4 0 7
3 3 3 3 4 0 7
// SECOND column has four consecurive 5s.
0 1 0 3 1 6 1
0 1 6 8 6 0 1
5 5 2 1 8 2 9
6 5 6 1 1 9 1
1 5 6 1 4 0 7
3 5 3 3 4 0 7
// FOUR 6s are in the diagonal
0 1 0 3 1 6 1
0 1 6 8 6 0 1
5 6 2 1 6 2 9
6 5 6 6 1 9 1
1 3 6 1 4 0 7
3 6 3 3 4 0 7
// Four 9s are in the diagonal
0 1 0 3 1 6 1
0 1 6 8 6 0 1
9 6 2 1 8 2 9
6 9 6 1 1 9 1
1 3 9 1 4 0 7
3 3 3 9 4 0 7
*/
import java.util.Scanner;
public class PatternRecognition{
public static boolean ExistRowPattern(int[][] thedigits){
// For each row, check whether it contains four consecutive digits.
for (int rindex = 0; rindex < 6; rindex++){
for (int begincolindex = 0; begincolindex <= 3; begincolindex++){
// we will check thedigits[rindex, begincolindex]
// thedigits[rindex, begincolindex+1]
// thedigits[rindex, begincolindex+2]
// thedigits[rindex, begincolindex+3]
int digit2compare = thedigits[rindex][begincolindex];
for (int comparecolindex = begincolindex+1; comparecolindex <= begincolindex + 3;
comparecolindex++){
int curdigit2compare = thedigits[rindex][comparecolindex];
if (curdigit2compare == digit2compare){
if (comparecolindex == begincolindex + 3)
return true;
continue;
}
else break;
}
}
}
}
public static void main(String []args){
// Define a scannner, explain this one
// Please refer https://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html
Scanner scanner = new Scanner(System.in);
// get the number of points
System.out.println("Please enter the pattern six rows, seven columns: ");
// enter 81 digits
int[][] thedigits = new int[9][9];
for (int row = 0 ; row < 6 ; row++)
for (int col = 0; col < 7; col ++)
thedigits[row][col] = scanner.nextInt();
System.out.println("The input pattern is: ");
for (int row = 0 ; row < 6 ; row++){
System.out.println();
for (int col = 0; col < 7; col ++){
System.out.print(thedigits[row][col] + " ");
}
}
// For each column, check whether it contains four consecutive digits.
// For each diagonal, check whether it contains four consecutive digits.
// brute-force checking, list each diagonal elements
// A[2][0], A[3][1], A[4, 2], A[5, 3]
// A[1][0], A[2][1], A[3, 2], A[4, 3], A[5, 4]
// A[0][0], ........................., A[4, 4], A[5, 5]
// A[0][1], A[1][2], A[2, 3], A[3, 4], A[4, 5], A[5, 6]
// A[0][2], A[1][3], A[2, 4], A[3, 5], A[4, 6]
// A[0][3], A[1][4], A[2, 5], A[3, 6]
// If it is a bigger dimension, we need to generalize the situation
return;
}
}