 GeeksforGeeks App
Open App Browser
Continue

# Trabb Pardo–Knuth Algorithm

This article is not about learning some new complex algorithm, its more about the history of programming. TPK was introduced to illustrate the evolution of computer programming languages. By the time you are finished with this article you will have learnt something about the history of programming rather than a new concept. In their 1977 work “The Early Development of Programming Languages”, Trabb Pardo and Knuth introduced a small program that involved arrays, indexing, mathematical functions, subroutines, I/O, conditionals and iteration. This program was written in several early programming language to show the evolution of programming languages. Just like the “Hello World!” program has the purpose of introducing beginners to programming the TPK has the same purpose and has no practical applications.

```Algorithm:
input 11 numbers into a sequence A
reverse sequence A
for each item in sequence A
call a function to do an operation
if result overflows
else
print result```

## C++

 `#include ``#include ``using` `namespace` `std;``// f(x) = sqrt(|x|) + 5*x**3``double` `f(``double` `x)``{``    ``return` `(``sqrt``(``fabs``(x)) + 5.0 * ``pow``(x, 3.0));``}` `int` `main()``{``    ``double` `y;``    ``int` `i;` `    ``// Read in the values of the array A``    ``double` `A = {7.9, 7.3, 20.9, 112.0, 5.0, 3.0, 2.9, 9.0, 21.7, 31.2, 4.1};` `    ``// In reverse order, apply "f"``    ``// to each element of A and print``    ``for` `(i=10; i>=0; i--)``    ``{``        ``y = f(A[i]);``        ``if` `(y > 400.0)``        ``{``            ``cout<

## C

 `// C program to implement TPK algorithm``#include ``#include ` `// f(x) = sqrt(|x|) + 5*x**3``double` `f (``double` `x)``{``    ``return` `(``sqrt``(``fabs``(x)) + 5.0 * ``pow``(x, 3.0));``}` `int` `main (``int` `argc, ``char``* argv[])``{``    ``double` `y;``    ``int` `i;` `    ``// Read in the values of the array A``    ``double` `A = {7.9, 7.3, 20.9, 112.0, 5.0, 3.0, 2.9, 9.0, 21.7, 31.2, 4.1};` `    ``// In reverse order, apply "f"``    ``// to each element of A and print``    ``for` `(i=10; i>=0; i--)``    ``{``        ``y = f (A[i]);``        ``if` `(y > 400.0)``        ``{``            ``printf` `(``"%d TOO LARGE\n"``, i);``        ``}``        ``else``        ``{``            ``printf` `(``"%d %f\n"``, i, y);``        ``}``    ``}``    ``return` `(0);``}`

## Java

 `// Java program to implement TPK algorithm``import` `java.util.*;``import` `java.io.*;``  ` `public` `class` `TPKA {``    ``public` `static` `void` `main(String... args) {``        ``double``[] input = {``7.9``, ``7.3``, ``20.9``, ``112.0``, ``5.0``, ``3.0``, ``2.9``, ``9.0``, ``21.7``, ``31.2``, ``4.1``};``         ` `        ``for``(``int` `j = ``10``; j >= ``0``; j--) {``            ``double` `y = f(input[j]);``            ``if``( y < ``400.0``) {``                ``System.out.printf(``"%d %.2f\n"``, j, y);``            ``} ``else` `{``                ``System.out.printf(``"%d %s\n"``, j, ``"TOO LARGE"``);``            ``}``        ``}``    ``}``  ` `    ``private` `static` `double` `f(``double` `x) {``        ``return` `Math.pow(Math.abs(x), ``0.5``) + (``5``*(Math.pow(x, ``3``)));``    ``}``}`

## Python

 `# Python program to implement TPK algorithm``def` `f(x):``    ``return` `abs``(x) ``*``*` `0.5` `+` `5` `*` `x``*``*``3` `def` `main():``    ``s ``=` `[``7.9``, ``7.3``, ``20.9``, ``112.0``, ``5.0``, ``3.0``, ``2.9``, ``9.0``, ``21.7``, ``31.2``, ``4.1``]``    ``s.reverse()``    ``i ``=` `10``    ``for` `x ``in` `s:``        ``result ``=` `f(x)``        ``if` `result > ``400``:``            ``print``(``'%d %s'` `%` `(i, ``"TOO LARGE"``))``            ``i ``=` `i``-``1``        ``else``:``            ``print``(``'%d %f'` `%` `(i, result))``            ``i ``=` `i``-``1``    ``print``('')``    ` `if` `__name__ ``=``=` `'__main__'``:``    ``main()`

## C#

 `// C# program to implement TPK algorithm``using` `System;` `public` `class` `TPKAlgorithm {``    ``public` `static` `double` `F(``double` `x) {``        ``return` `Math.Sqrt(Math.Abs(x)) + 5 * Math.Pow(x, 3);``    ``}` `    ``public` `static` `void` `Main() {``        ``double``[] s = { 7.9, 7.3, 20.9, 112.0, 5.0, 3.0, 2.9, 9.0, 21.7, 31.2, 4.1 };``        ``Array.Reverse(s);``        ``int` `i = 10;``        ``foreach` `(``double` `x ``in` `s) {``            ``double` `result = F(x);``            ``if` `(result > 400) {``                ``Console.WriteLine(\$``"{i} TOO LARGE"``);``                ``i--;``            ``}``            ``else` `{``                ``Console.WriteLine(\$``"{i} {result:F6}"``);``                ``i--;``            ``}``        ``}``        ``Console.WriteLine();``    ``}``}``// This code is contributed by shivregkec`

## Javascript

 `function` `f(x) {``  ``return` `Math.pow(Math.abs(x), 0.5) + (5*(Math.pow(x, 3)));``}` `const input = [7.9, 7.3, 20.9, 112.0, 5.0, 3.0, 2.9, 9.0, 21.7, 31.2, 4.1];` `for``(let j = 10; j >= 0; j--) {``  ``let y = f(input[j]);``  ``if``(y < 400.0) {``    ``console.log(`\${j} \${y.toFixed(2)}`);``  ``} ``else` `{``    ``console.log(`\${j} TOO LARGE`);``  ``}``}``// This code is contributed by shivhack999`

Output

```10 346.63
9 TOO LARGE
8 TOO LARGE
7 TOO LARGE
6 123.648
5 136.732
4 TOO LARGE
3 TOO LARGE
2 TOO LARGE
1 TOO LARGE
0 TOO LARGE```