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, 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 ([Link]
7363) (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 turing 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.

int gcd(int A, int B) {

if (B == 0)
return A;
else if (A > B)
return gcd(A-B,B);
else
return gcd(A,B-A);
}

Recursive C implementation of Euclid's

algorithm from the above flowchart

Recursion
A recursive algorithm is one that
invokes (makes reference to) itself
repeatedly until a certain condition
(also known as termination condition)
matches, which is a method common
to functional programming. Iterative
algorithms use repetitive constructs
like loops and sometimes additional
data structures like stacks to solve the
given problems. Some problems are
naturally suited for one
implementation or the other. For
example, towers of Hanoi is well
understood using recursive
implementation. Every recursive
version has an equivalent (but possibly
more or less 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
algorithms 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 [Link] = 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

Mathematics
portal
Computer
programming
portal

Abstract machine
ALGOL
Algorithm engineering
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" ([Link]

[Link]/dictionary/algorith
m) . Merriam-Webster Online Dictionary.
Archived ([Link]
200214074446/[Link]
[Link]/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 (htt
ps://[Link]/books?id=RJV5D
wAAQBAJ) . Untimely Meditations.
Vol. 14. Translated by Chase, Jefferson.
Cambridge, Massachusetts: MIT Press.
p. 147. ISBN 9780262536370. Archived (h
ttps://[Link]/web/20191222120
705/[Link]
RJV5DwAAQBAJ) 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 ([Link]
com/books?id=-wt1aZrGXLYC) . 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" ([Link]
books?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 ([Link]
m/biography/Brahmagupta) .
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" ([Link]
[Link]/web/20121224100137/[Link]
[Link]/disk5/js/computer/
[Link]) (PDF). Commun. ACM. 15 (7):
671–677. doi:10.1145/361454.361514 (ht
tps://[Link]/10.1145%2F361454.36151
4) . ISSN 0001-0782 ([Link]
[Link]/issn/0001-0782) . S2CID 7829945
([Link]
D:7829945) . Archived from the original (h
ttp://[Link]/disk5/js/co
mputer/[Link]) (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" ([Link]
[Link]/history/men/eratosthen
[Link]) . Wichita State University:
Department of Mathematics and
Statistics. Archived ([Link]
rg/web/20150227150653/[Link]
[Link]/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 ([Link]
5-016-1004-2) . ISSN 0219-1377 (https://
[Link]/issn/0219-1377) .
S2CID 40772241 ([Link]
[Link]/CorpusID:40772241) .
35. Gillian Conahan (January 2013). "Better
Math Makes Faster Data Networks" (htt
p://[Link]/2013/jan-feb/
34-better-math-makes-faster-data-networ
ks) . [Link]. Archived (ht
tps://[Link]/web/20140513212
427/[Link]
an-feb/34-better-math-makes-faster-data-
networks) 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) ([Link]
m/2012SODA/data/papers/[Link])
Archived ([Link]
130704180806/[Link]
[Link]/2012SODA/data/papers/[Link]
f) July 4, 2013, at the Wayback Machine,
Kyoto, January 2012. See also the sFFT
Web Page ([Link]
mit/sFFT/) Archived ([Link]
[Link]/web/20120221145740/[Link]
[Link]/netmit/sFFT/) February
21, 2012, at the Wayback Machine.
37. Goodrich, Michael T.; Tamassia, Roberto
(2002). Algorithm Design: Foundations,
Analysis, and Internet Examples ([Link]
[Link]/[Link]
l) . John Wiley & Sons, Inc. ISBN 978-0-
471-38365-9. Archived ([Link]
[Link]/web/20150428201622/[Link]
[Link]/[Link])
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 ([Link]
om/us/book/9783540402862) . Springer.
doi:10.1007/978-3-540-24777-7 ([Link]
[Link]/10.1007%2F978-3-540-24777-7) .
ISBN 978-3-540-40286-2.
S2CID 28836720 ([Link]
[Link]/CorpusID:28836720) . Archived
([Link]
81055/[Link]
k/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 [Link].4600 ([Link]
[Link]/viewdoc/summary?doi=1
[Link].4600) .
doi:10.1145/102782.102783 ([Link]
rg/10.1145%2F102782.102783) .
S2CID 13268711 ([Link]
[Link]/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?" ([Link]
com/articles/SB10001424127887323582
904578487200821421958) . The Wall
Street Journal. May 16, 2013. ISSN 0099-
9660 ([Link]
9-9660) . Retrieved March 29, 2017.

Bibliography

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

and Primitive Recursive Degrees" ([Link]
[Link]/10.2307%2F1993169) . Transactions
of the American Mathematical Society. 92
(1): 85–105. doi:10.2307/1993169 (https://
[Link]/10.2307%2F1993169) .
JSTOR 1993169 ([Link]
ble/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" ([Link]
m/~gurevich/Opera/[Link]) (PDF).
Bulletin of European Association for
Theoretical Computer Science. 81. Archived
([Link]
9/[Link]
h/Opera/[Link]) (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 ([Link]
[Link]/details/computabilitylog0000bool_
r8y9) (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 (http
s://[Link]/10.2307%2F2371045) .
JSTOR 2371045 ([Link]
ble/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 ([Link]
307%2F2269326) . JSTOR 2269326 (http
s://[Link]/stable/2269326) .
S2CID 42323521 ([Link]
[Link]/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 ([Link]
307%2F2269030) . JSTOR 2269030 (http
s://[Link]/stable/2269030) .
S2CID 5557237 ([Link]
[Link]/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 ([Link]
cidablebasic0000davi) . 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" (htt
ps://[Link]/dads/HTML/algorithm.
html) . Dictionary of Algorithms and Data
Structures. NIST.
Dean, Tim (2012). "Evolution and moral
diversity" ([Link]
c.v7i0.1775) . Baltic International Yearbook
of Cognition, Logic and Communication. 7.
doi:10.4148/biyclc.v7i0.1775 ([Link]
g/10.4148%2Fbiyclc.v7i0.1775) .
Dennett, Daniel (1995). Darwin's Dangerous
Idea ([Link]
ngerous0000denn) . Vol. 2. New York:
Touchstone/Simon & Schuster. pp. 32 (http
s://[Link]/details/darwinsdangerous0
000denn/page/32) –36.
Bibcode:1996Cmplx...2a..32M ([Link]
[Link]/abs/1996Cmplx...2a..32
M) . doi:10.1002/(SICI)1099-
0526(199609/10)2:1<32::AID-
CPLX8>[Link];2-H ([Link]
2%2F%28SICI%291099-0526%28199609%2
F10%292%3A1%3C32%3A%3AAID-CPLX8%
[Link]%3B2-H) . ISBN 978-0-684-80290-
9. {{cite book}}: |journal= ignored
(help)
Dilson, Jesse (2007). The Abacus ([Link]
[Link]/details/abacusworldsfirs0000dil
s) ((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://[Link]/viewdoc/downloa
d?doi=[Link].3017&rep=rep1&type=pd
f) , 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. Vol. 37. New York: Simon and
Schuster. pp. 107–108.
Bibcode:1984PhT....37k.107H ([Link]
[Link]/abs/1984PhT....37k.107
H) . doi:10.1063/1.2915935 ([Link]
g/10.1063%2F1.2915935) . ISBN 978-0-
671-49207-6. {{cite book}}:
|journal= ignored (help), 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" (h
ttps://[Link]/web/201409030921
21/[Link]
hp?id=11&PPN=GDZPPN002278499&L=
1) . Mathematische Annalen. 112 (5): 727–
742. doi:10.1007/BF01565439 ([Link]
org/10.1007%2FBF01565439) .
S2CID 120517999 ([Link]
[Link]/CorpusID:120517999) . Archived
from the original ([Link]
[Link]/[Link]?id=11&PPN=GDZPPN002
278499&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" ([Link]
10.2307%2F1990131) . Transactions of the
American Mathematical Society. 53 (1): 41–
73. doi:10.2307/1990131 ([Link]
0.2307%2F1990131) . JSTOR 1990131 (htt
ps://[Link]/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" ([Link]
10.1145%2F359131.359136) .
Communications of the ACM. 22 (7): 424–
436. doi:10.1145/359131.359136 ([Link]
[Link]/10.1145%2F359131.359136) .
S2CID 2509896 ([Link]
[Link]/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 ([Link]
etails/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 ([Link]
307%2F2269031) . JSTOR 2269031 (http
s://[Link]/stable/2269031) .
S2CID 40284503 ([Link]
[Link]/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 ([Link]
g/10.2307%2F2269059) . JSTOR 2269059
([Link] .
S2CID 39499392 ([Link]
[Link]/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://[Link]/[Link]) (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 ([Link]
F978-3-319-08108-3_8) . ISBN 978-3-319-
08107-6. Archived ([Link]
g/archive/20221009/[Link]
[Link]) (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 ([Link]
details/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 ([Link]
tails/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 (h
ttps://[Link]/10.1112%2Fplms%2Fs2-42.1.
230) . S2CID 73712 ([Link]
[Link]/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 ([Link]
org/10.1112%2Fplms%2Fs2-45.1.161) .
hdl:21.11116/0000-0001-91CE-3 ([Link]
[Link]/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 ([Link]
[Link]/web/offices/pac/mpep/document
s/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.
[Link]

Further reading

Bellah, Robert Neelly (1985). Habits of the

Heart: Individualism and Commitment in
American Life ([Link]
ooks?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 ([Link]
tails/adventofalgorith0000berl) . 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 ([Link]
[Link]/~uno/[Link]) Archived (htt
ps://[Link]/web/20170701190647/
[Link]
html) 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 ([Link]
[Link]/~uno/[Link]) Archived (http
s://[Link]/web/20170716225848/h
ttp://[Link]/~uno/da.h
tml) 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 ([Link]
ks?id=3pr5DwAAQBAJ) . Oxford University
Press. ISBN 978-0-19-885373-2.

External links

Look up algorithm in Wiktionary, the

free dictionary.
Wikibooks has a book on the topic of:
Algorithms
At Wikiversity, you can learn more and
teach others about Algorithm at the
Department of Algorithm
Wikimedia Commons has media
related to Algorithms.
"Algorithm" ([Link]
[Link]/[Link]?title=Algorith
m) . Encyclopedia of Mathematics.
EMS Press. 2001 [1994].
Algorithms ([Link]
rs/Algorithms/) at Curlie
Weisstein, Eric W. "Algorithm" (https://
[Link]/[Link]
ml) . MathWorld.
Dictionary of Algorithms and Data
Structures ([Link]
s/) – National Institute of Standards
and Technology
Algorithm repositories

The Stony Brook Algorithm Repository

([Link]
 h/) – State University of New York at
Stony Brook
Collected Algorithms of the ACM (htt
p://[Link]/) – Associations
for Computing Machinery
The Stanford GraphBase ([Link]
[Link]/~knuth/[Link]
l) Archived ([Link]
eb/20151206222112/[Link]
[Link]/%7Eknuth/[Link])
December 6, 2015, at the Wayback
Machine – Stanford University

Retrieved from
"[Link]
title=Algorithm&oldid=1220421638"

This page was last edited on 23 April 2024, at

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