The Most Concise and Elegant Programs Across Programming Languages

Program conciseness and elegance are often sought after in the world of coding, as they not only make the code easier to understand but also contribute to its efficiency and readability. Below, we will explore some of the most concise and elegant programs that have been implemented in various programming languages.

Euclidean Algorithm in Python

The Euclidean algorithm is one of the earliest and simplest algorithms known to human civilization. Its primary use is to find the Greatest Common Divisor (GCD) of two numbers. Here’s a Python implementation that is both concise and efficient:

def gcd(a, b):
    while a ! b:
        if a  b:
            a - b
        else:
            b - a
    return a

This implementation uses a while loop and simple arithmetic operations to minimize the value of the larger number and maximize the value of the smaller number until both are equal, which is the GCD. This approach is both elegant and computationally efficient.

Prime Number Calculation in APL

APL is known for its terse and expressive syntax, especially in mathematical and algorithmic contexts. Here is a concise APL program designed to find all prime numbers up to a given number R:

~R R°.×R/R←1↓R

This program leverages APL's multidimensional array capabilities and built-in functions to identify prime numbers efficiently.

Quicksort in Haskell

Quicksort is a classic algorithm used for sorting data. In Haskell, the implementation is not only short but also very expressive, capturing the essence of the algorithm succinctly:

quicksort :: Ord a  [a] - [a]
quicksort []      []
quicksort p:xs  quicksort lesser    [p]    quicksort greater
    where
        lesser   filter  (  p) xs
        greater  filter (  p) xs

This version of quicksort is both elegant and functional, showcasing the purity and elegance of functional programming.

Binary Search in JavaScript

Binary search is a fundamental algorithm for searching a sorted array. Here is a concise implementation of binary search in JavaScript that is easy to understand and verify:

function binarySearch(array, value) {
  var low  -1;
  var high  array.length;
  while (high - low  1) {
    var mid  Math.floor((low   high) / 2);
    if (array[mid]  value) {
      low  mid;
    } else {
      high  mid;
    }
  }
  return high;
}

This implementation uses two pointers, `low` and `high`, to narrow down the range of the search by half each iteration, ensuring that the algorithm terminates correctly. The simplicity and clarity of the code make it easy to understand and maintain.

In summary, the programs discussed here demonstrate the power and elegance of various programming languages. From the straightforward but powerful Euclidean algorithm to the concise and expressive APL program, and from the concise Haskell implementation of quicksort to the simple yet effective JavaScript binary search, each example showcases the beauty of algorithmic elegance in different contexts.