Funkcja wypisującą wszystkie podzbiory z podanej tablicy znaków w oparciu o reprezentację binarną kolejnych liczb naturalnych.

Mam taki pomysł.
{a,b,c}
2^3=8
0 000 -zbiór pusty
1 001 {a}
2 010 {b}
3 011 {a,b}
4 100 {c}
5 101 {a,c}
6 110 {b,c}
7 111 {a,b,c}
tak bym widział tę reprezentację bitową , ale jak to zapisać
w sumie, można by było najpierw sprawdzić, czy i-ty bit w liczbie jest ustalony
coś takeigo może, n&(1<<1)

potem dwa fory dać, ale tu zaczyna się problem, ;/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int main(int argc, char *argv[]) {
		int n,i,l;
		int tab[256];
		for(n=0;n<256;n++ ){
			tab[n]=n;
		}
		
	for(n=0;n<256;n++ ){
	for(i=0.0;i<8;i++){
	switch(tab[n]&(1<<i)){
		case 1:printf("q");break;
		case 2:printf("w");break;
		case 4:printf("e");break;
		case 8:printf("r");break;
		case 16:printf("t");break;
		case 32:printf("y");break;
		case 64:printf("i");break;
		case 128:printf("u");break;
	}
	}
	puts("\t");
}return 0;
}

Próbowałem z czymś takim, ale nie funkcjonuje to tak, jak powinno

bool get_nth_bit(uint64_t value, int n)
{
    assert(n >= 0);
    assert(n < CHAR_BIT * sizeof(value));
    return value & (1 << n);
}

Chociaż w C nie istnieje typ danych bool, zazwyczaj trzeba do tego celu użyć zmiennej całkowitej (1 - true, 0 - false). Można jednak, za pomocą typedef, stworzyć własną, skróconą definicję typu enum

O, usunęli ponownie? http://en.cppreference.com/w/c/types/boolean

Można też, wziąć ustalony ciag bitów, zacząć od zera i konsekwentnie dodawać jeden; też dostaniemy wszystkie podzbiory z jedynką wskazującą na element. Przykład:
00, 01, 01, 11,
ten ciąg powstaje z, odpowiednio:
00, 00 + 1 = 01, 01 + 1 = 10, 10 + 1 = 11.

EDIT: Oczywiście, trzeba jeszcze prefiksować zerami, jak wynik nie ma zadanej długości.

Tak z założenia ma wyglądać wynik programu:
0 000 -zbiór pusty
1 001 {a}
2 010 {b}
3 011 {a,b}
4 100 {c}
5 101 {a,c}
6 110 {b,c}
7 111 {a,b,c}

Ma ktoś jakieś konkretny pomysł, zgodny z wymogiem zadania?

Dlaczego po prostu nie stworzysz prostej tablicy: char representationCharacters[] = {a, b, c};.
Na podstawie ustawionego bitu (jego "indeksu" w liczbie) mógłbyś wtedy wyświetlać z niej kolejne znaki...

No tak, ale jak to zrobić za pomocą operacji bitowych ?

Z premedytacją nie usunę niedoskonałości związanej z wyprowadzeniem przecinka na końcu listy. Zrób to sam..

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

// Zakładam że nie będziesz miał tablic większych niż 63 elementy...

void letters_generate(const char * table, size_t size) {
    uint64_t mask = (1 << size) - 1;
    size_t counter = 0;

    do {
        putchar('{');
        for(uint64_t shift_index = 0; shift_index < size; ++shift_index) {
            if(counter & (1 << shift_index)) {
                putchar(table[shift_index]);
                putchar(',');
            }
        }
        puts("}");
    } while((++counter & mask));
}

int main(void) {
    char letters[] = { 'a', 'b', 'c' };
    size_t array_size = sizeof(letters) / sizeof(letters[0]);
    letters_generate(letters, array_size);

    return EXIT_SUCCESS;
}

Wynik:

{}
{a,}
{b,}
{a,b,}
{c,}
{a,c,}
{b,c,}
{a,b,c,}

Dziękuję bardzo za pomoc, przeanalizuję kod