# How to Add 1 to the Value of each Array in C

## The challenge

Given an array of integers of any length, return an array that has 1 added to the value represented by the array.

- the array can’t be empty
- only non-negative, single digit integers are allowed

Return `nil`

(or your language’s equivalent) for invalid inputs.

**Examples**:

*Valid arrays*

`[4, 3, 2, 5]`

would return `[4, 3, 2, 6]`

`[1, 2, 3, 9]`

would return `[1, 2, 4, 0]`

`[9, 9, 9, 9]`

would return `[1, 0, 0, 0, 0]`

`[0, 1, 3, 7]`

would return `[0, 1, 3, 8]`

*Invalid arrays*

`[1, -9]`

is invalid because `-9`

is **not a non-negative integer**

`[1, 2, 33]`

is invalid because `33`

is **not a single-digit integer**

## The solution in C

Option 1:

```
#include <stdlib.h>
#include<string.h>
#include<stdio.h>
int *up_array(const int *arr, unsigned *count){
int i, retenue=1;
int *result;
int* resultbis;
result=(int*)calloc(100, sizeof(int));
resultbis=(int*)calloc(100, sizeof(int));
if(*count==0){
return NULL;
}
for(i=0; i<*count; i++){
result[i]=arr[i];
}
for(i=1; i<=*count; i++){
resultbis[i]=0;
}
resultbis[0]=1;
for(i=*count-1; i>=0; i--){
if(result[i]<0||result[i]>9){
return NULL;
}
if(retenue==1){
result[i]+=1;
retenue=0;
printf("%d ", result[i]);
if(result[i]==10){
result[i]=0;
retenue=1;
printf("%d\n", result[i]);
}
}
}
printf("%d\n", retenue);
for(i=0; i<*count; i++){
printf("%d ", result[i]);
}
if(retenue==1){
*count+=1;
return resultbis;
}
return result;
}
```

Option 2:

```
#include <stdlib.h>
#include <string.h>
int* up_array(const int* arr, unsigned* count)
{
if(*count == 0)
return NULL;
int* res = (int*)calloc(1, *count * sizeof(int));
int rest = 0;
for (size_t i = *count; i > 0; --i)
{
int actual = arr[i - 1];
if (actual >= 10 || actual < 0)
{
free(res);
return NULL;
}
res[i - 1] += actual + rest;
rest = 0;
if (i == *count)
{
res[i - 1] += 1;
}
if (res[i - 1] >= 10)
{
res[i - 1] %= 10;
rest = 1;
}
}
if (rest > 0)
{
int* temp = res;
res = (int*)calloc(1, (*count + 1u) * sizeof(int));
res[0] = rest;
memcpy(res + 1, temp, *count);
free(temp);
++*count;
}
return res;
}
```

Option 3:

```
#include <stdlib.h>
int *up_array(const int *arr, unsigned *count)
{
int * sum = malloc(((*count)+1) * sizeof(int));
int temp_sum = 0;
int carry = 1;
if((*count) == 0)
return NULL;
for(int i=(*count)-1;i>=0;i--)
{
if(arr[i] < 0 || arr[i] > 9)
return NULL;
temp_sum = arr[i] + carry;
if( temp_sum >= 10)
{
sum[i] = temp_sum%10;
carry = temp_sum/10;
}
else
{
sum[i] = temp_sum;
carry = 0;
}
}
if(carry == 1)
{
int temp;
for(int j=(*count);j>1; j--)
{
sum[j] = sum[j-1];
}
sum[0] = carry;
(*count)++;
}
return sum;
}
```

## Test cases to validate our solution

```
#include <criterion/criterion.h>
#define ARRAY_COUNT(a) (sizeof(a) / sizeof((a)[0]))
int *up_array(const int *arr, unsigned *count);
void do_test(const int *arr, unsigned count, const int *expected, unsigned expcount);
void complete_test();
// TODO: Replace examples and use TDD development by writing your own tests.
Test(sample_test, example_tests)
{
{
int arr[] = {2,3,9},
exp[] = {2,4,0};
do_test(arr, ARRAY_COUNT(arr), exp, ARRAY_COUNT(exp));
}
{
int arr[] = {4,3,2,5},
exp[] = {4,3,2,6};
do_test(arr, ARRAY_COUNT(arr), exp, ARRAY_COUNT(exp));
}
{
int arr[] = {1,-9};
do_test(arr, ARRAY_COUNT(arr), NULL, 0);
}
{
int arr[] = {0,4,2},
exp[] = {0,4,3};
do_test(arr, ARRAY_COUNT(arr), exp, ARRAY_COUNT(exp));
}
{
int arr[] = {9,9,9},
exp[] = {1,0,0,0};
do_test(arr, ARRAY_COUNT(arr), exp, ARRAY_COUNT(exp));
}
{
int arr[] = {9,2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,7},
exp[] = {9,2,2,3,3,7,2,0,3,6,8,5,4,7,7,5,8,0,8};
do_test(arr, ARRAY_COUNT(arr), exp, ARRAY_COUNT(exp));
}
complete_test();
}
```