Brilliant numbers: Difference between revisions

;* [https://www.numbersaplenty.com/set/brilliant_number Numbers Aplenty - Brilliant numbers]

;* [[oeis:A078972|OEIS:A078972 - Brilliant numbers: semiprimes whose prime factors have the same number of decimal digits]]

=={{header|ALGOL 68}}==

{{libheader|ALGOL 68-primes}}

# the same number of digits #

PR read "primes.incl.a68" PR # include prime utilities #

First brilliant number >= 1000000: 1018081 at position 10538

</pre>

=={{header|Arturo}}==

pf: factors.prime x

and? -> 2 = size pf

First brilliant number >= 10 ^ 5 is 100013 at position 2505

First brilliant number >= 10 ^ 6 is 1018081 at position 10538</pre>

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

{{libheader|Primesieve}}

#include <chrono>

#include <iomanip>

Elapsed time: 1.50048 seconds

</pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2022-04-03}}

math math.functions math.primes.factors prettyprint

project-euler.common sequences ;

First brilliant number >= 1000000: 1018081 at position 10538

</pre>

=={{header|Go}}==

{{trans|Wren}}

{{libheader|Go-rcu}}

import (

First >= 10,000,000,000,000 is 34,896,253,010 in the series: 10,000,000,000,073

</pre>

=={{header|Haskell}}==

import Data.Bifunctor (bimap)

import Data.List (intercalate, transpose)

(242,10201)

(2505,100013)</pre>

=={{header|J}}==

p:(+i.)/-/\ p:inv +/\1 9*10^y

}}

Task examples:

4 6 9 10 14 15 21 25 35 49

121 143 169 187 209 221 247 253 289 299

Stretch goal (results are order, index, value):

7 124363 10000043

(brillseq 5) (],.(I. 10^]) ([,.{) [) 8 9

8 573928 100140049

9 7407840 1000000081</syntaxhighlight>

=={{header|Java}}==

{{trans|C++}}

Uses the PrimeGenerator class from [[Extensible prime generator#Java]].

public class BrilliantNumbers {

First brilliant number >= 10^15 is 1,000,000,000,000,003 at position 2,601,913,448,897

</pre>

=={{header|Julia}}==

using Primes

First >= 1000000000 is 7407841 in the series: 1000000081

</pre>

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

PrimesDecade[n_Integer] := Module[{bounds},

bounds = {PrimePi[10^n] + 1, PrimePi[10^(n + 1) - 1]};

100140049 573929

1000000081 7407841</pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

=== Faster approach ===

{{trans|Sidef}}

use strict;

use warnings;

First brilliant number >= 10^13 is 10000000000073 at position 34896253010

</pre>

=={{header|Phix}}==

{{trans|C++}}

Replaced with C++ translation; much faster and now goes comfortably to 1e15 even on 32 bit.

You can run this online [http://phix.x10.mx/p2js/brilliant.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\BrilliantNumbers.exw

"3.3s"

</pre>

=={{header|Python}}==

Using primesieve and numpy modules. If program is run to above 10¹⁸ it overflows 64 bit integers (that's what primesieve module backend uses internally).

from math import isqrt

import numpy as np

Above 10^16: 10000001400000049 at #13163230391313

Above 10^17: 100000000000000831 at #201431415980419</pre>

=={{header|Raku}}==

1 through 7 are fast. 8 and 9 take a bit longer.

# Find an abundance of primes to use to generate brilliants

First >= 100,000,000 is 573929ᵗʰ in the series: 100,140,049

First >= 1,000,000,000 is 7407841ˢᵗ in the series: 1,000,000,081</pre>

=={{header|Rust}}==

{{trans|C++}}

// primal = "0.3"

// indexing = "0.4.1"

Elapsed time: 1515 milliseconds

</pre>

=={{header|Sidef}}==

n.is_semiprime && (n.factor.map{.len}.uniq.len == 1)

}

First brilliant number >= 10^12 is 1000006000009 at position 2409600866

</pre>

=={{header|Swift}}==

Magnitudes of 1 to 3 is decent, 4 and beyond becomes slow.

// https://www.geeksforgeeks.org/sieve-of-eratosthenes/?ref=leftbar-rightbar

// https://developer.apple.com/documentation/swift/array/init(repeating:count:)-5zvh4

First brilliant number >= 100000: 100013 at position 2505

First brilliant number >= 1000000: 1018081 at position 10538</pre>

=={{header|Wren}}==

{{libheader|Wren-math}}

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "./seq" for Lst

import "./fmt" for Fmt

First >= 1,000,000,000,000 is 2,409,600,866th in the series: 1,000,006,000,009

</pre>

=={{header|XPL0}}==

func NumDigits(N); \Return number of digits in N

int N, Cnt;