#-------------------------------------------------------------------------------
# Copyright (c) 2012 Jakub Kovac, Katarina Kotrlova, Pavol Lukca, Viktor Tomkovic, Tatiana Tothova
# 
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#-------------------------------------------------------------------------------

capacity = Capacity

dynamicarray = Dynamic array

dynamicarray-empty = The dynamic array is empty.

dynamicarray-full = The array is full.

dynamicarray-insert = Insert a new element.

dynamicarray-use-coin = Use these coins to allocate a new array.

dynamicarray-new = New array.

dynamicarray-copy = Copy elements from the old array.

dynamicarray-insert-coin = Store coins for later use.

dynamicarray-needless-first = The element is in the first half, so these are not needed.

dynamicarray-needless-second = The element is in the second half, so these are not needed.

dynamicarray-needless-empty = The array is empty, so these are not needed.

dynamicarray-insert-enough = Already stored; no more are needed for now.

dynamicarray-small = Only a quarter of the array is used, so free the unused memory.

dynamicarray-pop = Remove the last element.

dynamicarray-erase = Free the old memory.

dynamicarray-allocateText = Allocation

dynamicarray-copyText = Copying

button-pop = Pop

234tree = 2-3-4 tree

23tree = 2-3 tree

EMPTYSTR = \ 

aaok = This node is OK.

aaskew = Skew: Left subtree has the same rank — perform a right rotation.

aaskew2 = Skew2: Left subtree has the same rank — perform a right rotation.

aaskew3 = Skew3: Left subtree has the same rank — perform a right rotation.

aasplit = Split: The pseudonode (nodes of equal rank) is too large — perform a left rotation and promote the middle node.

aasplit2 = Split2: The pseudonode (nodes of equal rank) is too large — perform a left rotation and promote the middle node.

aatree = AA tree

activeheap = Active heap:

alreadythere = The key is already in the tree.

avedepth = Avg. depth

avldeletebal = Node deleted; update balance information on the way back.

avlinsertbal = Node inserted; update balance information on the way back.

avll = The right subtree is too high: perform a left rotation.

avllr = The left subtree is too high, but its right subtree is higher than the left: perform a left-right rotation.

avlr = The left subtree is too high: perform a right rotation.

avlrl = The right subtree is too high, but its left subtree is higher than the right: perform a right-left rotation.

avltree = AVL tree

avlupdatebal = New balance is #1.

badword = Invalid word. Use only letters A-Z; lowercase letters will be converted to uppercase.

bdelete1 = Case I: The key is in a leaf; remove it.

bdelete2 = Case II: The key is in an internal node; replace it with its successor.

bfind = #1 < #2 < #3 — follow the #4. link.

bfind0 = #1 < #2 — follow the 1st link.

bfindn = #1 < #2 — follow the #3. link.

binheap = Binomial heap

binheap-add-tree = Add another tree.

binheap-bottom-empty = The bottom heap is empty, melding is trivial.

binheap-findmax = Remove the maximum, then find the new maximum — it must be one of the roots in the list.

binheap-findmin = Remove the minimum, then find the new minimum — it must be one of the roots in the list.

binheap-insert = Inserting a new node to a heap is the same as melding it with a 1-node heap.


binheap-link = Trees #1 and #2 have the same order, so link them (#1 becomes a child of #2).

binheap-meld-idea = Gradually add trees from the bottom heap, linking binomial trees of the same order to form larger trees.

binheap-meldchildren = Children of the removed node form a binomial heap which will be melded with the original one.

binheap-newmax = The new maximum is #1.

binheap-newmin = The new minimum is #1.

binheap-next = Proceed to the next node.

binheap-nochildren = The deleted node had no children.

binheap-oldmax = #1 remains the maximum.

binheap-oldmin = #1 remains the minimum.

binheap-top-empty = The top heap is empty, melding is trivial.


binsertleaf = Insert the key into this node.

bleft = Case I: The node is too small, but its left sibling is large enough to donate a key.

bmerge = Case III: Both the node and its sibling are too small; merge them.

bplustree = B+ tree

bright = Case II: The node is too small, but its right sibling is large enough to donate a key.

bsplit = Node is too big; split it.

bst = Binary search tree

bst-delete-case1 = Case I: The node is a leaf, so remove it.

bst-delete-case2 = Case II: The node has only one son.

bst-delete-case3 = Case III: Node #1 has two children. Find its successor — the leftmost node in the right subtree — and replace #1 with it. The successor has at most one child, so it can be removed easily.

bst-delete-go-left = Go left.

bst-delete-linkpar = Remove #1 by linking #2 to its grandparent #3.

bst-delete-newroot = Remove #1. Its son #2 becomes the new root.

bst-delete-replace = Replace #1 by #2 and remove #1.

bst-delete-succ = Node #2 is the successor of #1 (no element lies between #1 and #2). Since #2 has no left child, remove it.

bst-delete-succ-link = Remove the successor by linking #1 under #2.

bst-delete-succ-start = Start at the root of the right subtree.

bst-delete-succ-unlink = Unlink the successor.

bst-delete-unlink = Unlink the node.

bst-insert-left = Since #1 < #2, insert into the left subtree.

bst-insert-right = Since #1 > #2, insert into the right subtree.

bst-insert-start = Start at the root.

bstdeletestart = First, find the node with the given key.

bstfindleft = Since #1 < #2, search the left subtree.

bstfindright = Since #1 > #2, search the right subtree.

bstfindstart = Start searching at the root.

btree = B tree

btreeorder = Order of the B Tree:

button-changekey = Change key

button-clear = Clear

button-create-st = Create suffix tree

button-decreasekey = Decrease key

button-delete = Delete

button-deletemax = Delete maximum

button-deletemin = Delete minimum

button-find = Find

button-findmax = Find max of interval

button-findmin = Find min of interval

button-findsum = Find sum of interval

button-increasekey = Increase key

button-insert = Insert

button-makeset = Add elements

button-meld = Meld

button-pause = Pause

button-random = Random

button-random-unions = Random unions

button-rotate = Rotate

button-save = Save

button-uffind = Find

button-union = Union

changekey = Change of value

changekeyv = Change the key's value.

control = Control

daryheap = d-ary heap

daryheaporder = Order of the d-ary heap:

datastructures = Data structures

decreasekey = Decrease key

decrkeymin = Decrease the key.

delete = Delete #1

delete-max = Delete maximum

delete-min = Delete minimum

deleted = Deleted

dictionary = Dictionaries

display = Display

done = Done.

empty = The tree is empty.

emptyheap = The heap is empty

excess = Excess nodes

fibheap = Fibonacci heap

find = Find #1

findmax = Find the maximum of the interval ⟨#1,#2⟩

findmin = Find the minimum of the interval ⟨#1,#2⟩

findsum = Find sum of the interval ⟨#1,#2⟩

found = Found.

full = full

fullheap = The heap is full

gbdeletedeleted = The node has been already deleted.

gbdeletemark = Mark the node for deletion (it will be removed when the subtree is rebuilt).

gbdeleterebuild = Half of the nodes have been marked for deletion; rebuild the entire tree.

gbfinddeleted = The node has been deleted. Not found.

gbinsertunmark = The key is in the tree but marked deleted. Unmark it.

gbrebuild1 = Phase I: Transform the subtree into a linear list and delete nodes marked for deletion.

gbrebuild2 = Phase II: Transform the list into a perfectly balanced tree.

gbtoohigh = The subtree is too tall; rebuild the entire subtree.

heap = Heap

heap-insert-last = Insert as the last node.

heap-last = This is the last node; the resulting heap will be empty.

heap-replace-root = Replace the root with the last node.

heapchange = Swap the root with the last node, then remove it.

heapempty = The heap is empty.

heapfull = The heap is full.

height = Height

implicit = Show implicit nodes

increasekey = Increase key

incrkeymax = Increase the key.

insert = Insert #1

intervalchangev = After changing a leaf's value, update all ancestor node values on the path from the leaf up to the root.

intervalempty = This node represents an empty interval ⟨#1,#2⟩.

intervalextend = The number of elements has reached the number of leaves; extend the tree.

intervalfind = There are three cases in terms of the relation between the current node's interval C and the searched interval I: \r\n<br/>1. Disjoint — skip the subtree rooted at this node. \r\n<br/>2. Overlap, but C is not contained in I — continue searching both subtrees. \r\n<br/>3. C is contained in I — include this node (update the result) and do not descend further.

intervalin = Node #3 represents interval ⟨#4,#5⟩, which is contained in interval ⟨#1,#2⟩.

intervalinsert = After inserting a new element, update ancestor node values on the path from the leaf up to the root.

intervalkeyempty = The right child is empty, so choose the left child's key #1.

intervalmax = Choose the larger key of #2 and #1.

intervalmin = Choose the smaller key of #1 and #2.

intervalout = Node #3 represents interval ⟨#4,#5⟩, which does not intersect ⟨#1,#2⟩.

intervalpart = Node #3 represents interval ⟨#4,#5⟩, which partially overlaps ⟨#1,#2⟩.

intervalsum = The node's value is the sum of its left and right children: #2 + #1.

intervaltree = Interval tree

intervaltrees = Interval trees

keys = Keys

language = Language

layout = Layout 

layout-compact = Compact

layout-simple = Simple

lazybinheap = Lazy binomial heap

leftheap = Leftist heap


leftinsertright = Since #1 > #2, insert into the right subtree.

leftinsertup = Since #1 ≤ #2, make #2 the right child of #1.

leftmeldnoson = Since #2 has no right child, append the rest of the heap as #2's right child.

leftmeldrightg = Since #1 > #2, continue along the right path.

leftmeldrightl = Since #1 < #2, continue along the right path.

leftmeldstart = Start by comparing the roots (first elements of the right path).

leftmeldswapg = Since #1 ≥ #2, swap the heaps and continue along the right path.

leftmeldswapl = Since #1 ≤ #2, swap the heaps and continue along the right path.

leftrankstart = Make the heap leftist by swapping left and right children according to their ranks. If the right child's rank is greater than the left's, swap them.

leftrankupdate = Update the node ranks.

lipsum = English lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut commodo, neque id accumsan imperdiet, metus felis pharetra est, nec molestie diam elit a lectus. Maecenas erat purus, tempor nec aliquam id, tincidunt vel dui. Cras fermentum suscipit porta. Aenean vel magna vestibulum augue hendrerit tincidunt et nec magna. Aliquam at metus et quam vehicula iaculis. Curabitur sapien est, ultrices id auctor vel, ullamcorper at ipsum. Mauris sodales adipiscing dignissim.

max = max

maxdheapbubbledown = Bubble the node down (swap it with the greatest child) until it is greater than all its children.

maxheap = Max heap

maxheapbubbledown = Bubble the node down (swap it with its greater child) until it is greater than both children.

maxheapbubbleup = Bubble the node up (swap it with its parent) until its parent has greater priority.

maximum = Maximum is  #1.

meld = Meld heaps ###1 and ###2

meldable-pq = Meldable priority queues

min = min

mindheapbubbledown = Bubble the node down (swap with the smallest child) until it is smaller than all its children.

minheap = Min heap

minheapbubbledown = Bubble the node down (swap it with its smaller child) until it is smaller than both children.

minheapbubbleup = Bubble the node up (swap it with its parent) until its parent has smaller priority.

minimum = Minimum is  #1.

mode23 = 2-3 tree correspondence

mode234 = 2-3-4 tree correspondence

newroot = If the tree is empty, create a new root.

next = Next

nodes = Nodes

notfound = Not found.

opt = opt

pairdecr = After decreasing a key, the heap property may be violated — cut the node and re-link it to the heap.

pairincr = After increasing a key, the heap property may be violated — cut the node and re-link it to the heap.

pairing = Pairing

pairingbf = Back–front

pairingfb = Front–back

pairingheap = Pairing heap

pairinglazymulti = Lazy multipass

pairinglrrl = Left-to-right then right-to-left

pairingmultipass = Multipass

pairingnaive = Naive

pairlinkmax = Since #1 < #2, link #1 under #2.

pairlinkmin = Since #1 < #2, link #2 under #1.

pairlrrl1 = For "left-to-right then right-to-left" pairing, first pair trees left-to-right (link 1st with 2nd, 3rd with 4th, ...).

pairlrrl2 = Then link each remaining tree to the last one, working right-to-left.

pairnaive = For the "naive" combining rule, pick one tree and successively link the remaining trees to it.

pq = Priority queues

previous = Previous

rbdelete1 = Case I: Node's sibling is red — recolor some nodes and transform to Case II, III, or IV.

rbdelete2 = Case II: Node's sibling and both its children are black — move the extra black up the tree.

rbdelete3 = Case III: Node's sibling is black, the nearer child is red and the farther one is black — transform to Case IV.

rbdelete4 = Case IV: Node's sibling and its nearer child are black while the farther child is red — recolor and rotate to remove the extra black.

rbinsertcase1 = Case I, red uncle: Color the parent and uncle black, color the grandparent red, and continue from the grandparent.

rbinsertcase2 = Case II, black uncle, "inner" node: Transform this to Case III.

rbinsertcase3 = Case III, black uncle, "outer" node: Perform a rotation and recolor the nodes.

redblack = Red-black tree

rotate = Rotate #1.

rotate-change = Nodes #1 and #2 exchange their roles: #1 becomes a new son of #2...

rotate-change-b = ...and #1 becomes son of #2.

rotate-change-nullb = ...and #1's son [null] becomes son of #2.

rotate-change-parent = ...#1 becomes parent of #2...

rotate-changes = Nodes #1 and #3 exchange their roles: #1 becomes a new son of #4 and #3 becomes a son of #1. Node #2 exchanges its parent #1 for #3.

rotate-fall = This subtree descends.

rotate-header = Rotate #1

rotate-newroot = ...#1 becomes the new root...

rotate-preserves-order = Note that rotation preserves node order.

rotate-rise = This subtree rises.

rotate-root = Node #1 is the root — cannot rotate it.

rotations = Rotations

scapegoat = Scapegoat tree

search = Search

show-order = Show order

show-subtrees = Show subtrees

size = Size

skewheap = Skew heap

skewheapswap = Swap the left and right children of every node on the right path, except the lowest one.

skipdelete = Delete the node from each level.

skipfindstart = Start searching at the top-left corner.

skipinsertafter = Insert the new node immediately after this one.

skipinsertnext = The next key is less than our key — insert to the right.

skipinsertstart = Start at the top-left corner and find the appropriate insertion point.

skiplist = Skiplist

skiplist-delete-found = We have found the node to delete.

skiplist-down = Next key > #1, so go down.

skiplist-head = Toss ##1: HEADS. Promote the node.

skiplist-next = Next key ≤ #1, so go right.

skiplist-tail = Toss ##1: TAILS. Stop.

skiplist-tossing = Toss a coin until it comes TAILS. For each HEAD, promote the node one level; on average there will be 1/2^k nodes on level k.

splay = Splay

splay-found = Found. Splay this node.

splay-higher = Key #1 is not in the tree; splay #2, the smallest larger key instead.

splay-insert-left = Note that the root and its left subtree is less than #1 while the whole root's right subtree is greater than #1.

splay-insert-left2 = Make #1 the new root, attach the current root as its left child and the current root's right subtree as the new right subtree.

splay-insert-right = Note that the root and its right subtree is greater than #1 while the whole root's left subtree is less than #1.

splay-insert-right2 = Make #1 the new root, attach the current root as its right child and the current root's left subtree as the new left subtree.

splay-lower = Key #1 is not in the tree; splay #2, the largest smaller key instead.

splay-root = No grandparent exists; perform a single rotation.

splay-start = Start by splaying #1; this brings it to the root. If #1 is not in the tree, splay the smallest higher or the largest lower key instead.

splay-zig-zag-left = Zig-zag case (#1 is a left child and #2 is a right child): rotate #1 twice.

splay-zig-zag-right = Zig-zag case (#1 is a right child and #2 is a left child): rotate #1 twice.

splay-zig-zig-left = Zig-zig case (both #1 and #2 are left children): rotate #2, then #1.

splay-zig-zig-right = Zig-zig case (both #1 and #2 are right children): rotate #2, then #1.

splaydelete = Delete the root, then splay the right subtree for the minimum.

splaydeleteleft = The root has no right subtree; delete it and make its left child the new root.

splaydeletelink = The minimum of the right subtree becomes the new root; since it has no left child, attach the left subtree.

splaydeleteright = The root has no left subtree; delete it and make its right child the new root.

splayinroot = Now the key (or the nearest smaller/larger key) is at the root.

splaytree = Splay tree

stringology = Stringology

suffixtree = Suffix Tree

suffixtree-found = Each leaf inn this subtree corresponds to a suffix starting with "#1" and stores its position. Found #2 occurrence(s).

sum = sum

sumimum = Sum of the interval is #1.

sxbaftersecondrule = Continue appending.

sxbcontinue = Start extending the active path by the letter '#1'.

sxbdownwalk = Find the position to append the letter '#1'.

sxbdownwalkedge = Continue searching along the edge.

sxbexplicit = Convert the tree to explicit form.

sxbfind = Find the string '#1'.

sxbfirstrule = Extend all applicable nodes (first rule) by the letter '#1'.

sxbphase = Enter phase #1.

sxbsecondrule = Split the edge and append the letter '#1'.

sxbslink = Use the suffix link.

sxbstart = Start inserting the word.

sxbthirdrule = Apply the third rule here; this phase is complete.

sxbupwalk = Move upward to the nearest node.

text = Text

treap = Treap

treapbubbledown = Bubble the node down.

treapbubbleup = Bubble the node up until its parent has greater priority.

treapdeletecase1 = The node is now a leaf and can be deleted.

trie = Trie

triea = Stringology

triedelete = Delete "#1"

triedeletedbdb = Delete a letter.

triedeletedbend = Remove the dead branch.

triedeletefindunsu = Cannot delete a word that is not present in the tree.

triedeletenote1 = First, find the given word in the tree.

triedeletenote2 = Remove the end-of-word mark, then delete any dead branch (nodes no longer part of any word).

triedeletewodb = Delete the dead branch.

triefind = Find "#1"

triefindending1 = Letter '#1' is not present as a child of this node; the word is not in the tree.

triefindending2 = The entire word was read, but no word ends here; the word is not in the tree.

triefindmovedown = Follow the edge labeled '#1'.

triefindnote = Traverse edges labeled with the word's letters. If the entire word is read and the current node is marked as an end-of-word, the tree contains the word.

triefindsucc = The word was read and the current node is marked as an end-of-word; the word is in the tree.

triei = Trie

trieinsert = Insert "#1"

trieinserteow = The whole word has been inserted; mark the end-of-word here.

trieinsertneow = The word is already in the tree.

trieinsertnote = Traverse the trie one letter at a time: follow an existing edge for each letter or create a new child edge if missing.

trieinsertwch = Follow the edge labeled '#1'.

trieinsertwoch = Append the letter '#1'.

trierootstart = Start at the root.

uf-byrank = By rank

uf-compresion = Path compression

uf-find-heuristic = Find:

uf-find-start = Start searching for the representative.

uf-found-root = This is the representative of the set containing #1.

uf-go-old-parent = Move to the former parent.

uf-go-up = Move toward the root.

uf-halving = Path halving

uf-link = Link #1 directly under #2.

uf-none = Naïve

uf-path-halved = Note that the path from #1 to the root has been halved.

uf-path-split = Note how the path from #1 to the root has been split.

uf-same-set = Elements are already in the same set; no linking needed.

uf-splitting = Path splitting

uf-union-heuristic = Union:

ufa = Union Find

ufcompression = Compress the marked path.

ufdown = Descend.

ufdownstart = Link all visited elements back to the representative.

uffind = Find a representative

ufi = Union Find

ufunion = Union

ufunionfirstsecond = Link #2 under #1 (this node has higher rank).

ufunionsamerank = Both representatives have the same rank: link #2 under #1 and increment #1's rank.

ufunionsecondfirst = Link #1 under #2 (this node has higher rank).

ufunionsimple = Link the second representative under the first.

ufupspecial = Link the grandchild.

zoomio = Zoom in/out