class HotelCodeBoard():   
    def __init__(self, n, rnum):
        # number of switches on the board
        self.n = n
        # number of rooms in the hotel
        self.rnum = rnum
        # number of bits required to represent the room from range
        self.rbits = math.ceil( math.log(self.rnum, 2) )
        # number of switchers required to encode the room
        self.nswitchers = 2**self.rbits - 1
        # number of states for meaningful switchers
        self.nstates = 2**self.nswitchers
        
    def get_room_list(self):
        """
        Returns a list of room numbers
        """
        return list( range(self.rnum) )          

    
    def get_states_list(self):
        """
        Returns a list of states of meaningful switchers
        """
        states = []
        for i in range( self.nstates, 2*self.nstates ):
            states.append( list(bin(i)[3:])  )
        return states
    
    def get_state_value(self, state):
        """
        (list) -> int
        Returns state value for a give state of switchers
        """
        return self.get_states_list().index(state)
    
    def get_state(self, state_value):
        """
        (int) -> list
        Returns state for a given state_value
        """
        return self.get_states_list()[state_value]
    
    def encode_room(self, room_number, state_value):
        """
        (int, int) -> int
        Returns encoded room number
        """        
        # Check the validity of room number    
        if room_number not in self.get_room_list():
            print("This room is not in the hotel,")
            print("and will not be encoded.")
            return
        
        # Check the validity of state_value
        n_states = self.nstates
        if state_value not in range( n_states ):
            print("The state you requested is not available")
            print("and will not be used for encoding")
            return
        
        # get state as combination of switches
        state = self.get_state(state_value)      
        
        # room number encoding       
        switch_position = room_number        
        
        for i in range( len(state) ):
            if state[i] == '1':
                switch_position = switch_position^(i+1)        

        switch_position = switch_position - 1 
        
        # if switch_position = -1 do not change anything       
        if switch_position < 0:
            new_state_value = state_value
            return new_state_value, state                
         
        # switching at switch_position    
          
        if state[switch_position] == '0':
            state[switch_position] = '1'
        else:
            state[switch_position] = '0'
            
        new_state_value = self.get_state_value(state)
        return new_state_value, state
    
    def decode_room(self, state_value):
        
        state = self.get_state(state_value)
        
        switch_position = 0
        
        for i in range( len(state) ):
            if state[i] == '1':
                switch_position = switch_position^(i+1)
        
        room_number = switch_position
        return room_number 
    
    def get_decode_table(self):
        key_table = []
        for i in range( self.nstates):
            key_row = []
            for j in range( self.rnum):
                val = self.encode_room(j, i)[0]
                key_row.append(val)
            key_table.append(key_row)            
        return key_table 

-------------------------
Rooms:       [0, 1, 2, 3]
-------------------------
State:  0 :  [0, 4, 2, 1]
State:  1 :  [0, 3, 5, 1]
State:  2 :  [0, 3, 2, 6]
State:  3 :  [7, 3, 2, 1]
State:  4 :  [0, 4, 5, 6]
State:  5 :  [7, 4, 5, 1]
State:  6 :  [7, 4, 2, 6]
State:  7 :  [7, 3, 5, 6]