takes in an integer n and returns a nbit gray code sequence an nbit gray code sequence is a sequence of 2n integers where a every integer is between 0 2n 1 inclusive b the sequence begins with 0 c an integer appears at most one times in the sequence dthe binary representation of every pair of integers differ by exactly one bit e the binary representation of first and last bit also differ by exactly one bit graycode2 0 1 3 2 graycode1 0 1 graycode3 0 1 3 2 6 7 5 4 graycode1 traceback most recent call last valueerror the given input must be positive graycode10 6 traceback most recent call last typeerror unsupported operand types for int and float bit count represents no of bits in the gray code get the generated string sequence convert them to integers will output the nbit grey sequence as a string of bits graycodesequencestring2 00 01 11 10 graycodesequencestring1 0 1 the approach is a recursive one base case achieved when either n 0 or n1 1 n is equivalent to 2n recursive answer will generate answer for n1 bits append 0 to first half of the smaller sequence generated append 1 to second half start from the end of the list takes in an integer n and returns a n bit gray code sequence an n bit gray code sequence is a sequence of 2 n integers where a every integer is between 0 2 n 1 inclusive b the sequence begins with 0 c an integer appears at most one times in the sequence d the binary representation of every pair of integers differ by exactly one bit e the binary representation of first and last bit also differ by exactly one bit gray_code 2 0 1 3 2 gray_code 1 0 1 gray_code 3 0 1 3 2 6 7 5 4 gray_code 1 traceback most recent call last valueerror the given input must be positive gray_code 10 6 traceback most recent call last typeerror unsupported operand type s for int and float bit count represents no of bits in the gray code get the generated string sequence convert them to integers will output the n bit grey sequence as a string of bits gray_code_sequence_string 2 00 01 11 10 gray_code_sequence_string 1 0 1 the approach is a recursive one base case achieved when either n 0 or n 1 defines the length of the sequence 1 n is equivalent to 2 n recursive answer will generate answer for n 1 bits append 0 to first half of the smaller sequence generated append 1 to second half start from the end of the list
def gray_code(bit_count: int) -> list:
    

    
    if bit_count < 0:
        raise ValueError("The given input must be positive")

    
    sequence = gray_code_sequence_string(bit_count)
    
    
    for i in range(len(sequence)):
        sequence[i] = int(sequence[i], 2)

    return sequence


def gray_code_sequence_string(bit_count: int) -> list:
    

    
    
    if bit_count == 0:
        return ["0"]

    if bit_count == 1:
        return ["0", "1"]

    seq_len = 1 << bit_count  
    

    
    smaller_sequence = gray_code_sequence_string(bit_count - 1)

    sequence = []

    
    for i in range(seq_len // 2):
        generated_no = "0" + smaller_sequence[i]
        sequence.append(generated_no)

    
    for i in reversed(range(seq_len // 2)):
        generated_no = "1" + smaller_sequence[i]
        sequence.append(generated_no)

    return sequence


if __name__ == "__main__":
    import doctest

    doctest.testmod()