Narcissistic decimal number: Difference between revisions

{{trans|Python}}

[Int] result

L(digits) 0..

print(n, end' ‘ ’)

I (L.index + 1) % 5 == 0

{{out}}

=={{header|Ada}}==

procedure Narcissistic is

Current := Current + 1;

end loop;

{{out}}

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

# print the first 25 narcissistic numbers

io.writeline()

{{out}}

<pre>

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

# returns TRUE if n is narcissitic, FALSE otherwise; n should be >= 0 #

FI

OD;

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|Agena}}

% print the first 25 narcissistic numbers %

write()

{{out}}

<pre>

=={{header|APL}}==

∇r ← digitsOf n;digitList

digitList ← ⍬

getASN 25

0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315

=={{header|AppleScript}}==

For an imperative hand-optimisation, and a contrasting view, see the variant approach below :-)

-- isDaffodil :: Int -> Int -> Bool

end script

end if

{{Out}}

----

When corrected actually to return the 25 numbers required by the task, the JavaScript/Haskell translation above takes seven minutes fifty-three seconds on my current machine. By contrast, the code here was written from scratch in AppleScript, takes the number of results required as its parameter rather than the numbers of digits in them, and returns the 25 numbers in just under a sixth of a second. The first 41 numbers take just under four-and-a-half seconds, the first 42 twenty-seven, and the first 44 a minute thirty-seven-and-a-half. The 43rd and 44th numbers are both displayed in Script Editor's result pane as 4.33828176939137E+15, but appear to be the correct values when tested. The JavaScript/Haskell translation's problems are certainly ''not'' due to AppleScript being "a little out of its depth here", but the narcissistic decimal numbers beyond the 44th are admittedly beyond the resolution of AppleScript's number classes.

Return the first q narcissistic decimal numbers

(or as many of the q as can be represented by AppleScript number values).

end narcissisticDecimalNumbers

{{output}}

=={{header|Arturo}}==

{{trans|REXX}}

map 0..9 'y [

x ^ y

]

inc 'i

{{out}}

=={{header|AutoHotkey}}==

#NoEnv ; Do not try to use environment variables

SetBatchLines, -1 ; Execute as quickly as you can

}

}

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f NARCISSISTIC_DECIMAL_NUMBER.AWK

BEGIN {

exit(0)

}

<p>output:</p>

<pre>

This can take several minutes to complete in most interpreters, so it's probably best to use a compiler if you want to see the full sequence.

>1>+>^v\_^#!:<p01p00:+1<>\>

>#-_>\>20p110g>\20g*\v>1-v|

{{out}}

<code>B10</code> is a BQNcrate idiom to get the digits of a number.

IsNarc ← {𝕩=+´⋆⟜≠B10 𝕩}

A much faster method is to generate a list of digit sums as addition tables (<code>+⌜</code>). A different list of digit sums is generated for each digit count, 0 to 7. To avoid leading 0s, 0 is removed from the first digit list with <code>(0=↕)↓¨</code>. Then all that needs to be done is to join the lists and return locations where the index (number) and value (digit power sum) are equal.

=={{header|C}}==

The following prints the first 25 numbers, though not in order...

#include <gmp.h>

return 0;

{{out}}

<pre>

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

using System;

}

}

{{out}}

<pre>

</pre>

===or===

//Narcissistic numbers: Nigel Galloway: February 17th., 2015

using System;

}

}

{{out}}

<pre>

{{libheader|System.Numerics}}

{{trans|FreeBASIC}} (FreeBASIC, GMP version)<br/>Why stop at 25? Even using '''ulong''' instead of '''int''' only gets one to the 44th item. The 89th (last) item has 39 digits, which '''BigInteger''' easily handles. Of course, the BigInteger implementation is slower than native data types. But one can compensate a bit by calculating in parallel. Not bad, it can get all 89 items in under 7 1/2 minutes on a core i7. The calculation to the 25th item takes a fraction of a second. The calculation for all items up to 25 digits long (67th item) takes about half a minute with sequential processing and less than a quarter of a minute using parallel processing. Note that parallel execution involves some overhead, and isn't a time improvement unless computing around 15 digits or more. This program can test all numbers up to 61 digits in under half an hour, of course the highest item found has only 39 digits.

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}(with command line parameter = "39")

<pre style="height:30ex;overflow:scroll">Calculations in parallel... 7 6 5 4 3 2 1 11 10 9 8 15 14 13 12 19 18 17 16 23 22 20 21 26 27 25 24 30 31 29 34 28 35 38 33 39 32 37 36

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

#include <iostream>

#include <vector>

return system( "pause" );

}

{{out}}

<pre>

=={{header|Clojure}}==

Find N first Narcissistic numbers.

(ns narcissistic.core

(:require [clojure.math.numeric-tower :as math]))

(defn firstNnarc [n] ;;list of the first "n" Narcissistic numbers.

(take n (filter narcissistic? (range))))

{{out}}

by Average-user

=={{header|COBOL}}==

PROGRAM-ID. NARCISSIST-NUMS.

DATA DIVISION.

END PROGRAM NARCISSIST-NUMS.

{{out}}

=={{header|Common Lisp}}==

(defun integer-to-list (n)

(map 'list #'digit-char-p (prin1-to-string n)))

counting (narcissisticp c) into narcissistic

do (if (narcissisticp c) (print c))))

{{out}}

<pre>

=={{header|D}}==

===Simple Version===

import std.stdio, std.algorithm, std.conv, std.range;

writefln("%(%(%d %)\n%)",

uint.max.iota.filter!isNarcissistic.take(25).chunks(5));

{{out}}

<pre>0 1 2 3 4

===Fast Version===

{{trans|Python}}

uint[] narcissists(in uint m) pure nothrow @safe {

void main() {

writefln("%(%(%d %)\n%)", 25.narcissists.chunks(5));

With LDC2 compiler prints the same output in less than 0.3 seconds.

===Faster Version===

{{trans|C}}

struct Narcissistics(TNum, uint maxLen) {

foreach (immutable i; 1 .. maxLength + 1)

narc.show(i);

{{out}}

<pre>length 1: 9 8 7 6 5 4 3 2 1 0

=={{header|Elixir}}==

{{trans|D}}

def narcissistic(m) do

Enum.reduce(1..10, [0], fn digits,acc ->

catch

x -> IO.inspect x

{{out}}

=={{header|ERRE}}==

!$DOUBLE

N=N+1

END LOOP

Output

<pre>

=={{header|F Sharp|F#}}==

//Naïve solution of Narcissitic number: Nigel Galloway - Febryary 18th., 2015

open System

let d = _Digits (n, [])

d |> List.fold (fun a l -> a + int ((float l) ** (float (List.length d)))) 0 = n) |> Seq.take(25) |> Seq.iter (printfn "%A")

{{out}}

<pre>

=={{header|Factor}}==

math.text.utils prettyprint sequences ;

IN: rosetta-code.narcissistic-decimal-number

: main ( -- ) first25 [ pprint bl ] each ;

{{out}}

<pre>

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

: dig.num \ returns input number and the number of its digits ( n -- n n1 )

dup

25 narc.num

{{out}}

<pre>

=={{header|FreeBASIC}}==

===Simple Version===

' compile with: fbc -s console

' can go up to 18 digits (ulongint is 64bit), above 18 overflow will occur

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>9

<pre>It takes about 35 min. to find all 88 numbers (39 digits).

To go all the way it takes about 2 hours.</pre>

' uses gmp

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

Left side: program output, right side: sorted on length, value

=={{header|FunL}}==

power = 1

powers = array( 0..9 )

narc( start )

{{out}}

=={{header|Go}}==

Nothing fancy as it runs in a fraction of a second as-is.

import "fmt"

func main() {

fmt.Println(narc(25))

{{out}}

<pre>

{{trans|FreeBASIC}}

Maximum for N (double) is14 digits, there are no 15 digits numbers

2 FOR A = 0 TO 9 : X2(A) = A : NEXT A

3 FOR N = 1 TO 7

29 PRINT

30 PRINT "done"

{{out}}

<pre> 9 8 7 6 5

=={{header|Haskell}}==

===Exhaustive search (integer series)===

isNarcissistic :: Int -> Bool

main :: IO ()

===Reduced search (unordered digit combinations)===

In this way we can find the 25th narcissistic number after '''length $ concatMap digitPowerSums [1 .. 7] == 19447''' tests – an improvement on the exhaustive trawl through '''9926315''' integers.

narcissiOfLength :: Int -> [Int]

w = maximum (length . xShow <$> xs)

in unlines $

{{Out}}

<pre>Narcissistic decimal numbers of length 1-7:

The following is a quick, dirty, and slow solution that works in both languages:

limit := integer(A[1]) | 25

every write(isNarcissitic(seq(0))\limit)

every (sum := 0) +:= (!sn)^m

return sum = n

Sample run:

=={{header|J}}==

'''Example Usage'''

=={{header|Java}}==

{{works with|Java|1.5+}}

public static boolean isNarc(long x){

if(x < 0) return false;

}

}

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315 </pre>

{{works with|Java|1.8}}

The statics and the System.exit(0) stem from having first developed a version that is not limited by the amount of narcisstic numbers that are to be calculated. I then read that this is a criterion and thus the implementation is an afterthought and looks awkwardish... but still... works!

import java.util.stream.IntStream;

public class NarcissisticNumbers {

});

}

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315 </pre>

===ES5===

{{trans|Java}}

var str = x.toString(),

i,

}

return n.join(' ');

{{out}}

<pre>"0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315"</pre>

===ES6===

====Exhaustive search (integer series)====

'use strict';

)

.narc

{{Out}}

(Generating the unordered digit combinations directly as power sums allows faster testing later, and needs less space)

'use strict';

// MAIN ---

return main();

{{Out}}

<pre>Narcissistic decimal numbers of lengths [1..7]:

A function for checking whether a given non-negative integer is narcissistic could be implemented in jq as follows:

def digits: tostring | explode[] | [.] | implode | tonumber;

def pow(n): . as $x | reduce range(0;n) as $i (1; . * $x);

(tostring | length) as $len

| . == reduce digits as $d (0; . + ($d | pow($len)) )

In the following, this definition is modified to avoid recomputing (d ^ i). This is accomplished introducing the array [i, [0^i, 1^i, ..., 9^i]].

To update this array for increasing values of i, the function powers(j) is defined as follows:

# Output: [j, [0^j, 1^j, 2^j, ..., 9^j]]

# provided j is i or (i+1)

else .[0] += 1

| reduce range(0;10) as $k (.; .[1][$k] *= $k)

The function is_narcisstic can now be modified to use powers(j) as follows:

def is_narcissistic:

def digits: tostring | explode[] | [.] | implode | tonumber;

| if . < 0 then false

else . == reduce digits as $d (0; . + $powers[$d] )

'''The task'''

def while(cond; update):

def _while: if cond then ., (update | _while) else empty end;

| "\(.[2]): \(.[0])" ;

{{out}}

1: 0

2: 1

23: 4210818

24: 9800817

=={{header|Julia}}==

This easy to implement brute force technique is plenty fast enough to find the first few Narcissistic decimal numbers.

function isnarcissist(n, b=10)

findnarcissist()

@time findnarcissist(true)

<pre>

Finding the first 25 Narcissistic numbers:

=={{header|Kotlin}}==

fun isNarcissistic(n: Int): Boolean {

}

while (count < 25)

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

_isnarcissist ${i} ; (( $? )) && printf "%3d. %d\n" $(( ++cnt )) ${i}

done

{{out}}<pre>

1. 0

=={{header|Lua}}==

This is a simple/naive/slow method but it still spits out the requisite 25 in less than a minute using LuaJIT on a 2.5 GHz machine.

local m, sum, digit = string.len(n), 0

for pos = 1, m do

end

n = n + 1

{{out}}

<pre>

=={{header|Maple}}==

Narc:=proc(i)

end do:

NDN;

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

narc[n_] := narc[n] = NestWhile[# + 1 &, narc[n - 1] + 1, Plus @@ (IntegerDigits[#]^IntegerLength[#]) != # &];

{{out}}

<pre>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084, 548834, 1741725, 4210818, 9800817, 9926315}</pre>

=={{header|MATLAB}}==

x = 0;

c = 0;

dig = sprintf('%d', n) - '0';

tf = n == sum(dig.^length(dig));

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315</pre>

=={{header|Nanoquery}}==

digits = {}

for digit in str(num)

print num + " "

end

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315 </pre>

=={{header|Nim}}==

A simple solution which runs in about one second.

func digits(n: Natural): seq[int] =

m *= 10

{{out}}

=={{header|Oforth}}==

| i m |

n 0 while( n ) [ n 10 /mod ->n swap 1 + ] ->m

ListBuffer new dup ->l

0 while(l size n <>) [ dup isNarcissistic ifTrue: [ dup l add ] 1 + ] drop ;

{{out}}

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

Naive code, could be improved by splitting the digits in half and meeting in the middle.

{{out}}

<pre>%1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084, 548834, 1741725, 4210818, 9800817, 9926315, 24678050]</pre>

A recursive version starting at the highest digit and recurses to digit 0. Bad runtime. One more digit-> 10x runtime

runtime ~ 10^(count of Digits).

program NdN;

//Narcissistic decimal number

NextPowDig;

end;

;output:

<pre>

recursive solution.Just counting the different combination of digits<BR>

See [[Combinations_with_repetitions]]<BR>

{$IFDEF FPC}

{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$COPERATORS ON}

{$ENDIF}

end.

{{out|@TIO.RUN}}

<pre style="height:180px">

=={{header|Perl}}==

Simple version using a naive predicate.

sub is_narcissistic ($n) {

}

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315</pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">narcissistic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

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

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

At least 100 times faster, gets the first 47 (the native precision limit) before the above gets the first 25.<br>

I tried a gmp version, but it was 20-odd times slower, presumably because it uses that mighty sledgehammer for many small int cases.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000080;font-style:italic;">-- Begin with zero, which is narcissistic by definition and is never the only digit used in other numbers.</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)</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;">"found %d in %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(loop

(when

(T (=0 C) 'done) ) )

=={{header|PL/I}}==

===version 1===

{{trans|REXX}}

Dcl (j,k,l,nn,n,sum) Dec Fixed(15)init(0);

Dcl s Char(15) Var;

Return(result);

End

{{out}}

<pre> 1 narcissistic: 0 0 16:10:17.586

===version 2===

Precompiled powers

narn3: Proc Options(main);

Dcl (i,j,k,l,nn,n,sum) Dec Fixed(15)init(0);

Return(result);

End;

{{out}}

<pre> 1 narcissistic: 0 0 00:41:43.632

=={{header|PowerShell}}==

function Test-Narcissistic ([int]$Number)

{

$narcissisticNumbers | Format-Wide {"{0,7}" -f $_} -Column 5 -Force

{{Out}}

<pre>

This solution pre-computes the powers once.

from itertools import count, islice

print(n, end=' ')

if i % 5 == 0: print()

{{out}}

{{trans|D}}

import psyco

psyco.full()

narc.show(i)

{{out}}

<pre>length 1: 9 8 7 6 5 4 3 2 1 0

{{Trans|Haskell}}{{Trans|JavaScript}}

{{Works with|Python|3.7}}

from itertools import chain

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Narcissistic numbers of digit lengths 1 to 7:

=={{header|Quackery}}==

[ 10 /mod

rot join swap

[ tuck join swap ]

1+ over size 25 = until ]

{{out}}

===For loop solution===

This is a slow method and it needed above 5 minutes on a i3 machine.

j <- nchar(u)

set2 <- c()

}

if (sum(control) == u) print(u)

{{out}}

<pre>

*As we are using format anyway, we take the chance to make the output look nicer.

{

resultCount <- i <- 0

}

}

{{out}}

<pre>Armstrong number 1: 0

=={{header|Racket}}==

;; definitions.

;;

(n (sequence-filter narcissitic? (in-naturals 1)))) n)

'(1 2 3 4 5 6 7 8 9 153 370 371))

{{out}}

===Faster Version===

This version uses lists of digits, rather than numbers themselves.

(define (non-decrementing-digital-sequences L)

(define (inr d l)

(check-equal? (narcissitic-numbers-of-length<= 1) '(0 1 2 3 4 5 6 7 8 9))

{{out}}

===Simple, with concurrency===

Simple implementation is not exactly speedy, but concurrency helps move things along.

my @N = lazy (0..∞).hyper.grep: *.&is-narcissistic;

{{out}}

<pre>0 1 2 3 4 5 6 7 8 9 153 370 371 407 1634 8208 9474 54748 92727 93084 548834 1741725 4210818 9800817 9926315</pre>

===Single-threaded, with precalculations===

This version that precalculates the values for base 1000 digits, but despite the extra work ends up taking more wall-clock time than the simpler version.

my int $i = $n;

my int $b = 1000;

say $l++, "\t", $_ if .&is-narcissistic for 10**($d-1) ..^ 10**$d;

last if $l > 25

{{out}}

<pre>1 0

=={{header|REXX}}==

===idiomatic===

numeric digits 39 /*be able to handle largest Armstrong #*/

parse arg N . /*obtain optional argument from the CL.*/

#=# + 1 /*bump count of narcissistic numbers. */

say right(#, 9) ' narcissistic:' j /*display index and narcissistic number*/

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

<pre>

It is about &nbsp; '''77%''' &nbsp; faster then 1^st REXX version.

numeric digits 39 /*be able to handle largest Armstrong #*/

parse arg N . /*obtain optional argument from the CL.*/

#=# + 1 /*bump count of narcissistic numbers. */

say right(#, 9) ' narcissistic:' j /*display index and narcissistic number*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

It is about &nbsp; &nbsp; '''44%''' &nbsp; faster then 2^nd REXX version, &nbsp; and

<br>it is about &nbsp; '''154%''' &nbsp; faster then 1^st REXX version.

numeric digits 39 /*be able to handle largest Armstrong #*/

parse arg N . /*obtain optional argument from the CL.*/

say right(#,9) ' narcissistic:' arg(1) /*display index and narcissistic number*/

if #==n & n<11 then exit /*finished showing of narcissistic #'s?*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

<br>it is about &nbsp; '''136%''' &nbsp; faster then 2^nd REXX version, &nbsp; and

<br>it is about &nbsp; '''317%''' &nbsp; faster then 1^st REXX version.

numeric digits 39 /*be able to handle largest Armstrong #*/

parse arg N . /*obtain optional argument from the CL.*/

say right(#,9) ' narcissistic:' arg(1) /*display index and narcissistic number*/

if #==n & n<11 then exit /*finished showing of narcissistic #'s?*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

=={{header|Ring}}==

n = 0

count = 0

nr = (sum = n)

return nr

=={{header|Ruby}}==

def narcissistic?

return false if negative?

end

{{out}}

<pre>

=={{header|Rust}}==

fn is_narcissistic(x: u32) -> bool {

let digits: Vec<u32> = x

}

}

{{out}}

<pre>

{{works with|Scala|2.9.x}}

val narc: Int => Int = n => (n.toString map (_.asDigit) map (math.pow(_, n.toString.size)) sum) toInt

println((Iterator from 0 filter isNarc take 25 toList) mkString(" "))

Output:

=={{header|Sidef}}==

n.digits »**» n.len -> sum == n

}

break if (count == 25)

}

{{out}}

<pre>

=={{header|Swift}}==

@inlinable

public var isNarcissistic: Bool {

let narcs = Array((0...).lazy.filter({ $0.isNarcissistic }).prefix(25))

{{out}}

=={{header|Tcl}}==

set m [string length $n]

for {set t 0; set N $n} {$N} {set N [expr {$N / 10}]} {

}

{{out}}

<pre>

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

{{works with|ksh93}}

integer n=$1 len=${#n} sum=0 i

for ((i=0; i<len; i++)); do

done

echo "${nums[*]}"

{{output}}

=={{header|VBA}}==

Dim d As String: d = CStr(n)

Dim l As Integer: l = Len(d)

Loop

Debug.Print Join(s, ", ")

<pre>0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084, 548834, 1741725, 4210818, 9800817, 9926315</pre>

=={{header|VBScript}}==

i = 0

j = 0

End Function

{{out}}

<pre>0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474, 54748, 92727, 93084, 548834, 1741725, 4210818, 9800817, 9926315,</pre>

=={{header|Wren}}==

{{trans|Go}}

var power = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

var limit = 10

}

{{out}}

=={{header|XPL0}}==

This is based on Ring's version for Own Digits Power Sum.

int A, B, T, I;

[T:= 1;

];

];

{{out}}

=={{header|zkl}}==

ns,m := n.split(), ns.len() - 1;

ns.reduce('wrap(s,d){ z:=d; do(m){z*=d} s+z },0) == n

Pre computing the first 15 powers of 0..9 for use as a look up table speeds things up quite a bit but performance is pretty underwhelming.

(1).pump(15,List,'wrap(p){ n.toFloat().pow(p).toInt() }) });

fcn isNarcissistic2(n){

m:=(n.numDigits - 1);

n.split().reduce('wrap(s,d){ s + powers[d][m] },0) == n

Now stick a filter on a infinite lazy sequence (ie iterator) to create an infinite sequence of narcissistic numbers (iterator.filter(n,f) --> n results of f(i).toBool()==True).

ns(15).println();

ns(5).println();

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

Array index starts at 1. Only 1 character long variable names are allowed for For-Next loops. 8 Digits or higher numbers are displayed as floating point numbers. Needs about 2 hours (3.5Mhz)

2 FOR Y=0 TO 9: LET M(Y+1)=Y: NEXT Y

3 FOR N=1 TO 7

37 NEXT N

38 PRINT

{{out}}

<pre>9 8