"""simple docstring"""







from __future__ import annotations

class 	UpperCamelCase    :



				def __init__(self       :   int			,						_A       :   str			,						_A       :   str)					->			Dict:
					__snake_case	,       __snake_case    :							Union[str, Any]   	=				text, pattern
					__snake_case	,       __snake_case    :							Tuple   	=				len(_A), len(_A)



				def       _lowercase  (self       :   Dict			,						_A       :   str)					->			int:

					for i in range(self.patLen - 1			,						-1			,						-1):
						if char == self.pattern[i]:
							return i
					return -1



				def       _lowercase  (self       :   Tuple			,						_A       :   int)					->			int:

					for i in range(self.patLen - 1			,						-1			,						-1):
						if self.pattern[i] != self.text[current_pos + i]:
							return current_pos + i
					return -1






				def       _lowercase  (self       :   Union[str, Any])					->			list[int]:
					# searches pattern in text and returns index positions
					__snake_case    :							Optional[int]   	=				[]
					for i in range(self.textLen - self.patLen + 1):
						__snake_case    :							Union[str, Any]   	=				self.mismatch_in_text(_A)
						if mismatch_index == -1:
							positions.append(_A)
						else:
							__snake_case    :							List[Any]   	=				self.match_in_pattern(self.text[mismatch_index])
							__snake_case    :							Optional[int]   	=				(
							    mismatch_index - match_index
							)  # shifting index lgtm [py/multiple-definition]
					return positions







_a  :  Dict=				"ABAABA"
_a  :  Union[str, Any]=				"AB"
_a  :  Tuple=				BoyerMooreSearch(text, pattern)
_a  :  Optional[Any]=				bms.bad_character_heuristic()

if len(positions) == 0:
	print("No match found")
else:
	print("Pattern found in following positions: ")
	print(positions)






"""simple docstring"""







from typing import Any

class 	UpperCamelCase    :



				def __init__(self       :   List[str]			,						_A       :   Any)					->			int:
					__snake_case    :							Any   	=				data
					__snake_case    :							Dict   	=				None






				def __repr__(self       :   Tuple)					->			str:
					return f"Node({self.data})"







class 	UpperCamelCase    :



				def __init__(self       :   Union[str, Any])					->			Union[str, Any]:
					__snake_case    :							Any   	=				None



				def __iter__(self       :   Tuple)					->			Any:
					__snake_case    :							List[str]   	=				self.head
					while node:
						yield node.data
						__snake_case    :							Any   	=				node.next



				def __len__(self       :   str)					->			int:
					return sum(1 for _ in self)



				def __repr__(self       :   int)					->			str:
					return "->".join([str(_A) for item in self])



				def __getitem__(self       :   List[Any]			,						_A       :   int)					->			Any:
					if not 0 <= index < len(self):
						raise ValueError('list index out of range.')
					for i, node in enumerate(self):
						if i == index:
							return node
					return None



				def __setitem__(self       :   int			,						_A       :   int			,						_A       :   Any)					->			None:
					if not 0 <= index < len(self):
						raise ValueError('list index out of range.')
					__snake_case    :							Optional[int]   	=				self.head
					for _ in range(_A):
						__snake_case    :							Any   	=				current.next
					__snake_case    :							Dict   	=				data



				def       _lowercase  (self       :   List[Any]			,						_A       :   Any)					->			None:
					self.insert_nth(len(self)			,						_A)



				def       _lowercase  (self       :   List[str]			,						_A       :   Any)					->			None:
					self.insert_nth(0			,						_A)



				def       _lowercase  (self       :   Optional[Any]			,						_A       :   int			,						_A       :   Any)					->			None:
					if not 0 <= index <= len(self):
						raise IndexError('list index out of range')
					__snake_case    :							str   	=				Node(_A)
					if self.head is None:
						__snake_case    :							str   	=				new_node
					elif index == 0:
						__snake_case    :							Union[str, Any]   	=				self.head  # link new_node to head
						__snake_case    :							int   	=				new_node
					else:
						__snake_case    :							Any   	=				self.head
						for _ in range(index - 1):
							__snake_case    :							Any   	=				temp.next
						__snake_case    :							Dict   	=				temp.next
						__snake_case    :							str   	=				new_node



				def       _lowercase  (self       :   Optional[int])					->			None:  # print every node data
					print(self)



				def       _lowercase  (self       :   Optional[Any])					->			Any:
					return self.delete_nth(0)



				def       _lowercase  (self       :   List[str])					->			Any:  # delete from tail
					return self.delete_nth(len(self) - 1)



				def       _lowercase  (self       :   int			,						_A       :   int = 0)					->			Any:
					if not 0 <= index <= len(self) - 1:  # test if index is valid
						raise IndexError('List index out of range.')
					__snake_case    :							int   	=				self.head  # default first node
					if index == 0:
						__snake_case    :							Any   	=				self.head.next
					else:
						__snake_case    :							List[Any]   	=				self.head
						for _ in range(index - 1):
							__snake_case    :							List[str]   	=				temp.next
						__snake_case    :							Union[str, Any]   	=				temp.next
						__snake_case    :							str   	=				temp.next.next
					return delete_node.data



				def       _lowercase  (self       :   str)					->			bool:
					return self.head is None






				def       _lowercase  (self       :   Tuple)					->			None:
					__snake_case    :							List[Any]   	=				None
					__snake_case    :							Optional[Any]   	=				self.head

					while current:
						# Store the current node's next node.
						__snake_case    :							List[str]   	=				current.next
						# Make the current node's next point backwards
						__snake_case    :							Optional[Any]   	=				prev
						# Make the previous node be the current node
						__snake_case    :							Optional[Any]   	=				current
						# Make the current node the next node (to progress iteration)
						__snake_case    :							Any   	=				next_node
					# Return prev in order to put the head at the end
					__snake_case    :							Optional[Any]   	=				prev







def 						__UpperCAmelCase       (					)							->    None:

	'''simple docstring'''





	__snake_case    :							Union[str, Any]   	=				LinkedList()
	assert linked_list.is_empty() is True
	assert str(UpperCAmelCase_						) == ""

	try:
		linked_list.delete_head()
		raise AssertionError  # This should not happen.
	except IndexError:
		assert True  # This should happen.

	try:
		linked_list.delete_tail()
		raise AssertionError  # This should not happen.
	except IndexError:
		assert True  # This should happen.

	for i in range(10						):
		assert len(UpperCAmelCase_						) == i
		linked_list.insert_nth(UpperCAmelCase_    ,							i + 1						)
	assert str(UpperCAmelCase_						) == "->".join(str(UpperCAmelCase_						) for i in range(1    ,							11						)						)

	linked_list.insert_head(0						)
	linked_list.insert_tail(11						)
	assert str(UpperCAmelCase_						) == "->".join(str(UpperCAmelCase_						) for i in range(0    ,							12						)						)

	assert linked_list.delete_head() == 0
	assert linked_list.delete_nth(9						) == 10
	assert linked_list.delete_tail() == 11
	assert len(UpperCAmelCase_						) == 9
	assert str(UpperCAmelCase_						) == "->".join(str(UpperCAmelCase_						) for i in range(1    ,							10						)						)

	assert all(linked_list[i] == i + 1 for i in range(0    ,							9						)						) is True

	for i in range(0    ,							9						):
		__snake_case    :							Tuple   	=				-i
	assert all(linked_list[i] == -i for i in range(0    ,							9						)						) is True

	linked_list.reverse()
	assert str(UpperCAmelCase_						) == "->".join(str(UpperCAmelCase_						) for i in range(-8    ,							1						)						)
def 						__UpperCAmelCase       (					)							->    None:

	'''simple docstring'''





	__snake_case    :							str   	=				[
	    -9,
	    1_00,
	    Node(77_34_51_12						),
	    'dlrow olleH',
	    7,
	    55_55,
	    0,
	    -192.55_555,
	    'Hello, world!',
	    77.9,
	    Node(10						),
	    None,
	    None,
	    12.20,
	]
	__snake_case    :							Optional[Any]   	=				LinkedList()

	for i in test_input:
		linked_list.insert_tail(UpperCAmelCase_						)

	# Check if it's empty or not
	assert linked_list.is_empty() is False
	assert (
	    str(UpperCAmelCase_						) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
	    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
	)

	# Delete the head
	__snake_case    :							int   	=				linked_list.delete_head()
	assert result == -9
	assert (
	    str(UpperCAmelCase_						) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
	    "Hello, world!->77.9->Node(10)->None->None->12.2"
	)

	# Delete the tail
	__snake_case    :							Any   	=				linked_list.delete_tail()
	assert result == 12.2
	assert (
	    str(UpperCAmelCase_						) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
	    "Hello, world!->77.9->Node(10)->None->None"
	)

	# Delete a node in specific location in linked list
	__snake_case    :							Tuple   	=				linked_list.delete_nth(10						)
	assert result is None
	assert (
	    str(UpperCAmelCase_						) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
	    "Hello, world!->77.9->Node(10)->None"
	)

	# Add a Node instance to its head
	linked_list.insert_head(Node('Hello again, world!'						)						)
	assert (
	    str(UpperCAmelCase_						)
	    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
	    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
	)

	# Add None to its tail
	linked_list.insert_tail(UpperCAmelCase_						)
	assert (
	    str(UpperCAmelCase_						)
	    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
	    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
	)

	# Reverse the linked list
	linked_list.reverse()
	assert (
	    str(UpperCAmelCase_						)
	    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
	    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
	)
def 						__UpperCAmelCase       (					)							->    List[Any]:

	'''simple docstring'''





	from doctest import testmod

	testmod()

	__snake_case    :							int   	=				LinkedList()
	linked_list.insert_head(input('Inserting 1st at head '						).strip()						)
	linked_list.insert_head(input('Inserting 2nd at head '						).strip()						)
	print('\nPrint list:'						)
	linked_list.print_list()
	linked_list.insert_tail(input('\nInserting 1st at tail '						).strip()						)
	linked_list.insert_tail(input('Inserting 2nd at tail '						).strip()						)
	print('\nPrint list:'						)
	linked_list.print_list()
	print('\nDelete head'						)
	linked_list.delete_head()
	print('Delete tail'						)
	linked_list.delete_tail()
	print('\nPrint list:'						)
	linked_list.print_list()
	print('\nReverse linked list'						)
	linked_list.reverse()
	print('\nPrint list:'						)
	linked_list.print_list()
	print('\nString representation of linked list:'						)
	print(UpperCAmelCase_						)
	print('\nReading/changing Node data using indexing:'						)
	print(F"Element at Position 1: {linked_list[1]}"						)
	__snake_case    :							Optional[Any]   	=				input('Enter New Value: '						).strip()
	print('New list:'						)
	print(UpperCAmelCase_						)
	print(F"length of linked_list is : {len(UpperCAmelCase_						)}"						)


if __name__ == "__main__":
	main()





