Data commit

Task/Super-d-numbers/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Super-d_numbers

Task/Super-d-numbers/00-TASK.txt

@@ -0,0 +1,22 @@
+A super-d number is a positive, decimal (base ten) integer &nbsp; '''n''' &nbsp; such that &nbsp; '''d × n<sup>d</sup>''' &nbsp; has at least &nbsp; '''d''' &nbsp; consecutive digits &nbsp; '''d''' &nbsp; where
+    <big>2 ≤ d ≤ 9</big>
+For instance, 753 is a super-3 number because 3 × 753<sup>3</sup> = 128087<u>333</u>1.
+
+
+'''Super-d''' &nbsp; numbers are also shown on &nbsp; '''MathWorld'''&trade; &nbsp; as &nbsp; '''super-''d'' ''' &nbsp; or &nbsp; '''super-<sup>''d''<sup>'''.
+
+
+;Task:
+:* Write a function/procedure/routine to find super-d numbers.
+:* For &nbsp; '''d=2''' &nbsp; through &nbsp; '''d=6''', &nbsp; use the routine to show the first &nbsp; '''10''' &nbsp; super-d numbers.
+
+
+;Extra credit:
+:* Show the first &nbsp; '''10''' &nbsp; super-7, super-8, and/or super-9 numbers &nbsp; (optional).
+
+
+;See also:
+:* &nbsp; [http://mathworld.wolfram.com/Super-dNumber.html Wolfram MathWorld - Super-d Number].
+:* &nbsp; [http://oeis.org/A014569 OEIS: A014569 - Super-3 Numbers].
+<br><br>
+

Task/Super-d-numbers/11l/super-d-numbers.11l

@@ -0,0 +1,16 @@
+V rd = [‘22’, ‘333’, ‘4444’, ‘55555’, ‘666666’, ‘7777777’, ‘88888888’, ‘999999999’]
+
+L(ii) 2..7
+   print(‘First 10 super-#. numbers:’.format(ii))
+   V count = 0
+
+   BigInt j = 3
+   L
+      V k = ii * j^ii
+      I rd[ii - 2] C String(k)
+         count++
+         print(j, end' ‘ ’)
+         I count == 10
+            print("\n")
+            L.break
+      j++

Task/Super-d-numbers/C++/super-d-numbers-1.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+uint64_t ipow(uint64_t base, uint64_t exp) {
+    uint64_t result = 1;
+    while (exp) {
+        if (exp & 1) {
+            result *= base;
+        }
+        exp >>= 1;
+        base *= base;
+    }
+    return result;
+}
+
+int main() {
+    using namespace std;
+
+    vector<string> rd{ "22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999" };
+
+    for (uint64_t ii = 2; ii < 5; ii++) {
+        cout << "First 10 super-" << ii << " numbers:\n";
+        int count = 0;
+
+        for (uint64_t j = 3; /* empty */; j++) {
+            auto k = ii * ipow(j, ii);
+            auto kstr = to_string(k);
+            auto needle = rd[(size_t)(ii - 2)];
+            auto res = kstr.find(needle);
+            if (res != string::npos) {
+                count++;
+                cout << j << ' ';
+                if (count == 10) {
+                    cout << "\n\n";
+                    break;
+                }
+            }
+        }
+    }
+
+    return 0;
+}

Task/Super-d-numbers/C++/super-d-numbers-2.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <gmpxx.h>
+
+using big_int = mpz_class;
+
+int main() {
+    for (unsigned int d = 2; d <= 9; ++d) {
+        std::cout << "First 10 super-" << d << " numbers:\n";
+        std::string digits(d, '0' + d);
+        big_int bignum;
+        for (unsigned int count = 0, n = 1; count < 10; ++n) {
+            mpz_ui_pow_ui(bignum.get_mpz_t(), n, d);
+            bignum *= d;
+            auto str(bignum.get_str());
+            if (str.find(digits) != std::string::npos) {
+                std::cout << n << ' ';
+                ++count;
+            }
+        }
+        std::cout << '\n';
+    }
+    return 0;
+}

Task/Super-d-numbers/C++/super-d-numbers-3.cpp

@@ -0,0 +1,70 @@
+#include <cstdio>
+#include <sstream>
+#include <chrono>
+
+using namespace std;
+using namespace chrono;
+
+struct LI { uint64_t a, b, c, d, e; }; const uint64_t Lm = 1e18;
+auto st = steady_clock::now(); LI k[10][10];
+
+string padZ(uint64_t x, int n = 18) { string r = to_string(x);
+  return string(max((int)(n - r.length()), 0), '0') + r; }
+
+uint64_t ipow(uint64_t b, uint64_t e) { uint64_t r = 1;
+  while (e) { if (e & 1) r *= b; e >>= 1; b *= b; } return r; }
+
+uint64_t fa(uint64_t x) { // factorial
+  uint64_t r = 1; while (x > 1) r *= x--; return r; }
+
+void set(LI &d, uint64_t s) { // d = s
+  d.a = s; d.b = d.c = d.d = d.e = 0; }
+
+void inc(LI &d, LI s) { // d += s
+  d.a += s.a; while (d.a >= Lm) { d.a -= Lm; d.b++; }
+  d.b += s.b; while (d.b >= Lm) { d.b -= Lm; d.c++; }
+  d.c += s.c; while (d.c >= Lm) { d.c -= Lm; d.d++; }
+  d.d += s.d; while (d.d >= Lm) { d.d -= Lm; d.e++; }
+  d.e += s.e;
+}
+
+string scale(uint32_t s, LI &x) { // multiplies x by s, converts to string
+  uint64_t A = x.a * s, B = x.b * s, C = x.c * s, D = x.d * s, E = x.e * s;
+  while (A >= Lm) { A -= Lm; B++; }
+  while (B >= Lm) { B -= Lm; C++; }
+  while (C >= Lm) { C -= Lm; D++; }
+  while (D >= Lm) { D -= Lm; E++; }
+  if (E > 0) return to_string(E) + padZ(D) + padZ(C) + padZ(B) + padZ(A);
+  if (D > 0) return to_string(D) + padZ(C) + padZ(B) + padZ(A);
+  if (C > 0) return to_string(C) + padZ(B) + padZ(A);
+  if (B > 0) return to_string(B) + padZ(A);
+  return to_string(A);
+}
+
+void fun(int d) {
+  auto m = k[d]; string s = string(d, '0' + d); printf("%d: ", d);
+  for (int i = d, c = 0; c < 10; i++) {
+    if (scale((uint32_t)d, m[0]).find(s) != string::npos) {
+      printf("%d ", i); ++c; }
+    for (int j = d, k = d - 1; j > 0; j = k--) inc(m[k], m[j]);
+  } printf("%ss\n", to_string(duration<double>(steady_clock::now() - st).count()).substr(0,5).c_str());
+}
+
+static void init() {
+  for (int v = 1; v < 10; v++) {
+    uint64_t f[v + 1], l[v + 1];
+    for (int j = 0; j <= v; j++) {
+      if (j == v) for (int y = 0; y <= v; y++)
+          set(k[v][y], v != y ? (uint64_t)f[y] : fa(v));
+      l[0] = f[0]; f[0] = ipow(j + 1, v);
+      for (int a = 0, b = 1; b <= v; a = b++) {
+        l[b] = f[b]; f[b] = f[a] - l[a];
+      }
+    }
+  }
+}
+
+int main() {
+  init();
+  for (int i = 2; i <= 9; i++) fun(i);
+}

Task/Super-d-numbers/C-sharp/super-d-numbers.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using BI = System.Numerics.BigInteger;
+using lbi = System.Collections.Generic.List<System.Numerics.BigInteger[]>;
+using static System.Console;
+
+class Program {
+
+    // provides 320 bits (90 decimal digits)
+    struct LI { public UInt64 lo, ml, mh, hi, tp; }
+
+    const UInt64 Lm = 1_000_000_000_000_000_000UL;
+    const string Fm = "D18";
+
+    static void inc(ref LI d, LI s) { // d += s
+        d.lo += s.lo; while (d.lo >= Lm) { d.ml++; d.lo -= Lm; }
+        d.ml += s.ml; while (d.ml >= Lm) { d.mh++; d.ml -= Lm; }
+        d.mh += s.mh; while (d.mh >= Lm) { d.hi++; d.mh -= Lm; }
+        d.hi += s.hi; while (d.hi >= Lm) { d.tp++; d.hi -= Lm; }
+        d.tp += s.tp;
+    }
+
+    static void set(ref LI d, UInt64 s) { // d = s
+        d.lo = s; d.ml = d.mh = d.hi = d.tp = 0;
+    }
+
+    const int ls = 10;
+
+    static lbi co = new lbi { new BI[] { 0 } }; // for BigInteger addition
+    static List<LI[]> Co = new List<LI[]> { new LI[1] }; // for UInt64 addition
+
+    static Int64 ipow(Int64 bas, Int64 exp) { // Math.Pow()
+        Int64 res = 1; while (exp != 0) {
+            if ((exp & 1) != 0) res *= bas; exp >>= 1; bas *= bas;
+        }
+        return res;
+    }
+
+    // finishes up, shows performance value
+    static void fin() { WriteLine("{0}s", (DateTime.Now - st).TotalSeconds.ToString().Substring(0, 5)); }
+
+    static void funM(int d) { // straightforward BigInteger method, medium performance
+        string s = new string(d.ToString()[0], d); Write("{0}: ", d);
+        for (int i = 0, c = 0; c < ls; i++)
+            if ((BI.Pow((BI)i, d) * d).ToString().Contains(s))
+                Write("{0} ", i, ++c);
+        fin();
+    }
+
+    static void funS(int d) { // BigInteger "mostly adding" method, low performance
+        BI[] m = co[d];
+        string s = new string(d.ToString()[0], d); Write("{0}: ", d);
+        for (int i = 0, c = 0; c < ls; i++) {
+            if ((d * m[0]).ToString().Contains(s))
+                Write("{0} ", i, ++c);
+            for (int j = d, k = d - 1; j > 0; j = k--) m[k] += m[j];
+        }
+        fin();
+    }
+
+    static string scale(uint s, ref LI x) { // performs a small multiply and returns a string value
+        ulong Lo = x.lo * s, Ml = x.ml * s, Mh = x.mh * s, Hi = x.hi * s, Tp = x.tp * s;
+        while (Lo >= Lm) { Lo -= Lm; Ml++; }
+        while (Ml >= Lm) { Ml -= Lm; Mh++; }
+        while (Mh >= Lm) { Mh -= Lm; Hi++; }
+        while (Hi >= Lm) { Hi -= Lm; Tp++; }
+        if (Tp > 0) return Tp.ToString() + Hi.ToString(Fm) + Mh.ToString(Fm) + Ml.ToString(Fm) + Lo.ToString(Fm);
+        if (Hi > 0) return Hi.ToString() + Mh.ToString(Fm) + Ml.ToString(Fm) + Lo.ToString(Fm);
+        if (Mh > 0) return Mh.ToString() + Ml.ToString(Fm) + Lo.ToString(Fm);
+        if (Ml > 0) return Ml.ToString() + Lo.ToString(Fm);
+        return Lo.ToString();
+    }
+
+    static void funF(int d) { // structure of UInt64 method, high performance
+        LI[] m = Co[d];
+        string s = new string(d.ToString()[0], d); Write("{0}: ", d);
+        for (int i = d, c = 0; c < ls; i++) {
+            if (scale((uint)d, ref m[0]).Contains(s))
+                Write("{0} ", i, ++c);
+            for (int j = d, k = d - 1; j > 0; j = k--)
+                inc(ref m[k], m[j]);
+        }
+        fin();
+    }
+
+    static void init() { // initializes co and Co
+        for (int v = 1; v < 10; v++) {
+            BI[] res = new BI[v + 1];
+            long[] f = new long[v + 1], l = new long[v + 1];
+            for (int j = 0; j <= v; j++) {
+                if (j == v) {
+                    LI[] t = new LI[v + 1];
+                    for (int y = 0; y <= v; y++) set(ref t[y], (UInt64)f[y]);
+                    Co.Add(t);
+                }
+                res[j] = f[j];
+                l[0] = f[0]; f[0] = ipow(j + 1, v);
+                for (int a = 0, b = 1; b <= v; a = b++) {
+                    l[b] = f[b]; f[b] = f[a] - l[a];
+                }
+            }
+            for (int z = res.Length - 2; z > 0; z -= 2) res[z] *= -1;
+            co.Add(res);
+        }
+    }
+
+    static DateTime st;
+
+    static void doOne(string title, int top, Action<int> func) {
+        WriteLine('\n' + title); st = DateTime.Now;
+        for (int i = 2; i <= top; i++) func(i);
+    }
+
+    static void Main(string[] args)
+    {
+        init(); const int top = 9;
+        doOne("BigInteger mostly addition:", top, funS);
+        doOne("BigInteger.Pow():", top, funM);
+        doOne("UInt64 structure mostly addition:", top, funF);
+    }
+}

Task/Super-d-numbers/C/super-d-numbers.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gmp.h>
+
+int main() {
+    for (unsigned int d = 2; d <= 9; ++d) {
+        printf("First 10 super-%u numbers:\n", d);
+        char digits[16] = { 0 };
+        memset(digits, '0' + d, d);
+        mpz_t bignum;
+        mpz_init(bignum);
+        for (unsigned int count = 0, n = 1; count < 10; ++n) {
+            mpz_ui_pow_ui(bignum, n, d);
+            mpz_mul_ui(bignum, bignum, d);
+            char* str = mpz_get_str(NULL, 10, bignum);
+            if (strstr(str, digits)) {
+                printf("%u ", n);
+                ++count;
+            }
+            free(str);
+        }
+        mpz_clear(bignum);
+        printf("\n");
+    }
+    return 0;
+}

Task/Super-d-numbers/Clojure/super-d-numbers.clj

@@ -0,0 +1,6 @@
+(defn super [d]
+  (let [run (apply str (repeat d (str d)))]
+   (filter #(clojure.string/includes? (str (* d (Math/pow % d ))) run) (range))))
+
+(doseq [d (range 2 9)]
+    (println (str d ": ") (take 10 (super d))))

Task/Super-d-numbers/D/super-d-numbers.d

@@ -0,0 +1,30 @@
+import std.bigint;
+import std.conv;
+import std.stdio;
+import std.string;
+
+void main() {
+    auto rd = ["22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999"];
+    BigInt one = 1;
+    BigInt nine = 9;
+
+    for (int ii = 2; ii <= 9; ii++) {
+        writefln("First 10 super-%d numbers:", ii);
+        auto count = 0;
+
+        inner:
+        for (BigInt j = 3; ; j++) {
+            auto k = ii * j ^^ ii;
+            auto ix = k.to!string.indexOf(rd[ii-2]);
+            if (ix >= 0) {
+                count++;
+                write(j, ' ');
+                if (count == 10) {
+                    writeln();
+                    writeln();
+                    break inner;
+                }
+            }
+        }
+    }
+}

Task/Super-d-numbers/F-Sharp/super-d-numbers-1.fs

@@ -0,0 +1,7 @@
+// Generate Super-N numbers. Nigel Galloway: October 12th., 2019
+let superD N=
+  let      I=bigint(pown 10 N)
+  let      G=bigint N
+  let      E=G*(111111111I%I)
+  let rec fL n=match (E-n%I).IsZero with true->true |_->if (E*10I)<n then false else fL (n/10I)
+  seq{1I..999999999999999999I}|>Seq.choose(fun n->if fL (G*n**N) then Some n else None)

Task/Super-d-numbers/F-Sharp/super-d-numbers-2.fs

@@ -0,0 +1,8 @@
+superD 2 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 3 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 4 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 5 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 6 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 7 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 8 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""
+superD 9 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""

Task/Super-d-numbers/Factor/super-d-numbers.factor

@@ -0,0 +1,18 @@
+USING: arrays formatting io kernel lists lists.lazy math
+math.functions math.ranges math.text.utils prettyprint sequences
+;
+IN: rosetta-code.super-d
+
+: super-d? ( seq n d -- ? ) tuck ^ * 1 digit-groups subseq? ;
+
+: super-d ( d -- list )
+    [ dup <array> ] [ drop 1 lfrom ] [ ] tri [ super-d? ] curry
+    with lfilter ;
+
+: super-d-demo ( -- )
+    10 2 6 [a,b] [
+        dup "First 10 super-%d numbers:\n" printf
+        super-d ltake list>array [ pprint bl ] each nl nl
+    ] with each ;
+
+MAIN: super-d-demo

Task/Super-d-numbers/Go/super-d-numbers.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+    "fmt"
+    "math/big"
+    "strings"
+    "time"
+)
+
+func main() {
+    start := time.Now()
+    rd := []string{"22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999"}
+    one := big.NewInt(1)
+    nine := big.NewInt(9)
+    for i := big.NewInt(2); i.Cmp(nine) <= 0; i.Add(i, one) {
+        fmt.Printf("First 10 super-%d numbers:\n", i)
+        ii := i.Uint64()
+        k := new(big.Int)
+        count := 0
+    inner:
+        for j := big.NewInt(3); ; j.Add(j, one) {
+            k.Exp(j, i, nil)
+            k.Mul(i, k)
+            ix := strings.Index(k.String(), rd[ii-2])
+            if ix >= 0 {
+                count++
+                fmt.Printf("%d ", j)
+                if count == 10 {
+                    fmt.Printf("\nfound in %d ms\n\n", time.Since(start).Milliseconds())
+                    break inner
+                }
+            }
+        }
+    }
+}

Task/Super-d-numbers/Haskell/super-d-numbers.hs

@@ -0,0 +1,17 @@
+import Data.List (isInfixOf)
+import Data.Char (intToDigit)
+
+isSuperd :: (Show a, Integral a) => a -> a -> Bool
+isSuperd p n =
+  (replicate <*> intToDigit) (fromIntegral p) `isInfixOf` show (p * n ^ p)
+
+findSuperd :: (Show a, Integral a) => a -> [a]
+findSuperd p = filter (isSuperd p) [1 ..]
+
+main :: IO ()
+main =
+  mapM_
+    (putStrLn .
+     ("First 10 super-" ++) .
+     ((++) . show <*> ((" : " ++) . show . take 10 . findSuperd)))
+    [2 .. 6]

Task/Super-d-numbers/Java/super-d-numbers.java

@@ -0,0 +1,34 @@
+import java.math.BigInteger;
+
+public class SuperDNumbers {
+
+    public static void main(String[] args) {
+        for ( int i = 2 ; i <= 9 ; i++ ) {
+            superD(i, 10);
+        }
+    }
+
+    private static final void superD(int d, int max) {
+        long start = System.currentTimeMillis();
+        String test = "";
+        for ( int i = 0 ; i < d ; i++ ) {
+            test += (""+d);
+        }
+
+        int n = 0;
+        int i = 0;
+        System.out.printf("First %d super-%d numbers: %n", max, d);
+        while ( n < max ) {
+            i++;
+            BigInteger val = BigInteger.valueOf(d).multiply(BigInteger.valueOf(i).pow(d));
+            if ( val.toString().contains(test) ) {
+                n++;
+                System.out.printf("%d ", i);
+            }
+        }
+        long end = System.currentTimeMillis();
+        System.out.printf("%nRun time %d ms%n%n", end-start);
+
+    }
+
+}

Task/Super-d-numbers/Jq/super-d-numbers.jq

@@ -0,0 +1,24 @@
+# To take advantage of gojq's arbitrary-precision integer arithmetic:
+def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);
+
+# Input is $d, the number of consecutive digits, 2 <= $d <= 9
+# $max is the number of superd numbers to be emitted.
+def superd($number):
+  . as $d
+  | tostring as $s
+  | ($s * $d) as $target
+  | {count:0, j: 3 }
+  |  while ( .count <= $number;
+        .emit = null
+        | if ((.j|power($d) * $d) | tostring) | index($target)
+          then .count += 1
+          | .emit = .j
+	  else .
+          end
+        | .j += 1 )
+   | select(.emit).emit ;
+
+# super-d for 2 <=d < 8
+range(2; 8)
+| "First 10 super-\(.) numbers:",
+   superd(10)

Task/Super-d-numbers/Julia/super-d-numbers.julia

@@ -0,0 +1,17 @@
+function superd(N)
+    println("First 10 super-$N numbers:")
+    count, j = 0, BigInt(3)
+    target = Char('0' + N)^N
+    while count < 10
+        if occursin(target, string(j^N * N))
+            count += 1
+            print("$j ")
+        end
+        j += 1
+    end
+    println()
+end
+
+for n in 2:9
+    @time superd(n)
+end

Task/Super-d-numbers/Kotlin/super-d-numbers.kotlin

@@ -0,0 +1,29 @@
+import java.math.BigInteger
+
+fun superD(d: Int, max: Int) {
+    val start = System.currentTimeMillis()
+    var test = ""
+    for (i in 0 until d) {
+        test += d
+    }
+
+    var n = 0
+    var i = 0
+    println("First $max super-$d numbers:")
+    while (n < max) {
+        i++
+        val value: Any = BigInteger.valueOf(d.toLong()) * BigInteger.valueOf(i.toLong()).pow(d)
+        if (value.toString().contains(test)) {
+            n++
+            print("$i ")
+        }
+    }
+    val end = System.currentTimeMillis()
+    println("\nRun time ${end - start} ms\n")
+}
+
+fun main() {
+    for (i in 2..9) {
+        superD(i, 10)
+    }
+}

Task/Super-d-numbers/Mathematica/super-d-numbers.math

@@ -0,0 +1,14 @@
+ClearAll[SuperD]
+SuperD[d_, m_] := Module[{n, res, num},
+  res = {};
+  n = 1;
+  While[Length[res] < m,
+   num = IntegerDigits[d n^d];
+   If[MatchQ[num, {___, Repeated[d, {d}], ___}],
+    AppendTo[res, n]
+    ];
+   n++;
+   ];
+  res
+  ]
+Scan[Print[SuperD[#, 10]] &, Range[2, 6]]

Task/Super-d-numbers/Nim/super-d-numbers.nim

@@ -0,0 +1,19 @@
+import sequtils, strutils, times
+import bignum
+
+iterator superDNumbers(d, maxCount: Positive): Natural =
+  var count = 0
+  var n = 2
+  let e = culong(d)   # Bignum ^ requires a culong as exponent.
+  let pattern = repeat(chr(d + ord('0')), d)
+  while count != maxCount:
+    if pattern in $(d * n ^ e):
+      yield n
+      inc count
+    inc n, 1
+
+let t0 = getTime()
+for d in 2..9:
+  echo "First 10 super-$# numbers:".format(d)
+  echo toSeq(superDNumbers(d, 10)).join(" ")
+echo "Time: ", getTime() - t0

Task/Super-d-numbers/Pascal/super-d-numbers.pas

@@ -0,0 +1,39 @@
+program Super_D;
+uses
+  sysutils,gmp;
+
+var
+  s :ansistring;
+  s_comp : ansistring;
+  test : mpz_t;
+  i,j,dgt,cnt : NativeUint;
+Begin
+  mpz_init(test);
+
+  for dgt := 2 to 9 do
+  Begin
+    //create '22' to '999999999'
+    i := dgt;
+    For j := 2 to dgt do
+      i := i*10+dgt;
+    s_comp := IntToStr(i);
+    writeln('Finding ',s_comp,' in ',dgt,'*i**',dgt);
+
+    i := dgt;
+    cnt := 0;
+    repeat
+      mpz_ui_pow_ui(test,i,dgt);
+      mpz_mul_ui(test,test,dgt);
+      setlength(s,mpz_sizeinbase(test,10));
+      mpz_get_str(pChar(s),10,test);
+      IF Pos(s_comp,s) <> 0 then
+      Begin
+        write(i,' ');
+        inc(cnt);
+      end;
+      inc(i);
+    until cnt = 10;
+    writeln;
+  end;
+  mpz_clear(test);
+End.

Task/Super-d-numbers/Perl/super-d-numbers.pl

@@ -0,0 +1,22 @@
+use strict;
+use warnings;
+use bigint;
+use feature 'say';
+
+sub super {
+    my $d = shift;
+    my $run = $d x $d;
+    my @super;
+    my $i = 0;
+    my $n = 0;
+    while ( $i < 10 ) {
+        if (index($n ** $d * $d, $run) > -1) {
+            push @super, $n;
+            ++$i;
+        }
+        ++$n;
+    }
+    @super;
+}
+
+say "\nFirst 10 super-$_ numbers:\n", join ' ', super($_) for 2..6;

Task/Super-d-numbers/Phix/super-d-numbers.phix

@@ -0,0 +1,27 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
+     <span style="color: #004080;">mpz</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</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;">2</span> <span style="color: #008080;">to</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">7</span><span style="color: #0000FF;">:</span><span style="color: #000000;">9</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</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 10 super-%d numbers:\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">:=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3</span>
+         <span style="color: #004080;">string</span> <span style="color: #000000;">tgt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'0'</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: #008080;">while</span> <span style="color: #000000;">count</span><span style="color: #0000FF;"><</span><span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
+             <span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">j</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
+             <span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
+             <span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
+             <span style="color: #004080;">integer</span> <span style="color: #000000;">ix</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tgt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
+             <span style="color: #008080;">if</span> <span style="color: #000000;">ix</span> <span style="color: #008080;">then</span>
+                 <span style="color: #000000;">count</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;">"%d "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">)</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #000000;">j</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"\nfound in %s\n\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+ <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
+<!--

Task/Super-d-numbers/Python/super-d-numbers-1.py

@@ -0,0 +1,13 @@
+from itertools import islice, count
+
+def superd(d):
+    if d != int(d) or not 2 <= d <= 9:
+        raise ValueError("argument must be integer from 2 to 9 inclusive")
+    tofind = str(d) * d
+    for n in count(2):
+        if tofind in str(d * n ** d):
+            yield n
+
+if __name__ == '__main__':
+    for d in range(2, 9):
+        print(f"{d}:", ', '.join(str(n) for n in islice(superd(d), 10)))

Task/Super-d-numbers/Python/super-d-numbers-2.py

@@ -0,0 +1,139 @@
+'''Super-d numbers'''
+
+from itertools import count, islice
+from functools import reduce
+
+
+# ------------------------ SUPER-D -------------------------
+
+# super_d :: Int -> Either String [Int]
+def super_d(d):
+    '''Either a message, if d is out of range, or
+       an infinite series of super_d numbers for d.
+    '''
+    if isinstance(d, int) and 1 < d < 10:
+        ds = d * str(d)
+
+        def p(x):
+            return ds in str(d * x ** d)
+
+        return Right(filter(p, count(2)))
+    else:
+        return Left(
+            'Super-d is defined only for integers drawn from {2..9}'
+        )
+
+
+# ------------------------- TESTS --------------------------
+# main :: IO ()
+def main():
+    '''Attempted sampling of first 10 values for d <- [1..6],
+       where d = 1 is out of range.
+    '''
+    for v in map(
+        lambda x: either(
+            append(str(x) + ' :: ')
+        )(
+            compose(
+                append('First 10 super-' + str(x) + ': '),
+                showList
+            )
+        )(
+            bindLR(
+                super_d(x)
+            )(compose(Right, take(10)))
+        ),
+        enumFromTo(1)(6)
+    ): print(v)
+
+
+# ------------------------ GENERIC -------------------------
+
+# Left :: a -> Either a b
+def Left(x):
+    '''Constructor for an empty Either (option type) value
+       with an associated string.
+    '''
+    return {'type': 'Either', 'Right': None, 'Left': x}
+
+
+# Right :: b -> Either a b
+def Right(x):
+    '''Constructor for a populated Either (option type) value'''
+    return {'type': 'Either', 'Left': None, 'Right': x}
+
+
+# append (++) :: [a] -> [a] -> [a]
+# append (++) :: String -> String -> String
+def append(xs):
+    '''A list or string formed by
+       the concatenation of two others.
+    '''
+    def go(ys):
+        return xs + ys
+    return go
+
+
+# bindLR (>>=) :: Either a -> (a -> Either b) -> Either b
+def bindLR(m):
+    '''Either monad injection operator.
+       Two computations sequentially composed,
+       with any value produced by the first
+       passed as an argument to the second.
+    '''
+    def go(mf):
+        return (
+            mf(m.get('Right')) if None is m.get('Left') else m
+        )
+    return go
+
+
+# compose :: ((a -> a), ...) -> (a -> a)
+def compose(*fs):
+    '''Composition, from right to left,
+       of a series of functions.
+    '''
+    def go(f, g):
+        def fg(x):
+            return f(g(x))
+        return fg
+    return reduce(go, fs, lambda x: x)
+
+
+# either :: (a -> c) -> (b -> c) -> Either a b -> c
+def either(fl):
+    '''The application of fl to e if e is a Left value,
+       or the application of fr to e if e is a Right value.
+    '''
+    return lambda fr: lambda e: fl(e['Left']) if (
+        None is e['Right']
+    ) else fr(e['Right'])
+
+
+# enumFromTo :: Int -> Int -> [Int]
+def enumFromTo(m):
+    '''Enumeration of integer values [m..n]
+    '''
+    return lambda n: range(m, 1 + n)
+
+
+# showList :: [a] -> String
+def showList(xs):
+    '''Stringification of a list.'''
+    return '[' + ','.join(str(x) for x in xs) + ']'
+
+
+# take :: Int -> [a] -> [a]
+# take :: Int -> String -> String
+def take(n):
+    '''The prefix of xs of length n,
+       or xs itself if n > length xs.
+    '''
+    def go(xs):
+        return islice(xs, n)
+    return go
+
+
+# MAIN ---
+if __name__ == '__main__':
+    main()

Task/Super-d-numbers/R/super-d-numbers.r

@@ -0,0 +1,46 @@
+library(Rmpfr)
+options(scipen = 999)
+
+find_super_d_number <- function(d, N = 10){
+
+  super_number <- c(NA)
+  n = 0
+  n_found = 0
+
+  while(length(super_number) < N){
+
+    n = n + 1
+    test = d * mpfr(n, precBits = 200) ** d   #Here I augment precision
+    test_formatted = .mpfr2str(test)$str      #and I extract the string from S4 class object
+
+    iterable = strsplit(test_formatted, "")[[1]]
+
+    if (length(iterable) < d) next
+
+    for(i in d:length(iterable)){
+      if (iterable[i] != d) next
+      equalities = 0
+
+      for(j in 1:d) {
+        if (i == j) break
+
+        if(iterable[i] == iterable[i-j])
+          equalities = equalities + 1
+        else break
+      }
+
+      if (equalities >= (d-1)) {
+        n_found = n_found + 1
+        super_number[n_found] = n
+        break
+      }
+    }
+  }
+
+  message(paste0("First ", N, " super-", d, " numbers:"))
+  print((super_number))
+
+  return(super_number)
+}
+
+for(d in 2:6){find_super_d_number(d, N = 10)}

Task/Super-d-numbers/REXX/super-d-numbers.rexx

@@ -0,0 +1,17 @@
+/*REXX program computes and displays the first  N  super─d  numbers for D from LO to HI.*/
+numeric digits 100                               /*ensure enough decimal digs for calc. */
+parse arg n LO HI .                              /*obtain optional arguments from the CL*/
+if  n=='' |  n==","  then  n= 10                 /*the number of super─d numbers to calc*/
+if LO=='' | LO==","  then LO=  2                 /*low  end of  D  for the super─d nums.*/
+if HI=='' | HI==","  then HI=  9                 /*high  "   "  "   "   "     "      "  */
+                                                 /* [↓]   process  D  from  LO ──►  HI. */
+     do d=LO  to HI;     #= 0;     $=            /*count & list of super─d nums (so far)*/
+     z= copies(d, d)                             /*the string that is being searched for*/
+           do j=2  until #==n                    /*search for super─d numbers 'til found*/
+           if pos(z, d * j**d)==0  then iterate  /*does product have the required reps? */
+           #= # + 1;               $= $ j        /*bump counter;  add the number to list*/
+           end   /*j*/
+     say
+     say center(' the first '     n     " super-"d 'numbers ',  digits(),  "═")
+     say $
+     end   /*d*/                                 /*stick a fork in it,  we're all done. */

Task/Super-d-numbers/Raku/super-d-numbers.raku

@@ -0,0 +1,9 @@
+sub super (\d) {
+    my \run = d x d;
+    ^∞ .hyper.grep: -> \n { (d * n ** d).Str.contains: run }
+}
+
+(2..9).race(:1batch).map: {
+    my $now = now;
+    put "\nFirst 10 super-$_ numbers:\n{.&super[^10]}\n{(now - $now).round(.1)} sec."
+}

Task/Super-d-numbers/Ruby/super-d-numbers.rb

@@ -0,0 +1,5 @@
+(2..8).each do |d|
+  rep = d.to_s * d
+  print "#{d}: "
+  puts (2..).lazy.select{|n| (d * n**d).to_s.include?(rep) }.first(10).join(", ")
+end

Task/Super-d-numbers/Rust/super-d-numbers.rust

@@ -0,0 +1,29 @@
+// [dependencies]
+// rug = "1.9"
+
+fn print_super_d_numbers(d: u32, limit: u32) {
+    use rug::Assign;
+    use rug::Integer;
+
+    println!("First {} super-{} numbers:", limit, d);
+    let digits = d.to_string().repeat(d as usize);
+    let mut count = 0;
+    let mut n = 1;
+    let mut s = Integer::new();
+    while count < limit {
+        s.assign(Integer::u_pow_u(n, d));
+        s *= d;
+        if s.to_string().contains(&digits) {
+            print!("{} ", n);
+            count += 1;
+        }
+        n += 1;
+    }
+    println!();
+}
+
+fn main() {
+    for d in 2..=9 {
+        print_super_d_numbers(d, 10);
+    }
+}

Task/Super-d-numbers/Sidef/super-d-numbers.sidef

@@ -0,0 +1,8 @@
+func super_d(d) {
+    var D = Str(d)*d
+    1..Inf -> lazy.grep {|n| Str(d * n**d).contains(D) }
+}
+
+for d in (2..8) {
+    say ("#{d}: ", super_d(d).first(10))
+}

Task/Super-d-numbers/Swift/super-d-numbers.swift

@@ -0,0 +1,33 @@
+import BigInt
+import Foundation
+
+let rd = ["22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999"]
+
+for d in 2...9 {
+  print("First 10 super-\(d) numbers:")
+
+  var count = 0
+  var n = BigInt(3)
+  var k = BigInt(0)
+
+  while true {
+    k = n.power(d)
+    k *= BigInt(d)
+
+    if let _ = String(k).range(of: rd[d - 2]) {
+      count += 1
+
+      print(n, terminator: " ")
+      fflush(stdout)
+
+      guard count < 10 else {
+        break
+      }
+    }
+
+    n += 1
+  }
+
+  print()
+  print()
+}

Task/Super-d-numbers/Visual-Basic-.NET/super-d-numbers.vb

@@ -0,0 +1,33 @@
+Imports System.Numerics
+
+Module Module1
+
+    Sub Main()
+        Dim rd = {"22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999"}
+        Dim one As BigInteger = 1
+        Dim nine As BigInteger = 9
+
+        For ii = 2 To 9
+            Console.WriteLine("First 10 super-{0} numbers:", ii)
+            Dim count = 0
+
+            Dim j As BigInteger = 3
+            While True
+                Dim k = ii * BigInteger.Pow(j, ii)
+                Dim ix = k.ToString.IndexOf(rd(ii - 2))
+                If ix >= 0 Then
+                    count += 1
+                    Console.Write("{0} ", j)
+                    If count = 10 Then
+                        Console.WriteLine()
+                        Console.WriteLine()
+                        Exit While
+                    End If
+                End If
+
+                j += 1
+            End While
+        Next
+    End Sub
+
+End Module

Task/Super-d-numbers/Wren/super-d-numbers-1.wren

@@ -0,0 +1,23 @@
+import "/big" for BigInt
+import "/fmt" for Fmt
+
+var start = System.clock
+var rd = ["22", "333", "4444", "55555", "666666", "7777777", "88888888"]
+for (i in 2..8) {
+    Fmt.print("First 10 super-$d numbers:", i)
+    var count = 0
+    var j = BigInt.three
+    while (true) {
+        var k = j.pow(i) * i
+        var ix = k.toString.indexOf(rd[i-2])
+        if (ix >= 0) {
+            count = count + 1
+            Fmt.write("$i ", j)
+            if (count == 10) {
+                Fmt.print("\nfound in $f seconds\n", System.clock - start)
+                break
+            }
+        }
+        j = j.inc
+    }
+}

Task/Super-d-numbers/Wren/super-d-numbers-2.wren

@@ -0,0 +1,26 @@
+/* super-d_numbers_gmp.wren */
+
+import "./gmp" for Mpz
+import "./fmt" for Fmt
+
+var start = System.clock
+var rd = ["22", "333", "4444", "55555", "666666", "7777777", "88888888", "999999999"]
+for (i in 2..9) {
+    Fmt.print("First 10 super-$d numbers:", i)
+    var count = 0
+    var j = Mpz.three
+    var k = Mpz.new()
+    while (true) {
+        k.pow(j, i).mul(i)
+        var ix = k.toString.indexOf(rd[i-2])
+        if (ix >= 0) {
+            count = count + 1
+            Fmt.write("$i ", j)
+            if (count == 10) {
+                Fmt.print("\nfound in $f seconds\n", System.clock - start)
+                break
+            }
+        }
+        j.inc
+    }
+}

Task/Super-d-numbers/Zkl/super-d-numbers.zkl

@@ -0,0 +1,8 @@
+var [const] BI=Import("zklBigNum");  // libGMP
+
+fcn superDW(d){
+   digits:=d.toString()*d;
+   [2..].tweak('wrap(n)
+      { BI(n).pow(d).mul(d).toString().holds(digits) and n or Void.Skip });
+}
+foreach d in ([2..8]){ println(d," : ",superDW(d).walk(10).concat(" ")) }