Cómo tomar un número y sumar sus dígitos elevados a las potencias consecutivas en C

El reto

El número 89 es el primer entero con más de un dígito que cumple la propiedad parcialmente introducida en el título de este desafío. ¿De qué sirve decir “Eureka”? Porque esta suma da el mismo número.

En efecto: 89 = 8^1 + 9^2

El siguiente número en tener esta propiedad es 135.

Vuelva a ver esta propiedad: 135 = 1^1 + 3^2 + 5^3

Necesitamos una función para recolectar estos números, que pueden recibir dos enteros a, b que outline el rango (a, b) (inclusive) y genera una lista de los números ordenados en el rango que cumple con la propiedad descrita anteriormente.

Veamos algunos casos (entrada -> salida):

1, 10 -> (1, 2, 3, 4, 5, 6, 7, 8, 9)

1, 100 -> (1, 2, 3, 4, 5, 6, 7, 8, 9, 89)

Si no hay números de este tipo en el rango (a, b), la función debería generar una lista vacía.

90, 100 --> ()

La solución en C

Opción 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;
}

Opcion 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;
}

Opción 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;
}

Casos de prueba para validar nuestra solución

#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));

Take a look at(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);
}