# Count permutations that produce positive result

Given an array of digits of length n > 1, digits lies within range 0 to 9. We perform sequence of below three operations until we are done with all digits

- Select starting two digits and add ( + )
- Then next digit is subtracted ( – ) from result of above step.
- The result of above step is multiplied ( X ) with next digit.

We perform above sequence of operations linearly with remaining digits.

The task is to find how many permutations of given array that produce positive result after above operations.

For Example, consider input number[] = {1, 2, 3, 4, 5}. Let us consider a permutation 21345 to demonstrate sequence of operations.

- Add first two digits, result = 2+1 = 3
- Subtract next digit, result=result-3= 3-3 = 0
- Multiply next digit, result=result*4= 0*4 = 0
- Add next digit, result = result+5 = 0+5 = 5
- result = 5 which is positive so increment count by one

Examples:

Input : number[]="123" Output: 4 // here we have all permutations // 123 --> 1+2 -> 3-3 -> 0 // 132 --> 1+3 -> 4-2 -> 2 ( positive ) // 213 --> 2+1 -> 3-3 -> 0 // 231 --> 2+3 -> 5-1 -> 4 ( positive ) // 312 --> 3+1 -> 4-2 -> 2 ( positive ) // 321 --> 3+2 -> 5-1 -> 4 ( positive ) // total 4 permutations are giving positive result Input : number[]="112" Output: 2 // here we have all permutations possible // 112 --> 1+1 -> 2-2 -> 0 // 121 --> 1+2 -> 3-1 -> 2 ( positive ) // 211 --> 2+1 -> 3-1 -> 2 ( positive )

**Asked in :**** Morgan Stanley**

We first generate all possible permutations of given digit array and perform given sequence of operations sequentially on each permutation and check for which permutation result is positive. Below code describes problem solution easily.

** Note : ** We can generate all possible permutations either by using iterative method, see this article or we can use STL function next_permutation() function to generate it.

`// C++ program to find count of permutations that produce ` `// positive result. ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to find all permutation after executing given ` `// sequence of operations and whose result value is positive ` `// result > 0 ) number[] is array of digits of length of n ` `int` `countPositivePermutations(` `int` `number[], ` `int` `n) ` `{ ` ` ` `// First sort the array so that we get all permutations ` ` ` `// one by one using next_permutation. ` ` ` `sort(number, number+n); ` ` ` ` ` `// Initialize result (count of permutations with positive ` ` ` `// result) ` ` ` `int` `count = 0; ` ` ` ` ` `// Iterate for all permutation possible and do operation ` ` ` `// sequentially in each permutation ` ` ` `do` ` ` `{ ` ` ` `// Stores result for current permutation. First we ` ` ` `// have to select first two digits and add them ` ` ` `int` `curr_result = number[0] + number[1]; ` ` ` ` ` `// flag that tells what operation we are going to ` ` ` `// perform ` ` ` `// operation = 0 ---> addition operation ( + ) ` ` ` `// operation = 1 ---> subtraction operation ( - ) ` ` ` `// operation = 0 ---> multiplication operation ( X ) ` ` ` `// first sort the array of digits to generate all ` ` ` `// permutation in sorted manner ` ` ` `int` `operation = 1; ` ` ` ` ` `// traverse all digits ` ` ` `for` `(` `int` `i=2; i<n; i++) ` ` ` `{ ` ` ` `// sequentially perform + , - , X operation ` ` ` `switch` `(operation) ` ` ` `{ ` ` ` `case` `0: ` ` ` `curr_result += number[i]; ` ` ` `break` `; ` ` ` `case` `1: ` ` ` `curr_result -= number[i]; ` ` ` `break` `; ` ` ` `case` `2: ` ` ` `curr_result *= number[i]; ` ` ` `break` `; ` ` ` `} ` ` ` ` ` `// next operation (decides case of switch) ` ` ` `operation = (operation + 1) % 3; ` ` ` `} ` ` ` ` ` `// result is positive then increment count by one ` ` ` `if` `(curr_result > 0) ` ` ` `count++; ` ` ` ` ` `// generate next greater permutation until it is ` ` ` `// possible ` ` ` `} ` `while` `(next_permutation(number, number+n)); ` ` ` ` ` `return` `count; ` `} ` ` ` `// Driver program to test the case ` `int` `main() ` `{ ` ` ` `int` `number[] = {1, 2, 3}; ` ` ` `int` `n = ` `sizeof` `(number)/` `sizeof` `(number[0]); ` ` ` `cout << countPositivePermutations(number, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output:

4

If you have better and optimized solution for this problem then please share in comments.

This article is contributed by **Shashank Mishra ( Gullu )** and reviewed by team geeksforgeeks. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Count permutations that are first decreasing then increasing.
- Count the number of special permutations
- Count ordered pairs of positive numbers such that their sum is S and XOR is K
- Generate all binary permutations such that there are more or equal 1's than 0's before every point in all permutations
- Find a permutation of 2N numbers such that the result of given expression is exactly 2K
- Permutations of a given string using STL
- All permutations of a string using iteration
- Missing Permutations in a list
- Number of palindromic permutations | Set 1
- Distinct permutations of the string | Set 2
- Problem on permutations and combinations | Set 2
- Check if two arrays are permutations of each other
- Print all permutations of a string in Java
- Sum of all numbers that can be formed with permutations of n digits
- Permutations of string such that no two vowels are adjacent