Χωρισμός binary αριθμού και αποθήκευση σε πίνακα

[CtrlFreak]

Έχω έναν αριθμό πχ. 13 ο οποίος σε δυαδικό αναπαριστάτε ως 1101. Θα ήθελα κάθε ψηφίο 

να αποθηκεύεται σε έναν πίνακα. Δηλαδή αφού πάρω τον αριθμό να τον μοιράσω και να έχω:

 

array[0] = 1

array[1] = 1

array[2] = 0

array[3] = 1

 

κάθε bit σημαίνει και κάτι γι αυτό θέλω να μπορώ να το ελέγχω ξεχωριστά. 

 

[zynif]

Πολύ απλό

number=13
array=[]
while number >0:
    array.append(number % 2)
    number=int (number/2)
array.reverse()
for i in range(0, array.__len__()):
    print (array[i])

[CtrlFreak]

Βρήκα και μία ακόμα λύση στην ουσία ελέγχει το bit που θέλουμε.

 

bool is_bit_set(unsigned char value, unsigned char bitindex)
    {
    return (value & (1 << bitindex)) != 0;
    }

Το παράδειγμα σου zynif φαίνεται να μην είναι συμβατό με το compiler που χρησιμοποιώ. Γράφω σε C με τον xc16. 

[παπι]

Δες την itoa

[DeltaLover]

Αν μιλαμε για C++ δες αυτο:

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>


std::vector<int> int_to_bit_array(unsigned int_to_convert)
{
    std::vector<int> bit_array;

    // Βαλε καθε bit στο array ξεκινωντας απο το 0 και πηγαινωντας
    // ενα-ενα προς το τελος...
    //
    // Παρατηρησε οτι σε καθε iteration, το int_to_convert χανει ενα
    // bit μεχρι που τελικα γινεται 0
    //
    //

    while (int_to_convert) {

        // Παρε το πρωτο bit του int_to_convert και προσθεσε το στην array
        bit_array.push_back( int_to_convert & 1 ? 1 : 0);

       // Παρατηρησε οτι σε καθε iteration, το int_to_convert χανει ενα
       // bit μεχρι που τελικα γινεται 0
       // Αυτο ακριβως συμβαινει εδω:
       int_to_convert >>= 1;

    }

    if (bit_array.empty())
        // Σε αυτη τη περιπτωση, το int_to_convert προφανως ηταν 0
        // και το παραπανω loop δεν εκετελεσθει καθολου
        bit_array.push_back(0);
    else
        // Αφου τα bit προσετεθησαν απο το μικροτερο προς μεγαλυτερο
        // πρεπει να κανουμε reserve το array
        std::reverse(bit_array.begin(), bit_array.end()); 

   return bit_array;
}


int main(){
    using namespace std;
    for(auto x :int_to_bit_array(13)){
        cout << x ;
    }
    cout << endl;
}

[pmav99]

@CtrlFreak

Το παράδειγμα του Zynif είναι σε Python οχι σε C. Για C όπως σου ειπε και το Παπί η atoa() θα κανει αυτο που θες.

 

@Zynif

Σε python γίνεται και έτσι

array = [int(c) for c in bin(number)[2:]]
print(array)

[CtrlFreak]

Like για την itoa! Αλλά το έλυσα το θέμα με τον τρόπο που έγραψα πιο πάνω. 

[DeltaLover]

Το ιδιο σε Python

#!/usr/bin/python

def int_to_bit_array(i):
    return [int(x) for x in bin(i)[2:]]

if __name__ == '__main__':
    print int_to_bit_array(13)

Ησαστε ΠΟΛΥ ΓΡΗΓΟΡΟΙ...  Ο φιλος pmav99 εδωσε την ιδια λυση οσο εγραφα αυτο το POST

[migf1]

Σε C, μια πιθανή υλοποίηση που θα χρησιμοποιούσε μονάχα τα χρήσιμα bits και θα τα έβαζε απευθείας στη σωστή σειρά του bit-array (χωρίς δηλαδή να χρειάζεται να αντιστραφεί εκ των υστέρων) θα μπορούσε να είναι κάπως έτσι...

 

Κώδικας:

 

 

#include <stdio.h>
#include <stdlib.h>

/*********************************************************//**
 * Return the minimum number of bits needed to represent n in binary form
 *************************************************************
 */
int count_minbits( unsigned int n )
{
	int i=0;
	for (; n; i++)
		n >>= 1;

	return i;
}

/*********************************************************//**
 * Convert an unsigned int n to a binary bit-array and return it.
 * nbits passes to the caller the minimum number of bits needed
 * for the binary representation of n.
 *************************************************************
 */
unsigned char *uint_to_bitarray( unsigned int n, int *nbits )
{
	// sanity check
	if ( !nbits ) {
		return NULL;
	}

	// calc min number of bits for the binary represention of n
	*nbits = count_minbits( n );
	if ( *nbits < 1 ) {
		return NULL;
	}

	// allocate the bit-array
	unsigned char *ret = calloc( *nbits, sizeof(*ret) );
	if ( !ret ) {
		return NULL;
	}

	// fill in the bit-array with the bits of n,
	// starting from the end of the array towards its beginning
	unsigned char *bit = ret + *nbits - 1;
	while ( n  ) {
		*bit-- = (n & 1) ? 1 : 0;
		n >>= 1;
	}

	return ret;
}

/*********************************************************//**
 *
 *************************************************************
 */
int main( void )
{
	unsigned int   n = 13;
	int            nbits = 0;
	unsigned char *bitarray = uint_to_bitarray(n, &nbits);
	if ( !bitarray ) {
		fputs( "*** internal error, bye...\n", stderr );
		exit( EXIT_FAILURE );
	}

	for (int i=0; i < nbits; i++) {
		printf("%hu", bitarray[i]);
	}
	putchar('\n');

	free( bitarray );
	exit( EXIT_SUCCESS );
}

 

Αν τα χρήσιμα bits δεν είναι προϋπόθεση, τότε μπορεί να αποφευχθεί η συνάρτηση count_minbits, και το bit-array να γίνει allocated απευθείας σε CHAR_BIT * sizeof(n) ή στατικά στη stack.

 

ΥΓ. H itoa() δεν είναι standard συνάρτηση της C.