添加到随机生成的分数，以查看它们是否加起来存储在数组中的10

Question

I need some help writing a program for an intro java class I'm taking. There is a homework assignment that requires us to generate a score that is no higher than 9 and pair them with another "person" whose score adds up to 10 with another person. There are 20 contestants in this "game". So far I created hypothetical rows and columns for the pairing of the 2 scores and nested 2 for loops and ended it off with an if to see if the rows and columns will add to 10.

The program did compile, but when running, it doesn't seem to give me a solution.

public static void main(String[] args) { 
    int rows = 2; 
    int cols = 10; 
    int[][] scoreTotal = new int[rows][cols]; 

    for (int row = 0; row < rows; row++) { 
        int teamBlue = (int)(Math.random()* 10);

        for (int col = 0; col < cols; col++) { 
            int teamRed = (int)( Math.random()* 10); 

            if (scoreTotal[row][col] == 10) { 
                System.out.println(scoreTotal);
            }
        }
    }
}

Sorry if this is a very confusing or newbie question to be asking, but like I said i'm in an intro to java class.

Answer 1

Often when getting assignments we try to complete it all in one go, but you can try to abstract the problem away to smaller "components". Try to think of it as a recipe when cooking, you simply write the steps you need to take and then write out the code afterwards.

First, start off with your main method, you did that already

public static void main(String[] args) {
}

Next, you have one requirement that states

generate a score that is no higher than 9

So what you can do is create an array of "scores", and fill that with scores for each player (I used player instead of person since you mention "score" and "contestants").

public static void main(String[] args) {
    // generate a score for each of the contestants
}

and pair them with another "person" whose score adds up to 10 with another person.

public static void main(String[] args) {
    // generate a score for each of the contestants
    // if score of player1 and another player is equal to 10, save pair
}

The if statement is kind of cumbersome, so we can try to break it down. To simplify things, try to think of only testing with one player to begin with.

public static void main(String[] args) {
    // generate a score for each of the contestants
    // take score of first player, s
    // compare s + x = 10, where x is score of other player
    // if x = 10 - s, save pair
}

Now we got something a bit more simple. Lets try putting in some code.

public static void main(String[] args) {
    int[] scores = new int[20];
    // generate a score for each of the contestants
    for (int i = 0; i < scores.length; ++i) {
        scores[i] = getRandomNumber();
    }
    // take score of first player, s
    int s = scores[0]; // the first player is at index 0
    // compare s + x = 10, where x is score of other player
    for (int i = 1; i < 20; ++i) {
        // note: We don't have to test against index 0 (that's the first player)
        //       so we start at index 1
        // if x = 10 - s
        int x = scores[i];
        if (x == 10 - s) {
            // save pair
        }
    }
}

public static int getRandomNumber() {
   // todo: generate a random score between 0 and 9 and return it
   return 4;
}

You seemed to know how to use the for loop in your original code. What you didn't do was assigning a value in the array. The scores[i] = x; (where x is an int) takes care of that, similar to assigning an int for instance, int a = 0 . I used a method for generating a score that returns an int , since the implementation of how to get a random value is "not interesting" (so we abstract it away). So the for loop sets a score value for each index of the array.

Next, since the scores array have all the scores for the contestants, we need to pair them. Using some simple math, we construct an if statement that checks if the first player and a second player has scores that sum up to 10.

Next we need to save the pairs of contestants. You were on the right path of creating a two-dimensional array, one for holding the players, and the other dimension for the "teams". When filling this array, the 2D array can look something like this

        | players |
        |  0    1 |
 -------+----+----+
 team 0 |  0 |  1 |
 team 1 |  3 |  7 |
 team 2 |  8 |  9 |
 -------+----+----+

ie we team up player 0 with 1, player 3 with player 7, and player 8 with player 9. We notice from this that the team index (0-2) is not related to the actual players, so we can conclude that we need a separate index for the teams.

public static void main(String[] args) {
    // generate a score for each of the contestants
    // create the team array, 10 teams each with 2 participants
    // for every player: take score of player, s
    // compare s + x = 10, where x is score of every other contestant
        // if x = 10 - s
            // assign the current team to player s and player x
            // increment team integer (assign next team)
}

So using similar code to yours, we construct the teams array and assign the first team with our player, before we continue with the rest of the teams.

// create the team array, 10 teams, each with 2 participants
int[][] teams = new int[10][2];
// assign the first team to player 3 and player 7
teams[0][0] = 3;
teams[0][1] = 7;

This is just an example, where Team 0 is assigned two team members, one at index 0 and one at index 1, to player 3 , and player 7 .

This is great. We can now pair up one player with anyone of the other players. From this, we know that we need a counter for the "current team", since each contestant doesn't have to have a teammate in this round, and when one team is assigned, we should assign the next one.

public static void main(String[] args) {
    int[] scores = new int[20];
    // generate a score for each of the contestants
    // ... same as before
    // create the team array, 10 teams each with 2 participants
    int[][] pairs = new int[10][2];
    // create a team integer
    int currentTeam = 0;
    // for every player: take score of player, s
    for (int i = 0; i < 20; ++i) {
        // todo: test if player i is already in teams array and continue; if it is
        int s = scores[i];
        for (int j = i + 1; j < 20; ++j) {
            // compare s + x = 10, where x is score of every other contestant
            int x = scores[j];
            // if x = 10 - s
            if (x == 10 - s) {
                // assign the current team to player i and player j
                pair[currentTeam][0] = i;
                pair[currentTeam][1] = j;
                // increment team integer (assign next team)
                ++currentTeam;
            }
        }
    }
}

Note that the second for loop starts from i + 1 , since we already tested the players with lower indexes.

Also; You don't mention it, but there's a "hidden" constraint in this problem that each pair is exclusive, so one contestant can only participate one time. You should add a third for loop that checks if the teams array contains the player already.

So, by breaking down the problem we managed to get some code that may or not work, but the logic is there anyways created by reasoning, and that's always important when solving problems!

Answer 2

As it stands now, one can not easily help you except for writing out the program for you, as you did not submit any code, so instead of plainly doing the homework for you, here are some pointers: First, break down the problem. Read the problem carefully and then identify what you have to do. In doing so, you should arrive at several steps that can be turned into code.

1. Create twenty integers containing random numbers from 0-9 (or 1 to 9, the question doesn't really specify) and put them in an array.
2. For each score, find another score so the sum of them is 10 and store them as a pair. Again, it isn't really specified how you should store these pairs.
3. After finding all pairs, output them and any left-over scores that didn't get any matches.

Answer 3

So your in the loops:

for (int row = 0; row < rows; row++) { 
    int teamBlue = (int)(Math.random()* 10);// teamBlue never used

    for (int col = 0; col < cols; col++) { 
        int teamRed = (int)( Math.random()* 10);// teamBlue never used 

        if (scoreTotal[row][col] == 10) {
            // scoreTotal[row][col] never modified
            // never reached because scoreTotal[row][col] == 0 by default
            System.out.println(scoreTotal);
        }
    }
}

In other words your 2D array is full of 0's:

{ {0 0 0 0 0 0 0 0 0 0}
  {0 0 0 0 0 0 0 0 0 0} }

Since you didn't do anything with the scores. You could:

public static void main(String[] args) { 
    int rows = 2; 
    int cols = 10; 
    int[][] scoreTotal = new int[rows][cols]; 

    for (int row = 0; row < rows; row++) { 
        for (int col = 0; col < cols; col++) { 
            int randScore = (int)(Math.random()* 9) + 1;// in case you want a 1-9
            scoreTotal[row][col] = randScore
        }
    }
}

This way you have a 2D array of scores:

           { {1 2 3 4 5 6 7 8 9 2}    // row == 0, 1st player random scores
             {1 2 3 4 3 5 6 7 8 9} }  // row == 1, 2nd player random scores
//col index:  0 1 2 3 4 5 6 7 8 9
//eg. scoreTotal[2][4] would be 3

Now you can do anything you want with the scores. The pairing would depend on whether you want pair that only add up to 10 or some other rules.