





"""simple docstring"""






from random import shuffle

import tensorflow as tf
from numpy import array






def 	snake_case_  (				A_ :		Tuple,    A_ :		Tuple						):


       '''simple docstring'''





       _lowerCamelCase						:    Any         =			int(__a						)
       assert noofclusters < len(__a						)

       # Find out the dimensionality
       _lowerCamelCase						:    Optional[Any]         =			len(vectors[0]						)

       # Will help select random centroids from among the available vectors
       _lowerCamelCase						:    int         =			list(range(len(__a						)						)						)
       shuffle(__a						)

       # GRAPH OF COMPUTATION
       # We initialize a new graph and set it as the default during each run
       # of this algorithm. This ensures that as this function is called
       # multiple times, the default graph doesn't keep getting crowded with
       # unused ops and Variables from previous function calls.

       _lowerCamelCase						:    str         =			tf.Graph()

       with graph.as_default():
              # SESSION OF COMPUTATION

              _lowerCamelCase						:    Optional[Any]         =			tf.Session()

              ##CONSTRUCTING THE ELEMENTS OF COMPUTATION

              ##First lets ensure we have a Variable vector for each centroid,
              ##initialized to one of the vectors from the available data points
              _lowerCamelCase						:    int         =			[
                  tf.Variable(vectors[vector_indices[i]]						) for i in range(__a						)
              ]
              ##These nodes will assign the centroid Variables the appropriate
              ##values
              _lowerCamelCase						:    List[str]         =			tf.placeholder('''float64''',    [dim]						)
              _lowerCamelCase						:    Tuple         =			[]
              for centroid in centroids:
                     cent_assigns.append(tf.assign(__a,    __a						)						)

              ##Variables for cluster assignments of individual vectors(initialized
              ##to 0 at first)
              _lowerCamelCase						:    Dict         =			[tf.Variable(0						) for i in range(len(__a						)						)]
              ##These nodes will assign an assignment Variable the appropriate
              ##value
              _lowerCamelCase						:    Union[str, Any]         =			tf.placeholder('''int32'''						)
              _lowerCamelCase						:    List[str]         =			[]
              for assignment in assignments:
                     cluster_assigns.append(tf.assign(__a,    __a						)						)

              ##Now lets construct the node that will compute the mean
              # The placeholder for the input
              _lowerCamelCase						:    Union[str, Any]         =			tf.placeholder('''float''',    [None, dim]						)
              # The Node/op takes the input and computes a mean along the 0th
              # dimension, i.e. the list of input vectors
              _lowerCamelCase						:    str         =			tf.reduce_mean(__a,    0						)

              ##Node for computing Euclidean distances
              # Placeholders for input
              _lowerCamelCase						:    Dict         =			tf.placeholder('''float''',    [dim]						)
              _lowerCamelCase						:    List[Any]         =			tf.placeholder('''float''',    [dim]						)
              _lowerCamelCase						:    List[Any]         =			tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(__a,    __a						),    2						)						)						)

              ##This node will figure out which cluster to assign a vector to,
              ##based on Euclidean distances of the vector from the centroids.
              # Placeholder for input
              _lowerCamelCase						:    Union[str, Any]         =			tf.placeholder('''float''',    [noofclusters]						)
              _lowerCamelCase						:    Optional[Any]         =			tf.argmin(__a,    0						)

              ##INITIALIZING STATE VARIABLES

              ##This will help initialization of all Variables defined with respect
              ##to the graph. The Variable-initializer should be defined after
              ##all the Variables have been constructed, so that each of them
              ##will be included in the initialization.
              _lowerCamelCase						:    Tuple         =			tf.initialize_all_variables()

              # Initialize all variables
              sess.run(__a						)

              ##CLUSTERING ITERATIONS

              # Now perform the Expectation-Maximization steps of K-Means clustering
              # iterations. To keep things simple, we will only do a set number of
              # iterations, instead of using a Stopping Criterion.
              _lowerCamelCase						:    Optional[Any]         =			1_00
              for _ in range(__a						):
                     ##EXPECTATION STEP
                     ##Based on the centroid locations till last iteration, compute
                     ##the _expected_ centroid assignments.
                     # Iterate over each vector
                     for vector_n in range(len(__a						)						):
                            _lowerCamelCase						:    Optional[int]         =			vectors[vector_n]
                            # Compute Euclidean distance between this vector and each
                            # centroid. Remember that this list cannot be named
                            #'centroid_distances', since that is the input to the
                            # cluster assignment node.
                            _lowerCamelCase						:    Dict         =			[
                                sess.run(__a,    feed_dict={va: vect, va: sess.run(__a						)}						)
                                for centroid in centroids
                            ]
                            # Now use the cluster assignment node, with the distances
                            # as the input
                            _lowerCamelCase						:    Optional[Any]         =			sess.run(
                                __a,    feed_dict={centroid_distances: distances}						)
                            # Now assign the value to the appropriate state variable
                            sess.run(
                                cluster_assigns[vector_n],    feed_dict={assignment_value: assignment}						)

                     ##MAXIMIZATION STEP
                     # Based on the expected state computed from the Expectation Step,
                     # compute the locations of the centroids so as to maximize the
                     # overall objective of minimizing within-cluster Sum-of-Squares
                     for cluster_n in range(__a						):
                            # Collect all the vectors assigned to this cluster
                            _lowerCamelCase						:    str         =			[
                                vectors[i]
                                for i in range(len(__a						)						)
                                if sess.run(assignments[i]						) == cluster_n
                            ]
                            # Compute new centroid location
                            _lowerCamelCase						:    Dict         =			sess.run(
                                __a,    feed_dict={mean_input: array(__a						)}						)
                            # Assign value to appropriate variable
                            sess.run(
                                cent_assigns[cluster_n],    feed_dict={centroid_value: new_location}						)

        # Return centroids and assignments
              _lowerCamelCase						:    str         =			sess.run(__a						)
              _lowerCamelCase						:    Any         =			sess.run(__a						)
              return centroids, assignments







"""simple docstring"""






def 	snake_case_  (				A_ :		int						):


       '''simple docstring'''





       return 1 if digit in (0, 1) else (digit * factorial(digit - 1						))






def 	snake_case_  (				A_ :		int						):


       '''simple docstring'''





       _lowerCamelCase						:    str         =			0
       _lowerCamelCase						:    Any         =			number
       while duplicate > 0:
              _lowerCamelCase      ,   _lowerCamelCase						:    Union[str, Any]         =			divmod(A_,    10						)
              fact_sum += factorial(A_						)
       return fact_sum == number


if __name__ == "__main__":
   print('''Program to check whether a number is a Krisnamurthy Number or not.''')
   lowerCAmelCase__      =    int(input('''Enter number: ''').strip())
   print(
       F"""{number} is {"" if krishnamurthy(number) else "not "}a Krishnamurthy Number."""
   )


