Nonhypotenuse number - c

Question

A non-hypotenuse number is a natural number whose square cannot be written as the sum of two non-zero squares.
Given two integers a and b, the task is to find the sum of all odd length non-hypotenuse numbers within the range [L, R], where 𝐿=𝑎 and 𝑅=𝑏²−2^𝑎.
For example, if a=2 and b=5 then L=2 and R=5²−2²=21.The non-hypotenuse numbers of this range are: 2, 3, 4, 6, 7, 8, 9, 11,12, 14, 16, 18, 19, 21. But since we only include odd length numbers in our summation the final result is: 39 = 2 + 3 + 4 + 6 +7+ 8 +9.
For the the input 5 25, it returns 65590; however it is supposed to return 72483. It works for the inputs 2 5 and 4 100. What am I doing wrong?
Here's my code:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//function, that returns 1 if it is a nonHypoNum
int isNonHypo(int x){
double temp;
for (int i=1; i<x; i++){ //iterates through the possible lengths of one leg of the triangle
temp=sqrt((double)(x*x-i*i)); //calculate third leg
if (temp==(int)temp) //if the third is a whole number
return 0;
}
return 1;
}
//function, that tells weather it has an odd number off digits
int isOddLength(int x){
int digits=0;
while (x){
digits++;
x/=10;
}
return (digits%2==0?0:1);
}
//function, that returns the power of two
int powTwo(int exp){
int x=2;
for (;exp>0;exp--){
x*=2;
}
return (x);
}
int main(){
int a,b,sum=0;
scanf("%d%d",&a,&b);
for (int Hypo=a; Hypo<=(b*b-powTwo(a)); Hypo++){ //try out numbers in range [a,b²-2^a]
if (isOddLength(Hypo)&&isNonHypo(Hypo))
sum+=Hypo;
}
printf("%d",sum);
return 0;
}

Answer 1

There are some numerical issues with this line in your code
temp = sqrt((double)(x*x-i*i)); // where 'temp', 'x' and 'i' are int
Both x*x and i*i may overflow. It doesn't matter if the result is casted to double, because it happens after the product are performed. You should use a bigger type, like long long and cast the values before the multiplications. In that case, the cast to double may even introduce some rounding errors.
Assigning the result of sqrt to an int may also introduce some unwanted rounding errors. You may use round() to prevent those.
In this particular case, you may instead avoid sqrt and save some iterations using a different algorithm:
#include <stdbool.h>
static inline long long sq(int x)
{
return (long long)x * x;
}
bool is_nonhypotenuse(int x)
{
long long square_x = sq(x);
// Meet in the middle, instead of going up to x
for (int i = 1, j = x - 1; i <= j; i++)
{
long long square_j, target = square_x - sq(i);
// Iterates, instead of calculating the square root
while ( (square_j = sq(j)) > target )
--j;
if ( square_j == target )
return false;
}
return true;
}
Edit
The other problem (probably the most important, given the input data) lies in the function used to calculate the powers of 2.
int powTwo(int exp) {
int x=2; // <-- It should start from 1, here
for (;exp>0;exp--) {
x*=2;
}
return (x); // <-- Effectively returns 2^(exp + 1)
}
You may consider this more general approach, instead.
long long int_pow(int base, int exp)
{
long long result = 1;
while ( exp )
{
if (exp & 1)
result *= base;
exp /= 2;
base *= base;
}
return result;
}
Or, given that the base is 2, just use a bit shift
int R = b * b - (1 << a);
With those modifications, your program should output the desired value. See e.g. here.