0
What else can I help you with?
How do you convert 876 decimal to binary?
std::cout << std::bitset<CHAR_BIT>( 876 ) << std::endl;
How do you convert a decimal value to a binary value in c plus plus?
#include <iostream> #include <bitset> void Dec2Bin( unsigned int dec ) { // reverse notation: // need to point to last byte and work backwards, // printing each byte as we go.. char * pDec = ( char * ) &dec; pDec += sizeof( unsigned int ) - 1; do { std::cout << std::bitset<CHAR_BIT>( *pDec ); }while( pDec-- != ( char * ) &dec ); std::cout << std::endl; } int main() { int x = 7000; Dec2Bin( x ); // print 00000000000000000001101101011000 return( 0 ); }
What is the difference between DVD plus r and DVD minus r?
AnswerDVD+R and DVD-R are different in that certain DVD players can only play a specific kind of disk. If you read the information provided with you DVD player you can find which disk type your player requires. Computers with DVD players in them are able to play both disk types._______________________________________________DVD+ media performs better at high speeds due to the technique it uses (ADIP) to control and link different sessions. The principal user difference is that the 'header track' is not pre-written on the +R media; this allows burner software to use 'bitsetting'. Bitsetting is the process where the disc information written on the header is set to tell the reading drive that the disc is actually another type of disc, typically DVD-ROM. As DVD-ROM is the format that movies and games that are bought from the shops use, a disc that is bitset will play in almost any DVD player thus eliminating the compatibility problem.
How do you enumerate all the possible subsets of x y z in C plus plus?
Enumerating subsets requires that each element in the set be mapped to a bit value. Combining these bit values (with logical OR) gives you the subset. Each subset will then have a value in the range 0 to 7, giving 8 subsets in all: {}, {x}, {y}, {z}, {x, y}, {x, z}, {y, z}, {x, y, z}. However, you cannot simply count from 0 to 7 to enumerate these subsets because this is highly inefficient. In a set of 3 it's not a significant loss, but in a larger set the inefficiency is substantial. For instance, in a set of just 64 elements, you must count from 0 to 9,223,372,036,854,775,809 in order to enumerate the 64 subsets that have just one element. If that doesn't drive the point home, then nothing will.In order to correctly enumerate subsets you must use the Banker's sequence. Each sequence varies depending upon how many elements are in the set, however the sequence allows you to quickly enumerate one set after another in a logical sequence. It also allows you to start from anywhere in the sequence and continue from that point on, thus making it possible to quickly enumerate all sets with a specific number of elements.The following code is quite involved but includes several auxiliary functions that help speed up the main code at the bottom. Some examples are included to demonstrate different usages, including the enumeration of subsets of {x, y, z}, subsets of a set of 5 elements and subsets of a subset of a 9 element set. Note that the final example (all subsets of a 32 element set) is commented out because it will take a seriously long time to enumerate all the possible subsets. However, the code is flexible enough to allow you to narrow the search down to just those subsets with a specific number of elements.Note that the two main functions to focus upon are the find_first_subset() and find_next_subset() functions. These two functions are the driving force behind the Banker's sequence.#include // Returns the count of set bits in the given subset.// E.g., 01010010 returns 3.unsigned int count_set_bits( register unsigned int subset ){// An alternative method is to logical AND the bitset with 0x1// then right shift the bitset by 1 bit. That requires an average// of 32 separate operations (worst case is 64). This method always// uses 17, thus always returns in constant time. For unsigned// short, eliminate the last shift. For char, eliminate the last// two shifts.subset -= (( subset >> 1 ) & 0x55555555 );subset = ((( subset >> 2 ) & 0x33333333 ) + ( subset & 0x33333333 ));subset = ((( subset >> 4 ) + subset ) & 0x0f0f0f0f );subset += ( subset >> 8 );subset += ( subset >> 16 );return( subset & 0x0000003f );}// Returns all set bits from the given subset's MSB down.// E.g., 00100010 returns 00111111.// The inversion of the return value can be used to mask// bits that are greater than the MSB in another subset.unsigned int fill_down( register unsigned int subset ){subset |= ( subset >> 1 );subset |= ( subset >> 2 );subset |= ( subset >> 4 );subset |= ( subset >> 8 );subset |= ( subset >> 16 );return( subset );}// Returns the least-significant set bit in the given subset.// E.g., 00100110 returns 00000010.unsigned int get_LSB( register unsigned int subset ){return( subset ^ ( subset & ( subset - 1 )));}// Returns the most-significant set bit in the given subset.// E.g., 00100110 returns 00100000.unsigned int get_MSB( register unsigned int subset ){subset = fill_down( subset );return( subset & ~( subset >> 1 ));}// Returns the first subset of subset_count within the given set.// The return value can be passed to get_next_subset().unsigned int get_first_subset( const unsigned set, unsigned int subset_count ){// Initialise the subset.unsigned int subset = 0;// Check validity of parameters.if( subset_count && subset_count
How do you check a bit is on or off?
To determine if a specific bit within a bitset is on or off, use the bitwise AND operator. Note that a bitwise AND is not the same as a logical AND.Logical AND (or &&) is used in Boolean logic:x && y is true when x and y are both true, otherwise it is false.Bitwise AND (or &) compares each corresponding bit, returning a value that indicates which bits are set in both values. This is best seen when the two values are placed one above the other so we can compare the corresponding bits:10101100 &10110101 =10100100From this we can see that the 3rd, 6th and 8th bits are set in both values.Knowing this, we can determine the state of any individual bit in any value by simply bitwise ANDing the value with the specific bit we are looking for. If the result is zero, then the bit is not set but if the result is nonzero, then it is set.As an example, let us suppose we want to test if bit 4 is set. Note that bit 4 is not the same as saying the 4th bit. Bit 4 is actually the 5th bit because bit 0 is always the least significant bit in binary. The reason is that bit 0 represents 2 raised to the 0th power which is 1 in decimal or 00000001 in binary. Bit 4 therefore means 2 raised to the 4th power which is 16 decimal or 00010000 in binary.In decimal notation, we can determine if bit 4 is set in variable named x like so:x = 181;if ((x & 16) == 0){// bit 4 is not set}else{// bit 4 is set}Normally it is easier to use hexadecimal notation as it makes it more obvious we are performing a bitwise operation upon binary values rather than decimal values (which is notationally confusing). Given that 16 is 0x10 in hexadecimal, we then get:x = B5;if ((x & 0x10) == 0){// bit 4 is not set}else{// bit 4 is set}Note that ((x & 0x10) == 0) is the same as saying (!(x & 0x10)) while ((x & 0x10) != 0) is the same as saying (x & 0x10). The latter is notationally simpler, thus it often makes more sense to reverse the logic:x = 0xB5;if (x & 0x10) // read as: if (x & 0x10) is nonzero{// bit 4 is set}else{// bit 4 is not set}If we suppose that x is 0xB5 (181 decimal), then we can see more clearly how this works by examining the binary notation:0xB5 : 10110101 &0x10 : 00010000 =0x10 : 00010000 (non-zero, so bit 4 is set)If we now suppose that x is 0xA5 (165 decimal), then we get:0xA5 : 10100101 &0x10 : 00010000 =0x00 : 00000000 (zero, so bit 4 is not set)Note that when we're only checking for one bit and that bit is set, the return value is always the same value as the bit we are actually checking for. But when we check for more than one bit (as per the original example at the top of this answer), the result is either zero (none of the bits are set), or some combination of the bits we were looking for (one or more of the bits are set). Therefore it's easier to say the result is either zero or non-zero regardless of how many bits we're checking for.Another notation we often encounter is the following:x = 0xB5;if (x & (1
What Different between bit array and jagged array?
A bit array is a kind of array data structure that stores a sequence of bits or boolean values as an array. It is also called a bitset, bitmap or bitstring. A bit is the basic unit of data in computer science. The bit represents one of two possible values( 0 or 1, True or False, Yes or No) of a logical condition in the form of 0 and 1. An example of an eight-bit array is 10011100. A jagged array is a special kind of multidimensional array that stores a collection of arrays of variable sizes. Each row of the jagged array contains columns of different sizes. It is also called as a ragged array. This implies that you can create an array with each element serving as a pointer(reference or link) to another array of the same type. Consider an example of a 2D matrix of size 3 X 3. One can say that the rectangular collection of size 3 X 3 will have 3 rows and 3 columns, but this is not the case with jagged arrays. In the case of jagged arrays, the number of rows is fixed, but the number of columns may not be fixed. The differences between a bit array and a jagged array are as follows: Array Elements: The elements of a bit array are digits( only 0 and 1), whereas the elements of a jagged array are arrays of variable size. Example of a bit array: 11011100. Example of a jagged array: int jagged_arr[][] = new int[][]{ new int[] { 1, 5, 6, 4 }, new int[] { 2, 3}, new int[] { 9, 8, 7}, }; Dimensionality: A bit array is generally one-dimensional but can be represented as two dimensional bit array. On the other side, a jagged array is a multidimensional array. Size: The size of the bit array is fixed, whereas the column size of the jagged array may not be fixed. Complex: A bit array is a simple array data structure, whereas a jagged array is more complex than a bit array. Parallelism: Bit-level parallelism is possible in a bit array, whereas it is not possible in a jagged array. The bit-level parallelism enables long-term storage and manipulation of small arrays of bits in the register set. It also maximises the use of cache data. Speed: Jagged array is faster than a bit array since the traversal is faster in jagged arrays than in single or multi-dimensional arrays. Compactness: The bit arrays have a variety of uses in areas where the efficiency of the system or required space is at a premium due to their compact design. On the other side, the design of jagged arrays is not compact, but they have a flexible design. Uses: One can use the bit arrays for priority queues and boolean flags. A bloom filter is a hash-based probabilistic data structure to determine if a given element is a component of a set. A jagged array is mainly used for memory management and faster code execution.
