Bei einem Array von Ziffern mit der Länge n > 1 liegen die Ziffern im Bereich von 0 bis 9. Wir führen eine Folge der folgenden drei Operationen durch, bis wir mit allen Ziffern fertig sind
- Wählen Sie die ersten beiden Ziffern aus und fügen Sie ( + ) hinzu.
- Dann wird die nächste Ziffer vom Ergebnis des obigen Schritts subtrahiert (-).
- Das Ergebnis des obigen Schritts wird mit der nächsten Ziffer multipliziert (X).
Wir führen die obige Operationsfolge linear mit den verbleibenden Ziffern durch.
Die Aufgabe besteht darin, herauszufinden, wie viele Permutationen eines bestimmten Arrays nach den oben genannten Operationen zu einem positiven Ergebnis führen.
Betrachten Sie zum Beispiel die Eingabenummer[] = {1 2 3 4 5}. Betrachten wir eine Permutation 21345, um die Abfolge von Operationen zu demonstrieren.
- Addiere die ersten beiden Ziffern, Ergebnis = 2+1 = 3
- Subtrahiere die nächste Ziffer result=result-3= 3-3 = 0
- Multiplizieren Sie die nächste Ziffer mit result=result*4= 0*4 = 0
- Nächste Ziffer hinzufügen Ergebnis = Ergebnis+5 = 0+5 = 5
- Ergebnis = 5, was positiv ist, also die Anzahl um eins erhöhen
Beispiele:
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 )
Gefragt in: Morgan Stanley
Wir generieren zunächst alle möglichen Permutationen eines bestimmten Ziffernfelds, führen nacheinander eine bestimmte Abfolge von Operationen für jede Permutation durch und prüfen, welches Permutationsergebnis positiv ist. Der folgende Code beschreibt die Problemlösung einfach.
Notiz : Wir können alle möglichen Permutationen entweder mithilfe der iterativen Methode generieren, siehe Das Artikel oder wir können die STL-Funktion verwenden next_permutation() Funktion, um es zu generieren.
C++
// C++ program to find count of permutations that produce // positive result. #include
// 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>
Ausgabe:
4
Zeitkomplexität: O(n*n!)
Hilfsraum: O(1)
Wenn Sie eine bessere und optimierte Lösung für dieses Problem haben, teilen Sie diese bitte in den Kommentaren mit.