I think I have the bugs worked out with the ArrayList my problem now is that the result is giving me sets where I have two of the same value side by side and numbers are appearing more than three times. There should never be more than three values of any number.

In your code you recalculate ranA and ranB if in the first attempt they are the same but there is always a change that the second attempt (lines 43 & 44) also produce a pair (this gets more and more likely as the arraylist shrinks) but these would be accepted. The trick is to repeatably calculate ranA and ranB until you get 2 different numbers using a do-while loop see below lines 22 - 26 below) I have also tidied up some of the 'removal from arraylist' code to make it clearer.

1. import java.util.ArrayList;
2. //total number of values must be divisiable by 2 when mult * 3
3. int pts = 6;
4. 
   
5. ArrayList<Integer> balls;
6. ArrayList<Integer> keeps;
7. int[][] matrix = new int[pts*3][2];
8. balls = new ArrayList<Integer>();
9. keeps = new ArrayList<Integer>();
10. 
    
11. //make list of int values
12. //total number of values must be divisiable by 2
13. for (int i = 0; i <pts; i++) {
14.   for (int j = 0; j <3; j++) {
15.     balls.add(i);
16.   }
17. }
18. 
    
19. int ranA, ranB;
20. //pick two random values from the array list and add them to the array
21. for (int i = 0; i < (pts*3)/2; i++) { 
22.   do {
23.     ranA = (int)random(0, balls.size());
24.     ranB = (int)random(0, balls.size());
25.   }
26.   while (ranA == ranB);
27.   println(balls.size() + " size");
28.   matrix[i][0] =  balls.get(ranA);
29.   matrix[i][1] =  balls.get(ranB);
30.   if (ranA < ranB) {
31.     balls.remove(ranB);
32.     balls.remove(ranA);
33.   }
34.   else {
35.     balls.remove(ranA);
36.     balls.remove(ranB);
37.   }
38. }
39. 
    
40. println("RESULTS");
41. //print results
42. for (int i = 0; i <(pts*3)/2; i++) {
43.   println(matrix[i][0] + "," + matrix[i][1]);
44. }

Thank you so much this is a great help.

For some reason I am still getting two of a kind.... 

my other problem is that some times I will get two of a kind not only as 5,5 but also within the array. 

If pts = 6 then you have 18 values in the array list
0 0 0 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5

Because you are selecting any two at random then you will almost certainly get pairs. One way to avoid this is to change line 26 to

while (ranA == ranB || balls.get(ranA) == balls.get(ranB);

but this is not a good idea - consider when the arraylist has only two elements left if they both hold the same number then you have an inifinite loop because the second condition balls.get(ranA) == balls.get(ranB) is always true.

The other problem of getting two of a kind i.e.

is harder to solve but has a similar problem in that if we already have a pair 5,1 and the arraylist size is now 2 and the elements left are 1 and 5 then we have two possible outcomes
1, 5 or 5, 1 so there is a 50% chance of getting a pair and if reverse pairs i.e.
are not acceptable then the algorithm again becomes stuck.

The algorithm you are using will not produce the result you want

The problem you are describing is similar to determining the football fixtures for a season and of the top of my head I can't think of a straightforward way to fill the matrix to meet your constraints.

When I get a chance I will have a think about a solution but the algorithm is likely to be much more complex than the one you have at the moment.

By the way are reverse pairs acceptable?

reverse pairs are not acceptable either.

After some thought trying to find an algorithm that would do the job I realised that if I understood the problem correctly then there is no solution.

This is easily proven by an example.

You have 3 constraints for the final matrix array -
1) There should be no duplicates e.g.
    matrix[1] = 4,4
2) There should no pairs or reverse pairs eg
    matrix[1] = 5,1
    matrix[6] = 1,5
3) No number should appear more than 3 times in the final matrix.

If pts = 6 then we have 15 distinct possibilities which listed below - and other combination s would violate either constraint 1 or 2 - try it!

The trouble is you that these 15 couplets are boound to break constraint 3 

1. 0-1
2. 0-2
3. 0-3
4. 0-4
5. 0-5
6. 1-2
7. 1-3
8. 1-4
9. 1-5
10. 2-3
11. 2-4
12. 2-5
13. 3-4
14. 3-5
15. 4-5

I am trying to make a cubic graph also know as a TrivalentGraph.

I am trying to make a cubic graph also know as a TrivalentGraph.

http://mathworld.wolfram.com/CubicGraph.html

I know it is possible with the configurations shown on this website.

 

Ahhh! now I understand what you are trying to do. Let me think about it!

I now have a solution to your problem and knowing what you were trying to do (create TrivalentGraph) was the key to solving it.

The code is complex but I will try to explain the algorithm.

1) Create a list of all possible links between points avoiding -
      points being linked to themselves e.g. 2,2 and
      duplicate but reversed links e.g. 1,5 and 5,1
2) Pick a link at random and add the point numbers to the matrix
3) Remove this link from the list
4) For each of the link end points, Increment the number of links to it and if this reachs the maximum number (i.e. 3) then remove all links using that point from the available list.
5) repeat from (2)

It is possible for the available links list to empty before we have filled the matrix and if we did nothing about it the program would crash. So if this happens we just try again from (1).

Although the following code looks complex it is very easy to use, just include the Link class and the methods getMatrix, makeMatrix and removeLinksWithPointNo none of these need altering.  In fact just include everything from line 11 onwards.

If you want a matrix for 8 points then change line 6 to nbrPoints = 8;

1. // Must be even number
2. int nbrPts = 6;
3. int[][] matrix;  
   
4. 
   
5. void setup() {
6.   nbrPts = 6;
7.   matrix = getMatrix(nbrPts);
8.   printMatrix(matrix);
9. }
10. 
    
11. void printMatrix(int[][] m) {
12.   println("##### MATRIX #####");
13.   for(int i = 0; i < m.length; i++) {
14.     print("[ ");
15.     for(int j = 0; j < m[i].length; j++)
16.       print(m[i][j] + " ");
17.     println("]");
18.   }
19. }
20. int[][] getMatrix(int np)
21. {
22.   boolean success;
23.   int m[][] = new int[np * 3 / 2][2];
24.   do {
25.     success= makeMatrix(m, np);
26.   }
27.   while(success == false);
28.   return m;
29. }
30. 
    
31. boolean makeMatrix(int[][] m, int np)
32. {
33.   // int nbrLinks = np * 3 / 2;
34.   Link ln = null;
35.   int[] nbrPointLimks = new int[np];
36.   ArrayList<Link> availableLink = new ArrayList<Link>();
37.   for(int f = 0; f < np-1; f++) {
38.     for(int t = f + 1; t < np; t++)
39.       availableLink.add(new Link(f,t));
40.   }
41.   for(int i = 0; i < np * 3 / 2; i++) {
42.     if(availableLink.size() > 0)
43.       ln = availableLink.get((int)random(0, availableLink.size()));
44.     else
45.       return false;
46.     availableLink.remove(ln);
47.     nbrPointLimks[ln.n1]++;
48.     if(nbrPointLimks[ln.n1] == 3)
49.       removeLinksWithPointNo(availableLink, ln.n1);
50.     nbrPointLimks[ln.n2]++;
51.     if(nbrPointLimks[ln.n2] == 3)
52.       removeLinksWithPointNo(availableLink, ln.n2);
53.     m[i][0] = ln.n1;
54.     m[i][1] = ln.n2;
55.   }
56.   return true;
57. }
58. 
    
59. void removeLinksWithPointNo(ArrayList<Link> links, int pn) {
60.   ArrayList<Link> doneWith = new ArrayList<Link>();
61.   Link link;
62.   for(int i = 0; i < links.size(); i++) {
63.     link = links.get(i);
64.     if(link.isLinkTo(pn))
65.       doneWith.add(link);
66.   }
67.   for(int i = 0; i < doneWith.size(); i++)
68.     links.remove(doneWith.get(i));
69. }
70. 
    
71. class Link implements Comparable {
72.   public Integer n1, n2;
73. 
    
74.   public Link(int n1, int n2) {
75.     this.n1 = n1;
76.     this.n2 = n2;
77.   }
78. 
    
79.   public boolean isLinkTo(int pn) {
80.     return (pn == n1 || pn == n2);
81.   }
82. 
    
83.   public int compareTo(Object obj) {
84.     Link link = (Link)obj;
85.     if(n1 !=  link.n1)
86.       return n1.compareTo(link.n1);
87.     else
88.       return n2.compareTo(link.n2);
89.   }
90. }

Thank you so much this was a huge help!