Ами побитовотоо решение е следното:

За видиш кои подмножества правят определена сума, то в общия случай (ако сметнем, че не си оптимирал нещо) трябва да минеш през всички подмножества.

при множеството {1, -1, 2} възможните подмножества са

{ } празно множество

{ 1 } елемент на позиция [0]

{ -1 } елемент на позиция [1]

{ 2 } елемент па позиция [2]

{ 1, -1 } елементи на позиция [0, 1]

{ 1, 2 } елементи на позиция [0, 2]

{ 1, -1, 2 } елементи на позиция [0, 1, 2]

{-1. 2 } елементи на позиция [1. 2]

Както можем да видим това са 8 (осем) възможности от множество от 3 (три) елемента. Или иначе казано това е 2 на степен 3 (елемента) = 8. Елементите винаги може да са различни, затова ще приемем, че това са N елемента. Можем сейфли да кажем, че комбинациите са 2^N. (2^3 в конкретния случай).

Ако погледнем всички числа от 0 (inclusive) до 8 (exclusive, т.е. до 7). в двоична бройна система те са:

0 => 00000000

1 => 00000001

2 => 00000010

3 => 00000011

4 => 00000100

5 => 00000101

6 => 00000110

7 => 00000111

Ако погледнем оцветените единици в двоичната репрезентация, можем да видим, че те перфектно пасват на това кои елементи правят комбинацията от подмножества. При числото 0 това е празното множество, защото няма елементи. При числото 1, има единица само на нулева позиция т.е. [0]. При числото 2 има единица на 1ва позиция т.е. [1]. При 3 има единица на нулева и първа позиция т.е. [0,1]. При 4 - на втора позиция т.е. [2]. При пет на нулева и втора .е. [0, 2]. При шест на първа и втора т.е. [1,2] и при 7 на нулева, първа и втора т.е. [0,1,2]

Т.е. това което трябва да направиш е да завъртиш цикъл от 0 до 2^N и за всяко число в интервала 0...7 да намериш единиците на кои позиции са, после да сумираш елементите в множеството на тези позиции и да видиш дали правят 0.

Let Set = {1, -1, 2}

for K = 0; K < 2^Set.Length; K++

     Let M = K in Binary

     Let P = Масив от позициите, на които има единици в M

     Let Sum = 0

     for Pos in P

         Sum += Set[Pos]

     if Sum == 0 (или каквато е търсената сума) => Print("подможеството с позиции {P} отговаря на условието")

Като че ли зацепих малко, ама не точно. Например в задачата е даден следният пример: 0 11 1 10 5 6 3 4 7 2, което ако го представя по твоя начин в битове ще изглежда така:

0 =>   00000000
1 =>   00000001
2 =>   00000010
3 =>   00000011
4 =>   00000100
5 =>   00000101
6 =>   00000110
7 =>   00000111
10 => 00001010 
11 => 00001011

Забелязвам примерно, че комбинации от числа като:

1 + 10 = 11

1 =>   00000001

10 => 00001010 

ако ги съберем с побитово § ще се получат битове колкото на числото 11:

11 => 00001011

Но при други числа като 5 и 6 примерно това не се получава:

5 =>    00000101
6 =>    00000110

11 =>  00001011

Както и при 1 + 2 + 3 + 5 и т.н. 

Или побитово трябва да представя всички комбинации на 2^10? Като не ми става ясно ако е така, защо е така при положение, че ще включва много числа, които ние ги нямаме в началния input...

Което означава, че все още не съм разбрал напълно смисълът на задачата :( Ако можеш да отделиш 15мин на Скайп мисля, че на живо ще стане по-лесно и бързо, тъй като ще можем да обсъждаме на момента.

Благодаря!

Ако искаш ми пиши в някой от месинджърите, които съм оставил. Само не и скайп, че е пълна боза последните месеци. Малко съм болен и не ми се говори, по-скоро бих писал.

Има две неща, които не си разбрал от обяснението:

1. Битовите репрезентират позиции в масива, а не числа. Това което трябва да направиш е да вземеш позициите на които са единиците и това де факто са позиции в масива. После събираш на тези позиции масива с обикновен плюс и гледаш дали правят желаната сума, например 0

2. Комбинациите от подмножества в едно множество са точно 2 на N (2^N), където N е броят числа в множеството. Ако числата са 10, то това е 2 на 10та.

Побитовите репрезентации ти дават ВСИЧКИ подмножества. Не ти дават наготово множествата, които дават тази сума. Ти трябва да ги опиташ всичките и да видиш кое от тях дава желаната сума.