Problème avec C++ sortie du programme

Question

Example: Let’s say your user input is 6. 

Then the number of sequences that sum up to 6 is 11 (including 6 itself). This is shown clearly below: 

6 
5+1 
4+1+1 
3+1+1+1 
2+1+1+1+1 
1+1+1+1+1+1 
2+2+1+1 
3+2+1 
4+2 
2+2+2 
3+3 

You SHOULD NOT have any sequences that repeat. You cannot have 2+2+1+1 and 1+1+2+2 as two different combinations!! 

CODE:

#include <iostream> 

using namespace std; 

int sum(double number, int min, int & counter) 
{ 
    int temp=0, n; 
    n=number+temp; 
    if ((number>=(n/2)) & (number!=0)) 
    { 
     number --; 
     temp ++; 
     while (number>=(n/2)) 
     { 
      cout << number << "+"<< temp << "\n"; 
      number --; 
      temp ++; 
      counter ++; 
     } 
    } 
    else if (number==0) 
    { 
     return 0; 
    } 

    sum(n-min, 1,counter); 

    return 0; 
} 

int main() 
{ 
    int number, counter=1; 


    cout << "Please enter the number: "; 
    cin >> number ; 
    cout << "\n"; 

    sum(number, 1, counter); 
    cout << counter; 

    return 0; 
} 

Ma sortie est

6 
5+1 
4+1+1 
3+1+1+1 
2+1+1+1+1 
1+1+1+1+1+1 
2+2+1+1 
3+2+1 
3+1+2 
2+3+1 
4+2 
2+2+2 
3+3 
0+1 

Total out is 13. 

La production réelle qui est une version plus courte pour ceux qui ne aiment pas ce qui est affiché ci-dessus.

5+1 
4+2 
3+3 
4+1 
3+2 
2+3 
3+1 
2+2 
2+1 
1+2 
1+1 
0+1 

13 

Where 1+2 and 2+3 are doubles as listed above. 

Toutes les idées Qu'est-ce qui ne va pas ici?

Answer 1

Je suppose que ce serait plus facile si vous additionnez pour que le premier summand soit toujours le plus possible et que vous n'autorisiez pas deux Summands adjacents, le second est plus grand que le premier.

Juste une pensée ...

Answer 2

Voici un indice: Le problème est de calculer la partitions du nombre d'entrée. Voir aussi: partition function

Answer 3

Eh bien l'opérateur AND logique en C++ est &&, pas & que vous avez dans cette ligne:

if ((number>=(n/2)) & (number!=0)) 

Answer 4

Je l'ai déjà posté une solution dans votre question précédente:

void sum_r(int n, int m, int cnt, int* nums){ 
    for (;n >= m; m++) 
     sum_r(n-m, nums[cnt] = m, cnt+1, nums); 
    if (!n) for (int i=0; i<cnt; i++) printf("%d%c",nums[i],(i==cnt-1)?'\n':'+'); 
}; 

void sum(int n){ 
    int nums[100]; 
    return sum_r(n, 1, 0, nums); 
}; 

int main(){ 
    sum(6); 
    return 0; 
}; 

EDIT: Je vais essayer de mieux l'expliquer. L'idée principale est d'imposer un ordre sur la séquence générée, cela aidera à éviter la répétition.
Nous allons utiliser le paramètre min pour cela, ce sera le plus petit terme possible que nous puissions utiliser à partir de maintenant dans la séquence.
La fonction sum_r imprime simplement la séquence de valeurs de min à chaque niveau de récursivité.
Le terme num est utilisé comme une sorte d'accumulateur, ou la valeur laissée "pour épargner".

Nous pouvons écrire une fonction plus simple, que tout compte le nombre de ces séquences:

int sum_c(int n, int m){ 
    if (!n) return 1; // termination condition. end of sequence reached with "perfect match". this means we have found 1 additional sequence. Note that it's the only way of adding new values to result. 
    int comb_cnt = 0; 
    while (n >= m) { // we need a stop condition, and there is no point in having negative value of (n - m) 
     comb_cnt += // here we accumulate all the solutions from next levels 
      sum_c(n-m, m); // how many sequences are for current value of min? 
     m++; // trying a larger `min` 
    }; 
    return comb_cnt; // number of sequence fond at this level 
};