



'''simple docstring'''





from typing import Any






class __A    :



 '''simple docstring'''







 def __init__(self				,     A )					->  int:


      """simple docstring"""



      _a											=						data
      _a											=						None



 def __repr__(self )					->  Optional[int]:


      """simple docstring"""



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






class __A    :



 '''simple docstring'''







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


      """simple docstring"""



      _a											=						None



 def __iter__(self )					->  Optional[Any]:


      """simple docstring"""



      _a											=						self.head
      while node:
           yield node.data
           _a											=						node.next



 def __len__(self )					->  int:


      """simple docstring"""



      return sum(1 for _ in self )



 def __repr__(self )					->  Optional[Any]:


      """simple docstring"""



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



 def __getitem__(self				,     A )					->  List[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				,     A				,     A )					->  Optional[Any]:


      """simple docstring"""



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



 def       a__						(self				,     A )					->  Dict:


      """simple docstring"""



      self.insert_nth(len(self )				,     __A )



 def       a__						(self				,     A )					->  List[str]:


      """simple docstring"""



      self.insert_nth(0				,     __A )



 def       a__						(self				,     A				,     A )					->  Optional[Any]:


      """simple docstring"""



      if not 0 <= index <= len(self ):
           raise IndexError('''list index out of range''' )
      _a											=						Node(__A )
      if self.head is None:
           _a											=						new_node
      elif index == 0:
           _a											=						self.head  # link new_node to head
           _a											=						new_node
      else:
           _a											=						self.head
           for _ in range(index - 1 ):
                _a											=						temp.next
           _a											=						temp.next
           _a											=						new_node



 def       a__						(self )					->  Optional[Any]:  # print every node data


      """simple docstring"""



      print(self )



 def       a__						(self )					->  Optional[int]:


      """simple docstring"""



      return self.delete_nth(0 )



 def       a__						(self )					->  Tuple:  # delete from tail


      """simple docstring"""



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



 def       a__						(self				,     A = 0 )					->  Tuple:


      """simple docstring"""



      if not 0 <= index <= len(self ) - 1:  # test if index is valid
           raise IndexError('''List index out of range.''' )
      _a											=						self.head  # default first node
      if index == 0:
           _a											=						self.head.next
      else:
           _a											=						self.head
           for _ in range(index - 1 ):
                _a											=						temp.next
           _a											=						temp.next
           _a											=						temp.next.next
      return delete_node.data



 def       a__						(self )					->  List[str]:


      """simple docstring"""



      return self.head is None



 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						None
      _a											=						self.head

      while current:
           # Store the current node's next node.
           _a											=						current.next
           # Make the current node's next point backwards
           _a											=						prev
           # Make the previous node be the current node
           _a											=						current
           # Make the current node the next node (to progress iteration)
           _a											=						next_node
      # Return prev in order to put the head at the end
      _a											=						prev





def lowerCAmelCase						():



     """simple docstring"""



     _a											=						LinkedList()
     assert linked_list.is_empty() is True
     assert str(_lowerCAmelCase) == ""

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

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

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




def lowerCAmelCase						():



     """simple docstring"""



     _a											=						[
         -9,
         100,
         Node(77_345_112),
         "dlrow olleH",
         7,
         5_555,
         0,
         -192.55_555,
         "Hello, world!",
         77.9,
         Node(10),
         None,
         None,
         12.20,
     ]
     _a											=						LinkedList()

     for i in test_input:
          linked_list.insert_tail(_lowerCAmelCase)

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

     # Delete the tail
     _a											=						linked_list.delete_tail()
     assert result == 12.2
     assert (
         str(_lowerCAmelCase) == "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											=						linked_list.delete_nth(10)
     assert result is None
     assert (
         str(_lowerCAmelCase) == "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(_lowerCAmelCase)
         == "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(_lowerCAmelCase)
     assert (
         str(_lowerCAmelCase)
         == "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(_lowerCAmelCase)
         == "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()

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


if __name__ == "__main__":
  main()








'''simple docstring'''





import numpy as np
import qiskit




def lowerCAmelCase						(__A = 8						,			__A = None):



     """simple docstring"""



     _a											=						np.random.default_rng(seed=__A)

     # Roughly 25% of the qubits will contribute to the key.
     # So we take more than we need.
     _a											=						6 * key_len
     # Measurement basis for Alice's qubits.
     _a											=						rng.integers(2						,			size=__A)
     # The set of states Alice will prepare.
     _a											=						rng.integers(2						,			size=__A)
     # Measurement basis for Bob's qubits.
     _a											=						rng.integers(2						,			size=__A)

     # Quantum Circuit to simulate BB84
     _a											=						qiskit.QuantumCircuit(__A						,			name='''BB84''')

     # Alice prepares her qubits according to rules above.
     for index, _ in enumerate(__A):
          if alice_state[index] == 1:
               bbaa_circ.x(__A)
          if alice_basis[index] == 1:
               bbaa_circ.h(__A)
     bbaa_circ.barrier()

     # Bob measures the received qubits according to rules above.
     for index, _ in enumerate(__A):
          if bob_basis[index] == 1:
               bbaa_circ.h(__A)

     bbaa_circ.barrier()
     bbaa_circ.measure_all()

     # Simulate the quantum circuit.
     _a											=						qiskit.Aer.get_backend('''aer_simulator''')
     # We only need to run one shot because the key is unique.
     # Multiple shots will produce the same key.
     _a											=						qiskit.execute(__A						,			__A						,			shots=1						,			seed_simulator=__A)
     # Returns the result of measurement.
     _a											=						job.result().get_counts(__A).most_frequent()

     # Extracting the generated key from the simulation results.
     # Only keep measurement results where Alice and Bob chose the same basis.
     _a											=						''''''.join(
         [
             result_bit
             for alice_basis_bit, bob_basis_bit, result_bit in zip(
                 __A						,			__A						,			__A)
             if alice_basis_bit == bob_basis_bit
         ])

     # Get final key. Pad with 0 if too short, otherwise truncate.
     _a											=						gen_key[:key_len] if len(__A) >= key_len else gen_key.ljust(__A						,			'''0''')
     return key


if __name__ == "__main__":
  print(F"""The generated key is : {bbaa(8, seed=0)}""")
  from doctest import testmod

  testmod()



