Super-d numbers: Difference between revisions

{{trans|D}}

 

 

L(ii) 2..7

print("\n")

L.break

 

{{out}}

140997 490996 1184321 1259609 1409970 1783166 1886654 1977538 2457756 2714763

 

</pre>

 

{{libheader|System.Numerics}}

Done three ways, two with BigIntegers, and one with a UIint64 structure. More details on the "Mostly addition" method on the discussion page.

using System.Collections.Generic;

using BI = System.Numerics.BigInteger;

doOne("UInt64 structure mostly addition:", top, funF);

}

 

{{out}}

=={{header|C}}==

{{libheader|GMP}}

#include <stdlib.h>

#include <string.h>

}

return 0;

 

{{out}}

=={{header|C++}}==

{{trans|D}}

#include <sstream>

#include <vector>

return 0;

}

{{out}}

<pre>First 10 super-2 numbers:

{{libheader|GMP}}

{{trans|C}}

#include <gmpxx.h>

 

}

return 0;

 

{{out}}

===Alternative ''not'' using GMP===

{{trans|C#}}

#include <sstream>

#include <chrono>

for (int i = 2; i <= 9; i++) fun(i);

}

{{out}}

<pre>2: 19 31 69 81 105 106 107 119 127 131 0.002s

A more naïve implementation inspired by the Raku one, but without its use of parallelism; on my somewhat old and underpowered laptop, it gets through the basic task of 2 through 6 in about 6 seconds, then takes almost 40 to complete 7, and about six minutes for 8; with that growth rate, I didn't wait around for nine to complete.

 

(let [run (apply str (repeat d (str d)))]

(filter #(clojure.string/includes? (str (* d (Math/pow % d ))) run) (range))))

 

(doseq [d (range 2 9)]

{{Out}}

<pre>2: (19 31 69 81 105 106 107 119 127 131)

=={{header|D}}==

{{trans|Go}}

import std.conv;

import std.stdio;

}

}

{{out}}

<pre>First 10 super-2 numbers:

=={{header|F_Sharp|F#}}==

;The Function

// Generate Super-N numbers. Nigel Galloway: October 12th., 2019

let superD N=

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)

;The Task

superD 2 |> Seq.take 10 |> Seq.iter(printf "%A "); printfn ""

superD 3 |> 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 ""

{{out}}

<pre>

 

=={{header|Factor}}==

math.functions math.ranges math.text.utils prettyprint sequences

;

] with each ;

 

{{out}}

<pre>

27257 272570 302693 323576 364509 502785 513675 537771 676657 678146

</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

Simple brute force approach and so not particularly quick - about 2.25 minutes on a Core i7.

 

import (

}

}

 

{{out}}

</pre>

=={{header|Haskell}}==

import Data.Char (intToDigit)

 

("First 10 super-" ++) .

((++) . show <*> ((" : " ++) . show . take 10 . findSuperd)))

{{out}}

<pre>

 

=={{header|Java}}==

import java.math.BigInteger;

 

 

}

 

{{out}}

Run time 268460 ms

</pre>

 

=={{header|Julia}}==

{{trans|Phix}}

println("First 10 super-$N numbers:")

count, j = 0, BigInt(3)

@time superd(n)

end

<pre>

First 10 super-2 numbers:

=={{header|Kotlin}}==

{{trans|Java}}

 

fun superD(d: Int, max: Int) {

superD(i, 10)

}

{{out}}

<pre>First 10 super-2 numbers:

==={{header|Lua - using doubles}}===

Lua's default numeric type is IEEE-754 doubles, which are insufficient beyond d=5, but for reference:

local n, found = 0, {}

local dds = string.rep(d, d)

end

print("super-" .. d .. ": " .. table.concat(found,", "))

{{out}}

<pre>super-2: 19, 31, 69, 81, 105, 106, 107, 119, 127, 131

==={{header|Lua - using lbc}}===

Using the lbc library to provide support for arbitrary-precision integers, which are sufficient for both task and extra-credit:

for i = 2, 9 do

local d, n, found = bc.new(i), bc.new(0), {}

end

print("super-" .. d:tostring() .. ": " .. table.concat(found,", "))

{{out}}

<pre>super-2: 19, 31, 69, 81, 105, 106, 107, 119, 127, 131

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

SuperD[d_, m_] := Module[{n, res, num},

res = {};

res

]

{{out}}

<pre>{19,31,69,81,105,106,107,119,127,131}

Using only the standard library, we would be limited to "d = 2, 3, 4". So, here is the program using the third-party library "bignum".

 

import bignum

 

echo "First 10 super-$# numbers:".format(d)

echo toSeq(superDNumbers(d, 10)).join(" ")

 

{{out}}

{{works with|Free Pascal}}

gmp is fast.Same brute force as [http://rosettacode.org/wiki/Super-d_numbers#Go Go]

uses

sysutils,gmp;

end;

mpz_clear(test);

{{out}}

<pre>Finding 22 in 2*i**2

 

=={{header|Perl}}==

use warnings;

use bigint;

}

 

<pre>

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<pre>

First 10 super-9 numbers:

17546133 <killed>

</pre>

 

=={{header|Python}}==

===Procedural===

 

def superd(d):

if __name__ == '__main__':

for d in range(2, 9):

 

{{out}}

 

===Functional===

 

from itertools import count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>1 :: Super-d is defined only for integers drawn from {2..9}

First 10 super-5: [4602,5517,7539,12955,14555,20137,20379,26629,32767,35689]

First 10 super-6: [27257,272570,302693,323576,364509,502785,513675,537771,676657,678146]</pre>

 

=={{header|Raku}}==

2 - 6 take a few seconds, 7 about 17 seconds, 8 about 90... 9, bleh... around 700 seconds.

 

my \run = d x d;

^∞ .hyper.grep: -> \n { (d * n ** d).Str.contains: run }

my $now = now;

put "\nFirst 10 super-$_ numbers:\n{.&super[^10]}\n{(now - $now).round(.1)} sec."

 

<pre>First 10 super-2 numbers:

 

=={{header|REXX}}==

numeric digits 100 /*ensure enough decimal digs for calc. */

parse arg n LO HI . /*obtain optional arguments from the CL*/

say center(' the first ' n " super-"d 'numbers ', digits(), "═")

say $

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ruby}}==

rep = d.to_s * d

print "#{d}: "

puts (2..).lazy.select{|n| (d * n**d).to_s.include?(rep) }.first(10).join(", ")

end

{{out}}

<pre>2: 19, 31, 69, 81, 105, 106, 107, 119, 127, 131

=={{header|Rust}}==

// rug = "1.9"

 

print_super_d_numbers(d, 10);

}

 

{{out}}

 

=={{header|Sidef}}==

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))

{{out}}

<pre>

{{libheader|AttaSwift BigInt}}

 

import Foundation

 

print()

print()

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|D}}

 

Module Module1

End Sub

 

{{out}}

<pre>First 10 super-2 numbers:

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

Managed to get up to 8 but too slow for 9.

 

var start = System.clock

j = j.inc

}

 

{{out}}

185423 641519 1551728 1854230 6415190 12043464 12147605 15517280 16561735 18542300

found in 434.536825 seconds

</pre>

 

=={{header|zkl}}==

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

 

fcn superDW(d){

{ BI(n).pow(d).mul(d).toString().holds(digits) and n or Void.Skip });

}

{{out}}

<pre>