






def   UpperCamelCase  (       snake_case__     :   str  ):




     '''simple docstring'''






     if not all(x.isalpha() for x in string  ):
          raise ValueError("""String must only contain alphabetic characters."""  )

     __snake_case			:str          =						sorted(string.lower()  )
     return len(snake_case__  ) == len(set(snake_case__  )  )


if __name__ == "__main__":
     lowerCamelCase__							=     input("""Enter a string """).strip()

     lowerCamelCase__							=     is_isogram(input_str)
     print(f'''{input_str} is {'an' if isogram else 'not an'} isogram.''')










def   UpperCamelCase  (       snake_case__     :   str	,snake_case__     :   int  ):




     '''simple docstring'''






     __snake_case			:list[list[str]]          =						[[] for _ in range(snake_case__  )]
     __snake_case			:Union[str, Any]          =						key - 1

     if key <= 0:
          raise ValueError("""Height of grid can't be 0 or negative"""  )
     if key == 1 or len(snake_case__  ) <= key:
          return input_string

     for position, character in enumerate(snake_case__  ):
          __snake_case			:Any          =						position % (lowest * 2)  # puts it in bounds
          __snake_case			:Optional[int]          =						min(snake_case__	,lowest * 2 - num  )  # creates zigzag pattern
          temp_grid[num].append(snake_case__  )
     __snake_case			:List[Any]          =						["""""".join(snake_case__  ) for row in temp_grid]
     __snake_case			:Any          =						"""""".join(snake_case__  )

     return output_string






def   UpperCamelCase  (       snake_case__     :   str	,snake_case__     :   int  ):




     '''simple docstring'''






     __snake_case			:Union[str, Any]          =						[]
     __snake_case			:Optional[int]          =						key - 1

     if key <= 0:
          raise ValueError("""Height of grid can't be 0 or negative"""  )
     if key == 1:
          return input_string

     __snake_case			:list[list[str]]          =						[[] for _ in range(snake_case__  )]  # generates template
     for position in range(len(snake_case__  )  ):
          __snake_case			:List[str]          =						position % (lowest * 2)  # puts it in bounds
          __snake_case			:int          =						min(snake_case__	,lowest * 2 - num  )  # creates zigzag pattern
          temp_grid[num].append("""*"""  )

     __snake_case			:str          =						0
     for row in temp_grid:  # fills in the characters
          __snake_case			:str          =						input_string[counter : counter + len(snake_case__  )]
          grid.append(list(snake_case__  )  )
          counter += len(snake_case__  )

     __snake_case			:Any          =						""""""  # reads as zigzag
     for position in range(len(snake_case__  )  ):
          __snake_case			:Optional[int]          =						position % (lowest * 2)  # puts it in bounds
          __snake_case			:int          =						min(snake_case__	,lowest * 2 - num  )  # creates zigzag pattern
          output_string += grid[num][0]
          grid[num].pop(0  )
     return output_string






def   UpperCamelCase  (       snake_case__     :   str  ):




     '''simple docstring'''






     __snake_case			:Optional[Any]          =						{}
     for key_guess in range(1	,len(snake_case__  )  ):  # tries every key
          __snake_case			:Dict          =						decrypt(snake_case__	,snake_case__  )
     return results


if __name__ == "__main__":
     import doctest

     doctest.testmod()


