Super-d numbers: Difference between revisions

{{task}}

 

<big>2 ≤ d ≤ 9</big>

 

 

 

 

:* 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.

 

 

 

 

 

 

 

=={{header|C sharp|C#}}==

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

9: 17546133 32613656 93568867 107225764 109255734 113315082 121251742 175461330 180917907 182557181 275.4s</pre>

Slower than '''GMP''' on the core i7-7700 @ 3.6Ghz, over twice as slow. This one is 275 seconds, vs. 102 seconds for '''GMP'''.

 

=={{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:

17546133 32613656 93568867 107225764 109255734 113315082 121251742 175461330 180917907 182557181

Run time 392181 ms</pre>

 

=={{header|Pascal}}==

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

def p(x):

return ds in str(d * x ** d)

return Right(filter(p, count(2)))

else:

# 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*/

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? */

end /*j*/

say

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

First 10 super-8 numbers:

185423 641519 1551728 1854230 6415190 12043464 12147605 15517280 16561735 18542300

 

First 10 super-9 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>