leetcode_problems/2166_design_bitset.py at main · wide0s/leetcode_problems · GitHub

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
class Bitset(object):

    def __init__(self, size):
        """
        :type size: int
        """
        self.nb = 0
        self.bs = [0] * size
        self.flipped = False


    def fix(self, idx):
        """
        :type idx: int
        :rtype: None
        """
        if self.flipped:
            if self.bs[idx] == 1:
                self.nb += 1
            self.bs[idx] = 0
        else:
            if self.bs[idx] == 0:
                self.nb += 1
            self.bs[idx] = 1


    def unfix(self, idx):
        """
        :type idx: int
        :rtype: None
        """
        if self.flipped:
            if self.bs[idx] == 0:
                self.nb -= 1
            self.bs[idx] = 1
        else:
            if self.bs[idx] == 1:
                self.nb -= 1
            self.bs[idx] = 0


    def flip(self):
        """
        :rtype: None
        """
        self.flipped = not self.flipped
        self.nb = len(self.bs) - self.nb


    def all(self):
        """
        :rtype: bool
        """
        return len(self.bs) == self.count()


    def one(self):
        """
        :rtype: bool
        """
        return self.count() > 0


    def count(self):
        """
        :rtype: int
        """
        return self.nb


    def toString(self):
        """
        :rtype: str
        """
        return ''.join(str(1 - bit) for bit in self.bs) \
            if self.flipped else ''.join(str(bit) for bit in self.bs)


vectors = [
        'Bitset', 5, '00000',
        'fix', 3, '00010',
        'fix', 1, '01010',
        'flip', None, '10101',
        'all', None, False,
        'unfix', 0, '00101',
        'flip', None, '11010',
        'one', None, True,
        'unfix', 0, '01010',
        'count', None, 2,
        'toString', None, '01010',
        'Bitset', 2, '00',
        'flip', None, '11',
        'unfix', 1, '10',
        'all', None, False,
        'fix', 1, '11',
        'fix', 1, '11',
        'unfix', 1, '10',
        'all', None, False,
        'count', None, 1,
        'toString', None, '10',
        'toString', None, '10',
        'toString', None, '10',
        'unfix', 0, '00',
        'flip', None, '11',
        'all', None, True,
        'unfix', 0, '01',
        'one', None, True,
        'one', None, True,
        'all', None, False,
        'fix', 0, '11',
        'unfix', 0, '01',
        'Bitset', 256, ''.join(str(x) for x in [0] * 256),
        'flip', 0, ''.join(str(x) for x in [1] * 256),
        'unfix', 64, ''.join(str(x) for x in [1] * 64) + '0' + ''.join(str(x) for x in [1] * (256 - 65))
        ]

bs = None
for i in range(0, len(vectors), 3):
    action = vectors[i]
    value = vectors[i + 1]
    expected = vectors[i + 2]
    print(f'action = {action}, value = {value}, expected = {expected}')
    if action == 'Bitset':
        bs = Bitset(value)
        bs.toStringCalls = len(vectors)
        returned = bs.toString()
    elif action == 'fix':
        bs.fix(value)
        returned = bs.toString()
    elif action == 'unfix':
        bs.unfix(value)
        returned = bs.toString()
    elif action == 'flip':
        bs.flip()
        returned = bs.toString()
    elif action == 'one':
        returned = bs.one()
    elif action == 'all':
        returned = bs.all()
    elif action == 'count':
        returned = bs.count()
    elif action == 'toString':
        returned = bs.toString()
    assert returned == expected, f' returned {returned}!'