'''simple docstring'''

import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)





class 							lowercase						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	List[str])      ->					None:
         lowercase_     =      Vector([1, 2, 3])
         self.assertEqual(x.component(0)   ,		1)
         self.assertEqual(x.component(2)   ,		3)
         lowercase_     =      Vector()


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					None:
         lowercase_     =      Vector([0, 0, 0, 0, 0, 1])
         self.assertEqual(str(_lowerCamelCase)   ,		"(0,0,0,0,0,1)")


   def __UpperCAmelCase       (   self				:	str)      ->					None:
         lowercase_     =      Vector([1, 2, 3, 4])
         self.assertEqual(len(_lowerCamelCase)   ,		4)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					None:
         lowercase_     =      Vector([1, 2])
         lowercase_     =      Vector([1, 2, 3, 4, 5])
         lowercase_     =      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
         lowercase_     =      Vector([1, -1, 1, -1, 2, -3, 4, -5])
         self.assertAlmostEqual(x.euclidean_length()   ,		2.236   ,		3)
         self.assertAlmostEqual(y.euclidean_length()   ,		7.416   ,		3)
         self.assertEqual(z.euclidean_length()   ,		0)
         self.assertAlmostEqual(w.euclidean_length()   ,		7.616   ,		3)


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					None:
         lowercase_     =      Vector([1, 2, 3])
         lowercase_     =      Vector([1, 1, 1])
         self.assertEqual((x + y).component(0)   ,		2)
         self.assertEqual((x + y).component(1)   ,		3)
         self.assertEqual((x + y).component(2)   ,		4)


   def __UpperCAmelCase       (   self				:	Dict)      ->					None:
         lowercase_     =      Vector([1, 2, 3])
         lowercase_     =      Vector([1, 1, 1])
         self.assertEqual((x - y).component(0)   ,		0)
         self.assertEqual((x - y).component(1)   ,		1)
         self.assertEqual((x - y).component(2)   ,		2)


   def __UpperCAmelCase       (   self				:	Any)      ->					None:
         lowercase_     =      Vector([1, 2, 3])
         lowercase_     =      Vector([2, -1, 4])  # for test of dot product
         lowercase_     =      Vector([1, -2, -1])
         self.assertEqual(str(x * 3.0)   ,		"(3.0,6.0,9.0)")
         self.assertEqual((a * b)   ,		0)


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					None:
         self.assertEqual(str(zero_vector(10)).count("0")   ,		10)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					None:
         self.assertEqual(str(unit_basis_vector(3   ,		1))   ,		"(0,1,0)")


   def __UpperCAmelCase       (   self				:	Any)      ->					None:
         lowercase_     =      Vector([1, 2, 3])
         lowercase_     =      Vector([1, 0, 1])
         self.assertEqual(str(axpy(2   ,		_lowerCamelCase   ,		_lowerCamelCase))   ,		"(3,4,7)")


   def __UpperCAmelCase       (   self				:	Dict)      ->					None:
         lowercase_     =      Vector([1, 0, 0, 0, 0, 0])
         lowercase_     =      x.copy()
         self.assertEqual(str(_lowerCamelCase)   ,		str(_lowerCamelCase))


   def __UpperCAmelCase       (   self				:	List[str])      ->					None:
         lowercase_     =      Vector([1, 0, 0])
         x.change_component(0   ,		0)
         x.change_component(1   ,		1)
         self.assertEqual(str(_lowerCamelCase)   ,		"(0,1,0)")


   def __UpperCAmelCase       (   self				:	List[str])      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"   ,		str(_lowerCamelCase))


   def __UpperCAmelCase       (   self				:	Tuple)      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         lowercase_     =      [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
         for x in range(a.height()):
               for y in range(a.width()):
                     self.assertEqual(minors[x][y]   ,		a.minor(_lowerCamelCase   ,		_lowerCamelCase))


   def __UpperCAmelCase       (   self				:	int)      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         lowercase_     =      [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
         for x in range(a.height()):
               for y in range(a.width()):
                     self.assertEqual(cofactors[x][y]   ,		a.cofactor(_lowerCamelCase   ,		_lowerCamelCase))


   def __UpperCAmelCase       (   self				:	List[str])      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         self.assertEqual(-5   ,		a.determinant())


   def __UpperCAmelCase       (   self				:	Any)      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]   ,		3   ,		3)
         lowercase_     =      Vector([1, 2, 3])
         self.assertEqual("(14,32,50)"   ,		str(a * x))
         self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"   ,		str(a * 2))


   def __UpperCAmelCase       (   self				:	Dict)      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         a.change_component(0   ,		2   ,		5)
         self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"   ,		str(_lowerCamelCase))


   def __UpperCAmelCase       (   self				:	List[str])      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         self.assertEqual(7   ,		a.component(2   ,		1)   ,		0.01)


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         lowercase_     =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]   ,		3   ,		3)
         self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"   ,		str(a + b))


   def __UpperCAmelCase       (   self				:	List[Any])      ->					None:
         lowercase_     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,		3   ,		3)
         lowercase_     =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]   ,		3   ,		3)
         self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"   ,		str(a - b))


   def __UpperCAmelCase       (   self				:	List[Any])      ->					None:
         self.assertEqual(
             "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"   ,		str(square_zero_matrix(5))   ,		)


if __name__ == "__main__":
       unittest.main()







'''simple docstring'''

import functools
from typing import Any


def __a (	__lowerCamelCase			:						str ,		__lowerCamelCase			:						list[str]				)	->							bool:
      '''simple docstring'''


      if not isinstance(__lowerCamelCase ,		__lowerCamelCase				) or len(__lowerCamelCase				) == 0:
            raise ValueError("the string should be not empty string"				)

      if not isinstance(__lowerCamelCase ,		__lowerCamelCase				) or not all(
          isinstance(__lowerCamelCase ,		__lowerCamelCase				) and len(__lowerCamelCase				) > 0 for item in words				):
            raise ValueError("the words should be a list of non-empty strings"				)

      # Build trie
      lowercase_     =      {}
      lowercase_     =      "WORD_KEEPER"

      for word in words:
            lowercase_     =      trie
            for c in word:
                  if c not in trie_node:
                        lowercase_     =      {}

                  lowercase_     =      trie_node[c]

            lowercase_     =      True

      lowercase_     =      len(__lowerCamelCase				)

      # Dynamic programming method
      @functools.cache
      def is_breakable(__lowerCamelCase			:						int				) -> bool:
            if index == len_string:
                  return True

            lowercase_     =      trie
            for i in range(__lowerCamelCase ,		__lowerCamelCase				):
                  lowercase_     =      trie_node.get(string[i] ,		__lowerCamelCase				)

                  if trie_node is None:
                        return False

                  if trie_node.get(__lowerCamelCase ,		__lowerCamelCase				) and is_breakable(i + 1				):
                        return True

            return False

      return is_breakable(0				)


if __name__ == "__main__":
       import doctest

       doctest.testmod()






