An algorithm that solves the travelling salesman problem to optimality. It has a performance of O(n!) but is actually very complicated and slower than the naive (brute force) algorithm. It makes use of a converse approach. That is while the naive algorithm finds the edges for every possibility, this algorithm finds the possibilities for every edge. It can possibly be made into a mathematical equation. Developed in February 2012.

A notion involving two equations to number over two different sub-sequences. It has a close relationship with the notion of numeral systems. Developed in March 2012.

A very simple and efficient algorithm to generate a particular permutation given its corresponding index/rank. The core of the algorithm is the efficient generation of the Lehmer-code sequence using a new method. Developed in May 2012.

An algorithm to generate all permutations. It starts from a base permutation sequence, for example {0, 1, 2, ..., n-2, n-1} , and progressively generates the rest in recursive calls, doing constant work per permutation. It is simple to implement but rather tricky to understand. Developed in June 2012.

A simple algorithm to perform matrix multiplication in linear time with total matrix size. But this is true only for the special case where inputs are all natural numbers or zero. Developed in August 2012.

The pattern followed by palindromic numbers is analysed, then an algorithm is provided that implements this pattern to generate all palindromic numbers in increasing order starting from any given palindromic number, taking constant time per number generated. Finally a purely mathematical method is derived that computes the nth palindromic number, in time proportional to the number of digits of n. Developed in April 2013.

We generally number/index over a list of items sequentially. This is an algorithm to number/index over a list of items logarithmically *(though this may not be a good description!)* Developed in June 2013.

A new, simple and very efficient iterative algorithm to parse a mathematical expression into a structure which a computer can easily evaluate. The simplest structure used is the Binary Expression Tree. The stack array is then used for optimal space efficiency. The algorithm performance is O(n). It can be extended to parsing of computer application source codes inside a compiler. Originally developed to parse the equation of a graph in the Graph Plotter 3D software. Developed in December 2013 - last major improvement in February 2015.

A new, simple and very efficient iterative algorithm to convert a sorted list to a complete binary search tree (BST). It uses constant memory and does not compare list nodes. It is based on the same basic principle as that used by the expression parsing algorithm, along with an added rule to ensure tree completeness. And just like for the other algorithm, the basic principle causes this algorithm to have a performance of O(n), where n is the size of the list. Developed in February 2015.

How can we generate any non-decreasing sequence of integers having a repetitive pattern? For example the sequence {0,0,1,2,2,2, 3,3,4,5,5,5, 6,6,7,8,8,8, ...}. The fullfloor function is a new, simple and efficient mathematical method to generate such a sequence. It is originally developed to be used to generate sequences of numbers of the form '*not a multiple of *', as part of working towards generating prime numbers. Developed in June 2015.

A new, simple and efficient algorithm to generate prime numbers progressively. It turns out to be a *non-sieve* version of the *sieve of Eratosthenes*. It is based on generating all integers progressively starting from 2, taking O(n log n) time and O(sqrt(n)) space, where n is the largest integer generated so far. An improved version turns out to be a *non-sieve* version of the *sieve of Euler*. It has at its core the fundamental nature of prime numbers, which is used to prove the twin prime conjecture. Developed in December 2015 - last major improvement in May 2016.

A new and very efficient algorithm to solve the maximum matching problem for an unweighted graph, in O(E log V) time where E and V are respectively the number of edges and vertexes of the graph. It consists of two main parts: a simple vertex get-and-match traversal, followed by an improved backtracking-search for any residual unmatched vertexes. Developed in July 2016 - last major improvement in July 2017.

*Implemented algorithms athttps://github.com/rhyscitlema/algorithms*