Different modes of addition equal to a fixed number

I am trying to write a program that takes the number n as an input and Using values array numbers, write sums that equal n. I want the number of values element less than 5.

i write this in recursive function

int abjad (int n ,int values[]){
    if (n<1){
        return 0 ;
    }
    else {
        for (int i = 0 ; i<20; i++){
            if(n==values[i]){
                printf("%d ",n) ;
            }
            abjad(n-values[i],values) ;   
        }
    }    
    return 0 ;
}
int main() {
    int values[] = {1,2,3,4,5,6,7,9,10,20,30,40,50,60,70,80,100,200,300,600} ; 
    int max_len = 5 ;
    int n ;
    scanf("%d",&n);
    abjad(n,values) ;
   return 0 ;
}

if n = 3 output:

1 2 1 3 

but true output is:

1 1 1
1 2 
2 1
3

I think this is what you’re looking for:

#include <stdio.h>

#define arraySize(...) (sizeof(__VA_ARGS__) / sizeof(*__VA_ARGS__))

int const values[] = {
        1, 2, 3, 4, 5, 6, 7, 9,
        10, 20, 30, 40, 50, 60, 70, 80,
        100, 200, 300, 600,
    };
int selected[5], nbSelected = 0;

void abjad(int n)
{
    if (n == 0) {
        for (int i = 0; i < nbSelected; ++i) {
            printf("%d ", selected[i]);
        }
        printf("\n");
    } else if (nbSelected < arraySize(selected)) {
        for (int i = 0; i < arraySize(values); ++i) {
            selected[nbSelected] = values[i];
            ++nbSelected;
            abjad(n - values[i]);
            --nbSelected;
        }
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    abjad(n);
}

It reminds me some exercises on recursivity on France-IOI.org.

I’m adding explanations in reaction to user4581301’s comment to my answer. Indeed being a Cargo Cult programmer is a nonsense for me; if you want to learn programming, you should start with a platform such as France-IOI (this one is quite good but is in French only). I tend to think that my codes are structured so that they only deal with a specific problem, and if you don’t understand them, you won’t get much out of them. Understanding my code is the fastest way to get a lot of things from them. And even if I add explanations, if you want to Cargo Cult program, you may still Cargo Cult program… Moreover, the code here is just so simple…

Here is how I have understood the problem (as the original formulation wasn’t clear): you want to get the lists of terms whose sum is equal to a specific number. But you don’t want any list to have a size greater than 5. Your terms are selected among an existing list of values (any term may be selected more than once, and the same values in a different order count as 2 different lists).

You weren’t so far from the solution: you accept a term, then search recursively which term could follow. The first thing to understand is that you must not show each term you select, because you might end in a situation in which you won’t finally build a correct list (because you’ve reached the limit of 5, or because the smallest possible term is greater than n while n is still greater than 0), and the term you select might actually be used for several lists if there are several solutions in the recursive call.

Therefore what you need to do is to use a stack. Many people just write:

selected[nbSelected++] = values[i];

to add a value to a stack, but I don’t like combining instructions like that (and I never use postfix operators, whose purpose is not very well known). When n reaches 0, you just have to print the content of your stack. Otherwise, if your stack is full, then building a list has failed.

The only thing you may have to concentrate on is this idea to combine a stack and recursive calls. In fact, recursive calls form a stack too. But you must put in a data structure what you’ve built in each execution of your function, otherwise child calls cannot know what has been done by previous executions and they cannot show the content of the list.

(France-IOI offers a code quite close to mine above as a solution to the problem “Choix des cours” in the chapter “Récursivité avancée”.)