// 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   <  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  ;   }   

   // 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 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  ];   else   if   operation   ==   1  :   curr_result   -=   number  [  i  ];   else   if   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# 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..   

    <  script  >      // 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  ));        <  /script>