CODEWITHSUNDEEP
c#arraysloopsif-statement
Eva
Eva

Reputation: 37

How to solve an index out of bounds issue, when you have to take into consideration both neighbors of an array's element?

This thing that I'm writing should do the following: get as an input a number, then, that many kids' names, and that many grades. Then, assign each kid a number of coins, so that if their grade is bigger, than their neighbor's, they get more coins and vice versa. What I wrote is this:

        string input = Console.ReadLine();
        int n = Convert.ToInt32(input);
        int i = 0;
        string[] names = new string[n];
        for (i = 0; i < n; i++)
        {
            names[i] = Console.ReadLine();
        }
        string[] gradeText = new string[n];
        int[] grades = new int[n];

        for (i = 0; i < n; i++)
        {
            gradeText[i] = Console.ReadLine();
            grades[i] = Convert.ToInt32(gradeText[i]);
        }

        int[] minCoins = { 1, 2, 3 };
        int[] coinArray = new int[n];
        for (i = 1; i < n - 2; i++)
        {
            if (grades[0] > grades[1])
            {
                coinArray[0] = 3;
            }

            else
            {
                coinArray[0] = 1;
            }
            if (grades[i] > grades[i + 1] && grades[i] > grades[i - 1])
            {
                coinArray[i] = 3;
            }
            if (grades[i] > grades[i + 1] || grades[i] > grades[i - 1])
            {
                coinArray[i] = 2;
            }
            if (grades[i] < grades[i + 1] && grades[i] < grades[i - 1])
            {
                coinArray[i] = 1;
            }

            if (grades[n - 1] > grades[n - 2])
            {
                coinArray[n - 1] = 3;
            }
            else
            { coinArray[n - 1] = 1; }

        }



        for (i = 0; i < n; i++)
        {
            Console.WriteLine(names[i] + " " + coinArray[i]);
        }

I know my loop is hella messed up, but any tips on how to fix it would be kindly appreciated!

Upvotes: 0

Views: 151

Answers (2)

Scrobi
Scrobi

Reputation: 1200

Others here have already suggested how to deal with index out of bounds issues. So this is slight different approach to solving your problem.

It is very easy to see this as one problem and then try to resolve it all in one place but that isn't always the best solution.

Your for loop is trying to do quite a lot. Each iteration could have many checks to make. In addition you are making checks you have previously made.

  1. Do I have a neighbour to the left.
  2. Do I have a neighbour to the right.
  3. Did I get a better grade than both neighbours.
  4. Did I get a better grade than one neighbour.
  5. Did I lose to both neighbours.

My advice would be to break this down into two separate tasks.

1, To calculate how many neighbours each person got a higher grade than. 

string[] names = new string[]{"John", "Paul", "Ringo", "George"};
int[] grades = new[] {3, 4, 3,2};
int[] winnersandloser = new int[4];
for (int i = 1; i < grades.Length; i++) //note starting at position 1 so I dont need to handle index out of bounds inside the for loop
{
    if (grades[i] > grades[i - 1])
    {
        winnersandloser[i]++;
    }
    else
    {
        winnersandloser[i - 1]++;
    }
}

In the above code you should have an array with these values: {0,2,1,0}

0 = you lost to both neighbours 1 = you beat one neighbour 2 = well done you beat both neighbours

Then using this winnersandlosers array you can calculate how many coins to give each person. I'll leave that for you to do.

Update

If you require different behaviour for the first and last in the list of people you need to add the logic to your code for allocating coins.

An array gives each value and index value, starting from 0. So 0 points to the first value in you array. George is the 4th entry in the array but as the array index starts with 0 the index value is 3, you also get this from arrayname.Length - 1

So now when looping through the array to allocate coins we can add a check for the first and last positions in the array.

//allocating coins
for (int i = 0; i < winnersandloser.Length;  i++)
{
    if (i == 0 || i == winnersandloser.Length - 1)
    {
        //allocating rules for first and last 
    }
    else
    {
        //allocating rules for everyone else
    }
}

Upvotes: 1

Damien_The_Unbeliever
Damien_The_Unbeliever

Reputation: 239764

One common way to approach this kind of issue is to oversize your array by as many elements as you need to look ahead/look behind. Place you real elements in the "middle"1 of this array and suitable dummy values into the elements at the start/end that don't correspond to real entries. You pick the dummy values such that the comparisons work out how you need them to (e.g. often you'll put int.MinValue in the dummy elements at the start and int.MaxValue in the dummy elements at the end).

You then just enumerate the real elements in the array, but all of your computed look aheads/look behinds still correspond to valid indexes in the array.

1Sometimes you'll have uneven look ahead/look behind requirements so it may not be the true middle. E.g. say you need to be able to look behind one element and ahead 3 elements, and you want to process 20 elements. You then create an array containing 24 entries, put dummy values at index 0, 21, 22 and 23, and populate your real elements into indexes 1 - 20.

Upvotes: 1

Related Questions