Având în vedere o intrare binară care reprezintă reprezentarea binară a numărului pozitiv n, găsiți reprezentarea binară a celui mai mic număr mai mare decât n cu același număr de 1 și 0 ca și în reprezentarea binară a lui n. Dacă nu se poate forma un astfel de număr, imprimați „nici un număr mai mare”.
Intrarea binară poate fi și poate să nu se potrivească chiar și în unsigned long long int.
Exemple:
Input : 10010
Output : 10100
Here n = (18)10 = (10010)2
next greater = (20)10 = (10100)2
Binary representation of 20 contains same number of
1's and 0's as in 18 .
Input : 111000011100111110
Output : 111000011101001111
Această problemă se rezumă pur și simplu la găsirea următoarei permutări a unui șir dat. Putem găsi next_permutation() a numărului binar de intrare.
Mai jos este un algoritm pentru a găsi următoarea permutare în șirul binar.
do while loop în java
- Traversați șirul binar bstr din dreapta.
- În timp ce parcurgeți, găsiți primul indice i astfel încât bstr[i] = „0” și bstr[i+1] = „1”.
- Schimb caracter de la indexul „i” și „i+1”.
- Deoarece avem nevoie de cea mai mică valoare următoare, luați în considerare subșirul din index i+2 pentru a pune capăt și a muta toate 1 în subşir în final.
Mai jos este implementarea pașilor de mai sus.
C++// C++ program to find next permutation in a // binary string. #include
// Java program to find next permutation in a // binary string. class GFG { // Function to find the next greater number // with same number of 1's and 0's static String nextGreaterWithSameDigits(char[] bnum) { int l = bnum.length; int i; for (i = l - 2; i >= 1; i--) { // locate first 'i' from end such that // bnum[i]=='0' and bnum[i+1]=='1' // swap these value and break; if (bnum[i] == '0' && bnum[i+1] == '1') { char ch = bnum[i]; bnum[i] = bnum[i+1]; bnum[i+1] = ch; break; } } // if no swapping performed if (i == 0) System.out.println('no greater number'); // Since we want the smallest next value // shift all 1's at the end in the binary // substring starting from index 'i+2' int j = i + 2 k = l - 1; while (j < k) { if (bnum[j] == '1' && bnum[k] == '0') { char ch = bnum[j]; bnum[j] = bnum[k]; bnum[k] = ch; j++; k--; } // special case while swapping if '0' // occurs then break else if (bnum[i] == '0') break; else j++; } // required next greater number return String.valueOf(bnum); } // Driver program to test above public static void main(String[] args) { char[] bnum = '10010'.toCharArray(); System.out.println('Binary representation of next greater number = ' + nextGreaterWithSameDigits(bnum)); } } // This code contributed by Rajput-Ji
# Python3 program to find next permutation in a # binary string. # Function to find the next greater number # with same number of 1's and 0's def nextGreaterWithSameDigits(bnum): l = len(bnum) bnum = list(bnum) for i in range(l - 2 0 -1): # locate first 'i' from end such that # bnum[i]=='0' and bnum[i+1]=='1' # swap these value and break if (bnum[i] == '0' and bnum[i + 1] == '1'): ch = bnum[i] bnum[i] = bnum[i + 1] bnum[i + 1] = ch break # if no swapping performed if (i == 0): return 'no greater number' # Since we want the smallest next value # shift all 1's at the end in the binary # substring starting from index 'i+2' j = i + 2 k = l - 1 while (j < k): if (bnum[j] == '1' and bnum[k] == '0'): ch = bnum[j] bnum[j] = bnum[k] bnum[k] = ch j += 1 k -= 1 # special case while swapping if '0' # occurs then break else if (bnum[i] == '0'): break else: j += 1 # required next greater number return bnum # Driver code bnum = '10010' print('Binary representation of next greater number = '*nextGreaterWithSameDigits(bnum)sep='') # This code is contributed by shubhamsingh10
// C# program to find next permutation in a // binary string. using System; class GFG { // Function to find the next greater number // with same number of 1's and 0's static String nextGreaterWithSameDigits(char[] bnum) { int l = bnum.Length; int i; for (i = l - 2; i >= 1; i--) { // locate first 'i' from end such that // bnum[i]=='0' and bnum[i+1]=='1' // swap these value and break; if (bnum[i] == '0' && bnum[i+1] == '1') { char ch = bnum[i]; bnum[i] = bnum[i+1]; bnum[i+1] = ch; break; } } // if no swapping performed if (i == 0) Console.WriteLine('no greater number'); // Since we want the smallest next value // shift all 1's at the end in the binary // substring starting from index 'i+2' int j = i + 2 k = l - 1; while (j < k) { if (bnum[j] == '1' && bnum[k] == '0') { char ch = bnum[j]; bnum[j] = bnum[k]; bnum[k] = ch; j++; k--; } // special case while swapping if '0' // occurs then break else if (bnum[i] == '0') break; else j++; } // required next greater number return String.Join(''bnum); } // Driver code public static void Main(String[] args) { char[] bnum = '10010'.ToCharArray(); Console.WriteLine('Binary representation of next greater number = ' + nextGreaterWithSameDigits(bnum)); } } // This code is contributed by 29AjayKumar
<script> // Javascript program to find next permutation // in a binary string. // Function to find the next greater number // with same number of 1's and 0's function nextGreaterWithSameDigits(bnum) { let l = bnum.length; let i; for(i = l - 2; i >= 1; i--) { // Locate first 'i' from end such that // bnum[i]=='0' and bnum[i+1]=='1' // swap these value and break; if (bnum[i] == '0' && bnum[i + 1] == '1') { let ch = bnum[i]; bnum[i] = bnum[i+1]; bnum[i+1] = ch; break; } } // If no swapping performed if (i == 0) document.write('no greater number
'); // Since we want the smallest next value // shift all 1's at the end in the binary // substring starting from index 'i+2' let j = i + 2 k = l - 1; while (j < k) { if (bnum[j] == '1' && bnum[k] == '0') { let ch = bnum[j]; bnum[j] = bnum[k]; bnum[k] = ch; j++; k--; } // Special case while swapping if '0' // occurs then break else if (bnum[i] == '0') break; else j++; } // Required next greater number return (bnum).join(''); } // Driver code let bnum = '10010'.split(''); document.write('Binary representation of next ' + 'greater number = ' + nextGreaterWithSameDigits(bnum)); // This code is contributed by rag2127 </script>
Ieșire
Binary representation of next greater number = 10100
Complexitatea timpului: O(n) unde n este numărul de biți din intrare.
Spațiu auxiliar: O(1)
Abordarea 2:
Iată abordarea pentru a găsi următorul număr mai mare cu același număr de 1 și 0 într-un șir binar:
- Găsiți cel mai din dreapta care nu se află în urmă (RT1) din șir. Fie indicele lui i.
- Dacă nu există RT1, atunci șirul binar dat este deja cel mai mare șir binar posibil cu același număr de 1 și 0. Returnează „nici un număr mai mare”.
- Găsiți cel mai din dreapta zero la dreapta lui i (fie indicele lui j) și schimbați-l cu RT1.
- Sortați subșirul la dreapta lui j în ordine crescătoare.
- Returnează șirul rezultat.
Iată codul C++ și Java corectat pentru această abordare:
C++#include
import java.util.Arrays; public class GFG { // Function to find the next greater number // with the same number of 1's and 0's public static String nextGreaterWithSameDigits(String bnum) { int l = bnum.length(); int i = l - 1; // Find the rightmost non-trailing one while (i >= 0 && bnum.charAt(i) == '0') { i--; } if (i < 0) { return 'no greater number'; } // Find the rightmost zero to the right of i int j = i - 1; while (j >= 0 && bnum.charAt(j) == '1') { j--; } if (j < 0) { return 'no greater number'; } // Swap the RT1 with the rightmost zero to the right of i char[] bnumArray = bnum.toCharArray(); char temp = bnumArray[i]; bnumArray[i] = bnumArray[j]; bnumArray[j] = temp; // Sort the substring to the right of j in ascending order Arrays.sort(bnumArray j + 1 l); // Required next greater number return new String(bnumArray); } // Driver program to test above public static void main(String[] args) { String bnum = '10010'; System.out.println('Binary representation of next greater number = ' + nextGreaterWithSameDigits(bnum)); } }
# Function to find the next greater number # with the same number of 1's and 0's def next_greater_with_same_digits(bnum): l = len(bnum) i = l - 1 # Find the rightmost non-trailing one while i >= 0 and bnum[i] == '0': i -= 1 if i < 0: return 'no greater number' # Find the rightmost zero to the right of i j = i - 1 while j >= 0 and bnum[j] == '1': j -= 1 if j < 0: return 'no greater number' # Swap the rightmost one with the rightmost zero to the right of i bnum_list = list(bnum) bnum_list[i] bnum_list[j] = bnum_list[j] bnum_list[i] bnum = ''.join(bnum_list) # Sort the substring to the right of j in ascending order bnum = bnum[:j + 1] + ''.join(sorted(bnum[j + 1:])) # Required next greater number return bnum # Driver program to test the function if __name__ == '__main__': bnum = '10010' result = next_greater_with_same_digits(bnum) print('Binary representation of the next greater number =' result)
using System; namespace NextGreaterNumberWithSameDigits { class GFG { // Function to find the next greater number // with same number of 1's and 0's static string NextGreaterWithSameDigits(string bnum) { int l = bnum.Length; int i = l - 1; // Find the rightmost non-trailing one while (i >= 0 && bnum[i] == '0') { i--; } if (i < 0) { return 'no greater number'; } // Find the rightmost zero to the right of i int j = i - 1; while (j >= 0 && bnum[j] == '1') { j--; } if (j < 0) { return 'no greater number'; } // Swap the RT1 with the rightmost zero to the right of i char[] bnumArray = bnum.ToCharArray(); char temp = bnumArray[i]; bnumArray[i] = bnumArray[j]; bnumArray[j] = temp; // Sort the substring to the right of j in ascending order Array.Sort(bnumArray j + 1 l - j - 1); // Required next greater number return new string(bnumArray); } // Driver program to test above static void Main(string[] args) { string bnum = '10010'; Console.WriteLine('Binary representation of next greater number = ' + NextGreaterWithSameDigits(bnum)); } } }
function nextGreaterWithSameDigits(bnum) { const l = bnum.length; let i = l - 1; // Find the rightmost non-trailing one while (i >= 0 && bnum[i] === '0') { i--; } if (i < 0) { return 'no greater number'; } // Find the rightmost zero to the right of i let j = i - 1; while (j >= 0 && bnum[j] === '1') { j--; } if (j < 0) { return 'no greater number'; } // Convert string to array for swapping bnum = bnum.split(''); // Swap the RT1 with the rightmost zero to the right of i [bnum[i] bnum[j]] = [bnum[j] bnum[i]]; // Sort the substring to the right of j in ascending order const sortedSubstring = bnum.slice(j + 1).sort().join(''); // Required next greater number return bnum.slice(0 j + 1).join('') + sortedSubstring; } // Driver program to test above function main() { const bnum = '10010'; console.log('Binary representation of next greater number =' nextGreaterWithSameDigits(bnum)); } main();
Ieșire
Binary representation of next greater number = 10100
Complexitatea timpului : O(n + m log m) unde n este lungimea șirului de intrare și m este lungimea subșirului din dreapta caracterelor schimbate.
Spațiu auxiliar : O(n)