计算产生积极结果的排列

给定长度为n> 1的数字数组，数字位于0到9的范围内。我们执行以下三个操作的序列，直到完成所有数字为止

1. 选择前两位数字并添加(+)
2. 然后从上一步的结果中减去下一位(-)。
3. 上一步的结果与下一位相乘(X)。

我们使用剩余数字线性执行上述操作序列。
任务是查找在上述操作后产生给定结果的给定数组的排列数。
例如，考虑输入数字[] = {1,2,3,4,5}。让我们考虑排列21345来演示操作序列。

1. 将前两位数字相加，结果= 2 + 1 = 3
2. 减去下一位，结果=结果-3 = 3-3 = 0
3. 乘以下一位，结果=结果* 4 = 0 * 4 = 0
4. 添加下一位，结果=结果+5 = 0 + 5 = 5
5. 结果= 5，这是正数，所以递增计数为1

例子：

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 )

询问：摩根士丹利

我们首先生成给定数字数组的所有可能排列，并对每个排列顺序执行给定的操作序列，并检查哪个排列结果为正。下面的代码轻松地描述了问题的解决方案。
注意：我们可以使用迭代方法来生成所有可能的排列，请参见本文，或者可以使用STL函数next_permutation()函数来生成它。

C++

// C++ program to find count of permutations that produce
// positive result.
#include
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 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;
}

Java

// Java program to find count of permutations
// that produce positive result.
import java.util.*;
 
class GFG
{
 
// 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
static int countPositivePermutations(int number[],
                                     int n)
{
    // First sort the array so that we get
    // all permutations one by one using
    // next_permutation.
    Arrays.sort(number);
 
    // 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));
 
    return count;
}
 
static boolean next_permutation(int[] p)
{
    for (int a = p.length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
        for (int b = p.length - 1;; --b)
            if (p[b] > p[a])
            {
                int t = p[a];
                p[a] = p[b];
                p[b] = t;
                for (++a, b = p.length - 1; a < b; ++a, --b)
                {
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                }
                return true;
            }
    return false;
}
 
// Driver Code
public static void main(String[] args)
{
    int number[] = {1, 2, 3};
    int n = number.length;
    System.out.println(countPositivePermutations(number, n));
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 program to find count of permutations
# that produce positive result.
 
# 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
def countPositivePermutations(number, n):
 
    # First sort the array so that we get
    # all permutations one by one using
    # next_permutation.
    number.sort()
 
    # Initialize result (count of permutations
    # with positive result)
    count = 0;
 
    # Iterate for all permutation possible and
    # do operation sequentially in each permutation
    while True:
     
        # Stores result for current permutation.
        # First we have to select first two digits
        # and add them
        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
        operation = 1;
 
        # traverse all digits
        for i in range(2, n):
         
            # sequentially perform + , - , X operation
            if operation == 0:
                curr_result += number[i];
                 
            elif operation == 1:
                curr_result -= number[i];
             
            elif operation == 2:
                curr_result *= number[i];
               
            # next operation (decides case of switch)
            operation = (operation + 1) % 3;
     
        # result is positive then increment count by one
        if (curr_result > 0):
            count += 1
 
        # generate next greater permutation until
        # it is possible
        if(not next_permutation(number)):
            break
    return count;
 
def next_permutation(p):
    for a in range(len(p)-2, -1, -1):
        if (p[a] < p[a + 1]):
            for b in range(len(p)-1, -1000000000, -1):
                if (p[b] > p[a]):
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                    a += 1
                    b = len(p) - 1
                    while(a < b):          
                        t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        a += 1
                        b -= 1
                     
                    return True;
    return False;
 
# Driver Code
if __name__ =='__main__':
 
    number = [1, 2, 3]
    n = len(number)
    print(countPositivePermutations(number, n));
 
# This code is contributed by rutvik_56.

C#

// C# program to find count of permutations
// that produce positive result.
using System;
 
class GFG
{
     
// 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
static int countPositivePermutations(int []number,
                                     int n)
{
    // First sort the array so that we get
    // all permutations one by one using
    // next_permutation.
    Array.Sort(number);
 
    // 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));
 
    return count;
}
 
static bool next_permutation(int[] p)
{
    for (int a = p.Length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
        for (int b = p.Length - 1;; --b)
            if (p[b] > p[a])
            {
                int t = p[a];
                p[a] = p[b];
                p[b] = t;
                for (++a, b = p.Length - 1;
                           a < b; ++a, --b)
                {
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                }
                return true;
            }
    return false;
}
 
// Driver Code
static public void Main ()
{
    int []number = {1, 2, 3};
    int n = number.Length;
    Console.Write(countPositivePermutations(number, n));
}
}
 
// This code is contributed by ajit..

Javascript

 
    // Javascript program to find count of permutations
    // that produce positive result.
     
    // 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
    function countPositivePermutations(number, n)
    {
        // First sort the array so that we get
        // all permutations one by one using
        // next_permutation.
        number.sort(function(a, b){return a - b});
 
        // Initialize result (count of permutations
        // with positive result)
        let 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
            let 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
            let operation = 1;
 
            // traverse all digits
            for (let 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));
 
        return count;
    }
 
    function next_permutation(p)
    {
        for (let a = p.length - 2; a >= 0; --a)
            if (p[a] < p[a + 1])
              for (let b = p.length - 1;; --b)
                  if (p[b] > p[a])
                  {
                      let t = p[a];
                      p[a] = p[b];
                      p[b] = t;
                      for (++a, b = p.length - 1;
                                 a < b; ++a, --b)
                      {
                          t = p[a];
                          p[a] = p[b];
                          p[b] = t;
                      }
                      return true;
                  }
        return false;
    }
     
    let number = [1, 2, 3];
    let n = number.length;
    document.write(countPositivePermutations(number, n));
     

输出：

4