FilesExpand file tree

 master

/

subsets.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

80 lines (66 loc) · 2.22 KB

 master

/

subsets.py

Copy path

Top

File metadata and controls

• Code
• Blame

80 lines (66 loc) · 2.22 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

"""

Given a set of distinct integers, nums,

return all possible subsets.

Note: The solution set must not contain duplicate subsets.

For example,

If nums = [1,2,3], a solution is:

{

(1, 2),

(1, 3),

(1,),

(2,),

(3,),

(1, 2, 3),

(),

(2, 3)

}

"""

def subsets(nums):

"""

:param nums: List[int]

:return: Set[tuple]

"""

n = len(nums)

total = 1 << n

res = set()

for i in range(total):

subset = tuple(num for j, num in enumerate(nums) if i & 1 << j)

res.add(subset)

return res

"""

this explanation is from leet_nik @ leetcode

This is an amazing solution. Learnt a lot.

Number of subsets for {1 , 2 , 3 } = 2^3 .

why ?

case possible outcomes for the set of subsets

1 -> Take or dont take = 2

2 -> Take or dont take = 2

3 -> Take or dont take = 2

therefore,

total = 2*2*2 = 2^3 = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

Lets assign bits to each outcome ->

First bit to 1 , Second bit to 2 and third bit to 3

Take = 1

Dont take = 0

0) 0 0 0 -> Dont take 3 , Dont take 2 , Dont take 1 = { }

1) 0 0 1 -> Dont take 3 , Dont take 2 , take 1 = { 1 }

2) 0 1 0 -> Dont take 3 , take 2 , Dont take 1 = { 2 }

3) 0 1 1 -> Dont take 3 , take 2 , take 1 = { 1 , 2 }

4) 1 0 0 -> take 3 , Dont take 2 , Dont take 1 = { 3 }

5) 1 0 1 -> take 3 , Dont take 2 , take 1 = { 1 , 3 }

6) 1 1 0 -> take 3 , take 2 , Dont take 1 = { 2 , 3 }

7) 1 1 1 -> take 3 , take 2 , take 1 = { 1 , 2 , 3 }

In the above logic ,Insert S[i] only if (j>>i)&1 ==true

{ j E { 0,1,2,3,4,5,6,7 } i = ith element in the input array }

element 1 is inserted only into those places where 1st bit of j is 1

if( j >> 0 &1 ) ==> for above above eg.

this is true for sl.no.( j )= 1 , 3 , 5 , 7

element 2 is inserted only into those places where 2nd bit of j is 1

if( j >> 1 &1 ) == for above above eg.

this is true for sl.no.( j ) = 2 , 3 , 6 , 7

element 3 is inserted only into those places where 3rd bit of j is 1

if( j >> 2 & 1 ) == for above above eg.

this is true for sl.no.( j ) = 4 , 5 , 6 , 7

Time complexity : O(n*2^n) , for every input element loop traverses

the whole solution set length i.e. 2^n

"""