






'''simple docstring'''

from __future__ import annotations
def     __lowercase  (_lowercase,						_lowercase     )   ->     list[list[int]]:


     """simple docstring"""
     __lowerCamelCase						:       list[list[int]]				   =				[]
     create_all_state(1,						_lowercase,						_lowercase,						[],						_lowercase     )
     return result
def     __lowercase  (_lowercase,						_lowercase,						_lowercase,						_lowercase,						_lowercase,						)   ->     None:


     """simple docstring"""
     if level == 0:
          total_list.append(current_list[:]     )
          return

     for i in range(_lowercase,						total_number - level + 2     ):
          current_list.append(_lowercase     )
          create_all_state(i + 1,						_lowercase,						level - 1,						_lowercase,						_lowercase     )
          current_list.pop()
def     __lowercase  (_lowercase     )   ->     None:


     """simple docstring"""
     for i in total_list:
          print(*_lowercase     )


if __name__ == "__main__":
   UpperCAmelCase__						:Optional[int]          =			4
   UpperCAmelCase__						:Union[str, Any]          =			2
   UpperCAmelCase__						:Union[str, Any]          =			generate_all_combinations(n, k)
   print_all_state(total_list)











'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive"""     )

     # get the generated string sequence
     __lowerCamelCase						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

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

     __lowerCamelCase						:       str				   =				1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     __lowerCamelCase						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2     )     ):
          __lowerCamelCase						:       Optional[Any]				   =				"""1""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



