U
|
Z ±d+* ã @ s¬ d Z ddlmZ ddlZddlZddlmZmZmZ ddl m
|
Z
|
m Z m Z ddl mZ ddlmZmZmZmZmZmZmZmZ ddlmZ zdd lmZm Z W n$ e k
|
rÀ dd l mZm Z Y nX dd
|
l m Z dd lm!Z! e!d k r2dd l m"Z# ddl m$Z% zddl&m'Z' W n" e k
|
r. ddl(m'Z' Y nX n@ddl m)Z) zddl*m'Z' W n" e k
|
rp ddl+m'Z' Y nX dddZ,G dd de Z-dd Z.G dd de-Z/e/Z0dS )ab Sorted List
|
==============
|
|
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
|
collections library, written in pure-Python, and fast as C-extensions. The
|
:doc:`introduction<introduction>` is the best way to get started.
|
|
Sorted list implementations:
|
|
.. currentmodule:: sortedcontainers
|
|
* :class:`SortedList`
|
* :class:`SortedKeyList`
|
|
é )Úprint_functionN)Ú bisect_leftÚ bisect_rightÚinsort)ÚchainÚrepeatÚstarmap)Úlog)ÚaddÚeqÚneÚgtÚgeÚltÚleÚiadd)Údedent)ÚSequenceÚMutableSequence)Úwraps)Ú
|
hexversioni )Úimap)Úizip)Ú get_ident)Úreduceú...c s fdd}|S )zHDecorator to make a repr function return fillvalue for a recursive call.c s" t t fdd}|S )Nc sB t | t f}|kr S |¡ z | }W 5 |¡ X |S ©N)Úidr r
|
Údiscard)ÚselfÚkeyÚresult)Ú fillvalueÚ repr_runningÚ user_function© úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sortedcontainers/sortedlist.pyÚwrapper@ s
|
z<recursive_repr.<locals>.decorating_function.<locals>.wrapper)Úsetr )r$ r' ©r" )r# r$ r& Údecorating_function= s z+recursive_repr.<locals>.decorating_functionr% )r" r* r% r) r& Úrecursive_repr7 s r+ c @ sê e Zd ZdZdZdgddZdhddZedd Zd
|
d Z d d Z
|
e
|
Z dd Z dd Z dd ZeZdd Zdd Zdd Zdd Zd d Zd d Zd d! Zd"d# Zd$d% ZeZd&d' Zd(d) Zd*d+ Z d,d- Z did/d0Z d1d2 Z djd4d5Z d6d7 Z!d8d9 Z"d:d; Z#e#Z$e#Z%d<d= Z&d>d? Z'e'Z(d@dA Z)dBdC Z*dDdE Z+dkdGdHZ,dldIdJZ-dKdL Z.e.Z/dMdN Z0dOdP Z1e1Z2dQdR Z3dSdT Z4e4e5dUdVZ6e4e7dWdXZ8e4e9dYdZZ:e4e;d[d\Z<e4e=d]d^Z>e4e?d_d`Z@eAe4Z4dadb ZBeC dcdd ZDdedf ZEdS )mÚ
|
SortedLista½ Sorted list is a sorted mutable sequence.
|
|
Sorted list values are maintained in sorted order.
|
|
Sorted list values must be comparable. The total ordering of values must
|
not change while they are stored in the sorted list.
|
|
Methods for adding values:
|
|
* :func:`SortedList.add`
|
* :func:`SortedList.update`
|
* :func:`SortedList.__add__`
|
* :func:`SortedList.__iadd__`
|
* :func:`SortedList.__mul__`
|
* :func:`SortedList.__imul__`
|
|
Methods for removing values:
|
|
* :func:`SortedList.clear`
|
* :func:`SortedList.discard`
|
* :func:`SortedList.remove`
|
* :func:`SortedList.pop`
|
* :func:`SortedList.__delitem__`
|
|
Methods for looking up values:
|
|
* :func:`SortedList.bisect_left`
|
* :func:`SortedList.bisect_right`
|
* :func:`SortedList.count`
|
* :func:`SortedList.index`
|
* :func:`SortedList.__contains__`
|
* :func:`SortedList.__getitem__`
|
|
Methods for iterating values:
|
|
* :func:`SortedList.irange`
|
* :func:`SortedList.islice`
|
* :func:`SortedList.__iter__`
|
* :func:`SortedList.__reversed__`
|
|
Methods for miscellany:
|
|
* :func:`SortedList.copy`
|
* :func:`SortedList.__len__`
|
* :func:`SortedList.__repr__`
|
* :func:`SortedList._check`
|
* :func:`SortedList._reset`
|
|
Sorted lists use lexicographical ordering semantics when compared to other
|
sequences.
|
|
Some methods of mutable sequences are not supported and will raise
|
not-implemented error.
|
|
iè Nc C sH |dks t d| _| j| _g | _g | _g | _d| _|dk rD| |¡ dS )a¢ Initialize sorted list instance.
|
|
Optional `iterable` argument provides an initial iterable of values to
|
initialize the sorted list.
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> sl = SortedList()
|
>>> sl
|
SortedList([])
|
>>> sl = SortedList([3, 1, 2, 5, 4])
|
>>> sl
|
SortedList([1, 2, 3, 4, 5])
|
|
:param iterable: initial values (optional)
|
|
Nr ) ÚAssertionErrorÚ_lenÚDEFAULT_LOAD_FACTORÚ_loadÚ_listsÚ_maxesÚ_indexÚ_offsetÚ_update©r Úiterabler r% r% r& Ú__init__ s zSortedList.__init__c C s0 |dkrt | ¡S | tkr$t t¡S tddS )aJ Create new sorted list or sorted-key list instance.
|
|
Optional `key`-function argument will return an instance of subtype
|
:class:`SortedKeyList`.
|
|
>>> sl = SortedList()
|
>>> isinstance(sl, SortedList)
|
True
|
>>> sl = SortedList(key=lambda x: -x)
|
>>> isinstance(sl, SortedList)
|
True
|
>>> isinstance(sl, SortedKeyList)
|
True
|
|
:param iterable: initial values (optional)
|
:param key: function used to extract comparison key (optional)
|
:return: sorted list or sorted-key list instance
|
|
Nz&inherit SortedKeyList for key argument)ÚobjectÚ__new__r, Ú SortedKeyListÚ TypeError©Úclsr7 r r% r% r& r: ® s
|
|
|
zSortedList.__new__c C s dS )zFunction used to extract comparison key from values.
|
|
Sorted list compares values directly so the key function is none.
|
|
Nr% ©r r% r% r& r Ì s zSortedList.keyc C s* t t| jg }| ¡ || _| |¡ dS )a Reset sorted list load factor.
|
|
The `load` specifies the load-factor of the list. The default load
|
factor of 1000 works well for lists from tens to tens-of-millions of
|
values. Good practice is to use a value that is the cube root of the
|
list size. With billions of elements, the best load factor depends on
|
your usage. It's best to leave the load factor at the default until you
|
start benchmarking.
|
|
See :doc:`implementation` and :doc:`performance-scale` for more
|
information.
|
|
Runtime complexity: `O(n)`
|
|
:param int load: load-factor for sorted list sublists
|
|
N)r r r1 Ú_clearr0 r5 )r ÚloadÚvaluesr% r% r& Ú_resetÖ s zSortedList._resetc C s4 d| _ | jdd
= | jdd
= | jdd
= d| _dS )zQRemove all values from sorted list.
|
|
Runtime complexity: `O(n)`
|
|
r N)r. r1 r2 r3 r4 r? r% r% r& Úclearî s
|
zSortedList.clearc C s | j }| j}|r`t||}|t|krF|d8 }|| |¡ |||< nt|| | | |¡ n| |g¡ | |¡ | jd7 _dS )a Add `value` to sorted list.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList()
|
>>> sl.add(3)
|
>>> sl.add(1)
|
>>> sl.add(2)
|
>>> sl
|
SortedList([1, 2, 3])
|
|
:param value: value to add to sorted list
|
|
é N)r1 r2 r ÚlenÚappendr Ú_expandr. )r Úvaluer1 r2 Úposr% r% r& r
|
ý s
|
|
|
zSortedList.addc C sÊ | j }| j}| j}t|| |d> kr| j}|| }||d
}||d
= |d ||< | |d |¡ | |d |d ¡ |dd
= n@|rÆ| j| }|r¶|| d7 < |d d? }q|d d7 < dS ©a> Split sublists with length greater than double the load-factor.
|
|
Updates the index when the sublist length is less than double the load
|
level. This requires incrementing the nodes in a traversal from the
|
leaf node to the root. For an example traversal see
|
``SortedList._loc``.
|
|
rE Néÿÿÿÿr )r0 r1 r3 rF r2 Úinsertr4 ) r rJ r0 r1 r3 r2 Ú
|
_lists_posÚhalfÚchildr% r% r& rH ! s$
|
|
zSortedList._expandc sÈ | j }| j}t||rntd | jkrR| ¡ tt|g ¡ | ¡ n | j
|
}D ] }|| q\dS | j | fddt dt D ¡ | dd |D ¡ t| _| jdd
= dS )a Update sorted list by adding all values from `iterable`.
|
|
Runtime complexity: `O(k*log(n))` -- approximate.
|
|
>>> sl = SortedList()
|
>>> sl.update([3, 1, 2])
|
>>> sl
|
SortedList([1, 2, 3])
|
|
:param iterable: iterable of values to add
|
|
é Nc 3 s | ]}||
V qd S r r% ©Ú.0rJ ©r0 rB r% r& Ú <genexpr>a s ÿz$SortedList.update.<locals>.<genexpr>r c s s | ]}|d V qdS ©rL Nr% ©rS Úsublistr% r% r& rU c s )r1 r2 ÚsortedrF r. rG r r Úsortr@ r
|
r0 ÚextendÚranger3 )r r7 r1 r2 Ú_addÚvalr% rT r& ÚupdateC s(
|
|
|
ÿ
|
zSortedList.updatec C sL | j }|sdS t||}|t|kr(dS | j}t|| |}|| | |kS )aZ Return true if `value` is an element of the sorted list.
|
|
``sl.__contains__(value)`` <==> ``value in sl``
|
|
Runtime complexity: `O(log(n))`
|
|
>>> sl = SortedList([1, 2, 3, 4, 5])
|
>>> 3 in sl
|
True
|
|
:param value: search for value in sorted list
|
:return: true if `value` in sorted list
|
|
F)r2 r rF r1 ©r rI r2 rJ r1 Úidxr% r% r& Ú __contains__j s
|
zSortedList.__contains__c C s\ | j }|sdS t||}|t|kr(dS | j}t|| |}|| | |krX| ||¡ dS )ao Remove `value` from sorted list if it is a member.
|
|
If `value` is not a member, do nothing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList([1, 2, 3, 4, 5])
|
>>> sl.discard(5)
|
>>> sl.discard(0)
|
>>> sl == [1, 2, 3, 4]
|
True
|
|
:param value: `value` to discard from sorted list
|
|
N)r2 r rF r1 Ú_deleter` r% r% r& r s
|
zSortedList.discardc C s | j }|std |¡t||}|t|kr<td |¡| j}t|| |}|| | |krn| ||¡ ntd |¡dS )a Remove `value` from sorted list; `value` must be a member.
|
|
If `value` is not a member, raise ValueError.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList([1, 2, 3, 4, 5])
|
>>> sl.remove(5)
|
>>> sl == [1, 2, 3, 4]
|
True
|
>>> sl.remove(0)
|
Traceback (most recent call last):
|
...
|
ValueError: 0 not in list
|
|
:param value: `value` to remove from sorted list
|
:raises ValueError: if `value` is not in sorted list
|
|
ú{0!r} not in listN)r2 Ú
|
ValueErrorÚformatr rF r1 rc r` r% r% r& Úremoveª s
|
zSortedList.removec
|
C s( | j }| j}| j}|| }||= | jd8 _t|}|| jd? kr|d ||< |r| j| }|dkr|| d8 < |d d? }q^|d d8 < nt|dkrú|s®|d7 }|d } || || ¡ || d || < ||= ||= |dd
= | | ¡ n*|r|d ||< n||= ||= |dd
= dS ©a¯ Delete value at the given `(pos, idx)`.
|
|
Combines lists that are less than half the load level.
|
|
Updates the index when the sublist length is more than half the load
|
level. This requires decrementing the nodes in a traversal from the
|
leaf node to the root. For an example traversal see
|
``SortedList._loc``.
|
|
:param int pos: lists index
|
:param int idx: sublist index
|
|
rE rL r N) r1 r2 r3 r. rF r0 r4 r[ rH )
|
r rJ ra r1 r2 r3 rN Z len_lists_posrP Úprevr% r% r& rc Ñ s<
|
|
zSortedList._deletec C sZ |s|S | j }|s| ¡ d}|| j7 }|rR|d@ sD|||d 7 }|d d? }q(|| S )a Convert an index pair (lists index, sublist index) into a single
|
index number that corresponds to the position of the value in the
|
sorted list.
|
|
Many queries require the index be built. Details of the index are
|
described in ``SortedList._build_index``.
|
|
Indexing requires traversing the tree from a leaf node to the root. The
|
parent of each node is easily computable at ``(pos - 1) // 2``.
|
|
Left-child nodes are always at odd indices and right-child nodes are
|
always at even indices.
|
|
When traversing up from a right-child node, increment the total by the
|
left-child node.
|
|
The final index is the sum from traversal and the index in the sublist.
|
|
For example, using the index from ``SortedList._build_index``::
|
|
_index = 14 5 9 3 2 4 5
|
_offset = 3
|
|
Tree::
|
|
14
|
5 9
|
3 2 4 5
|
|
Converting an index pair (2, 3) into a single index involves iterating
|
like so:
|
|
1. Starting at the leaf node: offset + alpha = 3 + 2 = 5. We identify
|
the node as a left-child node. At such nodes, we simply traverse to
|
the parent.
|
|
2. At node 9, position 2, we recognize the node as a right-child node
|
and accumulate the left-child in our total. Total is now 5 and we
|
traverse to the parent at position 0.
|
|
3. Iteration ends at the root.
|
|
The index is then the sum of the total and sublist index: 5 + 3 = 8.
|
|
:param int pos: lists index
|
:param int idx: sublist index
|
:return: index in sorted list
|
|
r rE )r3 Ú _build_indexr4 )r rJ ra r3 Útotalr% r% r& Ú_loc s 2
|
zSortedList._locc C sê |dk rRt | jd }| |kr6t | jd || fS || j7 }|dk rdtdn|| jkrdtd|t | jd k r~d|fS | j}|s| ¡ d}d}t |}||k rÜ|| }||k r¾|}n||8 }|d }|d> d }q || j |fS )ai Convert an index into an index pair (lists index, sublist index)
|
that can be used to access the corresponding lists position.
|
|
Many queries require the index be built. Details of the index are
|
described in ``SortedList._build_index``.
|
|
Indexing requires traversing the tree to a leaf node. Each node has two
|
children which are easily computable. Given an index, pos, the
|
left-child is at ``pos * 2 + 1`` and the right-child is at ``pos * 2 +
|
2``.
|
|
When the index is less than the left-child, traversal moves to the
|
left sub-tree. Otherwise, the index is decremented by the left-child
|
and traversal moves to the right sub-tree.
|
|
At a child node, the indexing pair is computed from the relative
|
position of the child node as compared with the offset and the remaining
|
index.
|
|
For example, using the index from ``SortedList._build_index``::
|
|
_index = 14 5 9 3 2 4 5
|
_offset = 3
|
|
Tree::
|
|
14
|
5 9
|
3 2 4 5
|
|
Indexing position 8 involves iterating like so:
|
|
1. Starting at the root, position 0, 8 is compared with the left-child
|
node (5) which it is greater than. When greater the index is
|
decremented and the position is updated to the right child node.
|
|
2. At node 9 with index 3, we again compare the index to the left-child
|
node with value 4. Because the index is the less than the left-child
|
node, we simply traverse to the left.
|
|
3. At node 4 with index 3, we recognize that we are at a leaf node and
|
stop iterating.
|
|
4. To compute the sublist index, we subtract the offset from the index
|
of the leaf node: 5 - 3 = 2. To compute the index in the sublist, we
|
simply use the index remaining from iteration. In this case, 3.
|
|
The final index pair from our example is (2, 3) which corresponds to
|
index 8 in the sorted list.
|
|
:param int idx: index in sorted list
|
:return: (lists index, sublist index) pair
|
|
r rL rE úlist index out of range)rF r1 r. Ú
|
IndexErrorr3 rj r4 )r ra Zlast_lenr3 rJ rP Ú len_indexZ index_childr% r% r& Ú_posY s2 7
|
|
|
|
zSortedList._posc C sB t tt| j}t|dkr4|| jdd
< d| _dS t|}t|}t ttt ||}t|d@ rr|
|
|d ¡ t|dkr|| | jdd
< d| _dS dt t t|d dd }| td|t| ¡ ||g}t|d dkr t|d }t|}t ttt ||}|
|
|¡ qØttt|| j |d d | _dS )a Build a positional index for indexing the sorted list.
|
|
Indexes are represented as binary trees in a dense array notation
|
similar to a binary heap.
|
|
For example, given a lists representation storing integers::
|
|
0: [1, 2, 3]
|
1: [4, 5]
|
2: [6, 7, 8, 9]
|
3: [10, 11, 12, 13, 14]
|
|
The first transformation maps the sub-lists by their length. The
|
first row of the index is the length of the sub-lists::
|
|
0: [3, 2, 4, 5]
|
|
Each row after that is the sum of consecutive pairs of the previous
|
row::
|
|
1: [5, 9]
|
2: [14]
|
|
Finally, the index is built by concatenating these lists together::
|
|
_index = [14, 5, 9, 3, 2, 4, 5]
|
|
An offset storing the start of the first row is also stored::
|
|
_offset = 3
|
|
When built, the index can be used for efficient indexing into the list.
|
See the comment and notes on ``SortedList._pos`` for details.
|
|
rE Nr rL é )ÚlistÚmaprF r1 r3 r4 Úiterr r
|
ÚziprG Úintr r[ r r r Úreversed)r Zrow0ÚheadÚtailZrow1ÚsizeÚtreeÚrowr% r% r& rj · s0 $ zSortedList._build_indexc C s t |trä| | j¡\}}}|dkr||k r|dkrF|| jkrF| ¡ S | jd|| kr| td|¡}|| jk r|| t|d¡7 }| ¡ | |¡S t|||}|dkr´t|}| j | j
|
}}|D ]}||\} }
|
|| |
|
qÆn| |¡\} }
|
|
|
| |
|
¡ dS )aá Remove value at `index` from sorted list.
|
|
``sl.__delitem__(index)`` <==> ``del sl[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList('abcde')
|
>>> del sl[2]
|
>>> sl
|
SortedList(['a', 'b', 'd', 'e'])
|
>>> del sl[:2]
|
>>> sl
|
SortedList(['d', 'e'])
|
|
:param index: integer or slice for indexing
|
:raises IndexError: if index out of range
|
|
rE r é N) Ú
|
isinstanceÚsliceÚindicesr. r@ Ú_getitemr5 r\ rw rp rc ) r ÚindexÚstartÚstopÚsteprB r rp rc rJ ra r% r% r& Ú __delitem__ü s(
|
|
|
zSortedList.__delitem__c s( j }t|trb| j¡\}}}|dkr||k r|dkrX| jkrXtt j g S |¡\}}|| }|| | } t|| kr|||
S | jkr¶t|d }
|
t||
|
} n |¡\}
|
} || |d
} ||d |
|
} tt| | } | ||
|
d|
7 } | S |dkr@||kr@ t|d |d ¡} |
|
¡ | S t |||}t fdd|D S jr|dkr|d d S |dkr |d d S nt dd| krÀt|d k rÐn n |d | S t|d }| | k rödk r
|
n n|d || S |¡\}}|| | S dS )aÚ Lookup value at `index` in sorted list.
|
|
``sl.__getitem__(index)`` <==> ``sl[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList('abcde')
|
>>> sl[1]
|
'b'
|
>>> sl[-1]
|
'e'
|
>>> sl[2:5]
|
['c', 'd', 'e']
|
|
:param index: integer or slice for indexing
|
:return: value or list of values
|
:raises IndexError: if index out of range
|
|
rE r NrL c 3 s | ]} |¡V qd S r )r )rS r r? r% r& rU s s z)SortedList.__getitem__.<locals>.<genexpr>rm )r1 r~ r r r. r r rp rF r Úreverser\ rr rn )r r r1 r r r
Z start_posZ start_idxÚ
|
start_listZstop_idxZstop_posÚprefixZmiddler! r Úlen_lastrJ ra r% r? r& Ú __getitem__0 sN
|
|
|
$ zSortedList.__getitem__c C s d}t |dS )zÑRaise not-implemented error.
|
|
``sl.__setitem__(index, value)`` <==> ``sl[index] = value``
|
|
:raises NotImplementedError: use ``del sl[index]`` and
|
``sl.add(value)`` instead
|
|
z3use ``del sl[index]`` and ``sl.add(value)`` insteadN©ÚNotImplementedError)r r rI Úmessager% r% r& Ú __setitem__ s zSortedList.__setitem__c C s t | j¡S )zîReturn an iterator over the sorted list.
|
|
``sl.__iter__()`` <==> ``iter(sl)``
|
|
Iterating the sorted list while adding or deleting values may raise a
|
:exc:`RuntimeError` or fail to iterate over all values.
|
|
)r Ú from_iterabler1 r? r% r% r& Ú__iter__ s zSortedList.__iter__c C s t ttt| j¡S )zýReturn a reverse iterator over the sorted list.
|
|
``sl.__reversed__()`` <==> ``reversed(sl)``
|
|
Iterating the sorted list while adding or deleting values may raise a
|
:exc:`RuntimeError` or fail to iterate over all values.
|
|
)r r rs rw r1 r? r% r% r& Ú __reversed__¤ s zSortedList.__reversed__c C s t ddS )a¨ Raise not-implemented error.
|
|
Sorted list maintains values in ascending sort order. Values may not be
|
reversed in-place.
|
|
Use ``reversed(sl)`` for an iterator over values in descending sort
|
order.
|
|
Implemented to override `MutableSequence.reverse` which provides an
|
erroneous default implementation.
|
|
:raises NotImplementedError: use ``reversed(sl)`` instead
|
|
z use ``reversed(sl)`` insteadNr r? r% r% r& r ° s zSortedList.reverseFc C s | j }|stdS t|| | j ¡\}}}||kr:tdS | j}||\}}||krrt| jd } t| jd }
|
n ||\} }
|
| ||| |
|
|¡S )að Return an iterator that slices sorted list from `start` to `stop`.
|
|
The `start` and `stop` index are treated inclusive and exclusive,
|
respectively.
|
|
Both `start` and `stop` default to `None` which is automatically
|
inclusive of the beginning and end of the sorted list.
|
|
When `reverse` is `True` the values are yielded from the iterator in
|
reverse order; `reverse` defaults to `False`.
|
|
>>> sl = SortedList('abcdefghij')
|
>>> it = sl.islice(2, 6)
|
>>> list(it)
|
['c', 'd', 'e', 'f']
|
|
:param int start: start index (inclusive)
|
:param int stop: stop index (exclusive)
|
:param bool reverse: yield values in reverse order
|
:return: iterator
|
|
r% rE rL )r. rt r r rp rF r1 Ú_islice) r r r r r. Ú_rp Úmin_posÚmin_idxÚmax_posÚmax_idxr% r% r& Úislice s zSortedList.islicec C sº | j }||krtdS ||krZ|r@tt||}t|| j|S t||}t|| j|S |d }||krî|r²t|t|| } t|}
|
tt|| jt|
|
t|| jt| S t|t|| } t|}
|
tt|| j| t|| j|
|
S |r`t|t|| } t||} t|jt| } t|}
|
tt|| jt|
|
t tt| ¡t|| jt| S t|t|| } t||} t|j| } t|}
|
tt|| j| t | ¡t|| j|
|
S )ay Return an iterator that slices sorted list using two index pairs.
|
|
The index pairs are (min_pos, min_idx) and (max_pos, max_idx), the
|
first inclusive and the latter exclusive. See `_pos` for details on how
|
an index is converted to an index pair.
|
|
When `reverse` is `True`, values are yielded from the iterator in
|
reverse order.
|
|
r% rE ) r1 rt rw r\ rs r rF r r ) r r r r r r r1 r Znext_posZ min_indicesZ max_indicesZsublist_indicesZsublistsr% r% r& r ð sV
|
þþ
|
ý
|
ýzSortedList._islice©TTc C s@ | j }|stdS | j}|dkr*d}d}nb|d r`t||}|t|krPtdS t|| |}n,t||}|t|kr~tdS t|| |}|dkr®t|d } t|| }
|
n|d ròt||} | t|krâ| d8 } t|| }
|
nt|| |}
|
n<t||} | t|kr | d8 } t|| }
|
nt|| |}
|
| ||| |
|
|¡S )aÛ Create an iterator of values between `minimum` and `maximum`.
|
|
Both `minimum` and `maximum` default to `None` which is automatically
|
inclusive of the beginning and end of the sorted list.
|
|
The argument `inclusive` is a pair of booleans that indicates whether
|
the minimum and maximum ought to be included in the range,
|
respectively. The default is ``(True, True)`` such that the range is
|
inclusive of both minimum and maximum.
|
|
When `reverse` is `True` the values are yielded from the iterator in
|
reverse order; `reverse` defaults to `False`.
|
|
>>> sl = SortedList('abcdefghij')
|
>>> it = sl.irange('c', 'f')
|
>>> list(it)
|
['c', 'd', 'e', 'f']
|
|
:param minimum: minimum value to start iterating
|
:param maximum: maximum value to stop iterating
|
:param inclusive: pair of booleans
|
:param bool reverse: yield values in reverse order
|
:return: iterator
|
|
r% Nr rE )r2 rt r1 r rF r r ) r ÚminimumÚmaximumÚ inclusiver r2 r1 r r r r r% r% r& Úirange0 s>
|
|
|
|
zSortedList.irangec C s | j S )z~Return the size of the sorted list.
|
|
``sl.__len__()`` <==> ``len(sl)``
|
|
:return: size of sorted list
|
|
)r. r? r% r% r& Ú__len__ s zSortedList.__len__c C sF | j }|sdS t||}|t|kr*| jS t| j| |}| ||¡S )aè Return an index to insert `value` in the sorted list.
|
|
If the `value` is already present, the insertion point will be before
|
(to the left of) any existing values.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList([10, 11, 12, 13, 14])
|
>>> sl.bisect_left(12)
|
2
|
|
:param value: insertion index of value in sorted list
|
:return: index
|
|
r )r2 r rF r. r1 rl ©r rI r2 rJ ra r% r% r& r s
|
zSortedList.bisect_leftc C sF | j }|sdS t||}|t|kr*| jS t| j| |}| ||¡S )a Return an index to insert `value` in the sorted list.
|
|
Similar to `bisect_left`, but if `value` is already present, the
|
insertion point will be after (to the right of) any existing values.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList([10, 11, 12, 13, 14])
|
>>> sl.bisect_right(12)
|
3
|
|
:param value: insertion index of value in sorted list
|
:return: index
|
|
r )r2 r rF r. r1 rl r r% r% r& r ® s
|
zSortedList.bisect_rightc
|
C s¢ | j }|sdS t||}|t|kr(dS | j}t|| |}t||}|t|krd| j| ||¡ S t|| |}||kr|| S | ||¡}| ||¡} || S )a) Return number of occurrences of `value` in the sorted list.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
|
>>> sl.count(3)
|
3
|
|
:param value: value to count in sorted list
|
:return: count
|
|
r )r2 r rF r1 r r. rl )
|
r rI r2 Úpos_leftr1 Úidx_leftZ pos_rightZ idx_rightÚrightÚleftr% r% r& ÚcountÑ s"
|
|
zSortedList.countc C s
|
| | ¡S )zyReturn a shallow copy of the sorted list.
|
|
Runtime complexity: `O(n)`
|
|
:return: new sorted list
|
|
)Ú __class__r? r% r% r& Úcopyù s zSortedList.copyc C s t ddS )zàRaise not-implemented error.
|
|
Implemented to override `MutableSequence.append` which provides an
|
erroneous default implementation.
|
|
:raises NotImplementedError: use ``sl.add(value)`` instead
|
|
ú use ``sl.add(value)`` insteadNr ©r rI r% r% r& rG s zSortedList.appendc C s t ddS )zäRaise not-implemented error.
|
|
Implemented to override `MutableSequence.extend` which provides an
|
erroneous default implementation.
|
|
:raises NotImplementedError: use ``sl.update(values)`` instead
|
|
z!use ``sl.update(values)`` insteadNr ©r rB r% r% r& r[ s zSortedList.extendc C s t ddS )zjRaise not-implemented error.
|
|
:raises NotImplementedError: use ``sl.add(value)`` instead
|
|
r¨ Nr )r r rI r% r% r& rM s zSortedList.insertrL c C s6 | j std| j}|dkr8|d d }| dd¡ |S |dkrxt|d }t|| d }|| | }| ||¡ |S d| krt|d k r´n n |d | }| d|¡ |S t|d }| | k rØdk r n n0t|d }|| }|| | }| ||¡ |S | |¡\}}|| | }| ||¡ |S )a Remove and return value at `index` in sorted list.
|
|
Raise :exc:`IndexError` if the sorted list is empty or index is out of
|
range.
|
|
Negative indices are supported.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList('abcde')
|
>>> sl.pop()
|
'e'
|
>>> sl.pop(2)
|
'c'
|
>>> sl
|
SortedList(['a', 'b', 'd'])
|
|
:param int index: index of value (default -1)
|
:return: value
|
:raises IndexError: if index is out of range
|
|
zpop index out of ranger rL rE )r. rn r1 rc rF rp )r r r1 r^ rJ Úlocr ra r% r% r& Úpop' s8 zSortedList.popc C s6 | j }|std |¡|dkr$d}|dk r4||7 }|dk r@d}|dkrL|}|dk r\||7 }||krh|}||kr~td |¡| j}t||}|t|kr¨td |¡| j}t|| |}|| | |krÚtd |¡|d8 }| ||¡} || kr| |kr$| S n | |¡d }
|
||
|
kr$|S td |¡dS )aq Return first index of value in sorted list.
|
|
Raise ValueError if `value` is not present.
|
|
Index must be between `start` and `stop` for the `value` to be
|
considered present. The default value, None, for `start` and `stop`
|
indicate the beginning and end of the sorted list.
|
|
Negative indices are supported.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> sl = SortedList('abcde')
|
>>> sl.index('d')
|
3
|
>>> sl.index('z')
|
Traceback (most recent call last):
|
...
|
ValueError: 'z' is not in list
|
|
:param value: value in sorted list
|
:param int start: start index (default None, start of sorted list)
|
:param int stop: stop index (default None, end of sorted list)
|
:return: index of value
|
:raises ValueError: if value is not present
|
|
ú{0!r} is not in listNr rE ) r. re rf r2 r rF r1 rl Ú _bisect_right) r rI r r r. r2 r¡ r1 r¢ r¤ r£ r% r% r& r c sD
|
|
|
|
zSortedList.indexc C s" t t| jg }| |¡ | |¡S )a¾ Return new sorted list containing all values in both sequences.
|
|
``sl.__add__(other)`` <==> ``sl + other``
|
|
Values in `other` do not need to be in sorted order.
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> sl1 = SortedList('bat')
|
>>> sl2 = SortedList('cat')
|
>>> sl1 + sl2
|
SortedList(['a', 'a', 'b', 'c', 't', 't'])
|
|
:param other: other iterable
|
:return: new sorted list
|
|
)r r r1 r[ r¦ ©r ÚotherrB r% r% r& Ú__add__° s
|
zSortedList.__add__c C s | |¡ | S )a® Update sorted list with values from `other`.
|
|
``sl.__iadd__(other)`` <==> ``sl += other``
|
|
Values in `other` do not need to be in sorted order.
|
|
Runtime complexity: `O(k*log(n))` -- approximate.
|
|
>>> sl = SortedList('bat')
|
>>> sl += 'cat'
|
>>> sl
|
SortedList(['a', 'a', 'b', 'c', 't', 't'])
|
|
:param other: other iterable
|
:return: existing sorted list
|
|
)r5 )r r° r% r% r& Ú__iadd__É s
|
zSortedList.__iadd__c C s t t| jg | }| |¡S )aj Return new sorted list with `num` shallow copies of values.
|
|
``sl.__mul__(num)`` <==> ``sl * num``
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> sl = SortedList('abc')
|
>>> sl * 3
|
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
|
|
:param int num: count of shallow copies
|
:return: new sorted list
|
|
)r r r1 r¦ ©r ÚnumrB r% r% r& Ú__mul__ß s zSortedList.__mul__c C s( t t| jg | }| ¡ | |¡ | S )a Update the sorted list with `num` shallow copies of values.
|
|
``sl.__imul__(num)`` <==> ``sl *= num``
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> sl = SortedList('abc')
|
>>> sl *= 3
|
>>> sl
|
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
|
|
:param int num: count of shallow copies
|
:return: existing sorted list
|
|
)r r r1 r@ r5 r³ r% r% r& Ú__imul__ô s
|
zSortedList.__imul__c s: fdd} j }d |¡|_ d}t| |||¡|_|S )zMake comparator method.c sp t |tstS | j}t|}||kr< tkr0dS tkr<dS t| |D ] \}}||krF || S qF ||S )z,Compare method for sorted list and sequence.FT)r~ r ÚNotImplementedr. rF r r ru )r r° Zself_lenZ len_otherÚalphaÚbeta©Úseq_opr% r& Úcomparer s
|
z'SortedList.__make_cmp.<locals>.comparerz__{0}__a7 Return true if and only if sorted list is {0} `other`.
|
|
``sl.__{1}__(other)`` <==> ``sl {2} other``
|
|
Comparisons use lexicographical order as with sequences.
|
|
Runtime complexity: `O(n)`
|
|
:param other: `other` sequence
|
:return: true if sorted list is {0} `other`
|
|
)Ú__name__rf r Ú__doc__)r» ÚsymbolÚdocr¼ Z seq_op_nameZdoc_strr% rº r& Z
|
__make_cmp
|
s zSortedList.__make_cmpz==zequal toz!=z not equal toú<z less thanú>z greater thanz<=zless than or equal toz>=zgreater than or equal toc C s t t| jg }t| |ffS r )r r r1 Útyperª r% r% r& Ú
|
__reduce__; s zSortedList.__reduce__c C s d t| jt| ¡S )zReturn string representation of sorted list.
|
|
``sl.__repr__()`` <==> ``repr(sl)``
|
|
:return: string representation
|
|
z
|
{0}({1!r}))rf rà r½ rr r? r% r% r& Ú__repr__@ s zSortedList.__repr__c s zl| j dkstt| jt| jks*t| jtdd | jD ksHt| jD ]0}tdt|D ] }||d || ks`tq`qNtdt| jD ](}| j|d d | j| d kstqtt| jD ] }| j| | j| d ksÈtqÈ| j d> t fdd| jD st| j d? }tdt| jd D ] }t| j| |ks0tq0| j rl| j| j d ksntt| j | j
|
t| j ksttt| jD ].}| j | j
|
| }|t| j| kstqt| j
|
D ]}|d> d }|t| j kr | j | dkshtn\|d t| j kr<| j | | j | kshtn,| j | | j |d }|| j | ksÖtqÖW n t j t jd td | j td
|
| j td | j
|
td t| j td | j tdt| j td| j tdt| j td| j Y nX dS )zNCheck invariants of sorted list.
|
|
Runtime complexity: `O(n)`
|
|
rQ c s s | ]}t |V qd S r ©rF rW r% r% r& rU U s z$SortedList._check.<locals>.<genexpr>rE rL r c 3 s | ]}t | kV qd S r rÆ rW ©Údoubler% r& rU j s ©ÚfilerF rA Úoffsetro r Ú len_maxesÚmaxesÚ len_listsÚlistsN)r0 r- rF r2 r1 r. Úsumr\ Úallr3 r4 Ú tracebackÚ print_excÚsysÚstdoutÚprint)r rX rJ rO ÚleafrP Ú child_sumr% rÇ r& Ú_checkL sT
|
&
|
|
zSortedList._check)NN)NN)NNF)NNr F)rL )NN)Fr½ Ú
|
__module__Ú __qualname__r¾ r/ r8 r: Úpropertyr rC rD r@ r
|
rH r_ r5 rb r rg rc rl rp rj r r r r r r r r r r r r r Úbisectr® r¥ r§ Ú__copy__rG r[ rM r¬ r r± Ú__radd__r² rµ Ú__rmul__r¶ Z_SortedList__make_cmpr Ú__eq__r Ú__ne__r Ú__lt__r Ú__gt__r Ú__le__r Ú__ge__Ú staticmethodrÄ r+ rÅ rÙ r% r% r% r& r, U s~ 7
|
|
|
$"$ !'7Q^E4X
|
.@ ÿ
|
S (
|
|
<
|
M(
|
r, c C s | S )zIdentity function.r% )rI r% r% r& Úidentity s rè c @ s e Zd ZdZdefddZdefddZedd Zd d
|
Z e Z
|
d d Z d d Z dd Z e Zdd Zdd Zdd Zdd Zd7dd Zd8d d ZeZd d Zd!d" ZeZd#d$ ZeZd%d& ZeZ eZ d'd( Z d)d* Z e Z d9d+d,Z!d-d. Z"e"Z#d/d0 Z$d1d2 Z%e& d3d4 Z'd5d6 Z(dS ):r; ai Sorted-key list is a subtype of sorted list.
|
|
The sorted-key list maintains values in comparison order based on the
|
result of a key function applied to every value.
|
|
All the same methods that are available in :class:`SortedList` are also
|
available in :class:`SortedKeyList`.
|
|
Additional methods provided:
|
|
* :attr:`SortedKeyList.key`
|
* :func:`SortedKeyList.bisect_key_left`
|
* :func:`SortedKeyList.bisect_key_right`
|
* :func:`SortedKeyList.irange_key`
|
|
Some examples below use:
|
|
>>> from operator import neg
|
>>> neg
|
<built-in function neg>
|
>>> neg(1)
|
-1
|
|
Nc C sH || _ d| _| j| _g | _g | _g | _g | _d| _|dk rD| |¡ dS )a6 Initialize sorted-key list instance.
|
|
Optional `iterable` argument provides an initial iterable of values to
|
initialize the sorted-key list.
|
|
Optional `key` argument defines a callable that, like the `key`
|
argument to Python's `sorted` function, extracts a comparison key from
|
each value. The default is the identity function.
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList(key=neg)
|
>>> skl
|
SortedKeyList([], key=<built-in function neg>)
|
>>> skl = SortedKeyList([3, 1, 2], key=neg)
|
>>> skl
|
SortedKeyList([3, 2, 1], key=<built-in function neg>)
|
|
:param iterable: initial values (optional)
|
:param key: function used to extract comparison key (optional)
|
|
r N)
|
Ú_keyr. r/ r0 r1 Ú_keysr2 r3 r4 r5 r6 r% r% r& r8 ´ s zSortedKeyList.__init__c C s
|
t | ¡S r )r9 r: r= r% r% r& r: Ù s zSortedKeyList.__new__c C s | j S )z4Function used to extract comparison key from values.)ré r? r% r% r& r Ý s zSortedKeyList.keyc C s: d| _ | jdd
= | jdd
= | jdd
= | jdd
= dS )zURemove all values from sorted-key list.
|
|
Runtime complexity: `O(n)`
|
|
r N)r. r1 rê r2 r3 r? r% r% r& rD ã s
|
zSortedKeyList.clearc C sÒ | j }| j}| j}| |¡}|rt||}|t|krd|d8 }|| |¡ || |¡ |||< n.t|| |}|| ||¡ || ||¡ | |¡ n"| |g¡ | |g¡ | |¡ | j d7 _ dS )a{ Add `value` to sorted-key list.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList(key=neg)
|
>>> skl.add(3)
|
>>> skl.add(1)
|
>>> skl.add(2)
|
>>> skl
|
SortedKeyList([3, 2, 1], key=<built-in function neg>)
|
|
:param value: value to add to sorted-key list
|
|
rE N)
|
r1 rê r2 ré r rF rG rM rH r. )r rI r1 rê r2 r rJ ra r% r% r& r
|
ò s&
|
|
|
|
zSortedKeyList.addc C s | j }| j}| j}t|| | jd> kr¼| j}| j}|| }|| }||d
} ||d
}
|
||d
= ||d
= |d ||< | |d | ¡ | |d |
|
¡ | |d |
|
d ¡ |dd
= n@|rü| j| } | rì|| d7 < | d d? } qÊ|d d7 < dS rK )r1 rê r3 rF r0 r2 rM r4 ) r rJ r1 rê r3 r2 r0 rN Z _keys_posrO Z half_keysrP r% r% r& rH s.
|
|
|
zSortedKeyList._expandc sò j }j}j}t|jd|rtd jkrd| ¡ tt |g j
|
jd ¡ n j }D ] }|| qndS j | fddtdt D ¡ | fdd|D ¡ | dd |D ¡ t_jdd
= dS ) at Update sorted-key list by adding all values from `iterable`.
|
|
Runtime complexity: `O(k*log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList(key=neg)
|
>>> skl.update([3, 1, 2])
|
>>> skl
|
SortedKeyList([3, 2, 1], key=<built-in function neg>)
|
|
:param iterable: iterable of values to add
|
|
©r rQ Nc 3 s | ]}||
V qd S r r% rR rT r% r& rU e s ÿz'SortedKeyList.update.<locals>.<genexpr>r c 3 s | ]}t t j|V qd S r )rr rs ré )rS Z_listr? r% r& rU g s c s s | ]}|d V qdS rV r% rW r% r% r& rU h s )r1 rê r2 rY ré rF r. rG r r rZ r@ r
|
r0 r[ r\ r3 )r r7 r1 rê r2 r] r^ r% )r0 r rB r& r_ E s,
|
|
|
ÿ
|
zSortedKeyList.updatec
|
C s | j }|sdS | |¡}t||}|t|kr2dS | j}| j}t|| |}t|}t|| } || | |krtdS || | |krdS |d7 }|| kr`|d7 }||kr¬dS t|| } d}q`dS )a Return true if `value` is an element of the sorted-key list.
|
|
``skl.__contains__(value)`` <==> ``value in skl``
|
|
Runtime complexity: `O(log(n))`
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg)
|
>>> 3 in skl
|
True
|
|
:param value: search for value in sorted-key list
|
:return: true if `value` in sorted-key list
|
|
FTrE r N©r2 ré r rF r1 rê ©
|
r rI r2 r rJ r1 rê ra Úlen_keysÚ len_sublistr% r% r& rb o s.
|
|
zSortedKeyList.__contains__c
|
C sÎ | j }|sdS | |¡}t||}|t|kr2dS | j}| j}t|| |}t|}t|| } || | |krtdS || | |kr| ||¡ dS |d7 }|| kr`|d7 }||kr¸dS t|| } d}q`dS )a¬ Remove `value` from sorted-key list if it is a member.
|
|
If `value` is not a member, do nothing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.discard(1)
|
>>> skl.discard(0)
|
>>> skl == [5, 4, 3, 2]
|
True
|
|
:param value: `value` to discard from sorted-key list
|
|
NrE r )r2 ré r rF r1 rê rc rí r% r% r& r s0
|
|
zSortedKeyList.discardc
|
C sö | j }|std |¡| |¡}t||}|t|krFtd |¡| j}| j}t|| |}t|}t|| } || | |krtd |¡|| | |kr²| ||¡ dS |d7 }|| krt|d7 }||kràtd |¡t|| } d}qtdS )aS Remove `value` from sorted-key list; `value` must be a member.
|
|
If `value` is not a member, raise ValueError.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg)
|
>>> skl.remove(5)
|
>>> skl == [4, 3, 2, 1]
|
True
|
>>> skl.remove(0)
|
Traceback (most recent call last):
|
...
|
ValueError: 0 not in list
|
|
:param value: `value` to remove from sorted-key list
|
:raises ValueError: if `value` is not in sorted-key list
|
|
rd NrE r ) r2 re rf ré r rF r1 rê rc rí r% r% r& rg Ñ s0
|
|
zSortedKeyList.removec C s\ | j }| j}| j}| j}|| }|| }||= ||= | jd8 _t|} | | jd? krª|d ||< |r¨| j| }
|
|
|
dkr||
|
d8 < |
|
d d? }
|
qr|d d8 < n®t|dkr(|sÄ|d7 }|d } || || ¡ || || ¡ || d || < ||= ||= ||= |dd
= | | ¡ n0| r<|d ||< n ||= ||= ||= |dd
= dS rh )
|
r1 rê r2 r3 r. rF r0 r4 r[ rH ) r rJ ra r1 rê r2 r3 Zkeys_posZ lists_posZ len_keys_posrP ri r% r% r& rc sH
|
|
zSortedKeyList._deleter Fc C s> |dk r| |¡nd}|dk r(| |¡nd}| j||||dS )a Create an iterator of values between `minimum` and `maximum`.
|
|
Both `minimum` and `maximum` default to `None` which is automatically
|
inclusive of the beginning and end of the sorted-key list.
|
|
The argument `inclusive` is a pair of booleans that indicates whether
|
the minimum and maximum ought to be included in the range,
|
respectively. The default is ``(True, True)`` such that the range is
|
inclusive of both minimum and maximum.
|
|
When `reverse` is `True` the values are yielded from the iterator in
|
reverse order; `reverse` defaults to `False`.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg)
|
>>> it = skl.irange(14.5, 11.5)
|
>>> list(it)
|
[14, 13, 12]
|
|
:param minimum: minimum value to start iterating
|
:param maximum: maximum value to stop iterating
|
:param inclusive: pair of booleans
|
:param bool reverse: yield values in reverse order
|
:return: iterator
|
|
N)Úmin_keyÚmax_keyr r )ré Ú _irange_key)r r r r r rð rñ r% r% r& r B s þzSortedKeyList.irangec C s@ | j }|stdS | j}|dkr*d}d}nb|d r`t||}|t|krPtdS t|| |}n,t||}|t|kr~tdS t|| |}|dkr®t|d } t|| }
|
n|d ròt||} | t|krâ| d8 } t|| }
|
nt|| |}
|
n<t||} | t|kr | d8 } t|| }
|
nt|| |}
|
| ||| |
|
|¡S )a Create an iterator of values between `min_key` and `max_key`.
|
|
Both `min_key` and `max_key` default to `None` which is automatically
|
inclusive of the beginning and end of the sorted-key list.
|
|
The argument `inclusive` is a pair of booleans that indicates whether
|
the minimum and maximum ought to be included in the range,
|
respectively. The default is ``(True, True)`` such that the range is
|
inclusive of both minimum and maximum.
|
|
When `reverse` is `True` the values are yielded from the iterator in
|
reverse order; `reverse` defaults to `False`.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg)
|
>>> it = skl.irange_key(-14, -12)
|
>>> list(it)
|
[14, 13, 12]
|
|
:param min_key: minimum key to start iterating
|
:param max_key: maximum key to stop iterating
|
:param inclusive: pair of booleans
|
:param bool reverse: yield values in reverse order
|
:return: iterator
|
|
r% Nr rE )r2 rt rê r rF r r ) r rð rñ r r r2 rê r r r r r% r% r& Ú
|
irange_keyf s>
|
|
|
|
zSortedKeyList.irange_keyc C s | | |¡¡S )a Return an index to insert `value` in the sorted-key list.
|
|
If the `value` is already present, the insertion point will be before
|
(to the left of) any existing values.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.bisect_left(1)
|
4
|
|
:param value: insertion index of value in sorted-key list
|
:return: index
|
|
)Ú_bisect_key_leftré r© r% r% r& r ¼ s zSortedKeyList.bisect_leftc C s | | |¡¡S )a5 Return an index to insert `value` in the sorted-key list.
|
|
Similar to `bisect_left`, but if `value` is already present, the
|
insertion point will be after (to the right of) any existing values.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.bisect_right(1)
|
5
|
|
:param value: insertion index of value in sorted-key list
|
:return: index
|
|
)Ú_bisect_key_rightré r© r% r% r& r Ò s zSortedKeyList.bisect_rightc C sF | j }|sdS t||}|t|kr*| jS t| j| |}| ||¡S )a Return an index to insert `key` in the sorted-key list.
|
|
If the `key` is already present, the insertion point will be before (to
|
the left of) any existing keys.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.bisect_key_left(-1)
|
4
|
|
:param key: insertion index of key in sorted-key list
|
:return: index
|
|
r )r2 r rF r. rê rl ©r r r2 rJ ra r% r% r& Úbisect_key_leftê s
|
z SortedKeyList.bisect_key_leftc C sF | j }|sdS t||}|t|kr*| jS t| j| |}| ||¡S )a4 Return an index to insert `key` in the sorted-key list.
|
|
Similar to `bisect_key_left`, but if `key` is already present, the
|
insertion point will be after (to the right of) any existing keys.
|
|
Similar to the `bisect` module in the standard library.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.bisect_key_right(-1)
|
5
|
|
:param key: insertion index of key in sorted-key list
|
:return: index
|
|
r )r2 r rF r. rê rl rö r% r% r& Úbisect_key_right s
|
z SortedKeyList.bisect_key_rightc C sÊ | j }|sdS | |¡}t||}|t|kr2dS | j}| j}t|| |}d}t|} t|| }
|
|| | |krx|S || | |kr|d7 }|d7 }||
|
krd|d7 }|| kr´|S t|| }
|
d}qddS )ad Return number of occurrences of `value` in the sorted-key list.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([4, 4, 4, 4, 3, 3, 3, 2, 2, 1], key=neg)
|
>>> skl.count(2)
|
2
|
|
:param value: value to count in sorted-key list
|
:return: count
|
|
r rE Nrì ) r rI r2 r rJ r1 rê ra rk rî rï r% r% r& r¥ 3 s0
|
|
zSortedKeyList.countc C s | j | | jdS )zReturn a shallow copy of the sorted-key list.
|
|
Runtime complexity: `O(n)`
|
|
:return: new sorted-key list
|
|
rë )r¦ ré r? r% r% r& r§ a s zSortedKeyList.copyc C s¨ | j }|std |¡|dkr$d}|dk r4||7 }|dk r@d}|dkrL|}|dk r\||7 }||krh|}||kr~td |¡| j}| |¡}t||}|t|kr²td |¡|d8 }| j}| j} t| | |}
|
t| } t| | } | | |
|
|krtd |¡|| |
|
|krT| ||
|
¡} || kr>|krFn n| S | |krTq|
|
d7 }
|
|
|
| krè|d7 }|| krtd |¡t| | } d}
|
qètd |¡dS )a» Return first index of value in sorted-key list.
|
|
Raise ValueError if `value` is not present.
|
|
Index must be between `start` and `stop` for the `value` to be
|
considered present. The default value, None, for `start` and `stop`
|
indicate the beginning and end of the sorted-key list.
|
|
Negative indices are supported.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
|
>>> skl.index(2)
|
3
|
>>> skl.index(0)
|
Traceback (most recent call last):
|
...
|
ValueError: 0 is not in list
|
|
:param value: value in sorted-key list
|
:param int start: start index (default None, start of sorted-key list)
|
:param int stop: stop index (default None, end of sorted-key list)
|
:return: index of value
|
:raises ValueError: if value is not present
|
|
r Nr rE )
|
r. re rf r2 ré r rF r1 rê rl )r rI r r r. r2 r rJ r1 rê ra rî rï r« r% r% r& r n sX
|
|
|
|
zSortedKeyList.indexc C s( t t| jg }| |¡ | j|| jdS )a) Return new sorted-key list containing all values in both sequences.
|
|
``skl.__add__(other)`` <==> ``skl + other``
|
|
Values in `other` do not need to be in sorted-key order.
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> from operator import neg
|
>>> skl1 = SortedKeyList([5, 4, 3], key=neg)
|
>>> skl2 = SortedKeyList([2, 1, 0], key=neg)
|
>>> skl1 + skl2
|
SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>)
|
|
:param other: other iterable
|
:return: new sorted-key list
|
|
rë )r r r1 r[ r¦ ré r¯ r% r% r& r± Ã s
|
zSortedKeyList.__add__c C s" t t| jg | }| j|| jdS )a° Return new sorted-key list with `num` shallow copies of values.
|
|
``skl.__mul__(num)`` <==> ``skl * num``
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> from operator import neg
|
>>> skl = SortedKeyList([3, 2, 1], key=neg)
|
>>> skl * 2
|
SortedKeyList([3, 3, 2, 2, 1, 1], key=<built-in function neg>)
|
|
:param int num: count of shallow copies
|
:return: new sorted-key list
|
|
rë )r r r1 r¦ ré r³ r% r% r& rµ Ý s zSortedKeyList.__mul__c C s t t| jg }t| || jffS r )r r r1 rà r rª r% r% r& rÄ ñ s zSortedKeyList.__reduce__c C s t | j}d |t| | j¡S )zReturn string representation of sorted-key list.
|
|
``skl.__repr__()`` <==> ``repr(skl)``
|
|
:return: string representation
|
|
z{0}({1!r}, key={2!r}))rà r½ rf rr ré )r Z type_namer% r% r& rÅ ö s
|
zSortedKeyList.__repr__c s zÚ| j dkstt| jt| j kr8t| jks>n t| jtdd | jD ks\t| jD ]0}tdt|D ] }||d || ksttqtqbtdt| jD ](}| j|d d | j| d ks¤tq¤t | j| jD ]F\}}t|t|ksøtt ||D ] \}}|
|
|¡|kstqqÜtt| jD ]$}| j| | j| d ks2tq2| j d> t fdd| jD st| j d? }tdt| jd D ] }t| j| |kstq| j rÚ| j| j d ksÜtt| j | j t| j ksüttt| jD ].}| j | j | }|t| j| ks
|
tq
|
t| j D ]}|d> d } | t| j krz| j | dksÖtn\| d t| j krª| j | | j | ksÖtn,| j | | j | d }
|
|
|
| j | ksDtqDW n° tjtjd td | j td
|
| j td | j td t| j td | j tdt| j td| j tdt| j td| j tdt| j td| j Y nX dS )zRCheck invariants of sorted-key list.
|
|
Runtime complexity: `O(n)`
|
|
rQ c s s | ]}t |V qd S r rÆ rW r% r% r& rU
|
s z'SortedKeyList._check.<locals>.<genexpr>rE rL r c 3 s | ]}t | kV qd S r rÆ rW rÇ r% r& rU (
|
s rÉ rF rA rË ro r rÌ rÍ rî ÚkeysrÎ rÏ N)r0 r- rF r2 r1 rê r. rÐ r\ ru ré rÑ r3 r4 rÒ rÓ rÔ rÕ rÖ ) r rX rJ Z val_sublistZ key_sublistr^ r rO r× rP rØ r% rÇ r& rÙ
|
s` ,
|
&"
|
|
zSortedKeyList._check)NNr F)NNr F)NN))r½ rÚ rÛ r¾ rè r8 r: rÜ r rD r@ r
|
rH r_ r5 rb r rg rc r ró rò r r rÝ r÷ rô rø Z
|
bisect_keyrõ r¥ r§ rÞ r r± rß rµ rÄ r+ rÅ rÙ r% r% r% r& r; sR %
|
,''115< ÿ
|
$ ÿ
|
S!!.
|
|
U
|
r; )r )1r¾ Ú
|
__future__r rÔ rÒ rÝ r r r Ú itertoolsr r r Úmathr Úoperatorr
|
r r r r r r r Útextwrapr Úcollections.abcr r Ú ImportErrorÚ collectionsÚ functoolsr r r rs r ru Úthreadr Ú dummy_threadr Ú_threadÚ _dummy_threadr+ r, rè r; ZSortedListWithKeyr% r% r% r& Ú<module> sd (
|
|
M B
|
