Algorithm

In mathematics and computer science, an algorithm (/ˈælɡərɪðəm/ ) is a finite sequence of

mathematically rigorous instructions, typically used to solve a class of specific problems or to
perform a computation.[1] Algorithms are used as specifications for performing calculations and
data processing. More advanced algorithms can use conditionals to divert the code execution
through various routes (referred to as automated decision-making) and deduce valid inferences
(referred to as automated reasoning), achieving automation eventually. Using human
characteristics as descriptors of machines in metaphorical ways was already practiced by Alan
Turing with terms such as "memory", "search" and "stimulus".[2]

Flowchart of using successive

subtractions to find the greatest
common divisor of number r and s
In contrast, a heuristic is an approach to problem solving that may not be fully specified or may
not guarantee correct or optimal results, especially in problem domains where there is no well-
defined correct or optimal result.[3] For example, social media recommender systems rely on
heuristics in such a way that, although widely characterized as "algorithms" in 21st century
popular media, cannot deliver correct results due to the nature of the problem.

As an effective method, an algorithm can be expressed within a finite amount of space and
time[4] and in a well-defined formal language[5] for calculating a function.[6] Starting from an
initial state and initial input (perhaps empty),[7] the instructions describe a computation that,
when executed, proceeds through a finite[8] number of well-defined successive states, eventually
producing "output"[9] and terminating at a final ending state. The transition from one state to the
next is not necessarily deterministic; some algorithms, known as randomized algorithms,
incorporate random input.[10]

Etymology
Around 825 AD, Persian scientist and polymath Muḥammad ibn Mūsā al-Khwārizmī wrote kitāb
al-ḥisāb al-hindī ("Book of Indian computation") and kitab al-jam' wa'l-tafriq al-ḥisāb al-hindī
("Addition and subtraction in Indian arithmetic"). Both of these texts are lost in the original Arabic
at this time. However, his other book on algebra remains.[1]

In the early 12th century, Latin translations of said al-Khwarizmi texts involving the Hindu–Arabic
numeral system and arithmetic appeared: Liber Alghoarismi de practica arismetrice (attributed to
John of Seville) and Liber Algorismi de numero Indorum (attributed to Adelard of Bath).[2] Hereby,
alghoarismi or algorismi is the Latinization of Al-Khwarizmi's name; the text starts with the
phrase Dixit Algorismi ("Thus spoke Al-Khwarizmi").[3]

Around 1230, the English word algorism is attested and then by Chaucer in 1391, English
adopted the French term.[4][5] In the 15th century, under the influence of the Greek word ἀριθμός
(arithmos, "number"; cf. "arithmetic"), the Latin word was altered to algorithmus.
Definition
One informal definition is "a set of rules that precisely defines a sequence of operations",[11]
which would include all computer programs (including programs that do not perform numeric
calculations), and (for example) any prescribed bureaucratic procedure[12] or cook-book
recipe.[13] In general, a program is an algorithm only if it stops eventually[14]—even though infinite
loops may sometimes prove desirable. Boolos, Jeffrey & 1974, 1999 define an algorithm to be a
set of instructions for determining an output, given explicitly, in a form that can be followed by
either a computing machine, or a human who could only carry out specific elementary
operations on symbols.[15]

The concept of algorithm is also used to define the notion of decidability—a notion that is central
for explaining how formal systems come into being starting from a small set of axioms and
rules. In logic, the time that an algorithm requires to complete cannot be measured, as it is not
apparently related to the customary physical dimension. From such uncertainties, that
characterize ongoing work, stems the unavailability of a definition of algorithm that suits both
concrete (in some sense) and abstract usage of the term.

Most algorithms are intended to be implemented as computer programs. However, algorithms

are also implemented by other means, such as in a biological neural network (for example, the
human brain implementing arithmetic or an insect looking for food), in an electrical circuit, or in
a mechanical device.

History

Ancient algorithms
Since antiquity, step-by-step procedures for solving mathematical problems have been attested.
This includes Babylonian mathematics (around 2500 BC),[16] Egyptian mathematics (around
1550 BC),[16] Indian mathematics (around 800 BC and later; e.g. Shulba Sutras, Kerala School,
and Brāhmasphuṭasiddhānta),[17][18] The Ifa Oracle (https://www.jstor.org/stable/3027363)
(around 500 BC), Greek mathematics (around 240 BC, e.g. sieve of Eratosthenes and Euclidean
algorithm),[19] and Arabic mathematics (9th century, e.g. cryptographic algorithms for code-
breaking based on frequency analysis).[20] The first cryptographic algorithm for deciphering
encrypted code was developed by Al-Kindi, a 9th-century Arab mathematician, in A Manuscript
On Deciphering Cryptographic Messages. He gave the first description of cryptanalysis by
frequency analysis, the earliest codebreaking algorithm.[20]

Ancient Near East

The earliest evidence of algorithms is found in the Babylonian mathematics of ancient
Mesopotamia (modern Iraq). A Sumerian clay tablet found in Shuruppak near Baghdad and
dated to c. 2500 BC described the earliest division algorithm.[16] During the Hammurabi dynasty
c. 1800 – c. 1600 BC, Babylonian clay tablets described algorithms for computing formulas.[21]
Algorithms were also used in Babylonian astronomy. Babylonian clay tablets describe and
employ algorithmic procedures to compute the time and place of significant astronomical
events.[22]

Algorithms for arithmetic are also found in ancient Egyptian mathematics, dating back to the
Rhind Mathematical Papyrus c. 1550 BC.[16] Algorithms were later used in ancient Hellenistic
mathematics. Two examples are the Sieve of Eratosthenes, which was described in the
Introduction to Arithmetic by Nicomachus,[23][19]: Ch 9.2 and the Euclidean algorithm, which was
first described in Euclid's Elements (c. 300 BC).[19]: Ch 9.1
Computers

Weight-driven clocks
Bolter credits the invention of the weight-driven clock as "The key invention [of Europe in the
Middle Ages]", in particular, the verge escapement[24] that provides us with the tick and tock of a
mechanical clock. "The accurate automatic machine"[25] led immediately to "mechanical
automata" beginning in the 13th century and finally to "computational machines"—the difference
engine and analytical engines of Charles Babbage and Countess Ada Lovelace, mid-19th
century.[26] Lovelace is credited with the first creation of an algorithm intended for processing on
a computer—Babbage's analytical engine, the first device considered a real Turing-complete
computer instead of just a calculator—and is sometimes called "history's first programmer" as a
result, though a full implementation of Babbage's second device would not be realized until
decades after her lifetime.

Electromechanical relay
Bell and Newell (1971) indicate that the Jacquard loom (1801), precursor to Hollerith cards
(punch cards, 1887), and "telephone switching technologies" were the roots of a tree leading to
the development of the first computers.[27] By the mid-19th century the telegraph, the precursor
of the telephone, was in use throughout the world, its discrete and distinguishable encoding of
letters as "dots and dashes" a common sound. By the late 19th century, the ticker tape (c. 1870s)
was in use, as was the use of Hollerith cards in the 1890 U.S. census. Then came the teleprinter
(c. 1910) with its punched-paper use of Baudot code on tape.

Telephone-switching networks of electromechanical relays (invented 1835) was behind the work
of George Stibitz (1937), the inventor of the digital adding device. As he worked in Bell
Laboratories, he observed the "burdensome' use of mechanical calculators with gears. "He went
home one evening in 1937 intending to test his idea... When the tinkering was over, Stibitz had
constructed a binary adding device".[28] The mathematician Martin Davis supported the
particular importance of the electromechanical relay.[29]
Formalization

Ada Lovelace's diagram from "Note

G", the first published computer
algorithm

In 1928, a partial formalization of the modern concept of algorithms began with attempts to
solve the Entscheidungsproblem (decision problem) posed by David Hilbert. Later formalizations
were framed as attempts to define "effective calculability"[30] or "effective method".[31] Those
formalizations included the Gödel–Herbrand–Kleene recursive functions of 1930, 1934 and
1935, Alonzo Church's lambda calculus of 1936, Emil Post's Formulation 1 of 1936, and Alan
Turing's Turing machines of 1936–37 and 1939.

Representations
Algorithms can be expressed in many kinds of notation, including natural languages,
pseudocode, flowcharts, drakon-charts, programming languages or control tables (processed by
interpreters). Natural language expressions of algorithms tend to be verbose and ambiguous
and are rarely used for complex or technical algorithms. Pseudocode, flowcharts, drakon-charts
and control tables are structured ways to express algorithms that avoid many of the ambiguities
common in statements based on natural language. Programming languages are primarily
intended for expressing algorithms in a form that can be executed by a computer, but they are
also often used as a way to define or document algorithms.
Turing machines
There is a wide variety of representations possible and one can express a given Turing machine
program as a sequence of machine tables (see finite-state machine, state-transition table and
control table for more), as flowcharts and drakon-charts (see state diagram for more), or as a
form of rudimentary machine code or assembly code called "sets of quadruples" (see Turing
machine for more). Representations of algorithms can also be classified into three accepted
levels of Turing machine description: high level description, implementation description, and
formal description.[32] A high level description describes qualities of the algorithm itself, ignoring
how it is implemented on the Turing machine.[32] An implementation description describes the
general manner in which the machine moves its head and stores data in order to carry out the
algorithm, but doesn't give exact states.[32] In the most detail, a formal description gives the
exact state table and list of transitions of the Turing machine.[32]

Flowchart representation
The graphical aid called a flowchart offers a way to describe and document an algorithm (and a
computer program corresponding to it). Like the program flow of a Minsky machine, a flowchart
always starts at the top of a page and proceeds down. Its primary symbols are only four: the
directed arrow showing program flow, the rectangle (SEQUENCE, GOTO), the diamond (IF-THEN-
ELSE), and the dot (OR-tie). The Böhm–Jacopini canonical structures are made of these
primitive shapes. Sub-structures can "nest" in rectangles, but only if a single exit occurs from the
superstructure. The symbols and their use to build the canonical structures are shown in the
diagram.[33]
Algorithmic analysis
It is frequently important to know how much of a particular resource (such as time or storage) is
theoretically required for a given algorithm. Methods have been developed for the analysis of
algorithms to obtain such quantitative answers (estimates); for example, an algorithm which
adds up the elements of a list of n numbers would have a time requirement of , using big O
notation. At all times the algorithm only needs to remember two values: the sum of all the
elements so far, and its current position in the input list. Therefore, it is said to have a space
requirement of , if the space required to store the input numbers is not counted, or if
it is counted.

Different algorithms may complete the same task with a different set of instructions in less or
more time, space, or 'effort' than others. For example, a binary search algorithm (with cost
) outperforms a sequential search (cost ) when used for table lookups on sorted
lists or arrays.

Formal versus empirical

The analysis, and study of algorithms is a discipline of computer science, and is often practiced
abstractly without the use of a specific programming language or implementation. In this sense,
algorithm analysis resembles other mathematical disciplines in that it focuses on the underlying
properties of the algorithm and not on the specifics of any particular implementation. Usually,
pseudocode is used for analysis as it is the simplest and most general representation. However,
ultimately, most algorithms are usually implemented on particular hardware/software platforms
and their algorithmic efficiency is eventually put to the test using real code. For the solution of a
"one off" problem, the efficiency of a particular algorithm may not have significant consequences
(unless n is extremely large) but for algorithms designed for fast interactive, commercial or long
life scientific usage it may be critical. Scaling from small n to large n frequently exposes
inefficient algorithms that are otherwise benign.
Empirical testing is useful because it may uncover unexpected interactions that affect
performance. Benchmarks may be used to compare before/after potential improvements to an
algorithm after program optimization. Empirical tests cannot replace formal analysis, though,
and are not trivial to perform in a fair manner.[34]

Execution efficiency
To illustrate the potential improvements possible even in well-established algorithms, a recent
significant innovation, relating to FFT algorithms (used heavily in the field of image processing),
can decrease processing time up to 1,000 times for applications like medical imaging.[35] In
general, speed improvements depend on special properties of the problem, which are very
common in practical applications.[36] Speedups of this magnitude enable computing devices
that make extensive use of image processing (like digital cameras and medical equipment) to
consume less power.

Design
Algorithm design refers to a method or a mathematical process for problem-solving and
engineering algorithms. The design of algorithms is part of many solution theories, such as
divide-and-conquer or dynamic programming within operation research. Techniques for
designing and implementing algorithm designs are also called algorithm design patterns,[37] with
examples including the template method pattern and the decorator pattern. One of the most
important aspects of algorithm design is resource (run-time, memory usage) efficiency; the big
O notation is used to describe e.g., an algorithm's run-time growth as the size of its input
increases.
Structured programming
Per the Church–Turing thesis, any algorithm can be computed by a model known to be Turing
complete. In fact, it has been demonstrated that Turing completeness requires only four
instruction types—conditional GOTO, unconditional GOTO, assignment, HALT. However, Kemeny
and Kurtz observe that, while "undisciplined" use of unconditional GOTOs and conditional IF-
THEN GOTOs can result in "spaghetti code", a programmer can write structured programs using
only these instructions; on the other hand "it is also possible, and not too hard, to write badly
structured programs in a structured language".[38] Tausworthe augments the three Böhm-
Jacopini canonical structures:[39] SEQUENCE, IF-THEN-ELSE, and WHILE-DO, with two more: DO-
WHILE and CASE.[40] An additional benefit of a structured program is that it lends itself to proofs
of correctness using mathematical induction.[41]

Classification
There are various ways to classify algorithms, each with its own merits.

By implementation
One way to classify algorithms is by implementation means.

Recursion
A recursive algorithm is one that invokes
(makes reference to) itself repeatedly
until a certain condition
(also known as int
termination condition) gcd(int
A, int
matches, which is a
B) {
method common to if
functional (B == 0)
programming. Iterative
return
algorithms use A;
repetitive constructs else
if (A >
like loops and
B)
sometimes additional
data structures like return
stacks to solve the gcd(A-
B,B);
given problems. Some else
problems are naturally
suited for one return
implementation or the gcd(A,B-
A);
other. For example,
}
towers of Hanoi is well
understood using Recursive C
recursive implementation
implementation. Every of Euclid's
recursive version has algorithm from
an equivalent (but the above
possibly more or less flowchart
complex) iterative
version, and vice versa.
Serial, parallel or distributed
Algorithms are usually discussed with
the assumption that computers execute
one instruction of an algorithm at a
time. Those computers are sometimes
called serial computers. An algorithm
designed for such an environment is
called a serial algorithm, as opposed to
parallel algorithms or distributed
algorithms. Parallel algorithms are
algorithms that take advantage of
computer architectures where multiple
processors can work on a problem at
the same time. Distributed algorithms
are algorithms that use multiple
machines connected with a computer
network. Parallel and distributed
algorithms divide the problem into more
symmetrical or asymmetrical
subproblems and collect the results
back together. For example, a CPU
would be an example of a parallel
algorithm. The resource consumption in
such algorithms is not only processor
cycles on each processor but also the
communication overhead between the
processors. Some sorting algorithms
can be parallelized efficiently, but their
communication overhead is expensive.
Iterative algorithms are generally
parallelizable, but some problems have
no parallel algorithms and are called
inherently serial problems.
Deterministic or non-deterministic
Deterministic algorithms solve the
problem with exact decision at every
step of the algorithm whereas non-
deterministic algorithms solve problems
via guessing although typical guesses
are made more accurate through the
use of heuristics.
Exact or approximate
While many algorithms reach an exact
solution, approximation algorithms seek
an approximation that is closer to the
true solution. The approximation can be
reached by either using a deterministic
or a random strategy. Such algorithms
have practical value for many hard
problems. One of the examples of an
approximate algorithm is the Knapsack
problem, where there is a set of given
items. Its goal is to pack the knapsack
to get the maximum total value. Each
item has some weight and some value.
Total weight that can be carried is no
more than some fixed number X. So, the
solution must consider weights of items
as well as their value.[42]
Quantum algorithm
Quantum algorithms run on a realistic
model of quantum computation. The
term is usually used for those
algorithms which seem inherently
quantum, or use some essential feature
of Quantum computing such as
quantum superposition or quantum
entanglement.
By design paradigm
Another way of classifying algorithms is by their design methodology or paradigm. There is a
certain number of paradigms, each different from the other. Furthermore, each of these
categories includes many different types of algorithms. Some common paradigms are:

Brute-force or exhaustive search

Brute force is a method of problem-
solving that involves systematically
trying every possible option until the
optimal solution is found. This approach
can be very time consuming, as it
requires going through every possible
combination of variables. However, it is
often used when other methods are not
available or too complex. Brute force
can be used to solve a variety of
problems, including finding the shortest
path between two points and cracking
passwords.
Divide and conquer
A divide-and-conquer algorithm
repeatedly reduces an instance of a
problem to one or more smaller
instances of the same problem (usually
recursively) until the instances are small
enough to solve easily. One such
example of divide and conquer is merge
sorting. Sorting can be done on each
segment of data after dividing data into
segments and sorting of entire data can
be obtained in the conquer phase by
merging the segments. A simpler variant
of divide and conquer is called a
decrease-and-conquer algorithm, which
solves an identical subproblem and
uses the solution of this subproblem to
solve the bigger problem. Divide and
conquer divides the problem into
multiple subproblems and so the
conquer stage is more complex than
decrease and conquer algorithms. An
example of a decrease and conquer
algorithm is the binary search algorithm.
Search and enumeration
Many problems (such as playing chess)
can be modeled as problems on graphs.
A graph exploration algorithm specifies
rules for moving around a graph and is
useful for such problems. This category
also includes search algorithms, branch
and bound enumeration and
backtracking.
Randomized algorithm
Such algorithms make some choices
randomly (or pseudo-randomly). They
can be very useful in finding
approximate solutions for problems
where finding exact solutions can be
impractical (see heuristic method
below). For some of these problems, it
is known that the fastest
approximations must involve some
randomness.[43] Whether randomized
algorithms with polynomial time
complexity can be the fastest algorithm
for some problems is an open question
known as the P versus NP problem.
There are two large classes of such
algorithms:

1. Monte Carlo algorithms return a

correct answer with high-probability.
E.g. RP is the subclass of these that
run in polynomial time.
2. Las Vegas algorithms always return
the correct answer, but their running
time is only probabilistically bound,
e.g. ZPP.
Reduction of complexity
This technique involves solving a
difficult problem by transforming it into
a better-known problem for which we
have (hopefully) asymptotically optimal
algorithms. The goal is to find a
reducing algorithm whose complexity is
not dominated by the resulting reduced
algorithm's. For example, one selection
algorithm for finding the median in an
unsorted list involves first sorting the
list (the expensive portion) and then
pulling out the middle element in the
sorted list (the cheap portion). This
technique is also known as transform
and conquer.
Back tracking
In this approach, multiple solutions are
built incrementally and abandoned when
 it is determined that they cannot lead to
a valid full solution.

Optimization problems
For optimization problems there is a more specific classification of algorithms; an algorithm for
such problems may fall into one or more of the general categories described above as well as
into one of the following:

Linear programming
When searching for optimal solutions to
a linear function bound to linear equality
and inequality constraints, the
constraints of the problem can be used
directly in producing the optimal
solutions. There are algorithms that can
solve any problem in this category, such
as the popular simplex algorithm.[44]
Problems that can be solved with linear
programming include the maximum flow
problem for directed graphs. If a
problem additionally requires that one or
more of the unknowns must be an
integer then it is classified in integer
programming. A linear programming
algorithm can solve such a problem if it
can be proved that all restrictions for
integer values are superficial, i.e., the
solutions satisfy these restrictions
anyway. In the general case, a
specialized algorithm or an algorithm
that finds approximate solutions is used,
depending on the difficulty of the
problem.
Dynamic programming
When a problem shows optimal
substructures—meaning the optimal
solution to a problem can be
constructed from optimal solutions to
subproblems—and overlapping
subproblems, meaning the same
subproblems are used to solve many
different problem instances, a quicker
approach called dynamic programming
avoids recomputing solutions that have
already been computed. For example,
Floyd–Warshall algorithm, the shortest
path to a goal from a vertex in a
weighted graph can be found by using
the shortest path to the goal from all
adjacent vertices. Dynamic
programming and memoization go
together. The main difference between
dynamic programming and divide and
conquer is that subproblems are more
or less independent in divide and
conquer, whereas subproblems overlap
in dynamic programming. The difference
between dynamic programming and
straightforward recursion is in caching
or memoization of recursive calls. When
subproblems are independent and there
is no repetition, memoization does not
help; hence dynamic programming is
not a solution for all complex problems.
By using memoization or maintaining a
table of subproblems already solved,
dynamic programming reduces the
exponential nature of many problems to
polynomial complexity.
The greedy method
A greedy algorithm is similar to a
dynamic programming algorithm in that
it works by examining substructures, in
this case not of the problem but of a
given solution. Such algorithms start
with some solution, which may be given
or have been constructed in some way,
and improve it by making small
modifications. For some problems they
can find the optimal solution while for
others they stop at local optima, that is,
at solutions that cannot be improved by
the algorithm but are not optimum. The
most popular use of greedy algorithms
is for finding the minimal spanning tree
where finding the optimal solution is
possible with this method. Huffman
Tree, Kruskal, Prim, Sollin are greedy
algorithms that can solve this
optimization problem.
The heuristic method
In optimization problems, heuristic
algorithms can be used to find a
solution close to the optimal solution in
cases where finding the optimal solution
is impractical. These algorithms work by
getting closer and closer to the optimal
solution as they progress. In principle, if
run for an infinite amount of time, they
will find the optimal solution. Their merit
is that they can find a solution very close
to the optimal solution in a relatively
short time. Such algorithms include
local search, tabu search, simulated
annealing, and genetic algorithms.
Some of them, like simulated annealing,
are non-deterministic algorithms while
others, like tabu search, are
deterministic. When a bound on the
error of the non-optimal solution is
known, the algorithm is further
categorized as an approximation
algorithm.
Legal status
Algorithms, by themselves, are not usually patentable. In the United States, a claim consisting
solely of simple manipulations of abstract concepts, numbers, or signals does not constitute
"processes" (USPTO 2006), so algorithms are not patentable (as in Gottschalk v. Benson).
However practical applications of algorithms are sometimes patentable. For example, in
Diamond v. Diehr, the application of a simple feedback algorithm to aid in the curing of synthetic
rubber was deemed patentable. The patenting of software is controversial,[45] and there are
criticized patents involving algorithms, especially data compression algorithms, such as Unisys's
LZW patent. Additionally, some cryptographic algorithms have export restrictions (see export of
cryptography).

Examples
One of the simplest algorithms is to find the largest number in a list of numbers of random order.
Finding the solution requires looking at every number in the list. From this follows a simple
algorithm, which can be stated in a high-level description in English prose, as:

High-level description:

1. If there are no numbers in the set,

then there is no highest number.
2. Assume the first number in the set is
the largest number in the set.
 3. For each remaining number in the
set: if this number is larger than the
current largest number, consider this
number to be the largest number in
the set.
4. When there are no numbers left in the
set to iterate over, consider the
current largest number to be the
largest number of the set.
(Quasi-)formal description: Written in prose but much closer to the high-level language of a
computer program, the following is the more formal coding of the algorithm in pseudocode or
pidgin code:

Algorithm LargestNumber
Input: A list of numbers L.
Output: The largest number
in the list L.
 if L.size = 0 return null
largest ← L[0]
for each item in L, do
if item > largest, then
largest ← item
return largest

"←" denotes assignment. For instance, "largest

← item" means that the value of largest

changes to the value of item.

"return" terminates the algorithm and outputs

the following value.

See also

Abstract machine Mathematics

portal
ALGOL
Algorithm aversion Computer
programming
Algorithm engineering portal

Algorithm
characterizations
Algorithmic bias
Algorithmic composition
Algorithmic entities
Algorithmic synthesis
Algorithmic technique
Algorithmic topology
Garbage in, garbage out
Introduction to
Algorithms (textbook)
 Government by algorithm
List of algorithms
List of algorithm general topics
Regulation of algorithms
Theory of computation
Computability theory
Computational complexity theory
Computational mathematics

Notes

1. "Definition of ALGORITHM" (https://www.m

erriam-webster.com/dictionary/algorithm) .
Merriam-Webster Online Dictionary.
Archived (https://web.archive.org/web/202
00214074446/https://www.merriam-webst
 er.com/dictionary/algorithm) from the
original on February 14, 2020. Retrieved
November 14, 2019.
2. Blair, Ann, Duguid, Paul, Goeing, Anja-Silvia
and Grafton, Anthony. Information: A
Historical Companion, Princeton: Princeton
University Press, 2021. p. 247
3. David A. Grossman, Ophir Frieder,
Information Retrieval: Algorithms and
Heuristics, 2nd edition, 2004,
ISBN 1402030045
4. "Any classical mathematical algorithm, for
example, can be described in a finite
number of English words" (Rogers 1987:2).
5. Well defined with respect to the agent that
executes the algorithm: "There is a
computing agent, usually human, which can
react to the instructions and carry out the
computations" (Rogers 1987:2).
6. "an algorithm is a procedure for computing
a function (with respect to some chosen
notation for integers) ... this limitation (to
numerical functions) results in no loss of
generality", (Rogers 1987:1).
7. "An algorithm has zero or more inputs, i.e.,
quantities which are given to it initially
before the algorithm begins" (Knuth
1973:5).
 8. "A procedure which has all the
characteristics of an algorithm except that
it possibly lacks finiteness may be called a
'computational method' " (Knuth 1973:5).
9. "An algorithm has one or more outputs, i.e.
quantities which have a specified relation to
the inputs" (Knuth 1973:5).
10. Whether or not a process with random
interior processes (not including the input)
is an algorithm is debatable. Rogers opines
that: "a computation is carried out in a
discrete stepwise fashion, without the use
of continuous methods or analogue
devices ... carried forward deterministically,
without resort to random methods or
devices, e.g., dice" (Rogers 1987:2).
11. Stone 1973:4
12. Simanowski, Roberto (2018). The Death
Algorithm and Other Digital Dilemmas (http
s://books.google.com/books?id=RJV5DwA
AQBAJ) . Untimely Meditations. Vol. 14.
Translated by Chase, Jefferson. Cambridge,
Massachusetts: MIT Press. p. 147.
ISBN 9780262536370. Archived (https://we
b.archive.org/web/20191222120705/http
s://books.google.com/books?id=RJV5DwA
AQBAJ) from the original on December 22,
2019. Retrieved May 27, 2019. "[...] the next
level of abstraction of central bureaucracy:
globally operating algorithms."
13. Dietrich, Eric (1999). "Algorithm". In Wilson,
Robert Andrew; Keil, Frank C. (eds.). The
MIT Encyclopedia of the Cognitive Sciences
(https://books.google.com/books?id=-wt1a
ZrGXLYC) . MIT Cognet library. Cambridge,
Massachusetts: MIT Press (published
2001). p. 11. ISBN 9780262731447.
Retrieved July 22, 2020. "An algorithm is a
recipe, method, or technique for doing
something."
14. Stone requires that "it must terminate in a
finite number of steps" (Stone 1973:7–8).
15. Boolos and Jeffrey 1974,1999:19
16. Chabert, Jean-Luc (2012). A History of
Algorithms: From the Pebble to the
Microchip. Springer Science & Business
Media. pp. 7–8. ISBN 9783642181924.
17. Sriram, M. S. (2005). "Algorithms in Indian
Mathematics" (https://books.google.com/b
ooks?id=qfJdDwAAQBAJ&pg=PA153) . In
Emch, Gerard G.; Sridharan, R.; Srinivas, M.
D. (eds.). Contributions to the History of
Indian Mathematics. Springer. p. 153.
ISBN 978-93-86279-25-5.
18. Hayashi, T. (2023, January 1). Brahmagupta
(https://www.britannica.com/biography/Bra
hmagupta) . Encyclopedia Britannica.
19. Cooke, Roger L. (2005). The History of
Mathematics: A Brief Course. John Wiley &
Sons. ISBN 978-1-118-46029-0.
20. Dooley, John F. (2013). A Brief History of
Cryptology and Cryptographic Algorithms.
Springer Science & Business Media.
pp. 12–3. ISBN 9783319016283.
21. Knuth, Donald E. (1972). "Ancient
Babylonian Algorithms" (https://web.archiv
e.org/web/20121224100137/http://steiner.
math.nthu.edu.tw/disk5/js/computer/1.pd
f) (PDF). Commun. ACM. 15 (7): 671–677.
doi:10.1145/361454.361514 (https://doi.or
g/10.1145%2F361454.361514) .
ISSN 0001-0782 (https://www.worldcat.or
g/issn/0001-0782) . S2CID 7829945 (http
s://api.semanticscholar.org/CorpusID:7829
945) . Archived from the original (http://stei
ner.math.nthu.edu.tw/disk5/js/computer/1.
pdf) (PDF) on December 24, 2012.
22. Aaboe, Asger (2001). Episodes from the
Early History of Astronomy. New York:
Springer. pp. 40–62. ISBN 978-0-387-
95136-2.
23. Ast, Courtney. "Eratosthenes" (http://www.
math.wichita.edu/history/men/eratosthene
s.html) . Wichita State University:
Department of Mathematics and Statistics.
Archived (https://web.archive.org/web/201
50227150653/http://www.math.wichita.ed
u/history/men/eratosthenes.html) from
the original on February 27, 2015. Retrieved
February 27, 2015.
24. Bolter 1984:24
25. Bolter 1984:26
26. Bolter 1984:33–34, 204–206.
27. Bell and Newell diagram 1971:39, cf. Davis
2000
28. * Melina Hill, Valley News Correspondent, A
Tinkerer Gets a Place in History, Valley
News West Lebanon NH, Thursday, March
31, 1983, p. 13.
29. Davis 2000:14
30. Kleene 1943 in Davis 1965:274
31. Rosser 1939 in Davis 1965:225
32. Sipser 2006:157
33. cf Tausworthe 1977
34. Kriegel, Hans-Peter; Schubert, Erich; Zimek,
Arthur (2016). "The (black) art of run-time
evaluation: Are we comparing algorithms or
implementations?". Knowledge and
Information Systems. 52 (2): 341–378.
doi:10.1007/s10115-016-1004-2 (https://do
i.org/10.1007%2Fs10115-016-1004-2) .
ISSN 0219-1377 (https://www.worldcat.or
g/issn/0219-1377) . S2CID 40772241 (http
s://api.semanticscholar.org/CorpusID:4077
2241) .
35. Gillian Conahan (January 2013). "Better
Math Makes Faster Data Networks" (http://
discovermagazine.com/2013/jan-feb/34-be
tter-math-makes-faster-data-networks) .
discovermagazine.com. Archived (https://w
eb.archive.org/web/20140513212427/htt
p://discovermagazine.com/2013/jan-feb/3
4-better-math-makes-faster-data-network
s) from the original on May 13, 2014.
Retrieved May 13, 2014.
36. Haitham Hassanieh, Piotr Indyk, Dina
Katabi, and Eric Price, "ACM-SIAM
Symposium On Discrete Algorithms (SODA)
(http://siam.omnibooksonline.com/2012SO
DA/data/papers/500.pdf) Archived (http
s://web.archive.org/web/2013070418080
6/http://siam.omnibooksonline.com/2012S
ODA/data/papers/500.pdf) July 4, 2013, at
the Wayback Machine, Kyoto, January
2012. See also the sFFT Web Page (http://g
roups.csail.mit.edu/netmit/sFFT/)
Archived (https://web.archive.org/web/201
20221145740/http://groups.csail.mit.edu/n
etmit/sFFT/) February 21, 2012, at the
Wayback Machine.
37. Goodrich, Michael T.; Tamassia, Roberto
(2002). Algorithm Design: Foundations,
Analysis, and Internet Examples (http://ww
3.algorithmdesign.net/ch00-front.html) .
John Wiley & Sons, Inc. ISBN 978-0-471-
38365-9. Archived (https://web.archive.org/
web/20150428201622/http://ww3.algorith
mdesign.net/ch00-front.html) from the
original on April 28, 2015. Retrieved
June 14, 2018.
38. John G. Kemeny and Thomas E. Kurtz 1985
Back to Basic: The History, Corruption, and
Future of the Language, Addison-Wesley
Publishing Company, Inc. Reading, MA,
ISBN 0-201-13433-0.
39. Tausworthe 1977:101
40. Tausworthe 1977:142
41. Knuth 1973 section 1.2.1, expanded by
Tausworthe 1977 at pages 100ff and
Chapter 9.1
42. Kellerer, Hans; Pferschy, Ulrich; Pisinger,
David (2004). Knapsack Problems | Hans
Kellerer | Springer (https://www.springer.co
m/us/book/9783540402862) . Springer.
doi:10.1007/978-3-540-24777-7 (https://do
i.org/10.1007%2F978-3-540-24777-7) .
ISBN 978-3-540-40286-2. S2CID 28836720
(https://api.semanticscholar.org/CorpusID:
28836720) . Archived (https://web.archive.
org/web/20171018181055/https://www.sp
ringer.com/us/book/9783540402862)
from the original on October 18, 2017.
Retrieved September 19, 2017.
43. For instance, the volume of a convex
polytope (described using a membership
oracle) can be approximated to high
accuracy by a randomized polynomial time
algorithm, but not by a deterministic one:
see Dyer, Martin; Frieze, Alan; Kannan, Ravi
(January 1991). "A Random Polynomial-
time Algorithm for Approximating the
Volume of Convex Bodies". J. ACM. 38 (1):
1–17. CiteSeerX 10.1.1.145.4600 (https://ci
teseerx.ist.psu.edu/viewdoc/summary?doi
=10.1.1.145.4600) .
doi:10.1145/102782.102783 (https://doi.or
g/10.1145%2F102782.102783) .
S2CID 13268711 (https://api.semanticscho
lar.org/CorpusID:13268711) .
44. George B. Dantzig and Mukund N. Thapa.
2003. Linear Programming 2: Theory and
Extensions. Springer-Verlag.
45. "The Experts: Does the Patent System
Encourage Innovation?" (https://www.wsj.c
om/articles/SB1000142412788732358290
4578487200821421958) . The Wall Street
Journal. May 16, 2013. ISSN 0099-9660 (htt
ps://www.worldcat.org/issn/0099-9660) .
Retrieved March 29, 2017.

Bibliography

Axt, P (1959). "On a Subrecursive Hierarchy

and Primitive Recursive Degrees" (https://doi.
org/10.2307%2F1993169) . Transactions of
the American Mathematical Society. 92 (1):
85–105. doi:10.2307/1993169 (https://doi.or
g/10.2307%2F1993169) . JSTOR 1993169 (h
ttps://www.jstor.org/stable/1993169) .
Bell, C. Gordon and Newell, Allen (1971),
Computer Structures: Readings and Examples,
McGraw–Hill Book Company, New York.
ISBN 0-07-004357-4.
Blass, Andreas; Gurevich, Yuri (2003).
"Algorithms: A Quest for Absolute
Definitions" (http://research.microsoft.com/
~gurevich/Opera/164.pdf) (PDF). Bulletin of
European Association for Theoretical
Computer Science. 81. Archived (https://ghos
tarchive.org/archive/20221009/http://resear
ch.microsoft.com/~gurevich/Opera/164.pd
f) (PDF) from the original on October 9,
2022. Includes a bibliography of 56
references.
Bolter, David J. (1984). Turing's Man: Western
Culture in the Computer Age (1984 ed.).
Chapel Hill, NC: The University of North
Carolina Press. ISBN 978-0-8078-1564-9.,
ISBN 0-8078-4108-0
Boolos, George; Jeffrey, Richard (1999)
[1974]. Computability and Logic (https://archi
ve.org/details/computabilitylog0000bool_r8y
9) (4th ed.). Cambridge University Press,
London. ISBN 978-0-521-20402-6.: cf.
Chapter 3 Turing machines where they
discuss "certain enumerable sets not
effectively (mechanically) enumerable".
Burgin, Mark (2004). Super-Recursive
Algorithms. Springer. ISBN 978-0-387-95569-
8.
Campagnolo, M.L., Moore, C., and Costa, J.F.
(2000) An analog characterization of the
subrecursive functions. In Proc. of the 4th
Conference on Real Numbers and Computers,
Odense University, pp. 91–109
Church, Alonzo (1936). "An Unsolvable
Problem of Elementary Number Theory". The
American Journal of Mathematics. 58 (2):
345–363. doi:10.2307/2371045 (https://doi.
org/10.2307%2F2371045) . JSTOR 2371045
(https://www.jstor.org/stable/2371045) .
Reprinted in The Undecidable, p. 89ff. The
first expression of "Church's Thesis". See in
particular page 100 (The Undecidable) where
he defines the notion of "effective
calculability" in terms of "an algorithm", and
he uses the word "terminates", etc.
Church, Alonzo (1936). "A Note on the
Entscheidungsproblem". The Journal of
Symbolic Logic. 1 (1): 40–41.
doi:10.2307/2269326 (https://doi.org/10.230
7%2F2269326) . JSTOR 2269326 (https://w
ww.jstor.org/stable/2269326) .
S2CID 42323521 (https://api.semanticschola
r.org/CorpusID:42323521) . Church, Alonzo
(1936). "Correction to a Note on the
Entscheidungsproblem". The Journal of
Symbolic Logic. 1 (3): 101–102.
doi:10.2307/2269030 (https://doi.org/10.230
7%2F2269030) . JSTOR 2269030 (https://w
ww.jstor.org/stable/2269030) .
S2CID 5557237 (https://api.semanticscholar.
org/CorpusID:5557237) . Reprinted in The
Undecidable, p. 110ff. Church shows that the
Entscheidungsproblem is unsolvable in
about 3 pages of text and 3 pages of
footnotes.
Daffa', Ali Abdullah al- (1977). The Muslim
contribution to mathematics. London: Croom
Helm. ISBN 978-0-85664-464-1.
Davis, Martin (1965). The Undecidable: Basic
Papers On Undecidable Propositions,
Unsolvable Problems and Computable
Functions (https://archive.org/details/undeci
dablebasic0000davi) . New York: Raven
Press. ISBN 978-0-486-43228-1. Davis gives
commentary before each article. Papers of
Gödel, Alonzo Church, Turing, Rosser, Kleene,
and Emil Post are included; those cited in the
article are listed here by author's name.
Davis, Martin (2000). Engines of Logic:
Mathematicians and the Origin of the
Computer. New York: W.W. Nortion.
ISBN 978-0-393-32229-3. Davis offers
concise biographies of Leibniz, Boole, Frege,
Cantor, Hilbert, Gödel and Turing with von
Neumann as the show-stealing villain. Very
brief bios of Joseph-Marie Jacquard,
Babbage, Ada Lovelace, Claude Shannon,
Howard Aiken, etc.
This article incorporates public domain
material from Paul E. Black. "algorithm" (http
s://xlinux.nist.gov/dads/HTML/algorithm.ht
ml) . Dictionary of Algorithms and Data
Structures. NIST.
Dean, Tim (2012). "Evolution and moral
diversity" (https://doi.org/10.4148%2Fbiyclc.
v7i0.1775) . Baltic International Yearbook of
Cognition, Logic and Communication. 7.
doi:10.4148/biyclc.v7i0.1775 (https://doi.or
g/10.4148%2Fbiyclc.v7i0.1775) .
Dennett, Daniel (1995). Darwin's Dangerous
Idea (https://archive.org/details/darwinsdan
gerous0000denn) . New York:
Touchstone/Simon & Schuster. pp. 32 (http
s://archive.org/details/darwinsdangerous000
0denn/page/32) –36. ISBN 978-0-684-
80290-9.
Dilson, Jesse (2007). The Abacus (https://arc
hive.org/details/abacusworldsfirs0000dils)
((1968, 1994) ed.). St. Martin's Press, NY.
ISBN 978-0-312-10409-2., ISBN 0-312-10409-
X
Yuri Gurevich, Sequential Abstract State
Machines Capture Sequential Algorithms (htt
p://citeseerx.ist.psu.edu/viewdoc/download?
doi=10.1.1.146.3017&rep=rep1&type=pdf) ,
ACM Transactions on Computational Logic,
Vol 1, no 1 (July 2000), pp. 77–111. Includes
bibliography of 33 sources.
van Heijenoort, Jean (2001). From Frege to
Gödel, A Source Book in Mathematical Logic,
1879–1931 ((1967) ed.). Harvard University
Press, Cambridge. ISBN 978-0-674-32449-7.,
3rd edition 1976[?], ISBN 0-674-32449-8
(pbk.)
Hodges, Andrew (1983). Alan Turing: The
Enigma. New York: Simon and Schuster.
ISBN 978-0-671-49207-6., ISBN 0-671-49207-
1. Cf. Chapter "The Spirit of Truth" for a
history leading to, and a discussion of, his
proof.
Kleene, Stephen C. (1936). "General
Recursive Functions of Natural Numbers" (htt
ps://web.archive.org/web/20140903092121/
http://gdz.sub.uni-goettingen.de/index.php?i
d=11&PPN=GDZPPN002278499&L=1) .
Mathematische Annalen. 112 (5): 727–742.
doi:10.1007/BF01565439 (https://doi.org/10.
1007%2FBF01565439) . S2CID 120517999
(https://api.semanticscholar.org/CorpusID:1
20517999) . Archived from the original (htt
p://gdz.sub.uni-goettingen.de/index.php?id=
11&PPN=GDZPPN002278499&L=1) on
September 3, 2014. Retrieved September 30,
2013. Presented to the American
Mathematical Society, September 1935.
Reprinted in The Undecidable, p. 237ff.
Kleene's definition of "general recursion"
(known now as mu-recursion) was used by
Church in his 1935 paper An Unsolvable
Problem of Elementary Number Theory that
proved the "decision problem" to be
"undecidable" (i.e., a negative result).
Kleene, Stephen C. (1943). "Recursive
Predicates and Quantifiers" (https://doi.org/1
0.2307%2F1990131) . Transactions of the
American Mathematical Society. 53 (1): 41–
73. doi:10.2307/1990131 (https://doi.org/10.
2307%2F1990131) . JSTOR 1990131 (http
s://www.jstor.org/stable/1990131) .
Reprinted in The Undecidable, p. 255ff.
Kleene refined his definition of "general
recursion" and proceeded in his chapter "12.
Algorithmic theories" to posit "Thesis I"
(p. 274); he would later repeat this thesis (in
Kleene 1952:300) and name it "Church's
Thesis"(Kleene 1952:317) (i.e., the Church
thesis).
Kleene, Stephen C. (1991) [1952].
Introduction to Metamathematics (Tenth ed.).
North-Holland Publishing Company.
ISBN 978-0-7204-2103-3.
Knuth, Donald (1997). Fundamental
Algorithms, Third Edition. Reading,
Massachusetts: Addison–Wesley. ISBN 978-
0-201-89683-1.
Knuth, Donald (1969). Volume
2/Seminumerical Algorithms, The Art of
Computer Programming First Edition. Reading,
Massachusetts: Addison–Wesley.
Kosovsky, N.K. Elements of Mathematical
Logic and its Application to the theory of
Subrecursive Algorithms, LSU Publ.,
Leningrad, 1981
Kowalski, Robert (1979).
"Algorithm=Logic+Control" (https://doi.org/1
0.1145%2F359131.359136) .
Communications of the ACM. 22 (7): 424–
436. doi:10.1145/359131.359136 (https://do
i.org/10.1145%2F359131.359136) .
S2CID 2509896 (https://api.semanticscholar.
org/CorpusID:2509896) .
A.A. Markov (1954) Theory of algorithms.
[Translated by Jacques J. Schorr-Kon and
PST staff] Imprint Moscow, Academy of
Sciences of the USSR, 1954 [i.e., Jerusalem,
Israel Program for Scientific Translations,
1961; available from the Office of Technical
Services, U.S. Dept. of Commerce,
Washington] Description 444 p. 28 cm.
Added t.p. in Russian Translation of Works of
the Mathematical Institute, Academy of
Sciences of the USSR, v. 42. Original title:
Teoriya algerifmov. [QA248.M2943
Dartmouth College library. U.S. Dept. of
Commerce, Office of Technical Services,
number OTS 60-51085.]
Minsky, Marvin (1967). Computation: Finite
and Infinite Machines (https://archive.org/det
ails/computationfinit0000mins) (First ed.).
Prentice-Hall, Englewood Cliffs, NJ.
ISBN 978-0-13-165449-5. Minsky expands his
"...idea of an algorithm – an effective
procedure..." in chapter 5.1 Computability,
Effective Procedures and Algorithms. Infinite
machines.
Post, Emil (1936). "Finite Combinatory
Processes, Formulation I". The Journal of
Symbolic Logic. 1 (3): 103–105.
doi:10.2307/2269031 (https://doi.org/10.230
7%2F2269031) . JSTOR 2269031 (https://w
ww.jstor.org/stable/2269031) .
S2CID 40284503 (https://api.semanticschola
r.org/CorpusID:40284503) . Reprinted in The
Undecidable, pp. 289ff. Post defines a simple
algorithmic-like process of a man writing
marks or erasing marks and going from box
to box and eventually halting, as he follows a
list of simple instructions. This is cited by
Kleene as one source of his "Thesis I", the so-
called Church–Turing thesis.
Rogers, Hartley Jr. (1987). Theory of
Recursive Functions and Effective
Computability. The MIT Press. ISBN 978-0-
262-68052-3.
Rosser, J.B. (1939). "An Informal Exposition
of Proofs of Godel's Theorem and Church's
Theorem". Journal of Symbolic Logic. 4 (2):
53–60. doi:10.2307/2269059 (https://doi.or
g/10.2307%2F2269059) . JSTOR 2269059 (h
ttps://www.jstor.org/stable/2269059) .
S2CID 39499392 (https://api.semanticschola
r.org/CorpusID:39499392) . Reprinted in The
Undecidable, p. 223ff. Herein is Rosser's
famous definition of "effective method": "...a
method each step of which is precisely
predetermined and which is certain to
produce the answer in a finite number of
steps... a machine which will then solve any
problem of the set with no human
intervention beyond inserting the question
and (later) reading the answer" (p. 225–226,
The Undecidable)
Santos-Lang, Christopher (2015). "Moral
Ecology Approaches to Machine Ethics" (htt
p://grinfree.com/MoralEcology.pdf) (PDF). In
van Rysewyk, Simon; Pontier, Matthijs (eds.).
Machine Medical Ethics. Intelligent Systems,
Control and Automation: Science and
Engineering. Vol. 74. Switzerland: Springer.
pp. 111–127. doi:10.1007/978-3-319-08108-
3_8 (https://doi.org/10.1007%2F978-3-319-0
8108-3_8) . ISBN 978-3-319-08107-6.
Archived (https://ghostarchive.org/archive/2
0221009/http://grinfree.com/MoralEcology.p
df) (PDF) from the original on October 9,
2022.
Scott, Michael L. (2009). Programming
Language Pragmatics (3rd ed.). Morgan
Kaufmann Publishers/Elsevier. ISBN 978-0-
12-374514-9.
Sipser, Michael (2006). Introduction to the
Theory of Computation (https://archive.org/d
etails/introductiontoth00sips) . PWS
Publishing Company. ISBN 978-0-534-94728-
6.
Sober, Elliott; Wilson, David Sloan (1998).
Unto Others: The Evolution and Psychology of
Unselfish Behavior (https://archive.org/detail
s/untoothersevolut00sobe) . Cambridge:
Harvard University Press.
ISBN 9780674930469.
Stone, Harold S. (1972). Introduction to
Computer Organization and Data Structures
(1972 ed.). McGraw-Hill, New York. ISBN 978-
0-07-061726-1. Cf. in particular the first
chapter titled: Algorithms, Turing Machines,
and Programs. His succinct informal
definition: "...any sequence of instructions
that can be obeyed by a robot, is called an
algorithm" (p. 4).
Tausworthe, Robert C (1977). Standardized
Development of Computer Software Part 1
Methods. Englewood Cliffs NJ: Prentice–Hall,
Inc. ISBN 978-0-13-842195-3.
Turing, Alan M. (1936–37). "On Computable
Numbers, With An Application to the
Entscheidungsproblem". Proceedings of the
London Mathematical Society. Series 2. 42:
230–265. doi:10.1112/plms/s2-42.1.230 (htt
ps://doi.org/10.1112%2Fplms%2Fs2-42.1.23
0) . S2CID 73712 (https://api.semanticschol
ar.org/CorpusID:73712) .. Corrections, ibid,
vol. 43(1937) pp. 544–546. Reprinted in The
Undecidable, p. 116ff. Turing's famous paper
completed as a Master's dissertation while at
King's College Cambridge UK.
Turing, Alan M. (1939). "Systems of Logic
Based on Ordinals". Proceedings of the
London Mathematical Society. 45: 161–228.
doi:10.1112/plms/s2-45.1.161 (https://doi.or
g/10.1112%2Fplms%2Fs2-45.1.161) .
hdl:21.11116/0000-0001-91CE-3 (https://hdl.
handle.net/21.11116%2F0000-0001-91CE-
3) . Reprinted in The Undecidable, pp. 155ff.
Turing's paper that defined "the oracle" was
his PhD thesis while at Princeton.
United States Patent and Trademark Office
(2006), 2106.02 **>Mathematical Algorithms:
2100 Patentability (http://www.uspto.gov/we
b/offices/pac/mpep/documents/2100_2106
_02.htm) , Manual of Patent Examining
Procedure (MPEP). Latest revision August
2006
 Zaslavsky, C. (1970). Mathematics of
the Yoruba People and of Their
Neighbors in Southern Nigeria. The Two-
Year College Mathematics Journal, 1(2),
76–99.
https://doi.org/10.2307/3027363

Further reading

Bellah, Robert Neelly (1985). Habits of the

Heart: Individualism and Commitment in
American Life (https://books.google.com/bo
oks?id=XsUojihVZQcC) . Berkeley: University
of California Press. ISBN 978-0-520-25419-0.
Berlinski, David (2001). The Advent of the
Algorithm: The 300-Year Journey from an Idea
to the Computer (https://archive.org/details/a
dventofalgorith0000berl) . Harvest Books.
ISBN 978-0-15-601391-8.
Chabert, Jean-Luc (1999). A History of
Algorithms: From the Pebble to the Microchip.
Springer Verlag. ISBN 978-3-540-63369-3.
Thomas H. Cormen; Charles E. Leiserson;
Ronald L. Rivest; Clifford Stein (2009).
Introduction To Algorithms (3rd ed.). MIT
Press. ISBN 978-0-262-03384-8.
Harel, David; Feldman, Yishai (2004).
Algorithmics: The Spirit of Computing.
Addison-Wesley. ISBN 978-0-321-11784-7.
Hertzke, Allen D.; McRorie, Chris (1998). "The
Concept of Moral Ecology". In Lawler, Peter
Augustine; McConkey, Dale (eds.).
Community and Political Thought Today.
Westport, CT: Praeger.
Knuth, Donald E. (2000). Selected Papers on
Analysis of Algorithms (http://www-cs-faculty.
stanford.edu/~uno/aa.html) Archived (http
s://web.archive.org/web/20170701190647/htt
p://www-cs-faculty.stanford.edu/~uno/aa.htm
l) July 1, 2017, at the Wayback Machine.
Stanford, California: Center for the Study of
Language and Information.
Knuth, Donald E. (2010). Selected Papers on
Design of Algorithms (http://www-cs-faculty.st
anford.edu/~uno/da.html) Archived (https://
web.archive.org/web/20170716225848/http://
www-cs-faculty.stanford.edu/~uno/da.html)
July 16, 2017, at the Wayback Machine.
Stanford, California: Center for the Study of
Language and Information.
 Wallach, Wendell; Allen, Colin (November
2008). Moral Machines: Teaching Robots
Right from Wrong. US: Oxford University
Press. ISBN 978-0-19-537404-9.
Bleakley, Chris (2020). Poems that Solve
Puzzles: The History and Science of
Algorithms (https://books.google.com/book
s?id=3pr5DwAAQBAJ) . Oxford University
Press. ISBN 978-0-19-885373-2.

External links

"Algorithm" (https://ww Look

up
w.encyclopediaofmath.
algorith
org/index.php?title=Alg m in
Wiktion
orithm) . Encyclopedia
ary, the
free
of Mathematics. EMS diction
ary.
Press. 2001 [1994].
Wikibo
Algorithms (https://curl oks has
ie.org/Computers/Algo a book
on the
rithms/) at Curlie topic
of:
Weisstein, Eric W. Algorit
"Algorithm" (https://mat hms

hworld.wolfram.com/Al At
Wikiver
gorithm.html) .
sity,
MathWorld. you can
learn
Dictionary of more
Algorithms and Data and
teach
Structures (https://ww others
w.nist.gov/dads/) – about
Algorit
National Institute of hm at
Standards and the
Depart
Technology ment of
Algorith
Algorithm repositories
m
The Stony Brook Wikime
Algorithm Repository (h dia
Commo
ttp://www.cs.sunysb.ed ns has
u/~algorith/) – State media
related
University of New York to
at Stony Brook Algorith
ms.
Collected Algorithms of
the ACM (http://calgo.acm.org/) –
Associations for Computing Machinery
The Stanford GraphBase (http://www-cs
-staff.stanford.edu/~knuth/sgb.html)
Archived (https://web.archive.org/web/2
 0151206222112/http://www-cs-staff.st
anford.edu/%7Eknuth/sgb.html)
December 6, 2015, at the Wayback
Machine – Stanford University

Retrieved from
"https://en.wikipedia.org/w/index.php?
title=Algorithm&oldid=1225107452"

This page was last edited on 22 May 2024, at

12:03 (UTC). •
Content is available under CC BY-SA 4.0 unless
otherwise noted.