



'''simple docstring'''





def 						__snake_case(				_lowerCAmelCase		)		-> list:

      # 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
      snake_case__  :    Tuple    						=      gray_code_sequence_string(_lowerCAmelCase		)
      #
      # convert them to integers
      for i in range(len(_lowerCAmelCase		)		):
            snake_case__  :    Union[str, Any]    						=      int(sequence[i]     ,   2		)

      return sequence





def 						__snake_case(				_lowerCAmelCase		)		-> list:

      # 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"]

      snake_case__  :    Union[str, Any]    						=      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
      snake_case__  :    List[Any]    						=      gray_code_sequence_string(bit_count - 1		)

      snake_case__  :    int    						=      []

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

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

      return sequence


if __name__ == "__main__":
       import doctest

       doctest.testmod()






import math

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> float:
       if (
           not isinstance(_SCREAMING_SNAKE_CASE ,(int, float)    )
           or power_factor < -1
           or power_factor > 1
       ):
              raise ValueError("power_factor must be a valid float value between -1 and 1."    )
       return apparent_power * power_factor

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> float:
       if (
           not isinstance(_SCREAMING_SNAKE_CASE ,(int, float)    )
           or power_factor < -1
           or power_factor > 1
       ):
              raise ValueError("power_factor must be a valid float value between -1 and 1."    )
       return apparent_power * math.sqrt(1 - power_factor**2    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()






