Data commit

2023-07-01 11:58:00 -04:00 · 2023-07-01 11:58:00 -04:00 · cb5bb5e222
commit cb5bb5e222
parent 7387c8f97b
199093 changed files with 3378972 additions and 0 deletions
--- a/Task/Taxicab-numbers/00-META.yaml
+++ b/Task/Taxicab-numbers/00-META.yaml
@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Taxicab_numbers
+note: Mathematics
--- a/Task/Taxicab-numbers/00-TASK.txt
+++ b/Task/Taxicab-numbers/00-TASK.txt
@ -0,0 +1,31 @@
+A &nbsp; [[wp:Hardy–Ramanujan number|taxicab number]] &nbsp; (the definition that is being used here) &nbsp; is a positive integer that can be expressed as the sum of two positive cubes in more than one way.
+
+
+The first taxicab number is &nbsp; '''1729''', &nbsp; which is:
+::: 1<sup>3</sup> &nbsp; + &nbsp; 12<sup>3</sup> &nbsp; &nbsp; &nbsp; and also
+::: 9<sup>3</sup> &nbsp; + &nbsp; 10<sup>3</sup>.
+
+
+Taxicab numbers are also known as:
+::* &nbsp; taxi numbers
+::* &nbsp; taxi-cab numbers
+::* &nbsp; taxi cab numbers
+::* &nbsp; Hardy-Ramanujan numbers
+
+
+;Task:
+* Compute and display the lowest 25 taxicab numbers (in numeric order, and in a human-readable format).
+* For each of the taxicab numbers, show the number as well as it's constituent cubes.
+
+
+;Extra credit
+* Show the 2,000<sup>th</sup> taxicab number, and a half dozen more
+
+
+;See also:
+* [[oeis:A001235|A001235: taxicab numbers]] on The On-Line Encyclopedia of Integer Sequences.
+* [http://mathworld.wolfram.com/Hardy-RamanujanNumber.html Hardy-Ramanujan Number] on MathWorld.
+* [http://mathworld.wolfram.com/TaxicabNumber.html taxicab number] on MathWorld.
+* [[wp:Taxicab_number|taxicab number]] on Wikipedia &nbsp; (includes the story on how taxi-cab numbers came to be called).
+<br><br>
+
--- a/Task/Taxicab-numbers/11l/taxicab-numbers.11l
+++ b/Task/Taxicab-numbers/11l/taxicab-numbers.11l
@ -0,0 +1,25 @@
+V cubes = (1..1199).map(x -> Int64(x) ^ 3)
+[Int64 = Int64] crev
+L(x3) cubes
+   crev[x3] = L.index + 1
+
+V sums = sorted(multiloop_filtered(cubes, cubes, (x, y) -> y < x, (x, y) -> x + y))
+
+V idx = 0
+L(i) 1 .< sums.len - 1
+   I sums[i - 1] != sums[i] & sums[i] == sums[i + 1]
+      idx++
+      I (idx > 25 & idx < 2000) | idx > 2006
+         L.continue
+
+      V n = sums[i]
+      [(Int64, Int64)] p
+      L(x) cubes
+         I n - x < x
+            L.break
+         I n - x C crev
+            p.append((crev[x], crev[n - x]))
+      print(‘#4: #10’.format(idx, n), end' ‘ ’)
+      L(x1, x2) p
+         print(‘ = #4^3 + #4^3’.format(x1, x2), end' ‘ ’)
+      print()
--- a/Task/Taxicab-numbers/AWK/taxicab-numbers.awk
+++ b/Task/Taxicab-numbers/AWK/taxicab-numbers.awk
@ -0,0 +1,27 @@
+# syntax: GAWK -f TAXICAB_NUMBERS.AWK
+BEGIN {
+    stop = 99
+    for (a=1; a<=stop; a++) {
+      for (b=1; b<=stop; b++) {
+        n1 = a^3 + b^3
+        for (c=1; c<=stop; c++) {
+          if (a == c) { continue }
+          for (d=1; d<=stop; d++) {
+            n2 = c^3 + d^3
+            if (n1 == n2 && (a != d || b != c)) {
+              if (n1 in arr) { continue }
+              arr[n1] = sprintf("%7d = %2d^3 + %2d^3 = %2d^3 + %2d^3",n1,a,b,c,d)
+            }
+          }
+        }
+      }
+    }
+    PROCINFO["sorted_in"] = "@ind_num_asc"
+    for (i in arr) {
+      if (++count <= 25) {
+        printf("%2d: %s\n",count,arr[i])
+      }
+    }
+    printf("\nThere are %d taxicab numbers using bounds of %d\n",length(arr),stop)
+    exit(0)
+}
--- a/Task/Taxicab-numbers/Befunge/taxicab-numbers.bf
+++ b/Task/Taxicab-numbers/Befunge/taxicab-numbers.bf
@ -0,0 +1,4 @@
+v+1$$<_v#!`**::+1g42$$_v#<!`**::+1g43\g43::<<v,,.g42,<
+>004p:0>1+24p:24g\:24g>>1+:34p::**24g::**+-|p>9,,,14v,
+,,,"^3 + ^3= ^3 + ^3".\,,,9"= ".:\_v#g40g43<^v,,,,.g<^
+5+,$$$\1+:38*`#@_\::"~"1+:24p34p0\0>14p24g04^>,04g.,,5
--- a/Task/Taxicab-numbers/C++/taxicab-numbers.cpp
+++ b/Task/Taxicab-numbers/C++/taxicab-numbers.cpp
@ -0,0 +1,85 @@
+#include <algorithm>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <vector>
+
+template <typename T>
+size_t indexOf(const std::vector<T> &v, const T &k) {
+    auto it = std::find(v.cbegin(), v.cend(), k);
+
+    if (it != v.cend()) {
+        return it - v.cbegin();
+    }
+    return -1;
+}
+
+int main() {
+    std::vector<size_t> cubes;
+
+    auto dump = [&cubes](const std::string &title, const std::map<int, size_t> &items) {
+        std::cout << title;
+        for (auto &item : items) {
+            std::cout << "\n" << std::setw(4) << item.first << " " << std::setw(10) << item.second;
+            for (auto x : cubes) {
+                auto y = item.second - x;
+                if (y < x) {
+                    break;
+                }
+                if (std::count(cubes.begin(), cubes.end(), y)) {
+                    std::cout << " = " << std::setw(4) << indexOf(cubes, y) << "^3 + " << std::setw(3) << indexOf(cubes, x) << "^3";
+                }
+            }
+        }
+    };
+
+    std::vector<size_t> sums;
+
+    // create sorted list of cube sums
+    for (size_t i = 0; i < 1190; i++) {
+        auto cube = i * i * i;
+        cubes.push_back(cube);
+        for (auto j : cubes) {
+            sums.push_back(cube + j);
+        }
+    }
+    std::sort(sums.begin(), sums.end());
+
+    // now seek consecutive sums that match
+    auto nm1 = sums[0];
+    auto n = sums[1];
+    int idx = 0;
+    std::map<int, size_t> task;
+    std::map<int, size_t> trips;
+
+    auto it = sums.cbegin();
+    auto end = sums.cend();
+    it++;
+    it++;
+
+    while (it != end) {
+        auto np1 = *it;
+
+        if (nm1 == np1) {
+            trips.emplace(idx, n);
+        }
+        if (nm1 != n && n == np1) {
+            if (++idx <= 25 || idx >= 2000 == idx <= 2006) {
+                task.emplace(idx, n);
+            }
+        }
+        nm1 = n;
+        n = np1;
+
+        it++;
+    }
+
+    dump("First 25 Taxicab Numbers, the 2000th, plus the next half-dozen:", task);
+
+    std::stringstream ss;
+    ss << "\n\nFound " << trips.size() << " triple Taxicabs under 2007:";
+    dump(ss.str(), trips);
+
+    return 0;
+}
--- a/Task/Taxicab-numbers/C-sharp/taxicab-numbers-1.cs
+++ b/Task/Taxicab-numbers/C-sharp/taxicab-numbers-1.cs
@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TaxicabNumber
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            IDictionary<long, IList<Tuple<int, int>>> taxicabNumbers = GetTaxicabNumbers(2006);
+            PrintTaxicabNumbers(taxicabNumbers);
+            Console.ReadKey();
+        }
+
+        private static IDictionary<long, IList<Tuple<int, int>>> GetTaxicabNumbers(int length)
+        {
+            SortedList<long, IList<Tuple<int, int>>> sumsOfTwoCubes = new SortedList<long, IList<Tuple<int, int>>>();
+
+            for (int i = 1; i < int.MaxValue; i++)
+            {
+                for (int j = 1; j < int.MaxValue; j++)
+                {
+                    long sum = (long)(Math.Pow((double)i, 3) + Math.Pow((double)j, 3));
+
+                    if (!sumsOfTwoCubes.ContainsKey(sum))
+                    {
+                        sumsOfTwoCubes.Add(sum, new List<Tuple<int, int>>());
+                    }
+
+                    sumsOfTwoCubes[sum].Add(new Tuple<int, int>(i, j));
+
+                    if (j >= i)
+                    {
+                        break;
+                    }
+                }
+
+                // Found that you need to keep going for a while after the length, because higher i values fill in gaps
+                if (sumsOfTwoCubes.Count(t => t.Value.Count >= 2) >= length * 1.1)
+                {
+                    break;
+                }
+            }
+
+            IDictionary<long, IList<Tuple<int, int>>> values = (from t in sumsOfTwoCubes where t.Value.Count >= 2 select t)
+                .Take(2006)
+                .ToDictionary(u => u.Key, u => u.Value);
+
+            return values;
+        }
+
+        private static void PrintTaxicabNumbers(IDictionary<long, IList<Tuple<int, int>>> values)
+        {
+            int i = 1;
+
+            foreach (long taxicabNumber in values.Keys)
+            {
+                StringBuilder output = new StringBuilder().AppendFormat("{0,10}\t{1,4}", i, taxicabNumber);
+
+                foreach (Tuple<int, int> numbers in values[taxicabNumber])
+                {
+                    output.AppendFormat("\t= {0}^3 + {1}^3", numbers.Item1, numbers.Item2);
+                }
+
+                if (i <= 25 || (i >= 2000 && i <= 2006))
+                {
+                    Console.WriteLine(output.ToString());
+                }
+
+                i++;
+            }
+        }
+    }
+}
--- a/Task/Taxicab-numbers/C-sharp/taxicab-numbers-2.cs
+++ b/Task/Taxicab-numbers/C-sharp/taxicab-numbers-2.cs
@ -0,0 +1,35 @@
+using System; using static System.Console;
+using System.Collections.Generic; using System.Linq;
+
+class Program {
+
+  static void Main(string[] args) {
+
+    List<uint> cubes = new List<uint>(), sums = new List<uint>();
+
+    void dump(string title, Dictionary <int, uint> items) {
+      Write(title); foreach (var item in items) {
+        Write("\n{0,4} {1,10}", item.Key, item.Value);
+        foreach (uint x in cubes) { uint y = item.Value - x;
+          if (y < x) break; if (cubes.Contains(y))
+            Write(" = {0,4}³ + {1,3}³", cubes.IndexOf(y), cubes.IndexOf(x));
+      } } }
+
+    DateTime st = DateTime.Now;
+    // create sorted list of cube sums
+    for (uint i = 0, cube; i < 1190; i++) { cube = i * i * i;
+      cubes.Add(cube); foreach (uint j in cubes)
+        sums.Add(cube + j); } sums.Sort();
+    // now seek consecutive sums that match
+    uint nm1 = sums[0], n = sums[1]; int idx = 0;
+    Dictionary <int, uint> task = new Dictionary <int, uint>(),
+                           trips = new Dictionary <int, uint>();
+    foreach (var np1 in sums.Skip(2)) {
+      if (nm1 == np1) trips.Add(idx, n); if (nm1 != n && n == np1)
+        if (++idx <= 25 || idx >= 2000 == idx <= 2006)
+          task.Add(idx, n); nm1 = n; n = np1; }
+    // show results
+    dump("First 25 Taxicab Numbers, the 2000th, plus the next half-dozen:", task);
+    dump(string.Format("\n\nFound {0} triple Taxicabs under {1}:", trips.Count, 2007), trips);
+    Write("\n\nElasped: {0}ms", (DateTime.Now - st).TotalMilliseconds); }
+}
--- a/Task/Taxicab-numbers/C/taxicab-numbers.c
+++ b/Task/Taxicab-numbers/C/taxicab-numbers.c
@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef unsigned long long xint;
+typedef unsigned uint;
+typedef struct {
+	uint x, y; // x > y always
+	xint value;
+} sum_t;
+
+xint *cube;
+uint n_cubes;
+
+sum_t *pq;
+uint pq_len, pq_cap;
+
+void add_cube(void)
+{
+	uint x = n_cubes++;
+	cube = realloc(cube, sizeof(xint) * (n_cubes + 1));
+	cube[n_cubes] = (xint) n_cubes*n_cubes*n_cubes;
+	if (x < 2) return; // x = 0 or 1 is useless
+
+	if (++pq_len >= pq_cap) {
+		if (!(pq_cap *= 2)) pq_cap = 2;
+		pq = realloc(pq, sizeof(*pq) * pq_cap);
+	}
+
+	sum_t tmp = (sum_t) { x, 1, cube[x] + 1 };
+	// upheap
+	uint i, j;
+	for (i = pq_len; i >= 1 && pq[j = i>>1].value > tmp.value; i = j)
+		pq[i] = pq[j];
+
+	pq[i] = tmp;
+}
+
+void next_sum(void)
+{
+redo:	while (!pq_len || pq[1].value >= cube[n_cubes]) add_cube();
+
+	sum_t tmp = pq[0] = pq[1];	// pq[0] always stores last seen value
+	if (++tmp.y >= tmp.x) {		// done with this x; throw it away
+		tmp = pq[pq_len--];
+		if (!pq_len) goto redo;	// refill empty heap
+	} else
+		tmp.value += cube[tmp.y] - cube[tmp.y-1];
+
+	uint i, j;
+	// downheap
+	for (i = 1; (j = i<<1) <= pq_len; pq[i] = pq[j], i = j) {
+		if (j < pq_len && pq[j+1].value < pq[j].value) ++j;
+		if (pq[j].value >= tmp.value) break;
+	}
+	pq[i] = tmp;
+}
+
+uint next_taxi(sum_t *hist)
+{
+	do next_sum(); while (pq[0].value != pq[1].value);
+
+	uint len = 1;
+	hist[0] = pq[0];
+	do {
+		hist[len++] = pq[1];
+		next_sum();
+	} while (pq[0].value == pq[1].value);
+
+	return len;
+}
+
+int main(void)
+{
+	uint i, l;
+	sum_t x[10];
+	for (i = 1; i <= 2006; i++) {
+		l = next_taxi(x);
+		if (25 < i && i < 2000) continue;
+		printf("%4u:%10llu", i, x[0].value);
+		while (l--) printf(" = %4u^3 + %4u^3", x[l].x, x[l].y);
+		putchar('\n');
+	}
+	return 0;
+}
--- a/Task/Taxicab-numbers/Clojure/taxicab-numbers.clj
+++ b/Task/Taxicab-numbers/Clojure/taxicab-numbers.clj
@ -0,0 +1,68 @@
+(ns test-project-intellij.core
+  (:gen-class))
+
+(defn cube [x]
+  "Cube a number through triple multiplication"
+  (* x x x))
+
+(defn sum3 [[i j]]
+   " [i j] -> i^3 + j^3"
+  (+ (cube i) (cube j)))
+
+(defn next-pair [[i j]]
+  " Generate next [i j] pair of sequence  (producing lower triangle pairs) "
+  (if (< j i)
+    [i (inc j)]
+    [(inc i) 1]))
+
+;; Pair sequence generator [1 1] [2 1] [2 2] [3 1] [3 2] [3 3] ...
+(def pairs-seq	(iterate next-pair [1 1]))
+
+(defn dict-inc [m pair]
+  " Add pair to pair map m, with the key of the map based upon the cubic sum (sum3) and the value appends the pair "
+  (update-in m [(sum3 pair)] (fnil #(conj % pair) [])))
+
+(defn enough? [m n-to-generate]
+  " Checks if we have enough taxi numbers (i.e. if number in map >= count-needed "
+  (->> m                                ; hash-map of sum of cube of numbers [key] and their pairs as value
+       (filter #(if (> (count (second %)) 1) true false))   ; filter out ones which don't have more than 1 entry
+       (count)                                              ; count the item remaining
+       (<= n-to-generate)))                                ; true iff count-needed is less or equal to the nubmer filtered
+
+(defn find-taxi-numbers [n-to-generate]
+  " Generates 1st n-to-generate taxi numbers"
+  (loop [m {}               ; Hash-map containing cube of pairs (key) and set of pairs that produce sum (value)
+         p pairs-seq        ; select pairs from our pair sequence generator (i.e. [1 1] [2 1] [2 2] ...)
+         num-tried 0        ; Since its expensve to count how many taxi numbers we have found
+         check-after 1]     ; we only check if we have enough numbers every time (num-tried equals check-after)
+                            ; num-tried increments by 1 each time we try the next pair and
+                            ; check-after doubles if we don't have enough taxi numbers
+    (if (and (= num-tried check-after) (enough? m n-to-generate)) ; check if we found enough taxi numbers
+      (sort-by first (into [] (filter #(> (count (second %)) 1) m)))  ; sort the taxi numbers and this is the result
+      (if (= num-tried check-after)                                   ; Check if we need to increase our count between checking
+        (recur (dict-inc m (first p)) (rest p) (inc num-tried) (* 2 check-after))   ; increased count between checking
+        (recur (dict-inc m (first p)) (rest p) (inc num-tried) check-after)))))     ; didn't increase the count
+
+; Generate 1st 2006 taxi numbers
+(def result (find-taxi-numbers 2006))
+
+;; Show First 25
+(defn show-result [n sample]
+  " Prints one line of result "
+  (print (format "%4d:%10d" n  (first sample)))
+  (doseq [q  (second sample)
+          :let [[i j] q]]
+      (print (format " = %4d^3 + %4d^3" i j)))
+  (println))
+
+; 1st 25 taxi numbers
+(doseq [n (range 1 26)
+        :let [sample (nth result (dec n))]]
+  (show-result n sample))
+
+; taxi numbers from 2000th to 2006th
+(doseq [n (range 2000 2007)
+        :let [sample (nth result (dec n))]]
+  (show-result n sample))
+
+}
--- a/Task/Taxicab-numbers/D/taxicab-numbers-1.d
+++ b/Task/Taxicab-numbers/D/taxicab-numbers-1.d
@ -0,0 +1,19 @@
+void main() /*@safe*/ {
+    import std.stdio, std.range, std.algorithm, std.typecons, std.string;
+
+    auto iCubes = iota(1u, 1201u).map!(x => tuple(x, x ^^ 3));
+    bool[Tuple!(uint, uint)][uint] sum2cubes;
+    foreach (i, immutable i3; iCubes)
+        foreach (j, immutable j3; iCubes[i .. $])
+            sum2cubes[i3 + j3][tuple(i, j)] = true;
+
+    const taxis = sum2cubes.byKeyValue.filter!(p => p.value.length > 1)
+                  .array.schwartzSort!(p => p.key).release;
+
+    foreach (/*immutable*/ const r; [[0, 25], [2000 - 1, 2000 + 6]]) {
+        foreach (immutable i, const t; taxis[r[0] .. r[1]])
+            writefln("%4d: %10d =%-(%s =%)", i + r[0] + 1, t.key,
+                     t.value.keys.sort().map!q{"%4d^3 + %4d^3".format(a[])});
+        writeln;
+    }
+}
--- a/Task/Taxicab-numbers/D/taxicab-numbers-2.d
+++ b/Task/Taxicab-numbers/D/taxicab-numbers-2.d
@ -0,0 +1,65 @@
+import std.stdio, std.string, std.container;
+
+struct CubeSum {
+    ulong x, y, value;
+
+    this(in ulong x_, in ulong y_) pure nothrow @safe @nogc {
+        this.x = x_;
+        this.y = y_;
+        this.value = x_ ^^ 3 + y_ ^^ 3;
+    }
+}
+
+final class Taxi {
+    BinaryHeap!(Array!CubeSum, "a.value > b.value") pq;
+    CubeSum last;
+    ulong n = 0;
+
+    this() {
+        last = nextSum();
+    }
+
+    CubeSum nextSum() {
+        while (pq.empty || pq.front.value >= n ^^ 3)
+            pq.insert(CubeSum(++n, 1));
+
+        auto s = pq.front;
+        pq.removeFront;
+        if (s.x > s.y + 1)
+            pq.insert(CubeSum(s.x, s.y + 1));
+
+        return s;
+    }
+
+    CubeSum[] nextTaxi() {
+        CubeSum s;
+        typeof(return) train;
+
+        while ((s = nextSum).value != last.value)
+            last = s;
+
+        train ~= last;
+
+        do {
+            train ~= s;
+        } while ((s = nextSum).value == last.value);
+        last = s;
+
+        return train;
+    }
+}
+
+void main() {
+    auto taxi = new Taxi;
+
+    foreach (immutable i; 1 .. 2007) {
+        const t = taxi.nextTaxi;
+        if (i > 25 && i < 2000)
+            continue;
+
+        writef("%4d: %10d", i, t[0].value);
+        foreach (const s; t)
+            writef(" = %4d^3 + %4d^3", s.x, s.y);
+        writeln;
+    }
+}
--- a/Task/Taxicab-numbers/D/taxicab-numbers-3.d
+++ b/Task/Taxicab-numbers/D/taxicab-numbers-3.d
@ -0,0 +1,101 @@
+struct Taxicabs {
+    alias CubesSumT = uint; // Or ulong.
+
+    static struct Sum {
+        CubesSumT value;
+        uint x, y;
+    }
+
+    // The cubes can be pre-computed if CubesSumT is a BigInt.
+    private uint nCubes;
+    private Sum[] pq;
+    private uint pq_len;
+
+    private void addCube() pure nothrow @safe {
+        nCubes = nCubes ? nCubes + 1 : 2;
+        if (nCubes < 2)
+            return; // 0 or 1 is useless.
+
+        pq_len++;
+        if (pq_len >= pq.length)
+            pq.length = (pq.length == 0) ? 2 : (pq.length * 2);
+
+        immutable tmp = Sum(CubesSumT(nCubes - 2) ^^ 3 + 1,
+                            nCubes - 2, 1);
+
+        // Upheap.
+        uint i = pq_len;
+        for (; i >= 1 && pq[i >> 1].value > tmp.value; i >>= 1)
+            pq[i] = pq[i >> 1];
+
+        pq[i] = tmp;
+    }
+
+
+    private void nextSum() pure nothrow @safe {
+        while (!pq_len || pq[1].value >= (nCubes - 1) ^^ 3)
+            addCube();
+
+        Sum tmp = pq[0] = pq[1]; //pq[0] always stores last seen value.
+        tmp.y++;
+        if (tmp.y >= tmp.x) { // Done with this x; throw it away.
+            tmp = pq[pq_len];
+            pq_len--;
+            if (!pq_len)
+                return nextSum(); // Refill empty heap.
+        } else
+            tmp.value += tmp.y ^^ 3 - (tmp.y - 1) ^^ 3;
+
+        // Downheap.
+        uint i = 1;
+        while (true) {
+            uint j = i << 1;
+            if (j > pq_len)
+                break;
+            if (j < pq_len && pq[j + 1].value < pq[j].value)
+                j++;
+            if (pq[j].value >= tmp.value)
+                break;
+            pq[i] = pq[j];
+            i = j;
+        }
+
+        pq[i] = tmp;
+    }
+
+
+    Sum[] nextTaxi(size_t N)(ref Sum[N] hist)
+    pure nothrow @safe {
+        do {
+            nextSum();
+        } while (pq[0].value != pq[1].value);
+
+        uint len = 1;
+        hist[0] = pq[0];
+        do {
+            hist[len] = pq[1];
+            len++;
+            nextSum();
+        } while (pq[0].value == pq[1].value);
+
+        return hist[0 .. len];
+    }
+}
+
+
+void main() nothrow {
+    import core.stdc.stdio;
+
+    Taxicabs t;
+    Taxicabs.Sum[3] x;
+
+    foreach (immutable uint i; 1 .. 2007) {
+        const triples = t.nextTaxi(x);
+        if (i > 25 && i < 2000)
+            continue;
+        printf("%4u: %10lu", i, triples[0].value);
+        foreach_reverse (const s; triples)
+            printf(" = %4u^3 + %4u^3", s.x, s.y);
+        '\n'.putchar;
+    }
+}
--- a/Task/Taxicab-numbers/DCL/taxicab-numbers.dcl
+++ b/Task/Taxicab-numbers/DCL/taxicab-numbers.dcl
@ -0,0 +1,55 @@
+$ close /nolog sums_of_cubes
+$ on control_y then $ goto clean
+$ open /write sums_of_cubes sums_of_cubes.txt
+$ i = 1
+$ loop1:
+$  write sys$output i
+$  j = 1
+$  loop2:
+$   sum = i * i * i + j * j * j
+$   if sum .lt. 0
+$   then
+$    write sys$output "overflow at ", j
+$    goto next_i
+$   endif
+$   write sums_of_cubes f$fao( "!10SL,!10SL,!10SL", sum, i, j )
+$   j = j + 1
+$   if j .le. i then $ goto loop2
+$ next_i:
+$  i = i + 1
+$  if i .le. 1289 then $ goto loop1  ! cube_root of 2^31-1
+$ close sums_of_cubes
+$ sort sums_of_cubes.txt sorted_sums_of_cubes.txt
+$ close /nolog sorted_sums_of_cubes
+$ open sorted_sums_of_cubes sorted_sums_of_cubes.txt
+$ count = 0
+$ read sorted_sums_of_cubes prev_prev_line  ! need to detect when there are more than just 2 different sums, e.g. 456
+$ prev_prev_sum = f$element( 0, ",", f$edit( prev_prev_line, "collapse" ))
+$ read sorted_sums_of_cubes prev_line
+$ prev_sum = f$element( 0,",", f$edit( prev_line, "collapse" ))
+$ loop3:
+$  read /end_of_file = done sorted_sums_of_cubes line
+$  sum = f$element( 0, ",", f$edit( line, "collapse" ))
+$  if sum .eqs. prev_sum
+$  then
+$   if sum .nes. prev_prev_sum then $ count = count + 1
+$   int_sum = f$integer( sum )
+$   i1 = f$integer( f$element( 1, ",", prev_line ))
+$   j1 = f$integer( f$element( 2, ",", prev_line ))
+$   i2 = f$integer( f$element( 1, ",", line ))
+$   j2 = f$integer( f$element( 2, ",", line ))
+$   if count .le. 25 .or. ( count .ge. 2000 .and. count .le. 2006 ) then -
+$    write sys$output f$fao( "!4SL:!11SL =!5SL^3 +!5SL^3 =!5SL^3 +!5SL^3", count, int_sum, i1, j1, i2, j2 )
+$  endif
+$  prev_prev_line = prev_line
+$  prev_prev_sum = prev_sum
+$  prev_line = line
+$  prev_sum = sum
+$  goto loop3
+$ done:
+$ close sorted_sums_of_cubes
+$ exit
+$
+$ clean:
+$ close /nolog sorted_sums_of_cubes
+$ close /nolog sums_of_cubes
--- a/Task/Taxicab-numbers/EchoLisp/taxicab-numbers-1.l
+++ b/Task/Taxicab-numbers/EchoLisp/taxicab-numbers-1.l
@ -0,0 +1,48 @@
+(require '(heap compile))
+
+(define (scube a b) (+ (* a a a) (* b b b)))
+(compile 'scube "-f") ; "-f" means : no bigint, no rational used
+
+;; is n - a^3 a cube  b^3?
+;; if yes return b, else #f
+(define (taxi? n a (b 0))
+	(set! b (cbrt (- n (* a a a)))) ;; cbrt is ∛
+	(when (and (< b a) (integer? b)) b))
+(compile 'taxi? "-f")
+
+#|-------------------
+looking for taxis
+--------------------|#
+;; remove from heap until heap-top >= a
+;; when twins are removed, it is a taxicab number : push it
+;; at any time (top stack) = last removed
+
+(define (clean-taxi H limit: a  min-of-heap: htop)
+		(when (and htop (> a htop))
+				(when (!= (stack-top S) htop) (pop S))
+				(push S htop)
+				(heap-pop H)
+				(clean-taxi H  a (heap-top H))))
+(compile 'clean-taxi "-f")
+				
+;; loop on a and b, b <=a , until n taxicabs found
+(define (taxicab (n 2100))
+	(for ((a (in-naturals)))
+		(clean-taxi H (* a a a) (heap-top H))
+		#:break (> (stack-length S) n)
+		(for ((b a))
+			(heap-push H (scube a b)))))
+				
+#|------------------
+printing taxis
+---------------------|#
+;; string of all decompositions
+(define (taxi->string i n)
+	(string-append (format "%d. %d " (1+ i) n)
+	(for/string ((a (cbrt n)))
+		#:when (taxi? n a)
+		(format " = %4d^3 + %4d^3" a (taxi? n a)))))
+		
+(define (taxi-print taxis (nfrom 0) (nto 26))
+		(for ((i (in-naturals nfrom)) (taxi (sublist taxis nfrom nto)))
+		(writeln (taxi->string i (first taxi)))))
--- a/Task/Taxicab-numbers/EchoLisp/taxicab-numbers-2.l
+++ b/Task/Taxicab-numbers/EchoLisp/taxicab-numbers-2.l
@ -0,0 +1,43 @@
+(define S (stack 'S)) ;; to push taxis
+(define H (make-heap < )) ;; make min heap of all scubes
+
+(taxicab 2100)
+(define taxis (group (stack->list S)))
+(taxi-print taxis )
+
+1. 1729 =   10^3 +    9^3 =   12^3 +    1^3
+2. 4104 =   15^3 +    9^3 =   16^3 +    2^3
+3. 13832 =   20^3 +   18^3 =   24^3 +    2^3
+4. 20683 =   24^3 +   19^3 =   27^3 +   10^3
+#| ... |#
+24. 373464 =   60^3 +   54^3 =   72^3 +    6^3
+25. 402597 =   61^3 +   56^3 =   69^3 +   42^3
+26. 439101 =   69^3 +   48^3 =   76^3 +    5^3
+
+(taxi-print taxis 1999 2006)
+2000. 1671816384 = 944^3 + 940^3 = 1168^3 + 428^3
+2001. 1672470592 = 1124^3 + 632^3 = 1187^3 +   29^3
+2002. 1673170856 = 1034^3 + 828^3 = 1164^3 + 458^3
+2003. 1675045225 = 1081^3 + 744^3 = 1153^3 + 522^3
+2004. 1675958167 = 1096^3 + 711^3 = 1159^3 + 492^3
+2005. 1676926719 = 1095^3 + 714^3 = 1188^3 +   63^3
+2006. 1677646971 = 990^3 + 891^3 = 1188^3 +   99^3
+
+;; extra bonus : print all taxis which are triplets
+(define (taxi-tuples taxis (nfrom 0) (nto 2000))
+		(for ((i (in-naturals nfrom)) (taxi (sublist taxis nfrom nto)))
+		#:when (> (length taxi) 1) ;; filter for tuples is here
+		(writeln (taxi->string i (first taxi)))))
+		
+(taxi-tuples taxis)
+
+455. 87539319 = 414^3 + 255^3 = 423^3 + 228^3 = 436^3 + 167^3
+535. 119824488 = 428^3 + 346^3 = 492^3 +   90^3 = 493^3 +   11^3
+588. 143604279 = 423^3 + 408^3 = 460^3 + 359^3 = 522^3 + 111^3
+655. 175959000 = 525^3 + 315^3 = 552^3 + 198^3 = 560^3 +   70^3
+888. 327763000 = 580^3 + 510^3 = 661^3 + 339^3 = 670^3 + 300^3
+1299. 700314552 = 828^3 + 510^3 = 846^3 + 456^3 = 872^3 + 334^3
+1398. 804360375 = 920^3 + 295^3 = 927^3 + 198^3 = 930^3 +   15^3
+1515. 958595904 = 856^3 + 692^3 = 984^3 + 180^3 = 986^3 +   22^3
+1660. 1148834232 = 846^3 + 816^3 = 920^3 + 718^3 = 1044^3 + 222^3
+1837. 1407672000 = 1050^3 + 630^3 = 1104^3 + 396^3 = 1120^3 + 140^3
--- a/Task/Taxicab-numbers/Elixir/taxicab-numbers.elixir
+++ b/Task/Taxicab-numbers/Elixir/taxicab-numbers.elixir
@ -0,0 +1,15 @@
+defmodule Taxicab do
+  def numbers(n \\ 1200) do
+    (for i <- 1..n, j <- i..n, do: {i,j})
+    |> Enum.group_by(fn {i,j} -> i*i*i + j*j*j end)
+    |> Enum.filter(fn {_,v} -> length(v)>1 end)
+    |> Enum.sort
+  end
+end
+
+nums = Taxicab.numbers |> Enum.with_index
+Enum.each(nums, fn {x,i} ->
+  if i in 0..24 or i in 1999..2005 do
+    IO.puts "#{i+1} : #{inspect x}"
+  end
+end)
--- a/Task/Taxicab-numbers/Forth/taxicab-numbers.fth
+++ b/Task/Taxicab-numbers/Forth/taxicab-numbers.fth
@ -0,0 +1,56 @@
+variable taxicablist
+variable searched-cubessum
+73 constant max-constituent \ uses magic numbers
+
+: cube dup dup * * ;
+: cubessum cube swap cube + ;
+
+: ?taxicab ( a b -- c d true | false )
+\ does exist an (c, d) such that c^3+d^3 = a^3+b^3 ?
+  2dup cubessum searched-cubessum !
+  dup 1- rot 1+ do   \ c is possibly in [a+1 b-2]
+    dup i 1+ do      \ d is possibly in [c+1 b-1]
+      j i cubessum searched-cubessum @ = if drop j i true unloop unloop exit then
+    loop
+  loop drop false ;
+
+: swap-taxi ( n -- )
+  dup 5 cells + swap do
+    i @     i 5 cells - @     i !     i 5 cells - !
+  cell +loop ;
+
+: bubble-taxicablist
+  here 5 cells - taxicablist @ = if exit then        \ not for the first one
+  taxicablist @ here 5 cells - do
+    i @     i 5 cells - @     > if unloop exit then  \ no (more) need to reorder
+    i swap-taxi
+  5 cells -loop ;
+
+: store-taxicab ( a b c d -- )
+  2dup cubessum , swap , , swap , ,
+  bubble-taxicablist ;
+
+: build-taxicablist
+  here taxicablist !
+  max-constituent 3 - 1 do         \ a in [ 1 ; max-3 ]
+    i 3 + max-constituent swap do  \ b in [ a+3 ; max ]
+      j i ?taxicab if j i store-taxicab then
+    loop
+  loop ;
+
+: .nextcube cell + dup @ . ." ^3 " ;
+: .taxi
+  dup @ .
+  ." = " .nextcube ." + " .nextcube ." = " .nextcube ." + " .nextcube
+  drop ;
+
+: taxicab 5 cells * taxicablist @ + ;
+
+: list-taxicabs ( n -- )
+  0 do
+    cr I 1+ . ." : "
+    I taxicab .taxi
+  loop ;
+
+build-taxicablist
+25 list-taxicabs
--- a/Task/Taxicab-numbers/Fortran/taxicab-numbers.f
+++ b/Task/Taxicab-numbers/Fortran/taxicab-numbers.f
@ -0,0 +1,75 @@
+! A non-bruteforce approach
+     PROGRAM POOKA
+      IMPLICIT NONE
+!
+! PARAMETER definitions
+!
+      INTEGER , PARAMETER  ::  NVARS = 25
+!
+! Local variables
+!
+      REAL  ::  f1
+      REAL  ::  f2
+      INTEGER  ::  hits
+      INTEGER  ::  s
+      INTEGER  ::  TAXICAB
+
+      hits = 0
+      s = 0
+      f1 = SECOND()
+      DO WHILE ( hits<NVARS )
+         s = s + 1
+         hits = hits + TAXICAB(s)
+      END DO
+      f2 = SECOND()
+      PRINT * , 'elapsed time = ' , f2 - f1 , 'For ' , NVARS , ' Variables'
+      STOP
+      END PROGRAM POOKA
+
+      FUNCTION TAXICAB(N)
+      IMPLICIT NONE
+!
+! Dummy arguments
+!
+      INTEGER  ::  N
+      INTEGER  ::  TAXICAB
+      INTENT (IN) N
+!
+! Local variables
+!
+      INTEGER  ::  holder
+      INTEGER  ::  oldx
+      INTEGER  ::  oldy
+      INTEGER  ::  s
+      INTEGER  ::  x
+      INTEGER  ::  y
+      real*8,parameter :: xpon=(1.0D0/3.0D0)
+!
+      x = 0
+      holder = 0
+      oldx = 0
+      oldy = 0
+      TAXICAB = 0
+      y = INT(N**xpon)
+      DO WHILE ( x<=y )
+         s = x**3 + y**3
+         IF( s<N )THEN
+            x = x + 1
+         ELSE IF( s>N )THEN
+            y = y - 1
+         ELSE
+            IF( holder==s )THEN ! Print the last value and this one that correspond
+               WRITE(6 , 34)s , '(' , x**3 , y**3 , ')' , '(' , oldx**3 , oldy**3 , ')'
+ 34            FORMAT(1x , i12 , 10x , 1A1 , i12 , 2x , i12 , 1A1 , 10x , 1A1 , i12 , 2x ,&
+                    & i12 , 1A1)
+               TAXICAB = 1  ! Indicate that we found a Taxi Number
+            END IF
+            holder = s      ! Set to the number that appears a potential cab number
+            oldx = x       ! Retain the values for the 2 cubes
+            oldy = y
+            x = x + 1       ! Keep looking
+            y = y - 1
+         END IF
+      END DO
+      RETURN
+      END FUNCTION TAXICAB
--- a/Task/Taxicab-numbers/FreeBASIC/taxicab-numbers.basic
+++ b/Task/Taxicab-numbers/FreeBASIC/taxicab-numbers.basic
@ -0,0 +1,100 @@
+' version 11-10-2016
+' compile with: fbc -s console
+
+' Brute force
+
+' adopted from "Sorting algorithms/Shell" sort Task
+Sub shellsort(s() As String)
+  ' sort from lower bound to the highter bound
+  Dim As UInteger lb = LBound(s)
+  Dim As UInteger ub = UBound(s)
+  Dim As Integer done, i, inc = ub - lb
+
+  Do
+    inc = inc / 2.2
+    If inc < 1 Then inc = 1
+
+    Do
+      done = 0
+      For i = lb To ub - inc
+        If s(i) > s(i + inc) Then
+          Swap s(i), s(i + inc)
+          done = 1
+        End If
+      Next
+    Loop Until done = 0
+
+  Loop Until inc = 1
+
+End Sub
+
+' ------=< MAIN >=------
+
+Dim As UInteger x, y, count, c, sum
+Dim As UInteger cube(1290)
+Dim As String result(), str1, str2, str3
+Dim As String buf11 = Space(11), buf5 = Space(5)
+ReDim result(900000)    ' ~1291*1291\2
+
+' set up the cubes
+Print : Print " Calculate cubes"
+For x = 1 To 1290
+  cube(x) = x*x*x
+Next
+
+' combine and store
+Print : Print " Combine cubes"
+For x = 1 To 1290
+  For y = x To 1290
+    sum = cube(x)+cube(y)
+    RSet buf11, Str(sum) : str1 = buf11
+    RSet buf5, Str(x) : str2 = buf5
+    RSet buf5, Str(y) : Str3 = buf5
+    result(count)=buf11 + " = " + str2 + " ^ 3 + " + str3 + " ^ 3"
+    count = count +1
+  Next
+Next
+
+count= count -1
+ReDim Preserve result(count) ' trim the array
+
+Print : Print " Sort (takes some time)"
+shellsort(result())   ' sort
+
+Print : Print " Find the Taxicab numbers"
+c = 1 ' start at index 1
+For x = 0 To count -1
+  ' find sums that match
+  If Left(result(x), 11) = Left(result(x + 1), 11) Then
+    result(c) = result(x)
+    y = x +1
+    Do    ' merge the other solution(s)
+      result(c) = result(c) + Mid(result(y), 12)
+      y = y +1
+    Loop Until Left(result(x), 11) <> Left(result(y), 11)
+    x = y -1 ' let x point to last match result
+    c = c +1
+  End If
+Next
+
+c = c -1
+Print : Print " "; c; " Taxicab numbers found"
+ReDim Preserve result(c) ' trim the array again
+
+cls
+Print : Print " Print first 25 numbers" : Print
+For x = 1 To 25
+  Print result(x)
+Next
+
+Print : Print " The 2000th to the 2006th" : Print
+For x = 2000 To 2006
+  Print result(x)
+Next
+
+
+' empty keyboard buffer
+While Inkey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End
--- a/Task/Taxicab-numbers/Go/taxicab-numbers.go
+++ b/Task/Taxicab-numbers/Go/taxicab-numbers.go
@ -0,0 +1,113 @@
+package main
+
+import (
+	"container/heap"
+	"fmt"
+	"strings"
+)
+
+type CubeSum struct {
+	x, y  uint16
+	value uint64
+}
+
+func (c *CubeSum) fixvalue() { c.value = cubes[c.x] + cubes[c.y] }
+
+type CubeSumHeap []*CubeSum
+
+func (h CubeSumHeap) Len() int            { return len(h) }
+func (h CubeSumHeap) Less(i, j int) bool  { return h[i].value < h[j].value }
+func (h CubeSumHeap) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
+func (h *CubeSumHeap) Push(x interface{}) { (*h) = append(*h, x.(*CubeSum)) }
+func (h *CubeSumHeap) Pop() interface{} {
+	x := (*h)[len(*h)-1]
+	*h = (*h)[:len(*h)-1]
+	return x
+}
+
+type TaxicabGen struct {
+	n int
+	h CubeSumHeap
+}
+
+var cubes []uint64 // cubes[i] == i*i*i
+func cubesExtend(i int) {
+	for n := uint64(len(cubes)); n <= uint64(i); n++ {
+		cubes = append(cubes, n*n*n)
+	}
+}
+
+func (g *TaxicabGen) min() CubeSum {
+	for len(g.h) == 0 || g.h[0].value > cubes[g.n] {
+		g.n++
+		cubesExtend(g.n)
+		heap.Push(&g.h, &CubeSum{uint16(g.n), 1, cubes[g.n] + 1})
+	}
+	// Note, we use g.h[0] to "peek" at the min heap entry.
+	c := *(g.h[0])
+	if c.y+1 <= c.x {
+		// Instead of Pop and Push we modify in place and fix.
+		g.h[0].y++
+		g.h[0].fixvalue()
+		heap.Fix(&g.h, 0)
+	} else {
+		heap.Pop(&g.h)
+	}
+	return c
+}
+
+// Originally this was just: type Taxicab [2]CubeSum
+// and we always returned two sums. Now we return all the sums.
+type Taxicab []CubeSum
+
+func (t Taxicab) String() string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "%12d", t[0].value)
+	for _, p := range t {
+		fmt.Fprintf(&b, " =%5d³ +%5d³", p.x, p.y)
+	}
+	return b.String()
+}
+
+func (g *TaxicabGen) Next() Taxicab {
+	a, b := g.min(), g.min()
+	for a.value != b.value {
+		a, b = b, g.min()
+	}
+	//return Taxicab{a,b}
+
+	// Originally this just returned Taxicab{a,b} and we didn't look
+	// further into the heap. Since we start by looking at the next
+	// pair, that is okay until the first Taxicab number with four
+	// ways of expressing the cube, which doesn't happen until the
+	// 97,235th Taxicab:
+	//     6963472309248 = 16630³ + 13322³ = 18072³ + 10200³
+	//                   = 18948³ +  5436³ = 19083³ +  2421³
+	// Now we return all ways so we need to peek into the heap.
+	t := Taxicab{a, b}
+	for g.h[0].value == b.value {
+		t = append(t, g.min())
+	}
+	return t
+}
+
+func main() {
+	const (
+		low  = 25
+		mid  = 2e3
+		high = 4e4
+	)
+	var tg TaxicabGen
+	firstn := 3 // To show the first triple, quadruple, etc
+	for i := 1; i <= high+6; i++ {
+		t := tg.Next()
+		switch {
+		case len(t) >= firstn:
+			firstn++
+			fallthrough
+		case i <= low || (mid <= i && i <= mid+6) || i >= high:
+			//fmt.Printf("h:%-4d  ", len(tg.h))
+			fmt.Printf("%5d: %v\n", i, t)
+		}
+	}
+}
--- a/Task/Taxicab-numbers/Haskell/taxicab-numbers.hs
+++ b/Task/Taxicab-numbers/Haskell/taxicab-numbers.hs
@ -0,0 +1,38 @@
+import Data.List (groupBy, sortOn, tails, transpose)
+import Data.Function (on)
+
+--------------------- TAXICAB NUMBERS --------------------
+
+taxis :: Int -> [[(Int, ((Int, Int), (Int, Int)))]]
+taxis nCubes =
+  filter ((> 1) . length) $
+  groupBy (on (==) fst) $
+  sortOn fst
+    [ (fst x + fst y, (x, y))
+    | (x:t) <- tails $ ((^ 3) >>= (,)) <$> [1 .. nCubes]
+    , y <- t ]
+
+--------------------------- TEST -------------------------
+main :: IO ()
+main =
+  mapM_ putStrLn $
+  concat <$>
+  transpose
+    (((<$>) =<< flip justifyRight ' ' . maximum . (length <$>)) <$>
+     transpose (taxiRow <$> (take 25 xs <> take 7 (drop 1999 xs))))
+  where
+    xs = zip [1 ..] (taxis 1200)
+    justifyRight n c = (drop . length) <*> (replicate n c <>)
+
+------------------------- DISPLAY ------------------------
+taxiRow :: (Int, [(Int, ((Int, Int), (Int, Int)))]) -> [String]
+taxiRow (n, [(a, ((axc, axr), (ayc, ayr))), (b, ((bxc, bxr), (byc, byr)))]) =
+  concat
+    [ [show n, ". ", show a, " = "]
+    , term axr axc " + "
+    , term ayr ayc "  or  "
+    , term bxr bxc " + "
+    , term byr byc []
+    ]
+  where
+    term r c l = ["(", show r, "^3=", show c, ")", l]
--- a/Task/Taxicab-numbers/J/taxicab-numbers-1.j
+++ b/Task/Taxicab-numbers/J/taxicab-numbers-1.j
@ -0,0 +1,57 @@
+cubes=: 3^~1+i.100 NB. first 100 cubes
+triples=: /:~ ~. ,/ (+ , /:~@,)"0/~cubes NB. ordered pairs of cubes (each with their sum)
+candidates=: ;({."#. <@(0&#`({.@{.(;,)<@}."1)@.(1<#))/. ])triples
+
+NB. we just want the first 25 taxicab numbers
+25{.(,.~ <@>:@i.@#) candidates
+┌──┬──────┬────────────┬─────────────┐
+│1 │1729  │1 1728      │729 1000     │
+├──┼──────┼────────────┼─────────────┤
+│2 │4104  │8 4096      │729 3375     │
+├──┼──────┼────────────┼─────────────┤
+│3 │13832 │8 13824     │5832 8000    │
+├──┼──────┼────────────┼─────────────┤
+│4 │20683 │1000 19683  │6859 13824   │
+├──┼──────┼────────────┼─────────────┤
+│5 │32832 │64 32768    │5832 27000   │
+├──┼──────┼────────────┼─────────────┤
+│6 │39312 │8 39304     │3375 35937   │
+├──┼──────┼────────────┼─────────────┤
+│7 │40033 │729 39304   │4096 35937   │
+├──┼──────┼────────────┼─────────────┤
+│8 │46683 │27 46656    │19683 27000  │
+├──┼──────┼────────────┼─────────────┤
+│9 │64232 │4913 59319  │17576 46656  │
+├──┼──────┼────────────┼─────────────┤
+│10│65728 │1728 64000  │29791 35937  │
+├──┼──────┼────────────┼─────────────┤
+│11│110656│64 110592   │46656 64000  │
+├──┼──────┼────────────┼─────────────┤
+│12│110808│216 110592  │19683 91125  │
+├──┼──────┼────────────┼─────────────┤
+│13│134379│1728 132651 │54872 79507  │
+├──┼──────┼────────────┼─────────────┤
+│14│149389│512 148877  │24389 125000 │
+├──┼──────┼────────────┼─────────────┤
+│15│165464│8000 157464 │54872 110592 │
+├──┼──────┼────────────┼─────────────┤
+│16│171288│4913 166375 │13824 157464 │
+├──┼──────┼────────────┼─────────────┤
+│17│195841│729 195112  │10648 185193 │
+├──┼──────┼────────────┼─────────────┤
+│18│216027│27 216000   │10648 205379 │
+├──┼──────┼────────────┼─────────────┤
+│19│216125│125 216000  │91125 125000 │
+├──┼──────┼────────────┼─────────────┤
+│20│262656│512 262144  │46656 216000 │
+├──┼──────┼────────────┼─────────────┤
+│21│314496│64 314432   │27000 287496 │
+├──┼──────┼────────────┼─────────────┤
+│22│320264│5832 314432 │32768 287496 │
+├──┼──────┼────────────┼─────────────┤
+│23│327763│27000 300763│132651 195112│
+├──┼──────┼────────────┼─────────────┤
+│24│373464│216 373248  │157464 216000│
+├──┼──────┼────────────┼─────────────┤
+│25│402597│74088 328509│175616 226981│
+└──┴──────┴────────────┴─────────────┘
--- a/Task/Taxicab-numbers/J/taxicab-numbers-2.j
+++ b/Task/Taxicab-numbers/J/taxicab-numbers-2.j
@ -0,0 +1,16 @@
+   x:each 7 {. 1999 }. (,.~ <@>:@i.@#) ;({."#. <@(0&#`({.@{.(;,)<@}."1)@.(1<#))/. ])/:~~.,/(+,/:~@,)"0/~3^~1+i.10000
+┌────┬──────────┬────────────────────┬────────────────────┬┐
+│2000│1671816384│78402752 1593413632 │830584000 841232384 ││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2001│1672470592│24389 1672446203    │252435968 1420034624││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2002│1673170856│96071912 1577098944 │567663552 1105507304││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2003│1675045225│142236648 1532808577│411830784 1263214441││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2004│1675958167│119095488 1556862679│359425431 1316532736││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2005│1676926719│250047 1676676672   │363994344 1312932375││
+├────┼──────────┼────────────────────┼────────────────────┼┤
+│2006│1677646971│970299 1676676672   │707347971 970299000 ││
+└────┴──────────┴────────────────────┴────────────────────┴┘
--- a/Task/Taxicab-numbers/Java/taxicab-numbers.java
+++ b/Task/Taxicab-numbers/Java/taxicab-numbers.java
@ -0,0 +1,75 @@
+import java.util.PriorityQueue;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Iterator;
+
+class CubeSum implements Comparable<CubeSum> {
+	public long x, y, value;
+
+	public CubeSum(long x, long y) {
+		this.x = x;
+		this.y = y;
+		this.value = x*x*x + y*y*y;
+	}
+
+	public String toString() {
+		return String.format("%4d^3 + %4d^3", x, y);
+	}
+
+	public int compareTo(CubeSum that) {
+		return value < that.value ? -1 : value > that.value ? 1 : 0;
+	}
+}
+
+class SumIterator implements Iterator<CubeSum> {
+	PriorityQueue<CubeSum> pq = new PriorityQueue<CubeSum>();
+	long n = 0;
+
+	public boolean hasNext() { return true; }
+	public CubeSum next() {
+		while (pq.size() == 0 || pq.peek().value >= n*n*n)
+			pq.add(new CubeSum(++n, 1));
+
+		CubeSum s = pq.remove();
+		if (s.x > s.y + 1) pq.add(new CubeSum(s.x, s.y+1));
+
+		return s;
+	}
+}
+
+class TaxiIterator implements Iterator<List<CubeSum>> {
+	Iterator<CubeSum> sumIterator = new SumIterator();
+	CubeSum last = sumIterator.next();
+
+	public boolean hasNext() { return true; }
+	public List<CubeSum> next() {
+		CubeSum s;
+		List<CubeSum> train = new ArrayList<CubeSum>();
+
+		while ((s = sumIterator.next()).value != last.value)
+			last = s;
+
+		train.add(last);
+
+		do { train.add(s); } while ((s = sumIterator.next()).value == last.value);
+		last = s;
+
+		return train;
+	}
+}
+	
+public class Taxi {
+	public static final void main(String[] args) {
+		Iterator<List<CubeSum>> taxi = new TaxiIterator();
+
+		for (int i = 1; i <= 2006; i++) {
+			List<CubeSum> t = taxi.next();
+			if (i > 25 && i < 2000) continue;
+
+			System.out.printf("%4d: %10d", i, t.get(0).value);
+			for (CubeSum s: t)
+				System.out.print(" = " + s);
+			System.out.println();
+		}
+	}
+}
--- a/Task/Taxicab-numbers/JavaScript/taxicab-numbers.js
+++ b/Task/Taxicab-numbers/JavaScript/taxicab-numbers.js
@ -0,0 +1,27 @@
+var n3s = [],
+    s3s = {}
+for (var n = 1, e = 1200; n < e; n += 1) n3s[n] = n * n * n
+for (var a = 1; a < e - 1; a += 1) {
+    var a3 = n3s[a]
+    for (var b = a; b < e; b += 1) {
+        var b3 = n3s[b]
+        var s3 = a3 + b3,
+            abs = s3s[s3]
+        if (!abs) s3s[s3] = abs = []
+        abs.push([a, b])
+    }
+}
+
+var i = 0
+for (var s3 in s3s) {
+    var abs = s3s[s3]
+    if (abs.length < 2) continue
+    i += 1
+    if (abs.length == 2 && i > 25 && i < 2000) continue
+    if (i > 2006) break
+    document.write(i, ': ', s3)
+    for (var ab of abs) {
+        document.write(' = ', ab[0], '<sup>3</sup>+', ab[1], '<sup>3</sup>')
+    }
+    document.write('<br>')
+}
--- a/Task/Taxicab-numbers/Jq/taxicab-numbers-1.jq
+++ b/Task/Taxicab-numbers/Jq/taxicab-numbers-1.jq
@ -0,0 +1,39 @@
+# Output: an array of the form [i^3 + j^3, [i, j]] sorted by the sum.
+# Only cubes of 1 to ($in-1) are considered; the listing is therefore truncated
+# as it might not capture taxicab numbers greater than $in ^ 3.
+def sum_of_two_cubes:
+  def cubed: .*.*.;
+  . as $in
+  | (cubed + 1) as $limit
+  | [range(1;$in) as $i | range($i;$in) as $j
+
+  | [ ($i|cubed) + ($j|cubed), [$i, $j] ] ] | sort
+  | map( select( .[0] < $limit ) );
+
+# Output a stream of triples [t, d1, d2], in order of t,
+# where t is a taxicab number, and d1 and d2 are distinct
+# decompositions [i,j] with i^3 + j^3 == t.
+# The stream includes each taxicab number once only.
+#
+def taxicabs0:
+  sum_of_two_cubes as $sums
+  | range(1;$sums|length) as $i
+  | if $sums[$i][0] == $sums[$i-1][0]
+      and ($i==1 or $sums[$i][0] != $sums[$i-2][0])
+    then [$sums[$i][0], $sums[$i-1][1], $sums[$i][1]]
+    else empty
+    end;
+
+# Output a stream of $n taxicab triples: [t, d1, d2] as described above,
+# without repeating t.
+def taxicabs:
+  # If your jq includes until/2 then the following definition
+  # can be omitted:
+  def until(cond; next):
+    def _until: if cond then . else (next|_until) end;  _until;
+  . as $n
+  | [10, ($n / 10 | floor)] | max as $increment
+  | [20, ($n / 2 | floor)] | max
+  | [ ., [taxicabs0] ]
+  | until( .[1] | length >= $m; (.[0] + $increment) | [., [taxicabs0]] )
+  | .[1][0:$n] ;
--- a/Task/Taxicab-numbers/Jq/taxicab-numbers-2.jq
+++ b/Task/Taxicab-numbers/Jq/taxicab-numbers-2.jq
@ -0,0 +1,3 @@
+2006 | taxicabs as $t
+| (range(0;25), range(1999;2006)) as $i
+| "\($i+1): \($t[$i][0]) ~ \($t[$i][1]) and \($t[$i][2])"
--- a/Task/Taxicab-numbers/Jq/taxicab-numbers-3.jq
+++ b/Task/Taxicab-numbers/Jq/taxicab-numbers-3.jq
@ -0,0 +1,33 @@
+$ jq -n -r -f Taxicab_numbers.jq
+1: 1729 ~ [1,12] and [9,10]
+2: 4104 ~ [2,16] and [9,15]
+3: 13832 ~ [2,24] and [18,20]
+4: 20683 ~ [10,27] and [19,24]
+5: 32832 ~ [4,32] and [18,30]
+6: 39312 ~ [2,34] and [15,33]
+7: 40033 ~ [9,34] and [16,33]
+8: 46683 ~ [3,36] and [27,30]
+9: 64232 ~ [17,39] and [26,36]
+10: 65728 ~ [12,40] and [31,33]
+11: 110656 ~ [4,48] and [36,40]
+12: 110808 ~ [6,48] and [27,45]
+13: 134379 ~ [12,51] and [38,43]
+14: 149389 ~ [8,53] and [29,50]
+15: 165464 ~ [20,54] and [38,48]
+16: 171288 ~ [17,55] and [24,54]
+17: 195841 ~ [9,58] and [22,57]
+18: 216027 ~ [3,60] and [22,59]
+19: 216125 ~ [5,60] and [45,50]
+20: 262656 ~ [8,64] and [36,60]
+21: 314496 ~ [4,68] and [30,66]
+22: 320264 ~ [18,68] and [32,66]
+23: 327763 ~ [30,67] and [51,58]
+24: 373464 ~ [6,72] and [54,60]
+25: 402597 ~ [42,69] and [56,61]
+2000: 1671816384 ~ [428,1168] and [940,944]
+2001: 1672470592 ~ [29,1187] and [632,1124]
+2002: 1673170856 ~ [458,1164] and [828,1034]
+2003: 1675045225 ~ [522,1153] and [744,1081]
+2004: 1675958167 ~ [492,1159] and [711,1096]
+2005: 1676926719 ~ [63,1188] and [714,1095]
+2006: 1677646971 ~ [99,1188] and [891,990]
--- a/Task/Taxicab-numbers/Julia/taxicab-numbers.julia
+++ b/Task/Taxicab-numbers/Julia/taxicab-numbers.julia
@ -0,0 +1,54 @@
+using Printf, DataStructures, IterTools
+
+function findtaxinumbers(nmax::Integer)
+    cube2n = Dict{Int,Int}(x ^ 3 => x for x in 0:nmax)
+    sum2cubes = DefaultDict{Int,Set{NTuple{2,Int}}}(Set{NTuple{2,Int}})
+    for ((c1, _), (c2, _)) in product(cube2n, cube2n)
+        if c1 ≥ c2
+            push!(sum2cubes[c1 + c2], (cube2n[c1], cube2n[c2]))
+        end
+    end
+
+    taxied = collect((k, v) for (k, v) in sum2cubes if length(v) ≥ 2)
+    return sort!(taxied, by = first)
+end
+taxied = findtaxinumbers(1200)
+
+for (ith, (cube, set)) in zip(1:25, taxied[1:25])
+    @printf "%2i: %7i = %s\n" ith cube join(set, ", ")
+    # println(ith, ": ", cube, " = ", join(set, ", "))
+end
+println("...")
+for (ith, (cube, set)) in zip(2000:2006, taxied[2000:2006])
+    @printf "%-4i: %i = %s\n" ith cube join(set, ", ")
+end
+
+# version 2
+function findtaxinumbers(nmax::Integer)
+    cubes, crev = collect(x ^ 3 for x in 1:nmax), Dict{Int,Int}()
+    for (x, x3) in enumerate(cubes)
+        crev[x3] = x
+    end
+    sums = collect(x + y for x in cubes for y in cubes if y < x)
+    sort!(sums)
+
+    idx = 0
+    for i in 2:(endof(sums) - 1)
+        if sums[i-1] != sums[i] && sums[i] == sums[i+1]
+            idx += 1
+            if 25 < idx < 2000 || idx > 2006 continue end
+            n, p = sums[i], NTuple{2,Int}[]
+            for x in cubes
+                n < 2x && break
+                if haskey(crev, n - x)
+                    push!(p, (crev[x], crev[n - x]))
+                end
+            end
+            @printf "%4d: %10d" idx n
+            for x in p @printf(" = %4d ^ 3 + %4d ^ 3", x...) end
+            println()
+        end
+    end
+end
+
+findtaxinumbers(1200)
--- a/Task/Taxicab-numbers/Kotlin/taxicab-numbers.kotlin
+++ b/Task/Taxicab-numbers/Kotlin/taxicab-numbers.kotlin
@ -0,0 +1,61 @@
+// version 1.0.6
+
+import java.util.PriorityQueue
+
+class CubeSum(val x: Long, val y: Long) : Comparable<CubeSum> {
+    val value: Long = x * x * x + y * y * y
+
+    override fun toString() = String.format("%4d^3 + %3d^3", x, y)
+
+    override fun compareTo(other: CubeSum) = value.compareTo(other.value)
+}
+
+class SumIterator : Iterator<CubeSum> {
+    private val pq = PriorityQueue<CubeSum>()
+    private var n = 0L
+
+    override fun hasNext() = true
+
+    override fun next(): CubeSum {
+        while (pq.size == 0 || pq.peek().value >= n * n * n)
+            pq.add(CubeSum(++n, 1))
+        val s: CubeSum = pq.remove()
+        if (s.x > s.y + 1) pq.add(CubeSum(s.x, s.y + 1))
+        return s
+    }
+}
+
+class TaxiIterator : Iterator<MutableList<CubeSum>> {
+    private val sumIterator = SumIterator()
+    private var last: CubeSum = sumIterator.next()
+
+    override fun hasNext() = true
+
+    override fun next(): MutableList<CubeSum> {
+        var s: CubeSum = sumIterator.next()
+        val train = mutableListOf<CubeSum>()
+        while (s.value != last.value) {
+            last = s
+            s = sumIterator.next()
+        }
+        train.add(last)
+        do {
+            train.add(s)
+            s = sumIterator.next()
+        }
+        while (s.value == last.value)
+        last = s
+        return train
+    }
+}
+
+fun main(args: Array<String>) {
+    val taxi = TaxiIterator()
+    for (i in 1..2006) {
+        val t = taxi.next()
+        if (i in 26 until 2000) continue
+        print(String.format("%4d: %10d", i, t[0].value))
+        for (s in t) print("  = $s")
+        println()
+    }
+}
--- a/Task/Taxicab-numbers/Lua/taxicab-numbers.lua
+++ b/Task/Taxicab-numbers/Lua/taxicab-numbers.lua
@ -0,0 +1,18 @@
+sums, taxis, limit = {}, {}, 1200
+for i = 1, limit do
+  for j = 1, i-1 do
+    sum = i^3 + j^3
+    sums[sum] = sums[sum] or {}
+    table.insert(sums[sum], i.."^3 + "..j.."^3")
+  end
+end
+for k,v in pairs(sums) do
+  if #v > 1 then table.insert(taxis, { sum=k, num=#v, terms=table.concat(v," = ") }) end
+end
+table.sort(taxis, function(a,b) return a.sum<b.sum end)
+for i=1,2006 do
+  if i<=25 or i>=2000 or taxis[i].num==3 then
+    print(string.format("%4d%s: %10d = %s", i, taxis[i].num==3 and "*" or " ", taxis[i].sum, taxis[i].terms))
+  end
+end
+print("* n=3")
--- a/Task/Taxicab-numbers/Mathematica/taxicab-numbers.math
+++ b/Task/Taxicab-numbers/Mathematica/taxicab-numbers.math
@ -0,0 +1,4 @@
+findTaxi[n_] := Sort[Keys[Select[Counts[Flatten[Table[x^3 + y^3, {x, 1, n}, {y, x, n}]]], GreaterThan[1]]]];
+Take[findTaxiNumbers[100], 25]
+found=findTaxiNumbers[1200][[2000 ;; 2005]]
+Map[Reduce[x^3 + y^3 == # && x >= y && x > 0 && y > 0, {x, y}, Integers] &, found]
--- a/Task/Taxicab-numbers/Nim/taxicab-numbers.nim
+++ b/Task/Taxicab-numbers/Nim/taxicab-numbers.nim
@ -0,0 +1,45 @@
+import heapqueue, strformat
+
+type
+
+  CubeSum = tuple[x, y, value: int]
+
+# Comparison function needed for the heap queues.
+proc `<`(c1, c2: CubeSum): bool = c1.value < c2.value
+
+template cube(n: int): int = n * n * n
+
+
+iterator cubesum(): CubeSum =
+  var queue: HeapQueue[CubeSum]
+  var n = 1
+  while true:
+    while queue.len == 0 or queue[0].value > cube(n):
+      queue.push (n, 1, cube(n) + 1)
+      inc n
+    var s = queue.pop()
+    yield s
+    inc s.y
+    if s.y < s.x: queue.push (s.x, s.y, cube(s.x) + cube(s.y))
+
+
+iterator taxis(): seq[CubeSum] =
+  var result: seq[CubeSum] = @[(0, 0, 0)]
+  for s in cubesum():
+    if s.value == result[^1].value:
+      result.add s
+    else:
+      if result.len > 1: yield result
+      result.setLen(0)
+      result.add s      # These two statements are faster than the single result = @[s].
+
+
+var n = 0
+for t in taxis():
+  inc n
+  if n > 2006: break
+  if n <= 25 or n >= 2000:
+    stdout.write &"{n:4}: {t[0].value:10}"
+    for s in t:
+      stdout.write &" = {s.x:4}^3 + {s.y:4}^3"
+    echo()
--- a/Task/Taxicab-numbers/PARI-GP/taxicab-numbers.parigp
+++ b/Task/Taxicab-numbers/PARI-GP/taxicab-numbers.parigp
@ -0,0 +1,4 @@
+taxicab(n)=my(t); for(k=sqrtnint((n-1)\2,3)+1, sqrtnint(n,3), if(ispower(n-k^3, 3), if(t, return(1), t=1))); 0;
+cubes(n)=my(t); for(k=sqrtnint((n-1)\2,3)+1, sqrtnint(n,3), if(ispower(n-k^3, 3, &t), print(n" =  \t"k"^3\t+ "t"^3")))
+select(taxicab, [1..402597])
+apply(cubes, %);
--- a/Task/Taxicab-numbers/Pascal/taxicab-numbers.pas
+++ b/Task/Taxicab-numbers/Pascal/taxicab-numbers.pas
@ -0,0 +1,135 @@
+program taxiCabNo;
+uses
+  sysutils;
+type
+  tPot3    = Uint32;
+  tPot3Sol = record
+               p3Sum : tPot3;
+               i1,j1,
+               i2,j2 : Word;
+             end;
+ tpPot3    = ^tPot3;
+ tpPot3Sol = ^tPot3Sol;
+
+var
+//1290^3 = 2'146'689'000 < 2^31-1
+//1190 is the magic number of the task ;-)
+  pot3 : array[0..1190{1290}] of tPot3;//
+  AllSol : array[0..3000] of tpot3Sol;
+  AllSolHigh : NativeInt;
+
+procedure SolOut(const s:tpot3Sol;no: NativeInt);
+begin
+  with s do
+    writeln(no:5,p3Sum:12,' = ',j1:5,'^3 +',i1:5,'^3 =',j2:5,'^3 +',i2:5,'^3');
+end;
+
+procedure InsertAllSol;
+
+var
+  tmp: tpot3Sol;
+  p :tpPot3Sol;
+  p3Sum: tPot3;
+  i: NativeInt;
+Begin
+
+  i := AllSolHigh;
+  IF i > 0 then
+  Begin
+    p := @AllSol[i];
+    tmp := p^;
+    p3Sum := p^.p3Sum;
+    //search the right place for insertion
+    repeat
+      dec(i);
+      dec(p);
+      IF (p^.p3Sum <= p3Sum) then
+        BREAK;
+    until  (i<=0);
+    IF p^.p3Sum = p3Sum then
+      EXIT;
+    //free the right place by moving one place up
+    inc(i);
+    inc(p);
+    IF i<AllSolHigh then
+    Begin
+      move(p^,AllSol[i+1],SizeOf(AllSol[0])*(AllSolHigh-i));
+      p^ := tmp;
+    end;
+  end;
+  inc(AllSolHigh);
+end;
+
+function searchSameSum(var sol:tpot3Sol):boolean;
+//try to find a new combination for the same sum
+//within the limits given by lo and hi
+var
+  Sum,
+  SumLo: tPot3;
+  hi,lo: NativeInt;
+Begin
+  with Sol do
+  Begin
+    Sum := p3Sum;
+    lo:= i1;
+    hi:= j1;
+  end;
+
+  repeat
+    //Move hi down
+    dec(hi);
+    SumLo := Sum-Pot3[hi];
+    //Move lo up an check until new combination found or implicite lo> hi
+    repeat
+      inc(lo)
+    until (SumLo<=Pot3[lo]);
+    //found?
+    IF SumLo = Pot3[lo] then
+      BREAK;
+  until lo>=hi;
+
+  IF lo<hi then
+  Begin
+    sol.i2:= lo;
+    sol.j2:= hi;
+    searchSameSum := true;
+  end
+  else
+    searchSameSum := false;
+end;
+
+procedure Search;
+var
+  i,j: LongInt;
+Begin
+  AllSolHigh := 0;
+  For j := 2 to High(pot3)-1 do
+  Begin
+    For i := 1 to j-1 do
+    Begin
+      with AllSol[AllSolHigh] do
+      Begin
+        p3Sum:= pot3[i]+pot3[j];
+        i1:= i;
+        j1:= j;
+      end;
+      IF searchSameSum(AllSol[AllSolHigh]) then
+      BEGIN
+        InsertAllSol;
+        IF AllSolHigh>High(AllSol) then EXIT;
+      end;
+    end;
+  end;
+end;
+
+var
+  i: LongInt;
+Begin
+  For i := Low(pot3) to High(pot3) do
+    pot3[i] := i*i*i;
+  AllSolHigh := 0;
+  Search;
+  For i :=    0 to   24 do SolOut(AllSol[i],i+1);
+  For i := 1999 to 2005 do SolOut(AllSol[i],i+1);
+  writeln('count of solutions         ',AllSolHigh);
+end.
--- a/Task/Taxicab-numbers/Perl/taxicab-numbers.pl
+++ b/Task/Taxicab-numbers/Perl/taxicab-numbers.pl
@ -0,0 +1,54 @@
+my($beg, $end) = (@ARGV==0) ? (1,25) : (@ARGV==1) ? (1,shift) : (shift,shift);
+
+my $lim = 1e14;  # Ought to be dynamic as should segment size
+my @basis = map { $_*$_*$_ } (1 .. int($lim ** (1.0/3.0) + 1));
+my $paira = 2;  # We're looking for Ta(2) and larger
+
+my ($segsize, $low, $high, $i) = (500_000_000, 0, 0, 0);
+
+while ($i < $end) {
+  $low = $high+1;
+  die "lim too low" if $low > $lim;
+  $high = $low + $segsize - 1;
+  $high = $lim if $high > $lim;
+  foreach my $p (_find_pairs_segment(\@basis, $paira, $low, $high,
+                 sub { sprintf("%4d^3 + %4d^3", $_[0], $_[1]) })    ) {
+    $i++;
+    next if $i < $beg;
+    last if $i > $end;
+    my $n = shift @$p;
+    printf "%4d: %10d  = %s\n", $i, $n, join("  = ", @$p);
+  }
+}
+
+sub _find_pairs_segment {
+  my($p, $len, $start, $end, $formatsub) = @_;
+  my $plen = $#$p;
+
+  my %allpairs;
+  foreach my $i (0 .. $plen) {
+    my $pi = $p->[$i];
+    next if ($pi+$p->[$plen]) < $start;
+    last if (2*$pi) > $end;
+    foreach my $j ($i .. $plen) {
+      my $sum = $pi + $p->[$j];
+      next if $sum < $start;
+      last if $sum > $end;
+      push @{ $allpairs{$sum} }, $i, $j;
+    }
+    # If we wanted to save more memory, we could filter and delete every entry
+    # where $n < 2 * $p->[$i+1].  This can cut memory use in half, but is slow.
+  }
+
+  my @retlist;
+  foreach my $list (grep { scalar @$_ >= $len*2 } values %allpairs) {
+    my $n = $p->[$list->[0]] + $p->[$list->[1]];
+    my @pairlist;
+    while (@$list) {
+      push @pairlist, $formatsub->(1 + shift @$list, 1 + shift @$list);
+    }
+    push @retlist, [$n, @pairlist];
+  }
+  @retlist = sort { $a->[0] <=> $b->[0] } @retlist;
+  return @retlist;
+}
--- a/Task/Taxicab-numbers/Phix/taxicab-numbers.phix
+++ b/Task/Taxicab-numbers/Phix/taxicab-numbers.phix
@ -0,0 +1,45 @@
+(phixonline)-->
+ <span style="color: #000080;font-style:italic;">-- demo\rosetta\Taxicab_numbers.exw</span>
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">cube_sums</span><span style="color: #0000FF;">()</span>
+     <span style="color: #000080;font-style:italic;">// create cubes and sorted list of cube sums</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">cubes</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000000;">sums</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1189</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">atom</span> <span style="color: #000000;">cube</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">i</span>
+         <span style="color: #000000;">sums</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sq_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cube</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">cubes</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">cube</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #000000;">sums</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sums</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (706,266 in total)</span>
+     <span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sums</span><span style="color: #0000FF;">}</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">sequence</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sums</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cube_sums</span><span style="color: #0000FF;">()</span>
+
+ <span style="color: #004080;">atom</span> <span style="color: #000000;">nm1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sums</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span>
+        <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sums</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">idx</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First 25 Taxicab Numbers, 2000..2006th, and all interim triples:\n"</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">3</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sums</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">np1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sums</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">np1</span> <span style="color: #008080;">and</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">nm1</span> <span style="color: #008080;">then</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">idx</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">25</span>
+         <span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">2000</span> <span style="color: #008080;">and</span> <span style="color: #000000;">idx</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">2006</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">or</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">sums</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
+             <span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+             <span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+                 <span style="color: #004080;">atom</span> <span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cubes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span>
+                      <span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">x</span>
+                 <span style="color: #008080;">if</span> <span style="color: #000000;">y</span><span style="color: #0000FF;"><</span><span style="color: #000000;">x</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+                 <span style="color: #004080;">integer</span> <span style="color: #000000;">ydx</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">binary_search</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cubes</span><span style="color: #0000FF;">)</span>
+                 <span style="color: #008080;">if</span> <span style="color: #000000;">ydx</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+                     <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"(%3d^3=%9d) + (%4d^3=%10d)"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">j</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ydx</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">}))</span>
+                 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+             <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%4d %10d = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">idx</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" or "</span><span style="color: #0000FF;">)})</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">idx</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #000000;">nm1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
+     <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">np1</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--
--- a/Task/Taxicab-numbers/PicoLisp/taxicab-numbers.l
+++ b/Task/Taxicab-numbers/PicoLisp/taxicab-numbers.l
@ -0,0 +1,17 @@
+(load "@lib/simul.l")
+
+(off 'B)
+(for L (subsets 2 (range 1 1200))
+   (let K (sum '((N) (** N 3)) L)
+      (ifn (lup B K)
+         (idx 'B (list K 1 (list L)) T)
+         (inc (cdr @))
+         (push (cddr @) L) ) ) )
+(setq R
+   (filter
+      '((L) (>= (cadr L) 2))
+      (idx 'B)) )
+(for L (head 25 R)
+   (println (car L) (caddr L)) )
+(for L (head 7 (nth R 2000))
+   (println (car L) (caddr L)) )
--- a/Task/Taxicab-numbers/PureBasic/taxicab-numbers.basic
+++ b/Task/Taxicab-numbers/PureBasic/taxicab-numbers.basic
@ -0,0 +1,39 @@
+#MAX=1189
+
+Macro q3(a,b)
+  a*a*a+b*b*b
+EndMacro
+
+Structure Cap
+  x.i
+  y.i
+  s.i
+EndStructure
+
+NewList Taxi.Cap()
+
+For i=1 To #MAX
+  For j=i To #MAX
+    AddElement(Taxi()) : Taxi()\s=q3(i,j) : Taxi()\x=i : Taxi()\y=j
+  Next j
+Next i
+
+SortStructuredList(Taxi(),#PB_Sort_Ascending,OffsetOf(Cap\s),TypeOf(Cap\s))
+
+If OpenConsole()
+  ForEach Taxi()
+    If sum=Taxi()\s
+      r$+"="+RSet(Str(Taxi()\x),4)+"³ +"+RSet(Str(Taxi()\y),4)+"³ " : Continue
+    EndIf
+    If CountString(r$,"=")>=2 : c+1 : EndIf
+    If CountString(r$,"=")=2
+      Select c
+        Case 1 To 25, 2000 To 2006 : PrintN(RSet(Str(c),5)+": "+RSet(Str(sum),10)+r$)
+        Case Bool(c>2006) : Break
+      EndSelect
+    EndIf
+    r$=""
+    sum=Taxi()\s : r$="="+RSet(Str(Taxi()\x),4)+"³ +"+RSet(Str(Taxi()\y),4)+"³ "
+  Next
+  PrintN("FIN.") : Input()
+EndIf
--- a/Task/Taxicab-numbers/Python/taxicab-numbers-1.py
+++ b/Task/Taxicab-numbers/Python/taxicab-numbers-1.py
@ -0,0 +1,17 @@
+from collections import defaultdict
+from itertools import product
+from pprint import pprint as pp
+
+cube2n = {x**3:x for x in range(1, 1201)}
+sum2cubes = defaultdict(set)
+for c1, c2 in product(cube2n, cube2n):
+	if c1 >= c2: sum2cubes[c1 + c2].add((cube2n[c1], cube2n[c2]))
+	
+taxied = sorted((k, v) for k,v in sum2cubes.items() if len(v) >= 2)
+
+#pp(len(taxied))  # 2068
+for t in enumerate(taxied[:25], 1):
+    pp(t)
+print('...')
+for t in enumerate(taxied[2000-1:2000+6], 2000):
+    pp(t)
--- a/Task/Taxicab-numbers/Python/taxicab-numbers-2.py
+++ b/Task/Taxicab-numbers/Python/taxicab-numbers-2.py
@ -0,0 +1,20 @@
+cubes, crev = [x**3 for x in range(1,1200)], {}
+# for cube root lookup
+for x,x3 in enumerate(cubes): crev[x3] = x + 1
+
+sums = sorted(x+y for x in cubes for y in cubes if y < x)
+
+idx = 0
+for i in range(1, len(sums)-1):
+    if sums[i-1] != sums[i] and sums[i] == sums[i+1]:
+        idx += 1
+        if idx > 25 and idx < 2000 or idx > 2006: continue
+
+        n,p = sums[i],[]
+        for x in cubes:
+            if n-x < x: break
+            if n-x in crev:
+                p.append((crev[x], crev[n-x]))
+        print "%4d: %10d"%(idx,n),
+        for x in p: print " = %4d^3 + %4d^3"%x,
+        print
--- a/Task/Taxicab-numbers/Python/taxicab-numbers-3.py
+++ b/Task/Taxicab-numbers/Python/taxicab-numbers-3.py
@ -0,0 +1,30 @@
+from heapq import heappush, heappop
+
+def cubesum():
+    h,n = [],1
+    while True:
+        while not h or h[0][0] > n**3: # could also pre-calculate cubes
+            heappush(h, (n**3 + 1, n, 1))
+            n += 1
+
+        (s, x, y) = heappop(h)
+        yield((s, x, y))
+        y += 1
+        if y < x:    # should be y <= x?
+            heappush(h, (x**3 + y**3, x, y))
+
+def taxis():
+    out = [(0,0,0)]
+    for s in cubesum():
+        if s[0] == out[-1][0]:
+            out.append(s)
+        else:
+            if len(out) > 1: yield(out)
+            out = [s]
+
+n = 0
+for x in taxis():
+    n += 1
+    if n >= 2006: break
+    if n <= 25 or n >= 2000:
+        print(n, x)
--- a/Task/Taxicab-numbers/REXX/taxicab-numbers.rexx
+++ b/Task/Taxicab-numbers/REXX/taxicab-numbers.rexx
@ -0,0 +1,48 @@
+/*REXX program displays the specified first (lowest) taxicab numbers (for three ranges).*/
+parse arg  L.1  H.1      L.2 H.2      L.3 H.3 .  /*obtain optional arguments from the CL*/
+   if L.1=='' | L.1==","  then L.1=   1          /*L1  is the low  part of 1st range.   */
+   if H.1=='' | H.1==","  then H.1=  25          /*H1   "  "  high   "   "  "    "      */
+   if L.2=='' | L.2==","  then L.2= 454          /*L2   "  "  low    "   " 2nd   "      */
+   if H.2=='' | H.2==","  then H.2= 456          /*H2   "  "  high   "   "  "    "      */
+   if L.3=='' | L.3==","  then L.3=2000          /*L3   "  "  low    "   " 3rd   "      */
+   if H.3=='' | H.3==","  then H.3=2006          /*H3   "  "  high   "   "  "    "      */
+mx= max(H.1,    H.2,    H.3)                     /*find how many taxicab numbers needed.*/
+mx= mx   + mx % 10                               /*cushion;  compensate for the triples.*/
+ww= length(mx) * 3;           w= ww % 2          /*widths used for formatting the output*/
+numeric digits max(9, ww)                        /*prepare to use some larger numbers.  */
+@.=.;    #= 0;     @@.= 0;    @and= "  ──and── " /*set some REXX vars and handy literals*/
+$.=                                              /* [↓]  generate extra taxicab numbers.*/
+    do j=1  until #>=mx;            C= j**3      /*taxicab numbers may not be in order. */
+    !.j= C                                       /*use memoization for cube calculation.*/
+      do k=1  for j-1;              s= C + !.k   /*define a whole bunch of cube sums.   */
+      if @.s==.  then do;  @.s= j;  b.s= k       /*Cube not defined?   Then process it. */
+                           iterate               /*define  @.S  and  B.S≡sum  of 2 cubes*/
+                      end                        /* [↑]  define one cube sum at a time. */
+      has= @@.s                                  /*has this number been defined before? */
+      if has  then $.s= $.s @and U(j,'   +')U(k) /* ◄─ build a display string. [↓]      */
+              else $.s= right(s,ww)  '───►'   U(@.s,"   +")U(b.s)   @and   U(j,'   +')U(k)
+      @@.s= 1                                    /*mark taxicab number as a sum of cubes*/
+      if has   then iterate                      /*S  is a triple (or sometimes better).*/
+      #= # + 1;    #.#= s                        /*bump taxicab counter; define taxicab#*/
+      end   /*k*/                                /* [↑]  build the cubes one─at─a─time. */
+    end      /*j*/                               /* [↑]  complete with overage numbers. */
+A.=
+       do k=1  for mx;   _= #.k;    A.k= $._     /*re─assign disjoint $. elements to A. */
+       end   /*k*/
+call Esort  mx                                   /*sort taxicab #s with an exchange sort*/
+       do grp=1  for 3;  call tell L.grp, H.grp  /*display the three grps of numbers. */
+       end   /*grp*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+tell:  do t=arg(1)  to arg(2);    say right(t, 9)':'   A.t;     end;        say;    return
+U:     return right(arg(1), w)'^3'arg(2)         /*right─justify a number,  append "^3" */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+Esort: procedure expose A.; parse arg N;         h= N    /*Esort when items have blanks.*/
+         do  while h>1;     h= h % 2
+           do i=1  for N-h;           k=h + i;   j= i
+              do forever;   parse var A.k xk .;  parse var A.j xj .;  if xk>=xj then leave
+              _= A.j;       A.j= A.k; A.k= _             /*swap two elements of A. array*/
+              if h>=j  then leave;    j=j - h;   k= k - h
+              end   /*forever*/
+           end      /*i*/
+         end        /*while h>1*/;               return
--- a/Task/Taxicab-numbers/Racket/taxicab-numbers.rkt
+++ b/Task/Taxicab-numbers/Racket/taxicab-numbers.rkt
@ -0,0 +1,27 @@
+#lang racket
+
+(define (cube x) (* x x x))
+
+;floor of cubic root
+(define (cubic-root x)
+  (let ([aprox (inexact->exact (round (expt x (/ 1 3))))])
+    (if (> (cube aprox) x)
+        (- aprox 1)
+        aprox)))
+
+(let loop ([p 1] [n 1])
+  (let ()
+    (define pairs
+      (for*/list ([j (in-range 1 (add1 (cubic-root (quotient n 2))))]
+                  [k (in-value (cubic-root (- n (cube j))))]
+                  #:when (= n (+ (cube j) (cube k))))
+        (cons j k)))
+    (if (>= (length pairs) 2)
+      (begin
+        (printf "~a: ~a" p n)
+        (for ([pair (in-list pairs)])
+          (printf " = ~a^3 + ~a^3" (car pair) (cdr pair)))
+          (newline)
+        (when (< p 25)
+          (loop (add1 p) (add1 n))))
+      (loop p (add1 n)))))
--- a/Task/Taxicab-numbers/Raku/taxicab-numbers.raku
+++ b/Task/Taxicab-numbers/Raku/taxicab-numbers.raku
@ -0,0 +1,31 @@
+constant @cu = (^Inf).map: { .³ }
+
+sub MAIN ($start = 1, $end = 25) {
+    my %taxi;
+    my int $taxis = 0;
+    my $terminate = 0;
+    my int $max = 0;
+
+    for 1 .. * -> $c1 {
+        last if ?$terminate && ($terminate < $c1);
+        for 1 .. $c1 -> $c2 {
+            my $this = @cu[$c1] + @cu[$c2];
+            %taxi{$this}.push: [$c2, $c1];
+            if %taxi{$this}.elems == 2 {
+                ++$taxis;
+                $max max= $this;
+            }
+    	    $terminate = ceiling $max ** (1/3) if $taxis == $end and !$terminate;
+        }
+    }
+
+    display( %taxi, $start, $end );
+
+}
+
+sub display (%this_stuff, $start, $end) {
+    my $i = $start;
+    printf "%4d %10d  =>\t%s\n", $i++, $_.key,
+        (.value.map({ sprintf "%4d³ + %-s\³", |$_ })).join: ",\t"
+        for %this_stuff.grep( { $_.value.elems > 1 } ).sort( +*.key )[$start-1..$end-1];
+}
--- a/Task/Taxicab-numbers/Ring/taxicab-numbers.ring
+++ b/Task/Taxicab-numbers/Ring/taxicab-numbers.ring
@ -0,0 +1,25 @@
+# Project : Taxicab numbers
+
+num = 0
+for n = 1 to 500000
+    nr = 0
+    tax = []
+    for m = 1 to 75
+        for p = m + 1 to 75
+            if n = pow(m, 3) + pow(p, 3)
+               add(tax, m)
+               add(tax, p)
+               nr = nr + 1
+            ok
+        next
+    next
+    if nr > 1
+       num = num + 1
+       see "" + num + " " + n + " => " + tax[1] + "^3 + " + tax[2] + "^3" + ", "
+       see "" + tax[3] + "^3 +" + tax[4] + "^3" + nl
+       if num = 25
+          exit
+       ok
+    ok
+next
+see "ok" + nl
--- a/Task/Taxicab-numbers/Ruby/taxicab-numbers.rb
+++ b/Task/Taxicab-numbers/Ruby/taxicab-numbers.rb
@ -0,0 +1,9 @@
+def taxicab_number(nmax=1200)
+  [*1..nmax].repeated_combination(2).group_by{|x,y| x**3 + y**3}.select{|k,v| v.size>1}.sort
+end
+
+t = [0] + taxicab_number
+
+[*1..25, *2000...2007].each do |i|
+  puts "%4d: %10d" % [i, t[i][0]] + t[i][1].map{|a| " = %4d**3 + %4d**3" % a}.join
+end
--- a/Task/Taxicab-numbers/Rust/taxicab-numbers.rust
+++ b/Task/Taxicab-numbers/Rust/taxicab-numbers.rust
@ -0,0 +1,33 @@
+use std::collections::HashMap;
+use itertools::Itertools;
+
+fn cubes(n: u64) -> Vec<u64> {
+	let mut cube_vector = Vec::new();
+	for i in 1..=n {
+		cube_vector.push(i.pow(3));
+	}
+	cube_vector
+}
+
+fn main() {
+	let c = cubes(1201);
+	let it = c.iter().combinations(2);
+	let mut m = HashMap::new();
+	for x in it {
+		let sum = x[0] + x[1];
+		m.entry(sum).or_insert(Vec::new()).push(x)
+	}
+	
+	let mut result = Vec::new();
+	
+	for (k,v) in m.iter() {
+		if v.len() > 1 {
+			result.push((k,v));
+		}
+	}
+	
+	result.sort();
+	for f in result {
+		println!("{:?}", f);
+	}
+}
--- a/Task/Taxicab-numbers/Scala/taxicab-numbers.scala
+++ b/Task/Taxicab-numbers/Scala/taxicab-numbers.scala
@ -0,0 +1,32 @@
+import scala.collection.MapView
+import scala.math.pow
+
+implicit class Pairs[A, B]( p:List[(A, B)]) {
+  def collectPairs: MapView[A, List[B]] = p.groupBy(_._1).view.mapValues(_.map(_._2)).filterNot(_._2.size<2)
+}
+
+// Make a sorted List of Taxi Cab Numbers. Limit it to the cube of 1200 because we know it's high enough.
+val taxiNums = {
+  (1 to 1200).toList            // Start with a sequential list of integers
+    .combinations(2).toList     // Find all two number combinations
+    .map {
+      case a :: b :: nil => ((pow(a, 3) + pow(b, 3)).toInt, (a, b))
+      case _ => 0 ->(0, 0)
+    }                           // Turn the list into the sum of two cubes and
+    //      remember what we started with, eg. 28->(1,3)
+    .collectPairs               // Only keep taxi cab numbers with a duplicate
+    .toList.sortBy(_._1)        // Sort the results
+}
+
+def output() : Unit = {
+  println( "%20s".format( "Taxi Cab Numbers" ) )
+  println( "%20s%15s%15s".format( "-"*20, "-"*15, "-"*15 ) )
+
+  taxiNums.take(25) foreach {
+    case (p, a::b::Nil) => println( "%20d\t(%d\u00b3 + %d\u00b3)\t\t(%d\u00b3 + %d\u00b3)".format(p,a._1,a._2,b._1,b._2) )
+  }
+
+  taxiNums.slice(1999,2007) foreach {
+    case (p, a::b::Nil) => println( "%20d\t(%d\u00b3 + %d\u00b3)\t(%d\u00b3 + %d\u00b3)".format(p,a._1,a._2,b._1,b._2) )
+  }
+}
--- a/Task/Taxicab-numbers/Scheme/taxicab-numbers.ss
+++ b/Task/Taxicab-numbers/Scheme/taxicab-numbers.ss
@ -0,0 +1,35 @@
+(import (scheme base)
+        (scheme write)
+        (srfi 1)        ; lists
+        (srfi 69)       ; hash tables
+        (srfi 132))     ; sorting
+
+(define *max-n* 1500) ; let's go up to here, maximum for x and y
+(define *numbers* (make-hash-table eqv?)) ; hash table for total -> list of list of pairs
+
+(define (retrieve key) (hash-table-ref/default *numbers* key '()))
+
+;; add all combinations to the hash table
+(do ((i 1 (+ i 1)))
+  ((= i *max-n*) )
+  (do ((j (+ 1 i) (+ j 1)))
+    ((= j *max-n*) )
+    (let ((n (+ (* i i i) (* j j j))))
+      (hash-table-set! *numbers* n
+                       (cons (list i j) (retrieve n))))))
+
+(define (display-number i key)
+  (display (+ 1 i)) (display ": ")
+  (display key) (display " -> ")
+  (display (retrieve key)) (newline))
+
+(let ((sorted-keys (list-sort <
+                              (filter (lambda (key) (> (length (retrieve key)) 1))
+                                      (hash-table-keys *numbers*)))))
+  ;; first 25
+  (for-each (lambda (i) (display-number i (list-ref sorted-keys i)))
+            (iota 25))
+  ;; 2000-2006
+  (for-each (lambda (i) (display-number i (list-ref sorted-keys i)))
+            (iota 7 1999))
+  )
--- a/Task/Taxicab-numbers/Sidef/taxicab-numbers.sidef
+++ b/Task/Taxicab-numbers/Sidef/taxicab-numbers.sidef
@ -0,0 +1,29 @@
+var (start=1, end=25) = ARGV.map{.to_i}...
+ 
+func display (h, start, end) {
+    var i = start
+    for n in [h.grep {|_,v| v.len > 1 }.keys.sort_by{.to_i}[start-1 .. end-1]] {
+        printf("%4d %10d  =>\t%s\n", i++, n,
+            h{n}.map{ "%4d³ + %-s" % (.first, "#{.last}³") }.join(",\t"))
+    }
+}
+ 
+var taxi = Hash()
+var taxis = 0
+var terminate = 0
+ 
+for c1 (1..Inf) {
+    if (0<terminate && terminate<c1) {
+        display(taxi, start, end)
+        break
+    }
+    var c = c1**3
+    for c2 (1..c1) {
+        var this = (c2**3 + c)
+        taxi{this} := [] << [c2, c1]
+        ++taxis if (taxi{this}.len == 2)
+        if (taxis==end && !terminate) {
+            terminate = taxi.grep{|_,v| v.len > 1 }.keys.map{.to_i}.max.root(3)
+        }
+    }
+}
--- a/Task/Taxicab-numbers/Swift/taxicab-numbers.swift
+++ b/Task/Taxicab-numbers/Swift/taxicab-numbers.swift
@ -0,0 +1,48 @@
+extension Array {
+  func combinations(_ k: Int) -> [[Element]] {
+    return Self._combinations(slice: self[startIndex...], k)
+  }
+
+  static func _combinations(slice: Self.SubSequence, _ k: Int) -> [[Element]] {
+    guard k != 1 else {
+      return slice.map({ [$0] })
+    }
+
+    guard k != slice.count else {
+      return [slice.map({ $0 })]
+    }
+
+    let chopped = slice[slice.index(after: slice.startIndex)...]
+
+    var res = _combinations(slice: chopped, k - 1).map({ [[slice.first!], $0].flatMap({ $0 }) })
+
+    res += _combinations(slice: chopped, k)
+
+    return res
+  }
+}
+
+let cubes = (1...).lazy.map({ $0 * $0 * $0 })
+let taxis =
+  Array(cubes.prefix(1201))
+    .combinations(2)
+    .reduce(into: [Int: [[Int]]](), { $0[$1[0] + $1[1], default: []].append($1) })
+
+
+let res =
+  taxis
+    .lazy
+    .filter({ $0.value.count > 1 })
+    .sorted(by: { $0.key < $1.key })
+    .map({ ($0.key, $0.value) })
+    .prefix(2006)
+
+print("First 25 taxicab numbers:")
+for taxi in res[..<25] {
+  print(taxi)
+}
+
+print("\n2000th through 2006th taxicab numbers:")
+for taxi in res[1999..<2006] {
+  print(taxi)
+}
--- a/Task/Taxicab-numbers/Tcl/taxicab-numbers.tcl
+++ b/Task/Taxicab-numbers/Tcl/taxicab-numbers.tcl
@ -0,0 +1,53 @@
+package require Tcl 8.6
+
+proc heappush {heapName item} {
+    upvar 1 $heapName heap
+    set idx [lsearch -bisect -index 0 -integer $heap [lindex $item 0]]
+    set heap [linsert $heap [expr {$idx + 1}] $item]
+}
+coroutine cubesum apply {{} {
+    yield
+    set h {}
+    set n 1
+    while true {
+	while {![llength $h] || [lindex $h 0 0] > $n**3} {
+	    heappush h [list [expr {$n**3 + 1}] $n 1]
+	    incr n
+	}
+	set h [lassign $h item]
+	yield $item
+	lassign $item s x y
+	if {[incr y] < $x} {
+	    heappush h [list [expr {$x**3 + $y**3}] $x $y]
+	}
+    }
+}}
+coroutine taxis apply {{} {
+    yield
+    set out {{0 0 0}}
+    while true {
+	set s [cubesum]
+	if {[lindex $s 0] == [lindex $out end 0]} {
+	    lappend out $s
+	} else {
+	    if {[llength $out] > 1} {yield $out}
+	    set out [list $s]
+	}
+    }
+}}
+
+# Put a cache in front for convenience
+variable taxis {}
+proc taxi {n} {
+    variable taxis
+    while {$n > [llength $taxis]} {lappend taxis [taxis]}
+    return [lindex $taxis [expr {$n-1}]]
+}
+
+set 3 "\u00b3"
+for {set n 1} {$n <= 25} {incr n} {
+    puts ${n}:[join [lmap t [taxi $n] {format " %d = %d$3 + %d$3" {*}$t}] ","]
+}
+for {set n 2000} {$n <= 2006} {incr n} {
+    puts ${n}:[join [lmap t [taxi $n] {format " %d = %d$3 + %d$3" {*}$t}] ","]
+}
--- a/Task/Taxicab-numbers/VBA/taxicab-numbers.vba
+++ b/Task/Taxicab-numbers/VBA/taxicab-numbers.vba
@ -0,0 +1,134 @@
+Public Type tuple
+    i As Variant
+    j As Variant
+    sum As Variant
+End Type
+Public Type tuple3
+    i1 As Variant
+    j1 As Variant
+    i2 As Variant
+    j2 As Variant
+    i3 As Variant
+    j3 As Variant
+    sum As Variant
+End Type
+Sub taxicab_numbers()
+    Dim i As Variant, j As Variant
+    Dim k As Long
+    Const MAX = 2019
+    Dim p(MAX) As Variant
+    Const bigMAX = (MAX + 1) * (MAX / 2)
+    Dim big(1 To bigMAX) As tuple
+    Const resMAX = 4400
+    Dim res(1 To resMAX) As tuple3
+    For i = 1 To MAX
+        p(i) = CDec(i * i * i) 'convert Variant to Decimal
+    Next i                     'wich hold numbers upto 10^28
+
+    k = 1
+    For i = 1 To MAX
+        For j = i To MAX
+            big(k).i = CDec(i)
+            big(k).j = CDec(j)
+            big(k).sum = CDec(p(i) + p(j))
+            k = k + 1
+        Next j
+    Next i
+    n = 1
+    Quicksort big, LBound(big), UBound(big)
+    For i = 1 To bigMAX - 1
+        If big(i).sum = big(i + 1).sum Then
+            res(n).i1 = CStr(big(i).i)
+            res(n).j1 = CStr(big(i).j)
+            res(n).i2 = CStr(big(i + 1).i)
+            res(n).j2 = CStr(big(i + 1).j)
+            If big(i + 1).sum = big(i + 2).sum Then
+                res(n).i3 = CStr(big(i + 2).i)
+                res(n).j3 = CStr(big(i + 2).j)
+                i = i + 1
+            End If
+            res(n).sum = CStr(big(i).sum)
+            n = n + 1
+            i = i + 1
+        End If
+    Next i
+    Debug.Print n - 1; " taxis"
+    For i = 1 To 25
+        With res(i)
+            Debug.Print String$(4 - Len(CStr(i)), " "); i;
+            Debug.Print String$(11 - Len(.sum), " "); .sum; " = ";
+            Debug.Print String$(4 - Len(.i1), " "); .i1; "^3 +";
+            Debug.Print String$(4 - Len(.j1), " "); .j1; "^3 = ";
+            Debug.Print String$(4 - Len(.i2), " "); .i2; "^3 +";
+            Debug.Print String$(4 - Len(.j2), " "); .j2; "^3"
+        End With
+    Next i
+    Debug.Print
+    For i = 2000 To 2006
+        With res(i)
+            Debug.Print String$(4 - Len(CStr(i)), " "); i;
+            Debug.Print String$(11 - Len(.sum), " "); .sum; " = ";
+            Debug.Print String$(4 - Len(.i1), " "); .i1; "^3 +";
+            Debug.Print String$(4 - Len(.j1), " "); .j1; "^3 = ";
+            Debug.Print String$(4 - Len(.i2), " "); .i2; "^3 +";
+            Debug.Print String$(4 - Len(.j2), " "); .j2; "^3"
+        End With
+
+    Next i
+    Debug.Print
+    For i = 1 To resMAX
+        If res(i).i3 <> "" Then
+            With res(i)
+                Debug.Print String$(4 - Len(CStr(i)), " "); i;
+                Debug.Print String$(11 - Len(.sum), " "); .sum; " = ";
+                Debug.Print String$(4 - Len(.i1), " "); .i1; "^3 +";
+                Debug.Print String$(4 - Len(.j1), " "); .j1; "^3 = ";
+                Debug.Print String$(4 - Len(.i2), " "); .i2; "^3 +";
+                Debug.Print String$(4 - Len(.j2), " "); .j2; "^3";
+                Debug.Print String$(4 - Len(.i3), " "); .i3; "^3 +";
+                Debug.Print String$(4 - Len(.j3), " "); .j3; "^3"
+            End With
+        End If
+    Next i
+End Sub
+Sub Quicksort(vArray() As tuple, arrLbound As Long, arrUbound As Long)
+    'https://wellsr.com/vba/2018/excel/vba-quicksort-macro-to-sort-arrays-fast/
+    'Sorts a one-dimensional VBA array from smallest to largest
+    'using a very fast quicksort algorithm variant.
+    'Adapted to multidimensions/typedef
+    Dim pivotVal As Variant
+    Dim vSwap    As tuple
+    Dim tmpLow   As Long
+    Dim tmpHi    As Long
+
+    tmpLow = arrLbound
+    tmpHi = arrUbound
+    pivotVal = vArray((arrLbound + arrUbound) \ 2).sum
+
+    While (tmpLow <= tmpHi) 'divide
+        While (vArray(tmpLow).sum < pivotVal And tmpLow < arrUbound)
+            tmpLow = tmpLow + 1
+        Wend
+
+        While (pivotVal < vArray(tmpHi).sum And tmpHi > arrLbound)
+            tmpHi = tmpHi - 1
+        Wend
+
+        If (tmpLow <= tmpHi) Then
+             vSwap.i = vArray(tmpLow).i
+             vSwap.j = vArray(tmpLow).j
+             vSwap.sum = vArray(tmpLow).sum
+             vArray(tmpLow).i = vArray(tmpHi).i
+             vArray(tmpLow).j = vArray(tmpHi).j
+             vArray(tmpLow).sum = vArray(tmpHi).sum
+             vArray(tmpHi).i = vSwap.i
+             vArray(tmpHi).j = vSwap.j
+             vArray(tmpHi).sum = vSwap.sum
+             tmpLow = tmpLow + 1
+             tmpHi = tmpHi - 1
+        End If
+    Wend
+
+    If (arrLbound < tmpHi) Then Quicksort vArray, arrLbound, tmpHi 'conquer
+    If (tmpLow < arrUbound) Then Quicksort vArray, tmpLow, arrUbound 'conquer
+End Sub
--- a/Task/Taxicab-numbers/Visual-Basic-.NET/taxicab-numbers.vb
+++ b/Task/Taxicab-numbers/Visual-Basic-.NET/taxicab-numbers.vb
@ -0,0 +1,58 @@
+Imports System.Text
+
+Module Module1
+
+    Function GetTaxicabNumbers(length As Integer) As IDictionary(Of Long, IList(Of Tuple(Of Integer, Integer)))
+        Dim sumsOfTwoCubes As New SortedList(Of Long, IList(Of Tuple(Of Integer, Integer)))
+
+        For i = 1 To Integer.MaxValue - 1
+            For j = 1 To Integer.MaxValue - 1
+                Dim sum = CLng(Math.Pow(i, 3) + Math.Pow(j, 3))
+
+                If Not sumsOfTwoCubes.ContainsKey(sum) Then
+                    sumsOfTwoCubes.Add(sum, New List(Of Tuple(Of Integer, Integer)))
+                End If
+
+                sumsOfTwoCubes(sum).Add(Tuple.Create(i, j))
+
+                If j >= i Then
+                    Exit For
+                End If
+            Next
+
+            REM Found that you need to keep going for a while after the length, because higher i values fill in gaps
+            If sumsOfTwoCubes.AsEnumerable.Count(Function(t) t.Value.Count >= 2) >= length * 1.1 Then
+                Exit For
+            End If
+        Next
+
+        Dim values = (From t In sumsOfTwoCubes Where t.Value.Count >= 2 Select t) _
+            .Take(2006) _
+            .ToDictionary(Function(u) u.Key, Function(u) u.Value)
+        Return values
+    End Function
+
+    Sub PrintTaxicabNumbers(values As IDictionary(Of Long, IList(Of Tuple(Of Integer, Integer))))
+        Dim i = 1
+        For Each taxicabNumber In values.Keys
+            Dim output As New StringBuilder
+            output.AppendFormat("{0,10}" + vbTab + "{1,4}", i, taxicabNumber)
+
+            For Each numbers In values(taxicabNumber)
+                output.AppendFormat(vbTab + "= {0}^3 + {1}^3", numbers.Item1, numbers.Item2)
+            Next
+
+            If i <= 25 OrElse (i >= 2000 AndAlso i <= 2006) Then
+                Console.WriteLine(output.ToString)
+            End If
+
+            i += 1
+        Next
+    End Sub
+
+    Sub Main()
+        Dim taxicabNumbers = GetTaxicabNumbers(2006)
+        PrintTaxicabNumbers(taxicabNumbers)
+    End Sub
+
+End Module
--- a/Task/Taxicab-numbers/Wren/taxicab-numbers.wren
+++ b/Task/Taxicab-numbers/Wren/taxicab-numbers.wren
@ -0,0 +1,34 @@
+import "/sort" for Sort
+import "/fmt" for Fmt
+
+var cubesSum = {}
+var taxicabs = []
+
+for (i in 1..1199) {
+    for (j in i+1..1200) {
+        var sum = i*i*i + j*j*j
+        if (!cubesSum[sum]) {
+            cubesSum[sum] = [i, j]
+        } else {
+            taxicabs.add([sum, cubesSum[sum], [i, j]])
+        }
+    }
+}
+var cmp = Fn.new { |a, b| (a[0] - b[0]).sign }
+Sort.quick(taxicabs, 0, taxicabs.count-1, cmp)
+// remove those numbers which have additional pairs of cubes
+for (i in taxicabs.count-2..0) {
+    if (taxicabs[i][0] == taxicabs[i+1][0]) taxicabs.removeAt(i+1)
+}
+
+System.print("The first 25 taxicab numbers are:")
+for (i in 1..25) {
+    var t = taxicabs[i-1]
+    Fmt.lprint("$2d: $,7d = $2d³ + $2d³ = $2d³ + $2d³", [i, t[0], t[1][0], t[1][1], t[2][0], t[2][1]])
+}
+
+System.print("\nThe 2,000th to 2,006th taxicab numbers are:")
+for (i in 2000..2006) {
+    var t = taxicabs[i-1]
+    Fmt.lprint("$,5d: $,13d = $3d³ + $,5d³ = $3d³ + $,5d³", [i, t[0], t[1][0], t[1][1], t[2][0], t[2][1]])
+}
--- a/Task/Taxicab-numbers/XPL0/taxicab-numbers.xpl0
+++ b/Task/Taxicab-numbers/XPL0/taxicab-numbers.xpl0
@ -0,0 +1,27 @@
+int N, I, J, SI, SJ, Count, Tally;
+[Count:= 0;  N:= 0;
+repeat  Tally:= 0;
+        I:= 1;
+        repeat  J:= I+1;
+                repeat  if N = I*I*I + J*J*J then
+                            [Tally:= Tally+1;
+                            if Tally >= 2 then
+                                [Count:= Count+1;
+                                IntOut(0, Count);  Text(0, ": ");
+                                IntOut(0, N);  Text(0, " = ");
+                                IntOut(0, SI); Text(0, "^^3 + ");
+                                IntOut(0, SJ); Text(0, "^^3 = ");
+                                IntOut(0, I);  Text(0, "^^3 + ");
+                                IntOut(0, J);  Text(0, "^^3");
+                                CrLf(0);
+                                J:= 1000;  I:= J;
+                                ];
+                            SI:= I;  SJ:= J;
+                            ];
+                        J:= J+1;
+                until   I*I*I + J*J*J > N;
+                I:= I+1;
+        until   I*I*I*2 > N;
+        N:= N+1;
+until   Count >= 25;
+]
--- a/Task/Taxicab-numbers/ZX-Spectrum-Basic/taxicab-numbers-1.basic
+++ b/Task/Taxicab-numbers/ZX-Spectrum-Basic/taxicab-numbers-1.basic
@ -0,0 +1,36 @@
+10 DIM f(1625): REM populating a cube table at the start will be faster than computing the cubes on the fly
+20 FOR x=1 TO 1625
+30 LET f(x)=x*x*x: REM x*x*x rather than x^3 as the ZX Spectrum's exponentiation function is legendarily slow
+40 NEXT x
+50 LET c=0
+60 FOR x=1 TO 4294967295: REM the highest number the ZX Spectrum Basic can accurately hold internally; floor (cuberoot max)=1625, hence the table limit
+70 LET k=0
+80 FOR m=1 TO 1625
+90 FOR n=m+1 TO 1625
+100 IF f(m)+f(n)=x THEN GOTO 160
+110 IF f(n)>=x THEN LET n=1625: REM overshot, break out of the loop
+120 IF f(m)>=x THEN LET m=1625
+130 NEXT n
+140 NEXT m
+150 NEXT x
+160 IF k=1 THEN LET q=m: LET r=n: GO TO 230: REM got one!
+170 LET o=m
+180 LET p=n
+190 LET k=1
+200 NEXT n
+210 NEXT m
+220 NEXT x
+230 LET c=c+1
+240 IF c>25 AND c<2000 THEN GO TO 330
+250 LET t$="": REM convert number to string; while ZX Spectrum Basic can store all the digits of integers up to 2^32-1...
+260 LET t=INT (x/100000): REM ...it will resort to scientific notation trying to display any more than eight digits
+270 LET b=x-t*100000
+280 IF t=0 THEN GO TO 300: REM omit leading zero
+290 LET t$=STR$ t
+300 LET t$=t$+STR$ b
+310 PRINT c;":";t$;"=";q;"^3+";r;"^3=";o;"^3+";p;"^3"
+320 POKE 23692,10: REM suppress "scroll?" prompt when screen fills up at c=22
+330 IF c=2006 THEN LET x=4294967295: LET n=1625: LET m=1625
+340 NEXT n
+350 NEXT m
+360 NEXT x
--- a/Task/Taxicab-numbers/ZX-Spectrum-Basic/taxicab-numbers-2.basic
+++ b/Task/Taxicab-numbers/ZX-Spectrum-Basic/taxicab-numbers-2.basic
@ -0,0 +1,21 @@
+  10 LET T=0: DIM F(72): LET D=0: LET S=0: LET B=0: LET A=0: LET C=0
+  20 DIM H(50): DIM Y(50,2): FOR D=1 TO 72: LET F(D)=D*D*D: NEXT D
+  30 FOR A=1 TO 58: FOR B=A+1 TO 72: LET S=F(A)+F(B): FOR D=B-1 TO A STEP -1
+  40 LET T=S-F(D): IF T>F(D) THEN NEXT B: NEXT A: GO TO 90
+  45 IF s>405224 THEN GO TO 70
+  50 IF F(INT (EXP (LN (T)/3)+.5))=T THEN GO TO 80
+  60 NEXT D
+  70 NEXT B: NEXT A: GO TO 90
+  80 PRINT S,: LET C=C+1: LET H(C)=S: LET Y(C,1)=A*65536+B: LET Y(C,2)=INT (EXP (LN (T)/3)+.5)*65536+D: GO TO 70
+  90 LET S=INT (C/2)
+ 100 LET T=0: FOR A=1 TO C-S: IF H(A)>H(A+S) THEN LET T=H(A): LET H(A)=H(A+S): LET H(A+S)=T: LET T=Y(A,1): LET Y(A,1)=Y(A+S,1): LET Y(A+S,1)=T: LET T=Y(A,2): LET Y(A,2)=Y(A+S,2): LET Y(A+S,2)=T
+ 110 NEXT A: IF T<>0 THEN GO TO 100
+ 120 IF S<>1 THEN LET S=INT (S/2): GO TO 100
+ 130 CLS : FOR A=1 TO 25: PRINT A;":";H(A);"=";
+ 131 LPRINT A;":";H(A);"=";:
+ 140 LET T=INT (Y(A,1)/65536): PRINT T;"^3+";Y(A,1)-T*65536;"^3=";
+ 141 LPRINT T;"^3+";Y(A,1)-T*65536;"^3=";
+ 150 LET T=INT (Y(A,2)/65536): PRINT T;"^3+";Y(A,2)-T*65536;"^3"
+ 151 LPRINT T;"^3+";Y(A,2)-T*65536;"^3"
+ 160 NEXT A: PRINT
+ 170 STOP
--- a/Task/Taxicab-numbers/Zkl/taxicab-numbers-1.zkl
+++ b/Task/Taxicab-numbers/Zkl/taxicab-numbers-1.zkl
@ -0,0 +1,18 @@
+fcn taxiCabNumbers{
+   const HeapSZ=0d5_000_000;
+   iCubes:=[1..120].apply("pow",3);
+   sum2cubes:=Data(HeapSZ).fill(0);  // BFheap of 1 byte zeros
+   taxiNums:=List();
+   foreach i,i3 in ([1..].zip(iCubes)){
+      foreach j,j3 in ([i+1..].zip(iCubes[i,*])){
+         ij3:=i3+j3;
+	 if(z:=sum2cubes[ij3]){
+	    taxiNums.append(T(ij3,
+		z,(ij3-z.pow(3)).toFloat().pow(1.0/3).round().toInt(),
+		i,j));
+	 }
+	 else sum2cubes[ij3]=i;
+      }
+   }
+   taxiNums.sort(fcn([(a,_)],[(b,_)]){ a<b })
+}
--- a/Task/Taxicab-numbers/Zkl/taxicab-numbers-2.zkl
+++ b/Task/Taxicab-numbers/Zkl/taxicab-numbers-2.zkl
@ -0,0 +1,7 @@
+fcn print(n,taxiNums){
+   [n..].zip(taxiNums).pump(Console.println,fcn([(n,t)]){
+      "%4d: %10,d = %2d\u00b3 + %2d\u00b3 =  %2d\u00b3 + %2d\u00b3".fmt(n,t.xplode())
+   })
+}
+taxiNums:=taxiCabNumbers();  // 63 pairs
+taxiNums[0,25]:print(1,_);
--- a/Task/Taxicab-numbers/Zkl/taxicab-numbers-3.zkl
+++ b/Task/Taxicab-numbers/Zkl/taxicab-numbers-3.zkl
@ -0,0 +1,30 @@
+fcn cubeSum{
+   heap,n:=Heap(fcn([(a,_)],[(b,_)]){ a<=b }), 1;  // heap cnt maxes out @ 244
+   while(1){
+      while(heap.empty or heap.top[0]>n.pow(3)){ # could also pre-calculate cubes
+	 heap.push(T(n.pow(3) + 1, n,1));
+	 n+=1;
+      }
+      s,x,y:= sxy:=heap.pop();
+      vm.yield(sxy);
+      y+=1;
+      if(y<x)    # should be y <= x?
+	 heap.push(T(x.pow(3) + y.pow(3), x,y));
+   }
+}
+fcn taxis{
+   out:=List(T(0,0,0));
+   foreach s in (Utils.Generator(cubeSum)){
+      if(s[0]==out[-1][0]) out.append(s);
+      else{
+	 if(out.len()>1) vm.yield(out);
+	 out.clear(s)
+      }
+   }
+}
+n:=0;
+foreach x in (Utils.Generator(taxis)){
+   n += 1;
+   if(n >= 2006) break;
+   if(n <= 25 or n >= 2000) println(n,": ",x);
+}
--- a/Task/Taxicab-numbers/Zkl/taxicab-numbers-4.zkl
+++ b/Task/Taxicab-numbers/Zkl/taxicab-numbers-4.zkl
@ -0,0 +1,38 @@
+class Heap{  // binary heap
+   fcn init(lteqFcn='<=){
+      var [const, private] heap=List().pad(64,Void); // a power of 2
+      var cnt=0, cmp=lteqFcn;
+   }
+   fcn push(v){
+	// Resize the heap if it is too small to hold another item
+      if (cnt==heap.len()) heap.pad(cnt*2,Void);
+
+      index:=cnt; cnt+=1; while(index){	 // Find out where to put the element
+	 parent:=(index - 1)/2;
+	 if(cmp(heap[parent],v)) break;
+	 heap[index] = heap[parent];
+	 index = parent;
+      }
+      heap[index] = v;
+   }
+   fcn pop{  // Remove the biggest element and return it
+      if(not cnt) return(Void);
+      v,temp:=heap[0], heap[cnt-=1];
+
+      // Reorder the elements
+      index:=0; while(1){   // Find the child to swap with
+	 swap:=index*2 + 1;
+	 if (swap>=cnt) break; // If there are no children, the heap is reordered
+	 other:=swap + 1;
+	 if(other<cnt and cmp(heap[other],heap[swap])) swap = other;
+	 if(cmp(temp,heap[swap])) break; // If the bigger child is less than or equal to its parent, the heap is reordered
+
+	 heap[index]=heap[swap];
+	 index = swap;
+      }
+      heap[index] = temp;
+      v
+   }
+   var [proxy] top=fcn  { if(cnt==0) Void else heap[0] };
+   var [proxy] empty=fcn{ (not cnt) };
+}