1. int myArray[] = {0, 1, 2, 3};
2. int rand = (int)random(myArray.length);
3. println(myArray[rand]);

here's my new code:

2. 
   
3. 
   
4. int c1 = (int)random(0, 4);
5. int c2 = (int)random(0, 4);
6. int c3 = (int)random(0, 4);
7. int c4 = (int)random(0, 4);
8. int c5 = (int)random(0, 4);
9. 
   
10. 
    
11. int R[] = {
12.   0, 224, 255, 35
13. };
14. int G[] = {
15.   173, 0, 240, 31
16. };
17. int B[] = {
18.   239, 139, 0, 32
19. };
20. 
    
21. int scr = 0;
22. int a = 1;
23. 
    
24. int[] fillColor; //Declare array
25. int rand = (int)random(fillColor.length);
26. 
    
27. //int fillColor[] = {m1, m2, m3, m4, m5}; 
28. 
    
29. color r1 = color(R[c1], G[c1], B[c1]);
30. color r2 = color(R[c2], G[c2], B[c2]);
31. color r3 = color(R[c3], G[c3], B[c3]);
32. color r4 = color(R[c4], G[c4], B[c4]);
33. color r5 = color(R[c5], G[c5], B[c5]);
34. 
    
35. color m1 = color(R[c1], G[c1], B[c1]);
36. color m2 = color(R[c2], G[c2], B[c2]);
37. color m3 = color(R[c3], G[c3], B[c3]);
38. color m4 = color(R[c4], G[c4], B[c4]);
39. color m5 = color(R[c5], G[c5], B[c5]);
40. 
    
41. 
    
42. color pixelColor1;
43. color masterColor1;
44. //color fill1;
45. 
    
46. Score1 scr1; //declare the object
47. Circle crcl; 
48. Master mstr;
49. 
    
50. 
    
51. 
    
52. void setup() {
53.   //frameRate(200);
54.   size(500, 500);
55.   crcl = new Circle(250, 350, 85);
56.   mstr = new Master(250, 200, 85);
57.   scr1= new Score1();
58.   pixelColor1= get(mouseX, mouseY);
59.   masterColor1= get(250, 200);
60.   fillColor = new int[5];
61. 
    
62. 
    
63.    fillColor[0] = m1;
64.    fillColor[1] = m2;
65.    fillColor[2] = m3;
66.    fillColor[3] = m4;
67.    fillColor[4] = m5;
68. 
    
69. }
70. 
    
71. void draw() {
72.   background(255); 
73. 
    
74.   crcl.display();
75.   mstr.display();
76.   scr1.display();
77. }
78. 
    
79. void mousePressed() {
80. 
    
81.   //scr.select();
82. 
    
83.   if (mousePressed == true) {
84.     pixelColor1 = get(mouseX, mouseY);
85.     masterColor1 = get(250, 200);
86.     println(pixelColor1); // get color test
87.     println(masterColor1); // get color test   
88.     //delay(200);
89.     if ((masterColor1 == pixelColor1) && (mouseY > 264)) {
90.       scr++;
91.       mstr.display();
92.     }
93. 
    
94.     else {
95.       mstr.display();
96.     }
97.   }
98. }
99. 
    
100. String begin(int a) {
101.   String Buffer;
102.   Buffer=nf(a, 1);
103.   return(Buffer);
104. }
107. class Circle {
108.   float x, y, diameter;
109.   //float diameter;
110. 
     
111.   Circle(float xpos, float ypos, float dia ) {
112.     x = xpos;
113.     y = ypos;
114.     diameter = dia;
115.   }
116. 
     
117.   void display() {
118. 
     
119.     noStroke();
120.     fill(r1);
121.     ellipse(x, y, 85, 85);
122.     
123.     fill(r2);
124.     ellipse(x+85, y, 85, 85);
125.     
126.     fill(r3);
127.     ellipse(x-85, y, 85, 85);
128.     
129.     fill(r4);
130.     ellipse(x-42, y+75, 85, 85);
131.     
132.     fill(r5);
133.     ellipse(x+43, y+75, 85, 85);
134.  
135.   }
136.   
137. }
140. class Master {    //Circle w/ stroke == master circle
141.   float x, y, diameter;
142.   
143. 
     
144.   Master(float xpos, float ypos, float dia ) {
145.     x = xpos;
146.     y = ypos;
147.     diameter = dia;
148.   }
149. 
     
150.   void display() {
151. 
     
152.     strokeWeight(5);
153.     stroke(0);
154.     
155.     fill(rand);  
156.     
157.     ellipse(x, y, 85, 85);
158.     ellipse(x, y, 85, 85);
159.   }   
160. }
161. 
     
163. class Score1 {
164. 
     
165. 
     
166.   Score1() {
167.   }  
168. 
     
169.   void display() {
170.     noStroke();
171.     textAlign(CENTER);
172.     textSize(50);         
173.     fill(237, 28, 36);
174. 
     
175.     text (""+begin(scr), 250, 100);
176. 
     
177. 
     
178.    
179.   }
180. }

my new code:

2. 
   
3. 
   
4. int c1 = (int)random(0, 4);
5. int c2 = (int)random(0, 4);
6. int c3 = (int)random(0, 4);
7. int c4 = (int)random(0, 4);
8. int c5 = (int)random(0, 4);
9. 
   
10. 
    
11. int R[] = {
12.   0, 224, 255, 35
13. };
14. int G[] = {
15.   173, 0, 240, 31
16. };
17. int B[] = {
18.   239, 139, 0, 32
19. };
20. 
    
21. int scr = 0;
22. 
    
23. 
    
24. color r1 = color(R[c1], G[c1], B[c1]);
25. color r2 = color(R[c2], G[c2], B[c2]);
26. color r3 = color(R[c3], G[c3], B[c3]);
27. color r4 = color(R[c4], G[c4], B[c4]);
28. color r5 = color(R[c5], G[c5], B[c5]);
29. 
    
30. color m1 = color(R[c1], G[c1], B[c1]);
31. color m2 = color(R[c2], G[c2], B[c2]);
32. color m3 = color(R[c3], G[c3], B[c3]);
33. color m4 = color(R[c4], G[c4], B[c4]);
34. color m5 = color(R[c5], G[c5], B[c5]);
35. 
    
36. int fillColor[] = {
37.   m1, m2, m3, m4, m5
38. };
39. 
    
40. int rand = (int)random(fillColor.length);
41. 
    
42. 
    
43. color pixelColor1;
44. color masterColor1;
45. //color fill1;
46. Score1 scr1; //declare the object
47. Circle crcl; 
48. Master mstr;
49. 
    
50. void setup() {
51.   //frameRate(200);
52.   size(500, 500);
53.   crcl = new Circle(250, 350, 85);
54.   mstr = new Master(250, 200, 85);
55.   scr1= new Score1();
56.   pixelColor1= get(mouseX, mouseY);
57.   masterColor1= get(250, 200);
58.   fillColor = new int[5];
59. 
    
60. 
    
61.   fillColor[0] = m1;
62.   fillColor[1] = m2;
63.   fillColor[2] = m3;
64.   fillColor[3] = m4;
65.   fillColor[4] = m5;
66. }
67. 
    
68. void draw() {
69.   background(255); 
70. 
    
71.   crcl.display();
72.   mstr.display();
73.   scr1.display();
74. }
75. 
    
76. void mousePressed() {
77. 
    
78.   //scr.select();
79. 
    
80.   if (mousePressed == true) {
81.     pixelColor1 = get(mouseX, mouseY);
82.     masterColor1 = get(250, 200);
83.     println(pixelColor1); // get color test
84.     println(masterColor1); // get color test   
85.     //delay(200);
86.     if ((masterColor1 == pixelColor1) && (mouseY > 264)) {
87.       scr++;
88.       mstr.display();
89.     }
90. 
    
91.     else {
92.       mstr.display();
93.     }
94.   }
95. }
96. 
    
97. String begin(int a) {
98.   String Buffer;
99.   Buffer=nf(a, 1);
100.   return(Buffer);
101. }
103. 
     
105. class Circle {
106.   float x, y, diameter;
107.   //float diameter;
108. 
     
109.   Circle(float xpos, float ypos, float dia ) {
110.     x = xpos;
111.     y = ypos;
112.     diameter = dia;
113.   }
114. 
     
115.   void display() {
116. 
     
117.     noStroke();
118.     fill(r1);
119.     ellipse(x, y, 85, 85);
120.     
121.     fill(r2);
122.     ellipse(x+85, y, 85, 85);
123.     
124.     fill(r3);
125.     ellipse(x-85, y, 85, 85);
126.     
127.     fill(r4);
128.     ellipse(x-42, y+75, 85, 85);
129.     
130.     fill(r5);
131.     ellipse(x+43, y+75, 85, 85);
132.  
133.   }
134.   
135. }
138. class Master {    //Circle w/ stroke == master circle
139.   float x, y, diameter;
140.   
141. 
     
142.   Master(float xpos, float ypos, float dia ) {
143.     x = xpos;
144.     y = ypos;
145.     diameter = dia;
146.   }
147. 
     
148.   void display() {
149. 
     
150.     strokeWeight(5);
151.     stroke(0);
152.     
153.     fill(rand);     
154.     ellipse(x, y, 85, 85);
155.     
156.   }
157.   
158.   
159. }
160. 
     
162. class Score1 {
163. 
     
164. 
     
165.   Score1() {
166.   }  
167. 
     
168.   void display() {
169.     noStroke();
170.     textAlign(CENTER);
171.     textSize(50);         
172.     fill(237, 28, 36);
173. 
     
174.     text (""+begin(scr), 250, 100);
175. 
     
176. 
     
177.    
178.   }
179. }
180. 
     

It may be worthwhile to store color m inside your Master class to clean that from the global variables area. Also, your Circle class actually has 5 circles. Why not have 5 instantiations of Circle each of which could store their own color?

2. int R[] = {
3.   0, 224, 255, 35
4. };
5. int G[] = {
6.   173, 0, 240, 31
7. };
8. int B[] = {
9.   239, 139, 0, 32
10. };
11. 
    
12. color m;
13. color[] r = new color[5];
14. 
    
15. int scr = 0;
16. Score1 scr1;
17. Circle crcl; 
18. Master mstr;
19. 
    
20. void setup() {
21.   size(500, 500);
22.   crcl = new Circle(250, 350, 85);
23.   mstr = new Master(250, 200, 85);
24.   scr1 = new Score1();
25. 
    
26.   // 5 circles choose among 4 colors
27.   for (int i = 0; i < 5; i++) {
28.     int rand = (int)random(4);
29.     r[i] = color(R[rand], G[rand], B[rand]);
30.   }
31. 
    
32.   // Master chooses among 4 colors
33.   int rand = (int)random(4);
34.   m = color(R[rand], G[rand], B[rand]);
35. }
36. 
    
37. void draw() {
38.   background(255);
39.   crcl.display();
40.   mstr.display();
41.   scr1.display();
42. }
43. 
    
44. void mousePressed() {
45.   color pixelColor = get(mouseX, mouseY);
46.   println(red(pixelColor)+", "+green(pixelColor)+", "+blue(pixelColor));
47.   println(red(m)+", "+green(m)+", "+blue(m));
48.   if (m == pixelColor && (mouseY > 264)) {
49.     scr++; 
50.     int rand = (int)random(4);  
51.     m = color(R[rand], G[rand], B[rand]); 
52.     mstr.display();
53.   }
54.   else {
55.     int rand = (int)random(4);  
56.     m = color(R[rand], G[rand], B[rand]);
57.     mstr.display();
58.   }
59. }
60. 
    
61. 
    
62. 
    
63. 
    
64. String begin(int a) {
65.   String Buffer;
66.   Buffer = nf(a, 1);
67.   return(Buffer);
68. }
69. 
    
70. class Circle {
71.   float x, y, diameter;
72. 
    
73.   Circle(float xpos, float ypos, float dia) {
74.     x = xpos;
75.     y = ypos;
76.     diameter = dia;
77.   }
78. 
    
79.   void display() {
80.     noStroke();
81.     fill(r[0]);
82.     ellipse(x, y, 85, 85);
83. 
    
84.     fill(r[1]);
85.     ellipse(x+85, y, 85, 85);
86. 
    
87.     fill(r[2]);
88.     ellipse(x-85, y, 85, 85);
89. 
    
90.     fill(r[3]);
91.     ellipse(x-42, y+75, 85, 85);
92. 
    
93.     fill(r[4]);
94.     ellipse(x+43, y+75, 85, 85);
95.   }
96. }
97. 
    
98. class Master {
99.   float x, y, diameter;
100. 
     
101.   Master(float xpos, float ypos, float dia) {
102.     x = xpos;
103.     y = ypos;
104.     diameter = dia;
105.   }
106. 
     
107.   void display() {
108.     strokeWeight(5);
109.     stroke(0);
110.     fill(m);     
111.     ellipse(x, y, 85, 85);
112.   }
113. }
114. 
     
115. class Score1 {
116.   Score1() {
117.   }
118.   void display() {
119.     noStroke();
120.     textAlign(CENTER);
121.     textSize(50);         
122.     fill(237, 28, 36);
123.     text(""+begin(scr), 250, 100);
124.   }
125. }

It is worth keeping global variables associated with classes inside the classes as it particularly helps other programmers understand your code. Also the Circle class actually displays 5 circles, it seems intuitive to create 5 Circle instantiations and give each their own color. I implemented it below so you can see it, it is a little bulky in setup() as it needs x[] and y[] to place them, but after the initial adding of 85, -85, etc is never done again. It is trivially faster this way (trivially because the small calculation makes nearly no difference), but if it is not intuitive to you then keep your code as it is.

Last, in mousePressed() the code in the if and else statement is nearly identical and so most of it can be placed outside the curly brackets. I left notes in the code there to explain it.