


'''simple docstring'''



from typing import Any





class 							__UpperCamelCase    :




	def __init__(       self						,    __a							):

						'''simple docstring'''





						__a      :	int    =  data
						__a      :	Tuple    =  None





	def __repr__(       self							):

						'''simple docstring'''





						return f"""Node({self.data})"""





class 							__UpperCamelCase    :




	def __init__(       self							):

						'''simple docstring'''





						__a      :	str    =  None




	def __iter__(       self							):

						'''simple docstring'''





						__a      :	List[str]    =  self.head
						while node:
											yield node.data
											__a      :	Any    =  node.next




	def __len__(       self							):

						'''simple docstring'''





						return sum(1 for _ in self							)




	def __repr__(       self							):

						'''simple docstring'''





						return "->".join([str(__a							) for item in self]							)




	def __getitem__(       self						,    __a							):

						'''simple docstring'''





						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						,    __a						,    __a							):

						'''simple docstring'''





						if not 0 <= index < len(self							):
											raise ValueError('list index out of range.'							)
						__a      :	Dict    =  self.head
						for _ in range(__a							):
											__a      :	Any    =  current.next
						__a      :	int    =  data




	def 				__UpperCAmelCase							(       self						,    __a							):

						'''simple docstring'''





						self.insert_nth(len(self							)						,    __a							)




	def 				__UpperCAmelCase							(       self						,    __a							):

						'''simple docstring'''





						self.insert_nth(0						,    __a							)




	def 				__UpperCAmelCase							(       self						,    __a						,    __a							):

						'''simple docstring'''





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




	def 				__UpperCAmelCase							(       self							):  # print every node data

						'''simple docstring'''





						print(self							)




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						return self.delete_nth(0							)




	def 				__UpperCAmelCase							(       self							):  # delete from tail

						'''simple docstring'''





						return self.delete_nth(len(self							) - 1							)




	def 				__UpperCAmelCase							(       self						,    __a = 0							):

						'''simple docstring'''





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




	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						return self.head is None





	def 				__UpperCAmelCase							(       self							):

						'''simple docstring'''





						__a      :	Union[str, Any]    =  None
						__a      :	Any    =  self.head

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






def   lowerCamelCase							():
					__a      :	Tuple    =  LinkedList()
					assert linked_list.is_empty() is True
					assert str(_SCREAMING_SNAKE_CASE       ) == ""

					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(_SCREAMING_SNAKE_CASE       ) == i
										linked_list.insert_nth(_SCREAMING_SNAKE_CASE						,				i + 1       )
					assert str(_SCREAMING_SNAKE_CASE       ) == "->".join(str(_SCREAMING_SNAKE_CASE       ) for i in range(1						,				11       )       )

					linked_list.insert_head(0       )
					linked_list.insert_tail(11       )
					assert str(_SCREAMING_SNAKE_CASE       ) == "->".join(str(_SCREAMING_SNAKE_CASE       ) 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(_SCREAMING_SNAKE_CASE       ) == 9
					assert str(_SCREAMING_SNAKE_CASE       ) == "->".join(str(_SCREAMING_SNAKE_CASE       ) 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       ):
										__a      :	Optional[int]    =  -i
					assert all(linked_list[i] == -i for i in range(0						,				9       )       ) is True

					linked_list.reverse()
					assert str(_SCREAMING_SNAKE_CASE       ) == "->".join(str(_SCREAMING_SNAKE_CASE       ) for i in range(-8						,				1       )       )






def   lowerCamelCase							():
					__a      :	Union[str, Any]    =  [
					    -9,
					    100,
					    Node(77_345_112       ),
					    'dlrow olleH',
					    7,
					    5_555,
					    0,
					    -1_9_2.5_5_5_5_5,
					    'Hello, world!',
					    7_7.9,
					    Node(10       ),
					    None,
					    None,
					    1_2.2_0,
					]
					__a      :	Dict    =  LinkedList()

					for i in test_input:
										linked_list.insert_tail(_SCREAMING_SNAKE_CASE       )

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

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

					# Delete the tail
					__a      :	Any    =  linked_list.delete_tail()
					assert result == 1_2.2
					assert (
					    str(_SCREAMING_SNAKE_CASE       ) == "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
					__a      :	int    =  linked_list.delete_nth(10       )
					assert result is None
					assert (
					    str(_SCREAMING_SNAKE_CASE       ) == "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(_SCREAMING_SNAKE_CASE       )
					    == "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(_SCREAMING_SNAKE_CASE       )
					assert (
					    str(_SCREAMING_SNAKE_CASE       )
					    == "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(_SCREAMING_SNAKE_CASE       )
					    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
					    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
					)






def   lowerCamelCase							():
					from doctest import testmod

					testmod()

					__a      :	Dict    =  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(_SCREAMING_SNAKE_CASE       )
					print('\nReading/changing Node data using indexing:'       )
					print(F"""Element at Position 1: {linked_list[1]}"""       )
					__a      :	Optional[Any]    =  input('Enter New Value: '       ).strip()
					print('New list:'       )
					print(_SCREAMING_SNAKE_CASE       )
					print(F"""length of linked_list is : {len(_SCREAMING_SNAKE_CASE       )}"""       )


if __name__ == "__main__":
	main()







'''simple docstring'''



def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       int       ):
					return number & 1 == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()



