Esthetic numbers: Difference between revisions

{{trans|Nim}}

 

I n == 0 {R 0B}

V i = n % b

listEsths(100'000'000'000, 101'010'101'010, 130'000'000'000, 123'456'789'898, 7, 0B)

listEsths(100'000'000'000'000, 101'010'101'010'101, 130'000'000'000, 123'456'789'898'989, 5, 0B)

 

{{out}}

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

As with other solutions here, uses brute-force for the main task, generates the numbers for the stretch goal.

# returns TRUE if n is esthetic in the specified base, FALSE otherwise #

PRIO ISESTHETIC = 1;

print( ( newline ) );

print( ( "Found ", whole( e count, 0 ), " esthetic numbers", newline ) )

{{out}}

<pre>

=={{header|Arturo}}==

 

if n=0 -> return false

k: n % b

loop split.every: 16 select 1000..9999 'num -> esthetic? num 10 'row [

print map to [:string] row 'item -> pad item 4

 

{{out}}

=={{header|C}}==

{{trans|Go}}

#include <string.h>

#include <locale.h>

setlocale(LC_NUMERIC, oldLocale);

return 0;

 

{{out}}

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

{{trans|D}}

#include <iostream>

#include <sstream>

listEsths((uint64_t)1e17, 101'010'101'010'101'010, 13 * (uint64_t)1e16, 123'456'789'898'989'898, 4, false);

return 0;

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

=={{header|D}}==

{{trans|Go}}

import std.stdio;

 

listEsths(cast(ulong) 1e14, 101_010_101_010_101, 13*cast(ulong) 1e13, 123_456_789_898_989, 5, false);

listEsths(cast(ulong) 1e17, 101_010_101_010_101_010, 13*cast(ulong) 1e16, 123_456_789_898_989_898, 4, false);

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

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

===The functions===

// Generate Esthetic Numbers. Nigel Galloway: March 21st., 2020

let rec fN Σ n g = match g with h::t -> match List.head h with

let EtoS n = let g = "0123456789abcdef".ToCharArray()

n |> List.map(fun n->g.[n]) |> List.rev |> Array.ofList |> System.String

===The Tasks===

; Esthetic numbers in bases 2 through 16

[2..16]|>List.iter(fun n->printfn "\nBase %d" n; Esthetic n|>Seq.skip(4*n-1)|>Seq.take((6-4)*n+1)|>Seq.iter(EtoS >> printfn "%s"))

{{out}}

<pre style="height:30ex">

; Base 10 esthetic numbers with a magnitude between 1000 and 9999

 

Esthetic 10|>Seq.map(EtoS>>int)|>Seq.skipWhile(fun n->n<1000)|>Seq.takeWhile(fun n->n<9999)|>Seq.iter(printfn "%d");;

{{out}}

<pre style="height:30ex">

; Base 10 esthetic numbers with a magnitude between 1.0e8 and 1.3e8

 

Esthetic 10|>Seq.map(EtoS>>int)|>Seq.skipWhile(fun n->n<100000000)|>Seq.takeWhile(fun n->n< 130000000)|>Seq.iter(printfn "%d")

{{out}}

<pre style="height:30ex">

; Base 10 esthetic numbers with a magnitude between 1.0e11 and 1.3e11

 

Esthetic 10|>Seq.map(EtoS>>int64)|>Seq.skipWhile(fun n->n<100000000000L)|>Seq.takeWhile(fun n->n<130000000000L)|>Seq.iter(printfn "%d")

{{out}}

<pre style="height:30ex">

The <code>bfs</code> word is an adaptation of the algorithm from the Geeks for Geeks reference. It has been changed to work with any base. In summary, this algorithm constructs esthetic numbers directly using a breadth first search. For example, we know the only two esthetic numbers that can be constructed from 23 are 232 and 234, or in other words, the last digit of 23 ± 1 appended to 23. This forms a tree for each digit in a given base where each node is an esthetic number and can have at most two children. This method is very fast and has been used to find the count of esthetic numbers in base 10 between zero and one quadrillion.

{{works with|Factor|0.99 2020-01-23}}

locals make math math.order math.parser math.ranges

math.text.english prettyprint sequences sorting strings ;

 

"Count of base 10 esthetic numbers between zero and one quadrillion:"

{{out}}

<pre style="height:60ex">

=={{header|Forth}}==

{{works with|Gforth}}

\ esthetic number in that base or one less than a power of base.

: next_esthetic_number { n base -- n }

 

main

 

{{out}}

 

=={{header|FreeBASIC}}==

dim shared as string*16 digits = "0123456789ABCDEF"

 

make_base i, 10, number

if is_esthetic(number) then print number;" ";

{{out}}

<pre>

For the last two parts (stretched up to 1.0e17/1.3e17), a 'depth first search' approach

is used with the obvious range limitations imposed for extra speed.

 

import (

listEsths(1e14, 101_010_101_010_101, 13*1e13, 123_456_789_898_989, 5, false)

listEsths(1e17, 101_010_101_010_101_010, 13*1e16, 123_456_789_898_989_898, 4, false)

 

{{out}}

 

=={{header|Haskell}}==

import Control.Monad (replicateM, foldM, mzero)

 

showInBase b = foldMap (pure . digit) . toBase b

where digit = genericIndex (['0'..'9'] <> ['a'..'z'])

 

'''Tasks implementation'''

Implementation (brute force):

 

 

gen=: {{r=.$k=.1 while.y>#r do. r=.r,k#~u k

 

Task examples:

 

taskB=: {{;:inv y tobase&.> (<:4*y)}. y&isesthetic gen 6*y}}

 

 

(#~ isesthetic) 1000+i.1000

 

Stretch goal (the slow way):

 

126

q:126

 

(Result e not displayed here -- it's the same as <tt>next^:8]1</tt> below.)

For example, we can generate a directed graph, from one digit to the one or two viable adjacent digits, and then build up a result based on all viable values of the rightmost digit of the current list of partially built candidates:

 

next=: [:; (0 10#.],.graph {::~10|])each

 

123432323 123432343 123432345 123434321 123434323 123434343 123434345 123434543 123434545

123434565 123434567 123454321 123454323 123454343 123454345 123454543 123454545 123454565

 

(We organize the 126 values of the stretch goal into 14 rows of 9 columns (126=14*9) using the expression <tt>14 9 $</tt> ...)

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.stream.IntStream;

import java.util.stream.LongStream;

listEsths((long) 1e17, 101_010_101_010_101_010L, 13 * (long) 1e16, 123_456_789_898_989_898L, 4, false);

}

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

=={{header|JavaScript}}==

===JavaScript :: Procedural===

let arr = inp.toString(base).split('');

if (arr.length == 1) return false;

 

console.log( collectEsthetics(10, [1e8, 1.3e8]),

{{out}}<pre>2:

> Array(4) [ "1010101010", "10101010101", "101010101010", "1010101010101" ]

Constrained generation – more efficient than a filter over a larger space.

{{Trans|Haskell}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>Esthetics [8..12] for base 2:

=={{header|Julia}}==

Illustrates both brute force and iterative methods of generating numbers in the sequence.

import Base.iterate, Base.IteratorSize, Base.IteratorEltype

 

println("\nTotal esthetic numbers in interval: $count")

end

<pre>

For base 2, the esthetic numbers indexed from 8 to 12 are:

=={{header|Kotlin}}==

{{trans|D}}

 

fun isEsthetic(n: Long, b: Long): Boolean {

listEsths(1e14.toLong(), 101_010_101_010_101, 13 * 1e13.toLong(), 123_456_789_898_989, 5, false);

listEsths(1e17.toLong(), 101_010_101_010_101_010, 13 * 1e16.toLong(), 123_456_789_898_989_898, 4, false);

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

=={{header|Lua}}==

{{trans|C++}}

local BASE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

 

listEsths(1e11, 101010101010, 13 * 1e10, 123456789898, 7, false)

listEsths(1e14, 101010101010101, 13 * 1e13, 123456789898989, 5, false)

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

 

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

EstheticNumbersRangeHelper[power_, mima : {mi_, max_}, b_ : 10] := Module[{steps, cands},

steps = Tuples[{-1, 1}, power - 1];

Table[{b, EstheticNumbersRange[{1, If[b == 2, 100000, If[b == 3, 100000, b^4]]}, b][[4 b ;; 6 b]]}, {b, 2, 16}] // Grid

EstheticNumbersRange[{1000, 9999}]

{{out}}

<pre>2 {10101010,101010101,1010101010,10101010101,101010101010}

=={{header|Nim}}==

{{trans|Kotlin}}

 

func isEsthetic(n, b: int64): bool =

listEsths(100_000_000_000, 101_010_101_010, 130_000_000_000, 123_456_789_898, 7, false)

listEsths(100_000_000_000_000, 101_010_101_010_101, 130_000_000_000, 123_456_789_898_989, 5, false)

 

{{out}}

=={{header|Pascal}}==

Simple brute force, but fast and simple counting for complete first digit ranges.

{$IFDEF FPC}

{$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$codealign proc=16}

writeln(Numb2USA(IntToStr(Dgtcnt[64][0]-Dgtcnt[63][0])):28);

end.

{{out}}

<pre style="height:30ex">

{{libheader|ntheory}}

{{trans|Sidef}}

use warnings;

use experimental qw(signatures);

for (my @list = between_esthetic(1e8, 1.3e8) ; @list ;) {

say join(' ', splice(@list, 0, 9));

{{out}}

<pre>

=={{header|Phix}}==

Simple string based approach, very fast, manages stretch goal and much further in the blink of an eye.

<span style="color: #008080;">constant</span> <span style="color: #000000;">aleph</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0123456789ABCDEF"</span>

<span style="color: #0000FF;">{</span><span style="color: #000000;">comma</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">),</span><span style="color: #000000;">comma</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">),</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

In other words we can count the total number of 62-digit esthetic numbers with at most 574 additions from a

table of at most 610 entries, in practice obviously just do all 610.

<span style="color: #008080;">function</span> <span style="color: #000000;">count_esthetic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">len</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">start</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- a start digit of 0 means sum all 1..9</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;">"There are %,26d esthetic numbers with max 65 digits\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">64</span><span style="color: #0000FF;">),</span><span style="color: #000000;">count_esthetic</span><span style="color: #0000FF;">))})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<small>(It turns out that [1..9] is the same as [2..10] anyway, by symmetry, but technically the latter would be the more correct expression for digits 1..9)</small>

{{out}}

 

=={{header|PicoLisp}}==

(let Lst

(make

(while (cut 9 'L)

(mapc '((L) (prin L " ")) @)

 

{{out}}

=={{header|Prolog}}==

{{works with|SWI Prolog}}

forall(between(2, 16, Base),

(Min_index is Base * 4, Max_index is Base * 6,

D is C mod Base,

(D == 0 -> E = 1 ; E is D - 1),

 

{{out}}

===Python :: Procedural===

{{works with|Python|3.9.5}}

from itertools import dropwhile, islice, takewhile

from textwrap import wrap

task_3(100_000_000, 130_000_000)

 

{{out}}

<pre>======

===Python :: Functional===

{{Trans|Haskell}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Esthetics [8..12] for base 2:

{{works with|Rakudo|2020.02}}

 

 

sub esthetic($base = 10) {

my $top = @array.first: * > $hi, :k;

@array[^$top].grep: * > $lo

{{out}}

<div style="font-size:70%;">

 

=={{header|REXX}}==

parse arg baseL baseH range /*obtain optional arguments from the CL*/

if baseL=='' | baseL=="," then baseL= 2 /*Not specified? Then use the default.*/

if (z==vv(@.pe,-1)|z==vv(@.pe,1))&(z==vv(@.ae,-1)|z==vv(@.ae,1)) then iterate

return 0

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

<pre>

 

=={{header|Ring}}==

basePlus = []

decList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

binList = substr(binList,nl,"")

return binList

{{out}}

<pre>

=={{header|Ruby}}==

{{trans|Kotlin}}

if n == 0 then

return false

end

 

{{out}}

<pre>Base 2: 8th to 12th esthetic numbers:

 

=={{header|Rust}}==

// radix_fmt = "1.0"

 

println!();

}

 

{{out}}

 

=={{header|Sidef}}==

 

var v = root.digits2num(b)

 

say "\nBase 10 esthetic numbers between 100,000,000 and 130,000,000:"

{{out}}

<pre>

=={{header|Swift}}==

 

func take(_ n: Int) -> [Element] {

var res = [Element]()

 

print("Esthetics between \(Int(1e17)) and \(13 * Int(1e16)):")

 

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var isEsthetic = Fn.new { |n, b|

listEsths.call(1e8, 101010101, 13*1e7, 123456789, 9, true)

listEsths.call(1e11, 101010101010, 13*1e10, 123456789898, 7, false)

 

{{out}}