Bei einer gegebenen Zahl n werden zunächst n positive ganze Zahlen mit genau zwei gesetzten Bits in ihrer Binärdarstellung ausgegeben.
Beispiele:
Input: n = 3
Output: 3 5 6
The first 3 numbers with two set bits are 3 (0011)
5 (0101) and 6 (0110)
Input: n = 5
Output: 3 5 6 9 10 12
A Einfache Lösung besteht darin, alle positiven ganzen Zahlen nacheinander zu betrachten, beginnend bei 1. Überprüfen Sie für jede Zahl, ob genau zwei gesetzte Bits vorhanden sind. Wenn eine Zahl genau zwei gesetzte Bits hat, drucken Sie sie aus und erhöhen Sie die Anzahl dieser Zahlen.
Ein Effiziente Lösung besteht darin, solche Zahlen direkt zu generieren. Wenn wir die Zahlen genau beobachten, können wir sie wie folgt umschreiben: pow(21)+pow(20) pow(22)+pow(20) pow(22)+pow(21) pow(23)+pow(20) pow(23)+pow(21) pow(23)+pow(22) .........
Alle Zahlen können in aufsteigender Reihenfolge entsprechend dem höheren von zwei gesetzten Bits generiert werden. Die Idee besteht darin, das höhere von zwei Bits nacheinander zu korrigieren. Berücksichtigen Sie für das aktuell höher gesetzte Bit alle niedrigeren Bits und geben Sie die gebildeten Zahlen aus.
C++
// C++ program to print first n numbers // with exactly two set bits #include
// Java program to print first n numbers // with exactly two set bits import java.io.*; class GFG { // Function to print first n numbers with two set bits static void printTwoSetBitNums(int n) { // Initialize higher of two sets bits int x = 1; // Keep reducing n for every number // with two set bits while (n > 0) { // Consider all lower set bits for // current higher set bit int y = 0; while (y < x) { // Print current number System.out.print(((1 << x) + (1 << y)) +' '); // If we have found n numbers n--; if (n == 0) return; // Consider next lower bit for current // higher bit. y++; } // Increment higher set bit x++; } } // Driver program public static void main (String[] args) { int n = 4; printTwoSetBitNums(n); } } // This code is contributed by Pramod Kumar
# Python3 program to print first n # numbers with exactly two set bits # Prints first n numbers # with two set bits def printTwoSetBitNums(n) : # Initialize higher of # two sets bits x = 1 # Keep reducing n for every # number with two set bits. while (n > 0) : # Consider all lower set bits # for current higher set bit y = 0 while (y < x) : # Print current number print((1 << x) + (1 << y) end = ' ' ) # If we have found n numbers n -= 1 if (n == 0) : return # Consider next lower bit # for current higher bit. y += 1 # Increment higher set bit x += 1 # Driver code printTwoSetBitNums(4) # This code is contributed # by Smitha
// C# program to print first n numbers // with exactly two set bits using System; class GFG { // Function to print first n // numbers with two set bits static void printTwoSetBitNums(int n) { // Initialize higher of // two sets bits int x = 1; // Keep reducing n for every // number with two set bits while (n > 0) { // Consider all lower set bits // for current higher set bit int y = 0; while (y < x) { // Print current number Console.Write(((1 << x) + (1 << y)) +' '); // If we have found n numbers n--; if (n == 0) return; // Consider next lower bit // for current higher bit. y++; } // Increment higher set bit x++; } } // Driver program public static void Main() { int n = 4; printTwoSetBitNums(n); } } // This code is contributed by Anant Agarwal.
<script> // Javascript program to print first n numbers // with exactly two set bits // Prints first n numbers with two set bits function printTwoSetBitNums(n) { // Initialize higher of two sets bits let x = 1; // Keep reducing n for every number // with two set bits. while (n > 0) { // Consider all lower set bits for // current higher set bit let y = 0; while (y < x) { // Print current number document.write((1 << x) + (1 << y) + ' '); // If we have found n numbers n--; if (n == 0) return; // Consider next lower bit for current // higher bit. y++; } // Increment higher set bit x++; } } // Driver code printTwoSetBitNums(4); // This code is contributed by Mayank Tyagi </script>
// PHP program to print // first n numbers with // exactly two set bits // Prints first n numbers // with two set bits function printTwoSetBitNums($n) { // Initialize higher of // two sets bits $x = 1; // Keep reducing n for // every number with // two set bits. while ($n > 0) { // Consider all lower set // bits for current higher // set bit $y = 0; while ($y < $x) { // Print current number echo (1 << $x) + (1 << $y) ' '; // If we have found n numbers $n--; if ($n == 0) return; // Consider next lower // bit for current // higher bit. $y++; } // Increment higher set bit $x++; } } // Driver code printTwoSetBitNums(4); // This code is contributed by Ajit ?> Ausgabe :
Linux-Fehlercodes
3 5 6 9
Zeitkomplexität: An)
CSS-Ausrichtung von Bildern
Hilfsraum: O(1)
Ansatz Nr. 2: Verwendung von while und join
Der Ansatz besteht darin, mit der Ganzzahl 3 zu beginnen und zu prüfen, ob die Anzahl der gesetzten Bits in ihrer binären Darstellung gleich 2 ist oder nicht. Wenn es genau 2 gesetzte Bits hat, fügen Sie es der Liste der Zahlen mit 2 gesetzten Bits hinzu, bis die Liste n Elemente hat.
Algorithmus
1. Initialisieren Sie eine leere Liste res, um die Ganzzahlen mit genau zwei gesetzten Bits zu speichern.
2. Initialisieren Sie eine ganzzahlige Variable i auf 3.
3. Während die Länge der Liste res kleiner als n ist, gehen Sie wie folgt vor:
A. Überprüfen Sie mithilfe der count()-Methode des Strings, ob die Anzahl der gesetzten Bits in der binären Darstellung von i gleich 2 ist oder nicht.
B. Wenn die Anzahl der gesetzten Bits gleich 2 ist, dann hänge i an die Liste res an.
C. Erhöhe i um 1.
4. Geben Sie die Liste res zurück.
#include
// Java program for the above approach import java.util.ArrayList; import java.util.List; public class GFG { // Function to count the number of set bits (binary 1s) // in an integer static int countSetBits(int num) { int count = 0; while (num > 0) { count += num & 1; // Increment count if the last // bit is set (1) num >>= 1; // Right shift to check the next bit } return count; } // Function to generate 'n' numbers with exactly two set // bits in their binary representation static List<Integer> numbersWithTwoSetBits(int n) { List<Integer> res = new ArrayList<>(); int i = 3; // Start from 3 as the first number with // two set bits while (res.size() < n) { if (countSetBits(i) == 2) { // Check if the number has exactly // two set bits res.add( i); // Add the number to the result list } i++; // Move to the next number } return res; } public static void main(String[] args) { int n = 3; // Number of numbers with two set bits to // generate List<Integer> result = numbersWithTwoSetBits( n); // Get the generated numbers for (int num : result) { System.out.print( num + ' '); // Display the generated numbers } System.out.println(); } } // This code is contributed by Susobhan Akhuli
def numbersWithTwoSetBits(n): res = [] i = 3 while len(res) < n: if bin(i).count('1') == 2: res.append(i) i += 1 return res n = 3 result = numbersWithTwoSetBits(n) output_string = ' '.join(str(x) for x in result) print(output_string)
using System; using System.Collections.Generic; class Program { // Function to count the number of set bits (binary 1s) in an integer static int CountSetBits(int num) { int count = 0; while (num > 0) { count += num & 1; // Increment count if the last bit is set (1) num >>= 1; // Right shift to check the next bit } return count; } // Function to generate 'n' numbers with exactly two set bits in their binary representation static List<int> NumbersWithTwoSetBits(int n) { List<int> res = new List<int>(); int i = 3; // Start from 3 as the first number with two set bits while (res.Count < n) { if (CountSetBits(i) == 2) // Check if the number has exactly two set bits { res.Add(i); // Add the number to the result list } i++; // Move to the next number } return res; } static void Main(string[] args) { int n = 3; // Number of numbers with two set bits to generate List<int> result = NumbersWithTwoSetBits(n); // Get the generated numbers Console.Write('Result: '); foreach (int num in result) { Console.Write(num + ' '); // Display the generated numbers } Console.WriteLine(); } }
// Javascript program for the above approach // Function to count the number of set bits (binary 1s) // in an integer function countSetBits(num) { let count = 0; while (num > 0) { count += num & 1; // Increment count if the last // bit is set (1) num >>= 1; // Right shift to check the next bit } return count; } // Function to generate 'n' numbers with exactly two set // bits in their binary representation function numbersWithTwoSetBits(n) { let res = []; let i = 3; // Start from 3 as the first number with // two set bits while (res.length < n) { if (countSetBits(i) === 2) { // Check if the number has exactly // two set bits res.push(i); // Add the number to the result list } i++; // Move to the next number } return res; } // Number of numbers with two set bits to generate let n = 3; // Get the generated numbers let result = numbersWithTwoSetBits(n); // Display the generated numbers console.log(result.join(' ')); // This code is contributed by Susobhan Akhuli
Ausgabe
3 5 6
Zeitkomplexität: O(n log n) wobei n die Anzahl der ganzen Zahlen mit genau zwei gesetzten Bits ist. Dies liegt daran, dass wir die Anzahl der gesetzten Bits in der binären Darstellung jeder Ganzzahl überprüfen, was O(log n) Zeit benötigt.
Raumkomplexität: O(n) wobei n die Anzahl der ganzen Zahlen mit genau zwei gesetzten Bits ist. Dies liegt daran, dass wir die Liste der Ganzzahlen mit zwei gesetzten Bits im Speicher speichern.
Snipping-Tool in Ubuntu