## 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:

 `````` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 `````` ``````#include #include #include 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:

 `````` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 `````` ``````#include #include 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:

 `````` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 `````` ``````#include 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

 `````` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 `````` ``````#include #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(); } ``````