Self-describing numbers: Difference between revisions

Line 31:

<~~lang~~ 11l>F is_self_describing(n)

<syntaxhighlight lang="11l">F is_self_describing(n)

V s = String(n)

R all(enumerate(Array(s)).map((i, ch) -> @s.count(String(i)) == Int(ch)))

print((0.<4000000).filter(x -> is_self_describing(x)))</~~lang~~>

print((0.<4000000).filter(x -> is_self_describing(x)))</syntaxhighlight>

Line 43:

=={{header|360 Assembly}}==

<~~lang~~ 360asm>* Self-describing numbers 26/04/2020

<syntaxhighlight lang="360asm">* Self-describing numbers 26/04/2020

SELFDESC CSECT

USING SELFDESC,R13 base register

Line 106:

XDEC DS CL12 temp fo xdeco

REGEQU

END SELFDESC </~~lang~~>

END SELFDESC </syntaxhighlight>

<pre>

Line 116:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_IO; use Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;

procedure SelfDesc is

subtype Desc_Int is Long_Integer range 0 .. 10**10-1;

Line 140:

end if;

end loop;

end SelfDesc;</~~lang~~>

end SelfDesc;</syntaxhighlight>

<pre>1210

Line 151:

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

<~~lang~~ algol68>BEGIN

<syntaxhighlight lang="algol68">BEGIN

# return TRUE if number is self describing, FALSE otherwise #

Line 196:

)

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 207:

=={{header|AppleScript}}==

<~~lang~~ applescript>use AppleScript version "2.4"

<syntaxhighlight lang="applescript">use AppleScript version "2.4"

use framework "Foundation"

use scripting additions

Line 400:

set my text item delimiters to dlm

s

end unlines</~~lang~~>

end unlines</syntaxhighlight>

<pre>1210 -> true

Line 413:

=={{header|Arturo}}==

<~~lang~~ rebol>selfDescribing?: function [x][

<syntaxhighlight lang="rebol">selfDescribing?: function [x][

digs: digits x

loop.with:'i digs 'd [

Line 422:

]

print select 1..22000 => selfDescribing?</~~lang~~>

print select 1..22000 => selfDescribing?</syntaxhighlight>

Line 430:

=={{header|AutoHotkey}}==

Uses CountSubString: [[Count occurrences of a substring#AutoHotkey]]

<~~lang~~ ~~AutoHotkey~~>; The following directives and commands speed up execution:

<syntaxhighlight lang="autohotkey">; The following directives and commands speed up execution:

#NoEnv

SetBatchlines -1

Line 452:

return false

return true

}</~~lang~~>

}</syntaxhighlight>

Output:

<pre>---------------------------

Line 469:

=={{header|AWK}}==

<~~lang~~ ~~AWK~~># syntax: GAWK -f SELF-DESCRIBING_NUMBERS.AWK

<syntaxhighlight lang="awk"># syntax: GAWK -f SELF-DESCRIBING_NUMBERS.AWK

BEGIN {

for (n=1; n<=100000000; n++) {

Line 485:

}

return(1)

}</~~lang~~>

}</syntaxhighlight>

output:

<pre>

Line 496:

=={{header|BASIC}}==

<~~lang~~ qbasic>Dim x, r, b, c, n, m As Integer

<syntaxhighlight lang="qbasic">Dim x, r, b, c, n, m As Integer

Dim a, d As String

Dim v(10), w(10) As Integer

Line 519:

Print "End"

sleep

end</~~lang~~>

end</syntaxhighlight>

=={{header|BBC BASIC}}==

<~~lang~~ bbcbasic> FOR N = 1 TO 5E7

<syntaxhighlight lang="bbcbasic"> FOR N = 1 TO 5E7

IF FNselfdescribing(N) PRINT N

Line 538:

N% DIV=10

ENDWHILE

= O% = SUM(D%())</~~lang~~>

= O% = SUM(D%())</syntaxhighlight>

Output:

<pre>

Line 553:

Be aware, though, that even with a fast interpreter, it's going to be a very long time before you see the full set of results.

<~~lang~~ befunge>>1+9:0>\#06#:p#-:#1_$v

<syntaxhighlight lang="befunge">>1+9:0>\#06#:p#-:#1_$v

?v6:%+55:\+1\<<<\0:::<

#>g1+\6p55+/:#^_001p\v

^_@#!`<<v\+g6g10*+55\<

>:*:*:*^>>:01g1+:01p`|

^_\#\:#+.#5\#5,#$:<-$<</~~lang~~>

^_\#\:#+.#5\#5,#$:<-$<</syntaxhighlight>

Line 569:

=={{header|C}}==

Using integers instead of strings.

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

inline int self_desc(unsigned long long xx)

Line 594:

return 0;

}</~~lang~~>output<lang>1210

}</syntaxhighlight>output<syntaxhighlight lang="text">1210

2020

21200

3211000

42101000</~~lang~~>

42101000</syntaxhighlight>

===Backtracking version===

Backtracks on each digit from right to left, takes advantage of constraints "sum of digit values = number of digits" and "sum of (digit index * digit value) = number of digits". It is using as argument the list of allowed digits (example 012345789 to run the program in standard base 10).

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

#include <stdlib.h>

#include <string.h>

Line 695:

puts("");

}

}</~~lang~~>

}</syntaxhighlight>

Output for base 36

<lang>$ time ./selfdesc.exe 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ

<syntaxhighlight lang="text">$ time ./selfdesc.exe 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ

1210

2020

Line 735:

real 0m0.094s

user 0m0.046s

sys 0m0.030s</~~lang~~>

sys 0m0.030s</syntaxhighlight>

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

<~~lang~~ cpp>

#include <iostream>

Line 812:

return 0;

}

</syntaxhighlight>

</lang>

<pre>

Line 827:

Uses C++11. Build with

g++ -std=c++11 sdn.cpp

<~~lang~~ cpp>#include <algorithm>

<syntaxhighlight lang="cpp">#include <algorithm>

#include <array>

#include <iostream>

Line 852:

}

}</~~lang~~>

}</syntaxhighlight>

Output:

<pre>

Line 870:

probably much faster because it wouldn't have to allocate an array and then

turn around and "interpret" it back out but I didn't really pursue it.

<~~lang~~ lisp>(defun to-ascii (str) (mapcar #'char-code (coerce str 'list)))

<syntaxhighlight lang="lisp">(defun to-ascii (str) (mapcar #'char-code (coerce str 'list)))

(defun to-digits (n)

Line 889:

(digits (to-digits n) (cdr digits)))

((null digits) t)

(if (not (eql (car digits) (aref counts ipos))) (return nil)))))</~~lang~~>

(if (not (eql (car digits) (aref counts ipos))) (return nil)))))</syntaxhighlight>

Output:

<lang>(loop for i from 1 to 4000000 do (if (self-described-p i) (print i)))

<syntaxhighlight lang="text">(loop for i from 1 to 4000000 do (if (self-described-p i) (print i)))

1210

Line 898:

21200

3211000

NIL</~~lang~~>

NIL</syntaxhighlight>

=={{header|Crystal}}==

<~~lang~~ ruby>def self_describing?(n)

<syntaxhighlight lang="ruby">def self_describing?(n)

digits = n.to_s.chars.map(&.to_i) # 12345 => [1, 2, 3, 4, 5]

digits.each_with_index.all? { |digit, idx| digits.count(idx) == digit }

Line 909:

t = Time.monotonic

600_000_000.times { |n| (puts "#{n} in #{(Time.monotonic - t).total_seconds} secs";\

t = Time.monotonic) if self_describing?(n) }</~~lang~~>

t = Time.monotonic) if self_describing?(n) }</syntaxhighlight>

System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Crystal 0.35

Compil: $ crystal build selfdescribing.cr --release

Line 924:

<~~lang~~ ruby>def selfDesc(n)

<syntaxhighlight lang="ruby">def selfDesc(n)

ns = n.to_s

nc = ns.size

Line 973:

end

osecs = (Time.monotonic - start).total_seconds

print("\nTook #{osecs} secs overall")</~~lang~~>

print("\nTook #{osecs} secs overall")</syntaxhighlight>

System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Crystal 0.35

Line 990:

=={{header|D}}==

===Functional Version===

<~~lang~~ d>import std.stdio, std.algorithm, std.range, std.conv, std.string;

<syntaxhighlight lang="d">import std.stdio, std.algorithm, std.range, std.conv, std.string;

bool isSelfDescribing(in long n) pure nothrow @safe {

Line 999:

void main() {

4_000_000.iota.filter!isSelfDescribing.writeln;

}</~~lang~~>

}</syntaxhighlight>

===A Faster Version===

<~~lang~~ d>bool isSelfDescribing2(ulong n) nothrow @nogc {

<syntaxhighlight lang="d">bool isSelfDescribing2(ulong n) nothrow @nogc {

if (n <= 0)

return false;

Line 1,046:

if (i.isSelfDescribing2)

i.writeln;

}</~~lang~~>

}</syntaxhighlight>

<pre>1210

Line 1,063:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule Self_describing do

<syntaxhighlight lang="elixir">defmodule Self_describing do

def number(n) do

digits = Integer.digits(n)

Line 1,073:

m = 3300000

Enum.filter(0..m, fn n -> Self_describing.number(n) end)</~~lang~~>

Enum.filter(0..m, fn n -> Self_describing.number(n) end)</syntaxhighlight>

Line 1,082:

=={{header|Erlang}}==

<~~lang~~ erlang>

sdn(N) -> lists:map(fun(S)->length(lists:filter(fun(C)->C-$0==S end,N))+$0 end,lists:seq(0,length(N)-1))==N.

gen(M) -> lists:filter(fun(N)->sdn(integer_to_list(N)) end,lists:seq(0,M)).

</syntaxhighlight>

</lang>

=={{header|Factor}}==

<~~lang~~ factor>USING: kernel math.parser prettyprint sequences ;

<syntaxhighlight lang="factor">USING: kernel math.parser prettyprint sequences ;

IN: rosetta-code.self-describing-numbers

Line 1,100:

digits dup [ digit-count = ] with map-index [ t = ] all? ;

100,000,000 <iota> [ self-describing-number? ] filter .</~~lang~~>

100,000,000 <iota> [ self-describing-number? ] filter .</syntaxhighlight>

<pre>

Line 1,108:

=={{header|Forth}}==

<~~lang~~ forth>\ where unavailable.

<syntaxhighlight lang="forth">\ where unavailable.

: third ( A b c -- A b c A ) >r over r> swap ;

: (.) ( u -- c-addr u ) 0 <# #s #> ;

Line 1,123:

(.) [char] 0 third third bounds ?do

count i c@ [char] 0 - <> if drop 2drop false unloop exit then

loop drop 2drop true ;</~~lang~~>

loop drop 2drop true ;</syntaxhighlight>

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>' FB 1.05.0 Win64

<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

Function selfDescribing (n As UInteger) As Boolean

Line 1,148:

Print

Print "Press any key to quit"

Sleep</~~lang~~>

Sleep</syntaxhighlight>

Line 1,158:

=={{header|Go}}==

===Original===

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,187:

}

}</~~lang~~>

}</syntaxhighlight>

Output produced by above program:

<pre>

Line 1,201:

===Optimized===

Uses the optimized loop from the Wren entry - 12 times faster than before.

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 1,256:

osecs := time.Since(start).Seconds()

fmt.Printf("\nTook %.1f secs overall\n", osecs)

}</~~lang~~>

}</syntaxhighlight>

Line 1,274:

=={{header|Haskell}}==

<~~lang~~ ~~Haskell~~>import Data.Char

<syntaxhighlight lang="haskell">import Data.Char

count :: Int -> [Int] -> Int

Line 1,290:

isSelfDescribing <$>

[1210, 2020, 21200, 3211000, 42101000, 521001000, 6210001000]

print $ filter isSelfDescribing [0 .. 4000000]</~~lang~~>

print $ filter isSelfDescribing [0 .. 4000000]</syntaxhighlight>

Output:

<pre>[True,True,True,True,True,True,True]

Line 1,296:

Here are functions for generating all the self-describing numbers of a certain length. We capitalize on the fact (from Wikipedia) that a self-describing number of length n is a base-n number (i.e. all digits are 0..n-1).

<~~lang~~ haskell>import Control.Monad (forM_, replicateM)

<syntaxhighlight lang="haskell">import Control.Monad (forM_, replicateM)

import Data.Char (intToDigit)

Line 1,325:

. filter isSelfDescribing

. allBaseNNumsOfLength

<$> [1 .. 8]</~~lang~~>

<$> [1 .. 8]</syntaxhighlight>

Line 1,333:

The following program contains the procedure <code>is_self_describing</code> to test if a number is a self-describing number, and the procedure <code>self_describing_numbers</code> to generate them.

procedure count (test_item, str)

result := 0

Line 1,362:

every write (self_describing_numbers ()\4)

end

</syntaxhighlight>

</lang>

A slightly more concise solution can be derived from the above by taking

more advantage of Icon's (and Unicon's) automatic goal-directed

evaluation:

<~~lang~~ unicon>

procedure is_self_describing (n)

ns := string (n) # convert to a string

Line 1,377:

procedure self_describing_numbers ()

suspend is_self_describing(seq())

end</~~lang~~>

end</syntaxhighlight>

=={{header|J}}==

'''Solution''':<~~lang~~ j> digits =: 10&#.^:_1

'''Solution''':<syntaxhighlight lang="j"> digits =: 10&#.^:_1

counts =: _1 + [: #/.~ i.@:# , ]

selfdesc =: = counts&.digits"0 NB. Note use of "under"</~~lang~~>

selfdesc =: = counts&.digits"0 NB. Note use of "under"</syntaxhighlight>

'''Example''':<~~lang~~ j> selfdesc 2020 1210 21200 3211000 43101000 42101000

'''Example''':<syntaxhighlight lang="j"> selfdesc 2020 1210 21200 3211000 43101000 42101000

1 1 1 1 0 1</~~lang~~>

1 1 1 1 0 1</syntaxhighlight>

'''Extra credit''':<~~lang~~ j> I.@:selfdesc i. 1e6

'''Extra credit''':<syntaxhighlight lang="j"> I.@:selfdesc i. 1e6

1210 2020 21200</~~lang~~>

1210 2020 21200</syntaxhighlight>

'''Discussion''': The use of <tt>&.</tt> here is a great example of its surprisingly broad applicability, and the elegance it can produce.

Line 1,397:

=={{header|Java}}==

<~~lang~~ java>public class SelfDescribingNumbers{

<syntaxhighlight lang="java">public class SelfDescribingNumbers{

public static boolean isSelfDescribing(int a){

String s = Integer.toString(a);

Line 1,423:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|JavaScript}}==

<~~lang~~ javascript>function is_self_describing(n) {

<syntaxhighlight lang="javascript">function is_self_describing(n) {

var digits = Number(n).toString().split("").map(function(elem) {return Number(elem)});

var len = digits.length;

Line 1,455:

for (var i=1; i<=3300000; i++)

if (is_self_describing(i))

print(i);</~~lang~~>

print(i);</syntaxhighlight>

outputs

Line 1,465:

=={{header|jq}}==

<~~lang~~ jq># If your jq includes all/2 then comment out the following definition,

<syntaxhighlight lang="jq"># If your jq includes all/2 then comment out the following definition,

# which is slightly less efficient:

def all(generator; condition):

reduce generator as $i (true; if . then $i | condition else . end);</~~lang~~>

reduce generator as $i (true; if . then $i | condition else . end);</syntaxhighlight>

<~~lang~~ jq>def selfie:

<syntaxhighlight lang="jq">def selfie:

def count(value): reduce .[] as $i (0; if $i == value then . + 1 else . end);

def digits: tostring | explode | map(. - 48);

Line 1,477:

else . as $digits

| all ( range(0; length); . as $i | $digits | (.[$i] == count($i)) )

end;</~~lang~~>

end;</syntaxhighlight>

'''The task:'''

<~~lang~~ jq>range(0; 100000001) | select(selfie)</~~lang~~>

<syntaxhighlight lang="jq">range(0; 100000001) | select(selfie)</syntaxhighlight>

<~~lang~~ sh>$ jq -n -f Self-describing_numbers.jq

<syntaxhighlight lang="sh">$ jq -n -f Self-describing_numbers.jq

1210

2020

21200

3211000

42101000</~~lang~~>

42101000</syntaxhighlight>

=={{header|Julia}}==

<~~lang~~ julia>function selfie(x::Integer)

<syntaxhighlight lang="julia">function selfie(x::Integer)

ds = reverse(digits(x))

if sum(ds) != length(ds) return false end

Line 1,504:

selfies(x) = for i in 1:x selfie(i) && println(i) end

@time selfies(4000000)</~~lang~~>

@time selfies(4000000)</syntaxhighlight>

Line 1,514:

=={{header|K}}==

<~~lang~~ k> sdn: {n~+/'n=/:!#n:0$'$x}'

<syntaxhighlight lang="k"> sdn: {n~+/'n=/:!#n:0$'$x}'

sdn 1210 2020 2121 21200 3211000 42101000

1 1 0 1 1 1

&sdn@!:1e6

1210 2020 21200</~~lang~~>

1210 2020 21200</syntaxhighlight>

=={{header|Kotlin}}==

<~~lang~~ scala>// version 1.0.6

<syntaxhighlight lang="scala">// version 1.0.6

fun selfDescribing(n: Int): Boolean {

Line 1,542:

for (i in 0..99999999) if (selfDescribing(i)) print("$i ")

println()

}</~~lang~~>

}</syntaxhighlight>

Line 1,551:

=={{header|Liberty BASIC}}==

<~~lang~~ lb>'adapted from BASIC solution

<syntaxhighlight lang="lb">'adapted from BASIC solution

FOR x = 1 TO 5000000

a$ = TRIM$(STR$(x))

Line 1,569:

NEXT x

PRINT

PRINT "End"</~~lang~~>

PRINT "End"</syntaxhighlight>

=={{header|LiveCode}}==

<~~lang~~ ~~LiveCode~~>function selfDescNumber n

<syntaxhighlight lang="livecode">function selfDescNumber n

local tSelfD, tLen

put len(n) into tLen

Line 1,582:

end repeat

return tSelfD

end selfDescNumber</~~lang~~>

end selfDescNumber</syntaxhighlight>

To list the self-describing numbers to 10 million<~~lang~~ ~~LiveCode~~>on mouseUp

To list the self-describing numbers to 10 million<syntaxhighlight lang="livecode">on mouseUp

repeat with n = 0 to 10000000

if selfDescNumber(n) then

Line 1,591:

combine selfNum using comma

put selfNum

end mouseUp</~~lang~~>

end mouseUp</syntaxhighlight>

Output<lang ~~LiveCode~~>1210,2020,21200,3211000</~~lang~~>

Output<syntaxhighlight lang="livecode">1210,2020,21200,3211000</syntaxhighlight>

=={{header|Logo}}==

<~~lang~~ logo>TO XX

<syntaxhighlight lang="logo">TO XX

BT

MAKE "AA (ARRAY 10 0)

Line 1,620:

FOR [Z 0 9][SETITEM :Z :AA "0 SETITEM :Z :BB "0 ]]

PR [END]

END</~~lang~~>

END</syntaxhighlight>

=={{header|Lua}}==

<~~lang~~ lua>function Is_self_describing( n )

<syntaxhighlight lang="lua">function Is_self_describing( n )

local s = tostring( n )

Line 1,643:

for i = 1, 999999999 do

print( Is_self_describing( i ) )

end</~~lang~~>

end</syntaxhighlight>

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

<~~lang~~ ~~Mathematica~~>isSelfDescribing[n_Integer] := (RotateRight[DigitCount[n]] == PadRight[IntegerDigits[n], 10])</~~lang~~>

<syntaxhighlight lang="mathematica">isSelfDescribing[n_Integer] := (RotateRight[DigitCount[n]] == PadRight[IntegerDigits[n], 10])</syntaxhighlight>

<pre>Select[Range[10^10 - 1], isSelfDescribing]

-> {1210,2020,21200,3211000,42101000,521001000,6210001000}</pre>

=={{header|MATLAB}} / {{header|Octave}}==

<~~lang~~ ~~Matlab~~>function z = isSelfDescribing(n)

<syntaxhighlight lang="matlab">function z = isSelfDescribing(n)

s = int2str(n)-'0'; % convert to vector of digits

y = hist(s,0:9);

z = all(y(1:length(s))==s);

end;</~~lang~~>

end;</syntaxhighlight>

Test function:

<~~lang~~ ~~Matlab~~>for k = 1:1e10,

<syntaxhighlight lang="matlab">for k = 1:1e10,

if isSelfDescribing(k),

printf('%i\n',k);

end

end; </~~lang~~>

end; </syntaxhighlight>

Output:

Line 1,672:

=={{header|MiniScript}}==

<~~lang~~ ~~MiniScript~~>numbers = [12, 1210, 1300, 2020, 21200, 5]

<syntaxhighlight lang="miniscript">numbers = [12, 1210, 1300, 2020, 21200, 5]

occurrences = function(test, values)

Line 1,697:

end if

end for

</syntaxhighlight>

</lang>

<pre>

Line 1,711:

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

<~~lang~~ modula2>

MODULE SelfDescribingNumber;

Line 1,763:

WriteLn;

END SelfDescribingNumber.

</syntaxhighlight>

</lang>

<pre>

Line 1,778:

This is a brute-force algorithm. To speed-up, it uses integers instead of strings and the variable “digits” is allocated once, placed in global scope and accessed directly by the two functions (something I generally avoid). We have been able to check until 1_000_000_000.

<~~lang~~ nim>import algorithm, sequtils, std/monotimes, times

<syntaxhighlight lang="nim">import algorithm, sequtils, std/monotimes, times

type Digit = 0..9

Line 1,804:

echo n, " in ", getMonoTime() - t0

echo "\nTotal time: ", getMonoTime() - t0</~~lang~~>

echo "\nTotal time: ", getMonoTime() - t0</syntaxhighlight>

Line 1,817:

=={{header|ooRexx}}==

-- REXX program to check if a number (base 10) is self-describing.

parse arg x y .

Line 1,834:

say number "is a self describing number"

end

</syntaxhighlight>

</lang>

'''output''' when using the input of: <tt> 0 999999999 </tt>

Line 1,848:

=={{header|PARI/GP}}==

This is a finite set...

<~~lang~~ parigp>S=[1210, 2020, 21200, 3211000, 42101000, 521001000, 6210001000];

<syntaxhighlight lang="parigp">S=[1210, 2020, 21200, 3211000, 42101000, 521001000, 6210001000];

isself(n)=vecsearch(S,n)</~~lang~~>

isself(n)=vecsearch(S,n)</syntaxhighlight>

=={{header|Pascal}}==

<~~lang~~ pascal>Program SelfDescribingNumber;

<syntaxhighlight lang="pascal">Program SelfDescribingNumber;

uses

Line 1,894:

writeln (' ', x);

writeln('Job done.');

end.</~~lang~~>

end.</syntaxhighlight>

Output:

<pre>

Line 1,911:

The number is self-descriptive If the arrays are equal.

<~~lang~~ perl>sub is_selfdesc

<syntaxhighlight lang="perl">sub is_selfdesc

{

local $_ = shift;

Line 1,922:

for (0 .. 100000, 3211000, 42101000) {

print "$_\n" if is_selfdesc($_);

}</~~lang~~>

}</syntaxhighlight>

Output:

<pre>1210

Line 1,932:

=={{header|Phix}}==

with javascript_semantics

function self_desc(integer i)

Line 1,955:

end for

printf(1,"done (%s)\n",{elapsed(time()-t0)})

<pre>

Line 1,968:

Not quite as fast as I hoped it would be, although a bazillion times faster than the above and a good five times faster than Python, the following self(20) completes in just over a second whereas self(24) takes nearly 9s, and it continues getting exponentially slower after that. Curiously, it is the early stages (same output) that slow down, whereas the latter ones always complete fairly quickly.

with javascript_semantics

procedure impl(sequence d, c, integer m)

Line 2,001:

end procedure

self(20)

<pre>

Line 2,026:

Finishes in less than a tenth of a second

with javascript_semantics

constant string aleph = tagset('9','0')&tagset('z','a')&tagset('Z','A')

Line 2,064:

end for

?elapsed(time()-t0)

as above plus

Line 2,081:

Works with: PHP 5.

<~~lang~~ ~~PHP~~><?php

<syntaxhighlight lang="php"><?php

function is_describing($number) {

Line 2,098:

}

?></~~lang~~>

?></syntaxhighlight>

Output:

Line 2,111:

===Loop based approach===

<~~lang~~ ~~Picat~~>self_desc(Num,L) =>

L = [ I.to_integer() : I in Num.to_string()],

Len = L.len,

Line 2,123:

fail

end

end.</~~lang~~>

end.</syntaxhighlight>

===Constraint model 1===

Check if a number N is a self-describing number

<~~lang~~ ~~Picat~~>self_desc_cp(Num, Sequence) =>

<syntaxhighlight lang="picat">self_desc_cp(Num, Sequence) =>

N = length(Num.to_string()),

Line 2,139:

scalar_product({ I : I in 0..N-1}, Sequence, N),

solve([ffd,updown], Sequence).</~~lang~~>

solve([ffd,updown], Sequence).</syntaxhighlight>

===Constraint model 2===

Same idea as <code>self_desc_cp/2</code> but a different usage: generate all solutions of a specific length Len.

<~~lang~~ ~~Picat~~>self_desc_cp_len(Len, Num) =>

Sequence = new_list(Len),

Line 2,160:

to_num(List, Base, Num) =>

Len = length(List),

Num #= sum([List[I]*Base**(Len-I) : I in 1..Len]).</~~lang~~>

Num #= sum([List[I]*Base**(Len-I) : I in 1..Len]).</syntaxhighlight>

===Testing===

Testing some numbers using <code>self_desc_cp/2</code>:

<~~lang~~ ~~Picat~~>go =>

List = [1210, 2020, 21200, 3211000, 42101000,

123456,98,10,-121,0,1,

Line 2,171:

printf("%w: %w\n", N, cond(self_desc_cp(N,_S),"self desc", "not self desc"))

end,

nl.</~~lang~~>

nl.</syntaxhighlight>

Line 2,189:

===Generate all solutions of a specific length===

Using <code>self_desc_cp_len/3</code> to generates all solutions of length 1..13:

<~~lang~~ ~~Picat~~>go2 =>

Len :: 1..13,

println(findall(Num, (indomain(Len), self_desc_cp_len(Len,Num)))),

nl.

</syntaxhighlight>

</lang>

Line 2,207:

Here is one way to model this magic sequence problem.

<~~lang~~ ~~Picat~~>go3 ?=>

member(N, 4..1000),

magic_sequenceN,Seq),

Line 2,223:

sum(Sequence) #= N,

sum([I*Sequence[I+1] : I in 0..N-1]) #= N,

solve([ff,split], Sequence).</~~lang~~>

solve([ff,split], Sequence).</syntaxhighlight>

Line 2,267:

===Algorithmic approach===

Except for the self describing number 2020, these sequences can be found by the following "algorithmic" approach:

<~~lang~~ ~~Picat~~>magic_sequence_alg(N, Sequence) =>

<syntaxhighlight lang="picat">magic_sequence_alg(N, Sequence) =>

Sequence = new_list(N,0),

Sequence[1] := N - 4,

Sequence[2] := 2,

Sequence[3] := 1,

Sequence[N-3] := 1.</~~lang~~>

Sequence[N-3] := 1.</syntaxhighlight>

=={{header|PicoLisp}}==

<~~lang~~ ~~PicoLisp~~>(de selfDescribing (N)

<syntaxhighlight lang="picolisp">(de selfDescribing (N)

(fully '((D I) (= D (cnt = N (circ I))))

(setq N (mapcar format (chop N)))

(range 0 (length N)) ) )</~~lang~~>

(range 0 (length N)) ) )</syntaxhighlight>

Output:

<pre>: (filter selfDescribing (range 1 4000000))

Line 2,286:

According to the Wiki definition, the sum of the products of the index and the

digit contained at the index should equal the number of digits in the number:

function Test-SelfDescribing ([int]$Number)

{

Line 2,299:

$sum -eq $digits.Count

}

</syntaxhighlight>

</lang>

Test-SelfDescribing -Number 2020

</syntaxhighlight>

</lang>

<pre>

Line 2,308:

</pre>

It takes a very long while to test 100,000,000 numbers, and since they are already known just test a few:

11,2020,21200,321100 | ForEach-Object {

[PSCustomObject]@{

Line 2,315:

}

} | Format-Table -AutoSize

</syntaxhighlight>

</lang>

<pre>

Line 2,328:

=={{header|Prolog}}==

Works with SWI-Prolog and library clpfd written by Markus Triska.

<~~lang~~ ~~Prolog~~>:- use_module(library(clpfd)).

<syntaxhighlight lang="prolog">:- use_module(library(clpfd)).

self_describling :-

Line 2,434:

run(Var,[Other|RRest], [1, Var],[Other|RRest]):-

dif(Var,Other).</~~lang~~>

dif(Var,Other).</syntaxhighlight>

Output

Line 2,452:

=={{header|PureBasic}}==

<~~lang~~ ~~PureBasic~~>Procedure isSelfDescribing(x.q)

<syntaxhighlight lang="purebasic">Procedure isSelfDescribing(x.q)

;returns 1 if number is self-describing, otherwise it returns 0

Protected digitCount, digit, i, digitSum

Line 2,524:

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

EndIf</~~lang~~>

EndIf</syntaxhighlight>

Sample output:

<pre>1210 is selfdescribing.

Line 2,579:

=={{header|Python}}==

<~~lang~~ python>>>> def isSelfDescribing(n):

<syntaxhighlight lang="python">>>> def isSelfDescribing(n):

s = str(n)

return all(s.count(str(i)) == int(ch) for i, ch in enumerate(s))

Line 2,586:

[1210, 2020, 21200, 3211000]

>>> [(x, isSelfDescribing(x)) for x in (1210, 2020, 21200, 3211000, 42101000, 521001000, 6210001000)]

[(1210, True), (2020, True), (21200, True), (3211000, True), (42101000, True), (521001000, True), (6210001000, True)]</~~lang~~>

[(1210, True), (2020, True), (21200, True), (3211000, True), (42101000, True), (521001000, True), (6210001000, True)]</syntaxhighlight>

===Generator===

From [http://leetm.mingpao.com/cfm/Forum3.cfm?CategoryID=1&TopicID=1545&TopicOrder=Desc&TopicPage=1 here].

<~~lang~~ python>def impl(d, c, m):

<syntaxhighlight lang="python">def impl(d, c, m):

if m < 0: return

if d == c[:len(d)]: print d

Line 2,599:

def self(n): impl([], [0]*(n+1), n)

self(10)</~~lang~~>

self(10)</syntaxhighlight>

Output:

<pre>[]

Line 2,612:

=={{header|Quackery}}==

<~~lang~~ ~~Quackery~~> [ tuck over peek

<syntaxhighlight lang="quackery"> [ tuck over peek

1+ unrot poke ] is item++ ( n [ --> [ )

Line 2,633:

4000000 times

[ i^ self-desc if

[ i^ echo cr ] ]</~~lang~~>

[ i^ echo cr ] ]</syntaxhighlight>

Line 2,644:

=={{header|Racket}}==

<~~lang~~ ~~Racket~~>#lang racket

<syntaxhighlight lang="racket">#lang racket

(define (get-digits number (lst null))

(if (zero? number)

Line 2,657:

(and bool

(= (count (lambda (x) (= x i)) digits)

(list-ref digits i)))))))</~~lang~~>

(list-ref digits i)))))))</syntaxhighlight>

Sadly, the implementation is too slow for the optional task, taking somewhere around 3 minutes to check all numbers below 100.000.000

Line 2,663:

=={{header|Raku}}==

(formerly Perl 6)

<lang ~~perl6~~>my @values = <1210 2020 21200 3211000

<syntaxhighlight lang="raku" line>my @values = <1210 2020 21200 3211000

42101000 521001000 6210001000 27 115508>;

Line 2,683:

}

.say if .&sdn for ^9999999;</~~lang~~>

.say if .&sdn for ^9999999;</syntaxhighlight>

Output:

<pre>

Line 2,702:

=={{header|Red}}==

<~~lang~~ ~~Red~~>Red []

<syntaxhighlight lang="red">Red []

;;-------------------------------------

Line 2,732:

repeat i 4000000 [ if isSDN? to-string i [print i] ]

</syntaxhighlight>

</lang>

'''output'''

<pre>1210

Line 2,745:

  and   [http://oeis.org/A138480 OEIS A138480].

===digit by digit test===

<~~lang~~ rexx>/*REXX program determines if a number (in base 10) is a self─describing, */

<syntaxhighlight lang="rexx">/*REXX program determines if a number (in base 10) is a self─describing, */

/*────────────────────────────────────────────────────── self─descriptive, */

/*────────────────────────────────────────────────────── autobiographical, or a */

Line 2,770:

if substr(?,j,1)\==L-length(space(translate(?,,j-1),0)) then return 1

end /*j*/

return 0 /*faster if used inverted truth table. */</~~lang~~>

return 0 /*faster if used inverted truth table. */</syntaxhighlight>

<pre>

╔══════════════════════════════════════════════════════════════════╗

Line 2,793:

===faster method===

(Uses table lookup.)

<~~lang~~ rexx>/*REXX program determines if a number (in base 10) is a self-describing number.*/

<syntaxhighlight lang="rexx">/*REXX program determines if a number (in base 10) is a self-describing number.*/

parse arg x y . /*obtain optional arguments from the CL*/

if x=='' | x=="," then exit /*Not specified? Then get out of Dodge*/

Line 2,811:

say right(n,w) 'is a self-describing number.'

end /*n*/

/*stick a fork in it, we're all done. */</~~lang~~>

/*stick a fork in it, we're all done. */</syntaxhighlight>

'''output'''   is the same as the 1st REXX example.

Line 2,818:

(Results are instantaneous.)

<~~lang~~ rexx>/*REXX program determines if a number (in base 10) is a self-describing number.*/

<syntaxhighlight lang="rexx">/*REXX program determines if a number (in base 10) is a self-describing number.*/

parse arg x y . /*obtain optional arguments from the CL*/

if x=='' | x=="," then exit /*Not specified? Then get out of Dodge*/

Line 2,834:

if _<x | _>y then iterate /*if not self-describing, try again. */

say right(_, w) 'is a self-describing number.'

end /*n*/ /*stick a fork in it, we're all done. */</~~lang~~>

end /*n*/ /*stick a fork in it, we're all done. */</syntaxhighlight>

'''output'''   is the same as the 1st REXX example.

=={{header|Ring}}==

<~~lang~~ ring>

# Project : Self-describing numbers

Line 2,864:

end

return sum

</syntaxhighlight>

</lang>

Output:

<pre>

Line 2,875:

=={{header|Ruby}}==

<~~lang~~ ruby>def self_describing?(n)

<syntaxhighlight lang="ruby">def self_describing?(n)

digits = n.digits.reverse

digits.each_with_index.all?{|digit, idx| digits.count(idx) == digit}

end

3_300_000.times {|n| puts n if self_describing?(n)}</~~lang~~>

3_300_000.times {|n| puts n if self_describing?(n)}</syntaxhighlight>

outputs

<pre>1210

Line 2,888:

<~~lang~~ ruby>def selfDesc(n)

<syntaxhighlight lang="ruby">def selfDesc(n)

ns = n.to_s

nc = ns.size

Line 2,937:

end

osecs = (Time.now - start)

print("\nTook #{osecs} secs overall")</~~lang~~>

print("\nTook #{osecs} secs overall")</syntaxhighlight>

System: I7-6700HQ, 3.5 GHz, Linux Kernel 5.6.17, Ruby 2.7.1

Line 2,979:

=={{header|Run BASIC}}==

<~~lang~~ ~~Runbasic~~>for i = 0 to 50000000 step 10

<syntaxhighlight lang="runbasic">for i = 0 to 50000000 step 10

a$ = str$(i)

for c = 1 TO len(a$)

Line 2,995:

next i

print "== End =="

end</~~lang~~>

end</syntaxhighlight>

=={{header|Rust}}==

<~~lang~~ rust>

fn is_self_desc(xx: u64) -> bool

{

Line 3,021:

}

</syntaxhighlight>

</lang>

=={{header|Scala}}==

===Functional Programming===

<~~lang~~ ~~Scala~~>object SelfDescribingNumbers extends App {

<syntaxhighlight lang="scala">object SelfDescribingNumbers extends App {

def isSelfDescribing(a: Int): Boolean = {

val s = Integer.toString(a)

Line 3,038:

println("Successfully completed without errors.")

}</~~lang~~>

}</syntaxhighlight>

See it running in your browser by [https://scastie.scala-lang.org/vQv61PpoSLeWwyVipLUevQ Scastie (JVM)].

=={{header|Seed7}}==

<~~lang~~ seed>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed">$ include "seed7_05.s7i";

const func boolean: selfDescr (in string: stri) is func

Line 3,108:

gen(number);

end for;

end func;</~~lang~~>

end func;</syntaxhighlight>

Output:

Line 3,131:

=={{header|Sidef}}==

<~~lang~~ ruby>func sdn(Number n) {

<syntaxhighlight lang="ruby">func sdn(Number n) {

var b = [0]*n.len

var a = n.digits.flip

Line 3,146:

say "\nSelf-descriptive numbers less than 1e5 (in base 10):"

^1e5 -> each { |i| say i if sdn(i) }</~~lang~~>

^1e5 -> each { |i| say i if sdn(i) }</syntaxhighlight>

<pre>

Line 3,166:

'''Extra credit:''' this will generate all the self-describing numbers in bases 7 to 36:

<~~lang~~ ruby>for b in (7 .. 36) {

<syntaxhighlight lang="ruby">for b in (7 .. 36) {

var n = ((b-4) * b**(b-1) + 2*(b**(b-2)) + b**(b-3) + b**3 -> base(b))

say "base #{'%2d' % b}: #{n}"

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 3,206:

=={{header|Swift}}==

<~~lang~~ swift>import Foundation

<syntaxhighlight lang="swift">import Foundation

extension BinaryInteger {

Line 3,238:

}

dispatchMain()</~~lang~~>

dispatchMain()</syntaxhighlight>

Line 3,250:

=={{header|Tcl}}==

<~~lang~~ tcl>package require Tcl 8.5

<syntaxhighlight lang="tcl">package require Tcl 8.5

proc isSelfDescribing num {

set digits [split $num ""]

Line 3,265:

for {set i 0} {$i < 100000000} {incr i} {

if {[isSelfDescribing $i]} {puts $i}

}</~~lang~~>

}</syntaxhighlight>

=={{header|UNIX Shell}}==

Seeking self-describing numbers up to 100,000,000 is very time consuming, so we'll just verify a few numbers.

<~~lang~~ bash>selfdescribing() {

<syntaxhighlight lang="bash">selfdescribing() {

local n=$1

local count=()

Line 3,289:

printf "%d\t%s\n" $n no

fi

done</~~lang~~>

done</syntaxhighlight>

<pre>0 no

Line 3,304:

Takes a very, very long time to check 100M numbers that I have to terminate the script. But the function

works.

Function IsSelfDescribing(n)

IsSelfDescribing = False

Line 3,344:

end_time = Now

WScript.StdOut.WriteLine "Elapse Time: " & DateDiff("s",start_time,end_time) & " seconds"

</syntaxhighlight>

</lang>

=={{header|Wren}}==

Heavily optimized to complete the search in a reasonable time for a scripting language.

<~~lang~~ ecmascript>var selfDesc = Fn.new { |n|

<syntaxhighlight lang="ecmascript">var selfDesc = Fn.new { |n|

var ns = "%(n)"

var nc = ns.count

Line 3,397:

}

var osecs = ((System.clock - start) * 10).round / 10

System.print("\nTook %(osecs) secs overall")</~~lang~~>

System.print("\nTook %(osecs) secs overall")</syntaxhighlight>

Line 3,415:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>code ChOut=8, IntOut=11;

<syntaxhighlight lang="xpl0">code ChOut=8, IntOut=11;

func SelfDesc(N); \Returns 'true' if N is self-describing

Line 3,449:

int N;

for N:= 0 to 100_000_000-1 do

if SelfDesc(N) then [IntOut(0, N); ChOut(0, ^ )]</~~lang~~>

if SelfDesc(N) then [IntOut(0, N); ChOut(0, ^ )]</syntaxhighlight>

Output:

Line 3,458:

=={{header|Yabasic}}==

<~~lang~~ ~~Yabasic~~>FOR N = 1 TO 5E7

<syntaxhighlight lang="yabasic">FOR N = 1 TO 5E7

IF FNselfdescribing(N) PRINT N

Line 3,477:

FOR I = 0 TO 8 : L = L + D(I) : NEXT

RETURN O = L

END SUB</~~lang~~>

END SUB</syntaxhighlight>

=={{header|zkl}}==

<~~lang~~ zkl>fcn isSelfDescribing(n){

<syntaxhighlight lang="zkl">fcn isSelfDescribing(n){

if (n.bitAnd(1)) return(False); // Wikipedia: last digit must be zero

nu:= n.toString();

ns:=["0".."9"].pump(String,nu.inCommon,"len"); //"12233".inCommon("2")-->"22"

(nu+"0000000000")[0,10] == ns; //"2020","2020000000"

}</~~lang~~>

}</syntaxhighlight>

Since testing a humongous number of numbers is slow, chunk the task into a bunch of threads. Even so, it pegged my 8 way Ivy Bridge Linux box for quite some time (eg the Python & AWK solutions crush this one).

<~~lang~~ zkl>//[1..0x4_000_000].filter(isSelfDescribing).println();

<syntaxhighlight lang="zkl">//[1..0x4_000_000].filter(isSelfDescribing).println();

const N=0d500_000;

[1..0d100_000_000, N] // chunk and thread, 200 in this case

.apply(fcn(n){ n.filter(N,isSelfDescribing) }.future)

.filter().apply("noop").println();</~~lang~~>

.filter().apply("noop").println();</syntaxhighlight>

A future is a thread returning a [delayed] result, future.filter/future.noop will block until the future coughs up the result. Since the results are really sparse for the bigger numbers, filter out the empty results.