So the assignment is to make a Rock Paper Scissors Spock Lizard Player that plays against another student's player without using any Random generation for 100000 trials. We are supposed to be able to detect the patterns/sequences in the other player by storing their past moves and looking for any repeating sequences.

I'm doing a code in which I store the past moves in a two-dimensional array (but i don't really find a use for the second dimension?), and I keep checking if there is any repeating sequences within the past moves every time as the number of trials increase. But my code is piling up, I want to put it in a loop in which I can just run it for the number of turns that has happened.

Here's the part where I do the check, it's a lot of coding and I'm trying to figure out a way to compress it. Also, is there any way to store the past opponent moves using perhaps multi-dimensional arrays? Apparently, the teacher said that it would be good if we could do that, but I couldn't really think of a way in which it could be useful.

``````if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-2])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-3]))
{
return 1;//one repeating move
}

if (turnNumber>=4)
{
if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-3])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-4]))
{
return 2;//two moves switching back and forth
}

if (turnNumber>=6)
{
if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-4])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-5])
&&(pastOppMoves[turnNumber-3]==pastOppMoves[turnNumber-6]))
{
return 3;//three moves switching back and forth
}
if (turnNumber>=8)
{
if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-5])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-6])
&&(pastOppMoves[turnNumber-3]==pastOppMoves[turnNumber-7])
&&(pastOppMoves[turnNumber-4]==pastOppMoves[turnNumber-8]))
{
return 4;//four moves switching back and forth
}

if (turnNumber>=10)
{
if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-6])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-7])
&&(pastOppMoves[turnNumber-3]==pastOppMoves[turnNumber-8])
&&(pastOppMoves[turnNumber-4]==pastOppMoves[turnNumber-9])
&&(pastOppMoves[turnNumber-5]==pastOppMoves[turnNumber-10]))
{
return 5;//five moves switching back and forth
}

if (turnNumber>=20)
{
if ((pastOppMoves[turnNumber-1]==pastOppMoves[turnNumber-11])
&&(pastOppMoves[turnNumber-2]==pastOppMoves[turnNumber-12])
&&(pastOppMoves[turnNumber-3]==pastOppMoves[turnNumber-13])
&&(pastOppMoves[turnNumber-4]==pastOppMoves[turnNumber-14])
&&(pastOppMoves[turnNumber-5]==pastOppMoves[turnNumber-15]))

{
return 6;
}
}

}
}
}
}``````
``````static int test2(int T, int[] M, int LIMIT) {
System.out.println("LIMIT " + LIMIT);
System.out.println("T " + T);
System.out.println("====");
int B = 2;
int H = B / 2;
while (LIMIT > B) {
System.out.println("B " + B);
int counter = 0;
if (T >= B) {
for (int i = 0; i < H; i++) {
System.out.println("[" + (T - H + i) + "," + (T - B + i) + "]");
if (M[T - H + i] == M[T - B + i]) {
counter++;
}
// System.out.println("[" + M[T - H + i] + "," + M[T - B + i] + "]");
}
if (counter == H) {
return H;
}
}
B += 2;
H = B / 2;
System.out.println("----");
}
return 0;
}

public static void main(String[] args) {
int LIMIT = 30;
int T = 2;
int[] M = new int;
for (int i = 0; i < 200; i++) {
M[i] = i;
}
while (T < 30) {
int R = test2(T, M, LIMIT);
System.out.println("---- " + R);
T++;
}
}``````

develop:

``````1.change names
2.parametrize
3.search relations
4.count lines with == , transform logical && to arithmetical +
5.found step for B
6.found while-condition-loop
7.write negative test with own indexed array

B += 2; // B = 8;
int H = B / 2;// 4
int counter = 0;
if (T >= B) {
for (int i = 0; i < H; i++) {
if (M[T - H + i] == M[T - B + i]) {
counter++;
}
}
if (counter == H) {
return H;
}
.....
/*
if (

(M[T - H-3] == M[T - B-3])
&& (M[T - H-2] == M[T - B-2])
&& (M[T - H-1] == M[T - B-1])
&& (M[T - H] == M[T - B])

) {
return 4;//four moves switching back and forth
}
*/``````