


'''simple docstring'''






from typing import Any






class  __magic_name__							:






       def __init__(      self  ,							snake_case)						->  Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Dict							   =data
          _UpperCAmelCase       :       str							   =None






       def __repr__(      self)						->  str:




          '''simple docstring'''
          return f"Node({self.data})"






class  __magic_name__							:






       def __init__(      self)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =None






       def __iter__(      self)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =self.head
          while node:
             yield node.data
             _UpperCAmelCase       :       List[Any]							   =node.next






       def __len__(      self)						->  int:




          '''simple docstring'''
          return sum(1 for _ in self)






       def __repr__(      self)						->  str:




          '''simple docstring'''
          return "->".join([str(SCREAMING_SNAKE_CASE_) for item in self])






       def __getitem__(      self  ,							snake_case)						->  Any:




          '''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  ,							snake_case  ,							snake_case)						->  None:




          '''simple docstring'''
          if not 0 <= index < len(self):
             raise ValueError('list index out of range.')
          _UpperCAmelCase       :       List[str]							   =self.head
          for _ in range(SCREAMING_SNAKE_CASE_):
             _UpperCAmelCase       :       Union[str, Any]							   =current.next
          _UpperCAmelCase       :       Dict							   =data






       def       lowerCAmelCase		(      self  ,							snake_case)						->  None:




          '''simple docstring'''
          self.insert_nth(len(self)  ,							SCREAMING_SNAKE_CASE_)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  None:




          '''simple docstring'''
          self.insert_nth(0  ,							SCREAMING_SNAKE_CASE_)






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  None:




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






       def       lowerCAmelCase		(      self)						->  None:  # print every node data




          '''simple docstring'''
          print(self)






       def       lowerCAmelCase		(      self)						->  Any:




          '''simple docstring'''
          return self.delete_nth(0)






       def       lowerCAmelCase		(      self)						->  Any:  # delete from tail




          '''simple docstring'''
          return self.delete_nth(len(self) - 1)






       def       lowerCAmelCase		(      self  ,							snake_case = 0)						->  Any:




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






       def       lowerCAmelCase		(      self)						->  bool:




          '''simple docstring'''
          return self.head is None






       def       lowerCAmelCase		(      self)						->  None:




          '''simple docstring'''
          _UpperCAmelCase       :       int							   =None
          _UpperCAmelCase       :       Optional[Any]							   =self.head

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






def lowerCamelCase__      (						):







   '''simple docstring'''




   _UpperCAmelCase       :       Union[str, Any]							   =LinkedList()
   assert linked_list.is_empty() is True
   assert str(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(1_0							):
      assert len(snake_case__							) == i
      linked_list.insert_nth(snake_case__	,   i + 1							)
   assert str(snake_case__							) == "->".join(str(snake_case__							) for i in range(1	,   1_1							)							)

   linked_list.insert_head(0							)
   linked_list.insert_tail(1_1							)
   assert str(snake_case__							) == "->".join(str(snake_case__							) for i in range(0	,   1_2							)							)

   assert linked_list.delete_head() == 0
   assert linked_list.delete_nth(9							) == 1_0
   assert linked_list.delete_tail() == 1_1
   assert len(snake_case__							) == 9
   assert str(snake_case__							) == "->".join(str(snake_case__							) for i in range(1	,   1_0							)							)

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

   for i in range(0	,   9							):
      _UpperCAmelCase       :       Union[str, Any]							   =-i
   assert all(linked_list[i] == -i for i in range(0	,   9							)							) is True

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





def lowerCamelCase__      (						):







   '''simple docstring'''




   _UpperCAmelCase       :       Optional[Any]							   =[
       -9,
       1_0_0,
       Node(7_7_3_4_5_1_1_2							),
       'dlrow olleH',
       7,
       5_5_5_5,
       0,
       -1_92.5_55_55,
       'Hello, world!',
       77.9,
       Node(1_0							),
       None,
       None,
       12.20,
   ]
   _UpperCAmelCase       :       Any							   =LinkedList()

   for i in test_input:
      linked_list.insert_tail(snake_case__							)

   # Check if it's empty or not
   assert linked_list.is_empty() is False
   assert (
       str(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
   _UpperCAmelCase       :       Dict							   =linked_list.delete_head()
   assert result == -9
   assert (
       str(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
   _UpperCAmelCase       :       Any							   =linked_list.delete_tail()
   assert result == 12.2
   assert (
       str(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
   _UpperCAmelCase       :       Tuple							   =linked_list.delete_nth(1_0							)
   assert result is None
   assert (
       str(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(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(snake_case__							)
   assert (
       str(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(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__      (						):







   '''simple docstring'''




   from doctest import testmod

   testmod()

   _UpperCAmelCase       :       Union[str, Any]							   =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(snake_case__							)
   print('\nReading/changing Node data using indexing:'							)
   print(f"Element at Position 1: {linked_list[1]}"							)
   _UpperCAmelCase       :       int							   =input('Enter New Value: '							).strip()
   print('New list:'							)
   print(snake_case__							)
   print(f"length of linked_list is : {len(snake_case__							)}"							)


if __name__ == "__main__":
 main()









'''simple docstring'''






from __future__ import annotations





def lowerCamelCase__      (						__lowerCamelCase	:							list[int]							):







   '''simple docstring'''




   if not nums:
      return 0
   _UpperCAmelCase       :       Tuple							   =nums[0]
   _UpperCAmelCase       :       int							   =0
   for num in nums[1:]:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       Optional[int]							   =(
          max_excluding + num,
          max(__lowerCamelCase	,   __lowerCamelCase							),
      )
   return max(__lowerCamelCase	,   __lowerCamelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

