Cómo crear un incrementador en C

El reto

Dada la entrada de una matriz de dígitos, devuelva la matriz con cada dígito incrementado por su posición en la matriz: el primer dígito se incrementará en 1, el segundo dígito en 2, and so forth. Asegúrese de empieza a contar tus posiciones desde 1 (y no 0).

Tu resultado solo puede contener números de un solo dígito, por lo que si al agregar un dígito con su posición obtienes un número de varios dígitos, solo se debe devolver el último dígito del número.

Notas:

• devolver una matriz vacía si su matriz está vacía
• las matrices solo contendrán números, así que no se preocupe por verificar eso

Ejemplos:

(1, 2, 3)  -->  (2, 4, 6)   #  (1+1, 2+2, 3+3)

(4, 6, 9, 1, 3)  -->  (5, 8, 2, 5, 8)  #  (4+1, 6+2, 9+3, 1+4, 3+5)
                                       #  9+3 = 12  -->  2

La solución en C

Opción 1:

#embrace <stddef.h>

unsigned *incrementer(unsigned *dest, const unsigned *src, size_t n) {
  if (n == 0) return NULL;
  for (size_t i = 0; i < n; i++) {
    dest(i) = (src(i) + i + 1) % 10;
  }
  return dest;
}

Opcion 2:

#embrace <stddef.h>

unsigned *incrementer(unsigned *dest, const unsigned *src, size_t n) {
  if(!n) return NULL;
  for(size_t i = 0; i < n; i++) dest(i) = (src(i) + (i + 1)) % 10;
  return dest;
}

Opción 3:

#embrace <stddef.h>
#embrace <stdio.h>
#embrace <string.h>
#embrace <stdlib.h>

unsigned *incrementer(unsigned *dest, const unsigned *src, size_t n)
{
  if (n <= 0) return NULL;
  char str(100);
  for (unsigned i = 0; i < n; ++i) {
    sprintf(str, "%d", src(i) + (i+1));
    if (strlen(str) > 1) dest(i) = str(strlen(str)-1) - '0';
    else dest(i) = atoi(str);
    strcpy(str, "");
  }
  return dest;
}

Casos de prueba para validar nuestra solución

#embrace <criterion/criterion.h>
#embrace <stddef.h>
#embrace <limits.h>
#embrace <string.h>
#embrace <stdio.h>

extern unsigned *incrementer(unsigned *dest, const unsigned *src, size_t n);

#outline ARRLIM      0xF
#outline FMT_UINT    (CHAR_BIT * sizeof(unsigned) / 3)
#outline FMT_ALIGN   0x2
#outline FMT_DESCR   0x40
#outline FMT_ARR     ((FMT_UINT + FMT_ALIGN) * ARRLIM)
#outline OUTPFLEN    (FMT_DESCR + FMT_UINT * 3)

typedef enum {
    ASSERT_PASS,
    ASSERT_FAIL
} assertop;

assertop assert_mem_eq(const void *precise, const void *anticipated, size_t n, size_t measurement)
 !anticipated)
        return precise != anticipated ? ASSERT_FAIL : ASSERT_PASS;
    for (i = 0ul; n--; i += measurement)
        if (memcmp((char *)precise+i, (char *)anticipated+i, measurement))
            return ASSERT_FAIL;
    return ASSERT_PASS;


char *assert_fmt(char *outpf, const unsigned *precise, const unsigned *anticipated, const unsigned *arr, size_t n)
{
    const char *descr() = { "*Precise*:", "nExpected:", "n   Array:" };
    const unsigned *params() = { precise, anticipated, arr };
    //const unsigned *r;
    size_t pos, m, i;
    for (pos = m = 0ul; m < 3ul; ++m) {
        pos += sprintf(outpf+pos, "%s ", *(descr+m));
        if (!(arr = *(params+m))) {
            pos += sprintf(outpf+pos, "NULL");
            proceed;
        }
        pos += sprintf(outpf+pos, "( ");
        for (i = 0ul; i < n; ++i)
            pos += sprintf(outpf+pos, "%u, ", *(arr+i));
        if (i)
            pos -= FMT_ALIGN;
        pos += sprintf(outpf+pos, " )");
    }
    pos += sprintf(outpf+pos, "n    N: %lun", n);
    return outpf;
}

void assert_data(const unsigned *arr, size_t n, const unsigned *anticipated)
{
    char outpf(OUTPFLEN);
    unsigned dest(ARRLIM);
    unsigned *precise = incrementer(dest, arr, n);
    if (!precise) {
        if (anticipated)
            cr_assert_fail("%s", assert_fmt(outpf, precise, anticipated, arr, n));
        else
            cr_assert(1);
    }
    else if (assert_mem_eq(precise, anticipated, n, sizeof(unsigned)) == ASSERT_FAIL)
        cr_assert_fail("%s", assert_fmt(outpf, precise, anticipated, arr, n));
    else if (assert_mem_eq(dest, anticipated, n, sizeof(unsigned)) == ASSERT_FAIL)
        cr_assert_fail("Error: shouldn't allocate reminiscence!npercents", assert_fmt(outpf, precise, anticipated, arr, n));
    else
        cr_assert(1);
}

Take a look at(Sample_Test, should_return_the_incremented_array)
{
    assert_data((const unsigned()){ 1,2,3 }, 3ul, (const unsigned()){ 2,4,6 });
    assert_data((const unsigned()){ 4,6,7,1,3 }, 5ul, (const unsigned()){ 5,8,0,5,8 });
    assert_data((const unsigned()){ 3,6,9,8,9 }, 5ul, (const unsigned()){ 4,8,2,2,4 });
    assert_data((const unsigned()){ 1,2,3,4,5,6,7,8,9,9,9,9,9,8 }, 14ul, (const unsigned()){ 2,4,6,8,0,2,4,6,8,9,0,1,2,2 });
    assert_data((const unsigned()){ 0 }, 0ul, NULL);
}