I am making a little program in C# that checks if input is an arithmetic array or a normal array.
The problem is when I make a for loop that checks if the array is arithmetic, I lose the last two elements off the array because i had to reduce numbers.Length
with 2, otherwise I would get an error saying its out of bounds. (btw., arithmetic is for example: 2 - 4 - 6 - 8 - 10 - 12, so 2 every time)
int[] numbers = new int[6];
for (int i = 0; i < numbers.Length; i )
{
Console.Write("Give a number: ");
numbers[i] = int.Parse(Console.ReadLine());
}
bool boolArithmetic = false;
bool boolNormal = false;
int counterArithmetic = 0;
for (int i = 0; i < numbers.Length - 2; i )
{
if (numbers[i 1] - numbers[i] == numbers[i 2] - numbers[i 1])
{
Console.WriteLine("Arithmetic Array");
Console.WriteLine(i);
counterArithmetic ;
boolArithmetic = true;
}
else
{
Console.WriteLine("Normal Array");
Console.WriteLine(i);
boolNormal = true;
}
}
if (counterArithmetic == 6 && boolArithmetic)
{
Console.WriteLine("ARITHMETIC ARRAY");
}
else if (boolNormal)
{
Console.WriteLine("NORMAL ARRAY");
}
I tried adding 2 to the array but this didn't work at all. I also tried a do while loop but it just confused me even more.
Does someone know how to fix this so that my code work fine?
CodePudding user response:
You don't lose the last two elements.
In the body of the loop you check the i 1
and i 2
elements.
Why do you use a counter to count how many pairs have the same difference? Just use a single boolean flag. As soon as you see a difference that doesn't match, set the flag to true and break out of the loop.
bool isArithmetic = true;
for (int i = 0; i < numbers.Length - 2; i )
{
if (numbers[i 1] - numbers[i] != numbers[i 2] - numbers[i 1])
{
isArithmetic = false;
break;
}
}
Now, just check the bool isArithmetic
to figure out what to print:
if (isArithmetic)
{
Console.WriteLine("ARITHMETIC ARRAY");
}
else
{
Console.WriteLine("NORMAL ARRAY");
}
This assumes your array has at least 3 elements. Arrays with less than 3 elements will always be considered "arithmetic arrays" by this logic, since the for loop is never entered.
CodePudding user response:
The condition inside the second for
loop should be changed, it should be i < numbers.Length - 3
instead of i < numbers.Length - 2
.
If you are checking for arithmetic array, you can actually do the following:
- Compute the difference between first two elements, let call it pre-computed difference.
- Then starting from third element, calculate the difference of each consecutive terms, lets call it current difference.
- Check if the current difference is equal to the pre-computed difference.If not break, and conclude that the array is not arithmetic
- Keep on iterating, till you visit the entire array. If you have visited the entire array, then its arithmetic.
int preComputedDiff = numbers[1]-numbers[0];
for(int i = 2;i < numbers.Length -1;i ){
int currDiff = numbers[i 1] - numbers[i];
if(currDiff != preComputedDiff){
Console.WriteLine("Normal Array");
}
}
Console.WriteLine("ARITHMETIC ARRAY");
Although you have to add the constraints of the array to make the code more suitable.
CodePudding user response:
just modify your code like this:
int[] numbers = new int[6];
for (int i = 0; i < numbers.Length; i )
{
Console.Write("Give a number: ");
numbers[i] = int.Parse(Console.ReadLine());
}
int counterArithmetic = 0;
for (int i = 0; i <=numbers.Length-2; i )
{
if ((numbers[i 1] - numbers[i]) == 2)
{
counterArithmetic =1;
}
}
if (counterArithmetic == numbers.Length-1)
{
Console.WriteLine("ARITHMETIC ARRAY");
}
else
{
Console.WriteLine("NORMAL ARRAY");
}
CodePudding user response:
I would extract the arithmetic test into another method. This allows you to separate console input/output from the logic
private static bool IsArithmetic(int[] a)
{
if (a.Length < 3) {
return false;
}
int delta = a[1] - a[0];
for (int i = 2; i < a.Length; i ) {
if (a[i] - a[i - 1] != delta) {
return false;
}
}
return true;
}
It is easier to first compute the difference between the two first elements and to reuse it to compare it with the difference between the remaining elements instead of always comparing 3 elements.
Whether a sequence of 0, 1 or two terms is considered to be an arithmetic progression seems not to be clearly defined. See: Minimum number of terms in an arithmetic progression.
Tests:
int[] a1 = { 2, 4, 6, 8, 10, 12 }; // Yes 2
int[] a2 = { 2, 4, 6, 9, 10, 12 }; // No, deviation in the middle
int[] a3 = { 2, 4, 6, 8, 10, 13 }; // No, deviation at the end
int[] a4 = { 1, 4, 6, 8, 10, 12 }; // No, deviation at the beginning
int[] a5 = { 3, 4, 6, 8, 10, 12 }; // No, deviation at the beginning
int[] a6 = { 3, 6, 9, 12, 15 }; // Yes 3
int[] a7 = { 3, 8 }; // No, too short
int[] a8 = { 2, 5, 6, 8, 10, 12 }; // No, deviation at index = 1
int[] a9 = { 2, 4, 5, 8, 10, 12 }; // No, deviation at index = 2
Console.WriteLine($"Is a1 arithmetic: {(IsArithmetic(a1) ? "yes" : "no")}");
Console.WriteLine($"Is a2 arithmetic: {(IsArithmetic(a2) ? "yes" : "no")}");
Console.WriteLine($"Is a3 arithmetic: {(IsArithmetic(a3) ? "yes" : "no")}");
Console.WriteLine($"Is a4 arithmetic: {(IsArithmetic(a4) ? "yes" : "no")}");
Console.WriteLine($"Is a5 arithmetic: {(IsArithmetic(a5) ? "yes" : "no")}");
Console.WriteLine($"Is a6 arithmetic: {(IsArithmetic(a6) ? "yes" : "no")}");
Console.WriteLine($"Is a7 arithmetic: {(IsArithmetic(a7) ? "yes" : "no")}");
Console.WriteLine($"Is a8 arithmetic: {(IsArithmetic(a8) ? "yes" : "no")}");
Console.WriteLine($"Is a9 arithmetic: {(IsArithmetic(a9) ? "yes" : "no")}");
prints:
Is a1 arithmetic: yes
Is a2 arithmetic: no
Is a3 arithmetic: no
Is a4 arithmetic: no
Is a5 arithmetic: no
Is a6 arithmetic: yes
Is a7 arithmetic: no
Is a8 arithmetic: no
Is a9 arithmetic: no
These tests ensure that the logic covers the whole index range.