Sunday, March 5, 2023
HomeSoftware EngineeringMethods to Take a Quantity and Sum It’s Digits Raied to the...

# Methods to Take a Quantity and Sum It’s Digits Raied to the Consecutive Powers in C

## The problem#

The quantity `89` is the primary integer with multiple digit that fulfills the property partially launched within the title of this problem. What’s the usage of saying “Eureka”? As a result of this sum provides the identical quantity.

In impact: `89 = 8^1 + 9^2`

The subsequent quantity in having this property is `135`.

See this property once more: `135 = 1^1 + 3^2 + 5^3`

We want a perform to gather these numbers, that will obtain two integers `a``b` that defines the vary `[a, b]` (inclusive) and outputs a listing of the sorted numbers within the vary that fulfills the property described above.

Let’s see some instances (enter -> output):

``````1, 10 -> [1, 2, 3, 4, 5, 6, 7, 8, 9]

1, 100 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 89]
``````

If there aren’t any numbers of this type within the vary [a, b] the perform ought to output an empty listing.

``````90, 100 --> []
``````

## The answer in C#

Possibility 1:

``````#embrace <stddef.h>
#embrace <math.h>

typedef unsigned lengthy lengthy ull;

ull *sum_dig_pow(ull a, ull b, ull *outcomes, size_t *size) {
int place = 0;
for (int i = a; i <= b; i++) {
int okay = 0;
okay = log10(i) + 1;
if (pow((i % 10), okay) > i) i = i + (10 - (i % 10));
else {
int op = i;
int sum = 0;
for (int m = okay; m > 0; m--) {
sum += pow(op % 10, m);
op /= 10;
}
if (sum == i) {
outcomes[place] = i;
place++;
}
}
}
*size = place;
return outcomes;
}
``````

Possibility 2:

``````#embrace <stddef.h>

typedef unsigned lengthy lengthy ull;

ull *sum_dig_pow(ull a, ull b, ull *r, size_t *rl)
{
// A032799
static const ull A[20] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89, 135, 175, 518, 598, 1306, 1676, 2427, 2646798, 12157692622039623539ull};
size_t i;

for(*rl = i = 0; i < 20 && A[i] <= b; i++) {
if(a <= A[i]) { r[(*rl)++] = A[i]; }
}

return r;
}
``````

Possibility 3:

``````#embrace <stdio.h>
#embrace <string.h>
#embrace <math.h>
#embrace <stdlib.h>

typedef unsigned lengthy lengthy ull;

ull *sum_dig_pow (ull a, ull b, ull *outcomes, size_t *size) {
char str [snprintf (NULL, 0, "%llu", b) + 1];

for (*size = 0; a <= b; a++) {
sprintf (str, "%llu", a);

ull sum = 0;
for (size_t digit = 0; digit < strlen (str); digit++)
sum += (ull) pow (*(str + digit) - '0', digit + 1);

if (sum == a)
*(outcomes + (*size)++) = a;
}

return outcomes;
}
``````

## Check instances to validate our answer#

``````#embrace <criterion/criterion.h>
#embrace <stddef.h>
#embrace <stdio.h>

typedef unsigned lengthy lengthy ull;

ull *sum_dig_pow(ull a, ull b, ull *outcomes, size_t *size);
void tester(ull a, ull b, size_t e_len, ull anticipated[e_len]);

Check(sum_dig_pow, Sample_Tests) {
{
ull a = 1; ull b = 10;
const ull anticipated[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
tester(a, b, 9, (ull *)anticipated);
}
{
ull a = 1; ull b = 100;
const ull anticipated[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 89};
tester(a, b, 10, (ull *)anticipated);
}
{
ull a = 10; ull b = 100;
const ull anticipated[1] = {89};
tester(a, b, 1, (ull *)anticipated);
}
{
ull a = 90; ull b = 100;
const ull *anticipated = NULL;
tester(a, b, 0, (ull *)anticipated);
}
{
ull a = 90; ull b = 150;
const ull anticipated[1] = {135};
tester(a, b, 1, (ull *)anticipated);
}
{
ull a = 50; ull b = 150;
const ull anticipated[2] = {89, 135};
tester(a, b, 2, (ull *)anticipated);
}
{
ull a = 10; ull b = 150;
const ull anticipated[2] = {89, 135};
tester(a, b, 2, (ull *)anticipated);
}
}

void tester(ull a, ull b, size_t exp_len, ull anticipated[exp_len]) {
ull outcomes[exp_len];
for(size_t i=0; i<exp_len; i++) {
outcomes[i] = rand() - rand();
}
size_t sub_len = 0;
ull *submitted = sum_dig_pow(a, b, (ull *)outcomes, &sub_len);
if(sub_len != exp_len) {
cr_assert_fail(
"< Incorrect Output Size >n nSubmitted: %zunExpected:  %zun n",
sub_len,        exp_len
);
}
for(size_t i=0; i<exp_len; i++) {
if(submitted[i] != anticipated[i]) {
char sub_str[7 * sub_len + 1];
size_t s = 0, p = sprintf(sub_str, "{");
whereas(s < sub_len)
p += sprintf(sub_str + p, "%llu, ", submitted[s++]);
sprintf(sub_str + p - 2, "}");
char exp_str[7 * exp_len + 1];
size_t e = 0, q = sprintf(exp_str, "{");
whereas(e < exp_len)
q += sprintf(exp_str + q, "%llu, ", anticipated[e++]);
sprintf(exp_str + q - 2, "}");
cr_assert_fail(
"< Incorrect Worth(s) >n na = %llunb  = %llun nSubmitted: %snExpected:  %sn n",
a,        b,            sub_str,       exp_str
);
}
}
cr_assert(1);
}
``````
RELATED ARTICLES