Smith numbers: Difference between revisions

Line 30:

<~~lang~~ 11l>F factors(=n)

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

[Int] rt

V f = 2

Line 77:

print()

print(‘Last 12 Smith Numbers below 10000:’)

print_elements(sn[(len)-12..])</~~lang~~>

print_elements(sn[(len)-12..])</syntaxhighlight>

Line 92:

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

<~~lang~~ 360asm>* Smith numbers - 02/05/2017

<syntaxhighlight lang="360asm">* Smith numbers - 02/05/2017

SMITHNUM CSECT

USING SMITHNUM,R13 base register

Line 238:

XDEC DS CL12 temp

YREGS

END SMITHNUM</~~lang~~>

END SMITHNUM</syntaxhighlight>

<pre>

Line 270:

=={{header|Action!}}==

Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.

<~~lang~~ ~~Action~~!>CARD FUNC SumDigits(CARD n)

<syntaxhighlight lang="action!">CARD FUNC SumDigits(CARD n)

CARD res,a

Line 320:

Poke(77,0) ;turn off the attract mode

OD

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Smith_numbers.png Screenshot from Atari 8-bit computer]

Line 344:

=={{header|Ada}}==

<~~lang~~ ada>

with Ada.Text_IO;

Line 372:

end loop;

end smith;

</syntaxhighlight>

</lang>

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

<~~lang~~ algol68># sieve of Eratosthene: sets s[i] to TRUE if i is prime, FALSE otherwise #

<syntaxhighlight lang="algol68"># sieve of Eratosthene: sets s[i] to TRUE if i is prime, FALSE otherwise #

PROC sieve = ( REF[]BOOL s )VOID:

BEGIN

Line 447:

OD;

print( ( newline, "THere are ", whole( smith count, -7 ), " Smith numbers below ", whole( max number, -7 ), newline ) )

</syntaxhighlight>

</lang>

<pre>

Line 460:

=={{header|Arturo}}==

<~~lang~~ rebol>digitSum: function [v][

<syntaxhighlight lang="rebol">digitSum: function [v][

n: new v

result: new 0

Line 483:

]

print ""</~~lang~~>

print ""</syntaxhighlight>

Line 527:

=={{header|AWK}}==

# syntax: GAWK -f SMITH_NUMBERS.AWK

# converted from C

Line 605:

return(sum)

}

</syntaxhighlight>

</lang>

<pre>

Line 636:

=={{header|BASIC}}==

<~~lang~~ gwbasic>10 DEFINT A-Z

<syntaxhighlight lang="gwbasic">10 DEFINT A-Z

20 DIM F(32)

30 FOR I=2 TO 9999

Line 656:

190 NEXT

200 PRINT

210 PRINT "Found";C;"Smith numbers."</~~lang~~>

210 PRINT "Found";C;"Smith numbers."</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 685:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

// Find the sum of the digits of N

Line 736:

$)

writef("*NFound %N Smith numbers.*N", count)

$)</~~lang~~>

$)</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 766:

=={{header|C}}==

#include <stdlib.h>

#include <stdio.h>

Line 845:

return 0;

}

</syntaxhighlight>

</lang>

<pre>

Line 877:

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

<~~lang~~ csharp>using System;

<syntaxhighlight lang="csharp">using System;

using System.Collections.Generic;

Line 933:

}

}</~~lang~~>

}</syntaxhighlight>

<pre> 4 22 27 58 85 94 166 202

Line 984:

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

<~~lang~~ cpp>

#include <iostream>

#include <vector>

Line 1,030:

return 0;

}

</syntaxhighlight>

</lang>

<pre>

Line 1,041:

=={{header|Clojure}}==

<~~lang~~ clojure>(defn divisible? [a b]

<syntaxhighlight lang="clojure">(defn divisible? [a b]

(zero? (mod a b)))

Line 1,066:

(sum-digits (clojure.string/join "" (prime-factors n))))))

(filter smith-number? (range 1 10000))</~~lang~~>

(filter smith-number? (range 1 10000))</syntaxhighlight>

Line 1,076:

=={{header|CLU}}==

<~~lang~~ clu>% Get all digits of a number

<syntaxhighlight lang="clu">% Get all digits of a number

digits = iter (n: int) yields (int)

while n > 0 do

Line 1,137:

end

stream$putl(po, "\nFound " || int$unparse(count) || " Smith numbers.")

end start_up</~~lang~~>

end start_up</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 1,166:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

typedef N is uint16; # 16-bit math is good enough

Line 1,247:

print("Found ");

print_i32(count as uint32);

print(" Smith numbers.\n");</~~lang~~>

print(" Smith numbers.\n");</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 1,277:

=={{header|D}}==

{{trans|Java}} mostly

<~~lang~~ D>import std.stdio;

<syntaxhighlight lang="d">import std.stdio;

void main() {

Line 1,329:

}

return sum;

}</~~lang~~>

}</syntaxhighlight>

Line 1,374:

See [https://rosettacode.org/wiki/Smith_numbers#Pascal Pascal].

=={{header|Draco}}==

<~~lang~~ draco>/* Find the sum of the digits of a number */

<syntaxhighlight lang="draco">/* Find the sum of the digits of a number */

proc nonrec digitsum(word n) word:

word sum;

Line 1,443:

writeln();

writeln("Found ", count, " Smith numbers.")

corp</~~lang~~>

corp</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 1,472:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule Smith do

<syntaxhighlight lang="elixir">defmodule Smith do

def number?(n) do

d = decomposition(n)

Line 1,492:

IO.puts "#{length(smith)} smith numbers below #{m}:"

IO.puts "First 10: #{Enum.take(smith,10) |> Enum.join(", ")}"

IO.puts "Last 10: #{Enum.take(smith,-10) |> Enum.join(", ")}"</~~lang~~>

IO.puts "Last 10: #{Enum.take(smith,-10) |> Enum.join(", ")}"</syntaxhighlight>

Line 1,503:

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

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

<~~lang~~ fsharp>

// Generate Smith Numbers. Nigel Galloway: November 6th., 2020

let fN g=Seq.unfold(fun n->match n with 0->None |_->Some(n%10,n/10)) g |> Seq.sum

Line 1,510:

|>Seq.filter(fun g->fN g=fst(primes32()|>Seq.scan(fun n g->fG n g)(0,g)|>Seq.find(fun(_,n)->n=1)))

|>Seq.chunkBySize 20|>Seq.iter(fun n->Seq.iter(printf "%4d ") n; printfn "")

</syntaxhighlight>

</lang>

<pre>

Line 1,534:

</pre>

=={{header|Factor}}==

<lang>USING: formatting grouping io kernel math.primes.factors

<syntaxhighlight lang="text">USING: formatting grouping io kernel math.primes.factors

math.ranges math.text.utils sequences sequences.deep ;

Line 1,545:

10,000 [1,b] [ smith? ] filter 10 group

[ [ "%4d " printf ] each nl ] each</~~lang~~>

[ [ "%4d " printf ] each nl ] each</syntaxhighlight>

<pre>

Line 1,595:

The factorisation is represented in a data aggregate, which is returned by function FACTOR. This is a facility introduced with F90, and before that one would have to use a collection of ordinary arrays to identify the list of primes and powers of a factorisation because functions could only return simple variables. Also, earlier compilers did not allow the use of the function's name as a variable within the function, or might allow this but produce incorrect results. However, modern facilities are not always entirely beneficial. Here, the function returns a full set of data for type FACTORED, even though often only the first few elements of the arrays will be needed and the rest could be ignored. It is possible to declare the arrays of type FACTORED to be "allocatable" with their size being determined at run time for each invocation of function FACTOR, at the cost of a lot of additional syntax and statements, plus the common annoyance of not knowing "how big" until ''after'' the list has been produced. Alas, such arrangements incur a performance penalty with ''every'' reference to the allocatable entities. See for example [[Sequence_of_primorial_primes#Run-time_allocation]]

For layout purposes, the numbers found were stashed in a line buffer rather than attempt to mess with the latter-day facilities of "non-advancing" output. This should be paramaterised for documentation purposes with say <code>MBUF = 20</code> rather than just using the magic constant of 20, however getting that into the FORMAT statement would require <code>FORMAT(<MBUF>I6)</code> and this <n> facility may not be recognised. Alternatively, one could put <code>FORMAT(666I6)</code> and hope that MBUF would never exceed 666. <~~lang~~ ~~Fortran~~> MODULE FACTORISE !Produce a little list...

For layout purposes, the numbers found were stashed in a line buffer rather than attempt to mess with the latter-day facilities of "non-advancing" output. This should be paramaterised for documentation purposes with say <code>MBUF = 20</code> rather than just using the magic constant of 20, however getting that into the FORMAT statement would require <code>FORMAT(<MBUF>I6)</code> and this <n> facility may not be recognised. Alternatively, one could put <code>FORMAT(666I6)</code> and hope that MBUF would never exceed 666. <syntaxhighlight lang="fortran"> MODULE FACTORISE !Produce a little list...

USE PRIMEBAG !This is a common need.

INTEGER LASTP !Some size allowances.

Line 1,719:

13 FORMAT (I9," found.") !Just in case.

END DO !On to the next base.

END !That was strange.</~~lang~~>

END !That was strange.</syntaxhighlight>

Output: selecting the base ten result:

Line 1,767:

=={{header|FreeBASIC}}==

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

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

Sub getPrimeFactors(factors() As UInteger, n As UInteger)

Line 1,821:

Print

Print "Press any key to quit"

Sleep</~~lang~~>

Sleep</syntaxhighlight>

Line 1,865:

=={{header|Go}}==

package main

Line 1,949:

fmt.Println()

}

</syntaxhighlight>

</lang>

{{out}}<pre>

All the Smith Numbers less than 10000 are:

Line 1,956:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.Numbers.Primes (primeFactors)

<syntaxhighlight lang="haskell">import Data.Numbers.Primes (primeFactors)

import Data.List (unfoldr)

import Data.Tuple (swap)

Line 1,989:

, "\nLast 12 Smith Numbers below 10k:"

, unwords (show <$> drop (lowSmithCount - 12) lowSmiths)

]</~~lang~~>

]</syntaxhighlight>

<pre>Count of Smith Numbers below 10k:

Line 2,002:

=={{header|J}}==

Implementation:

<~~lang~~ J>digits=: 10&#.inv

<syntaxhighlight lang="j">digits=: 10&#.inv

sumdig=: +/@,@digits

notprime=: -.@(1&p:)

smith=: #~ notprime * (=&sumdig q:)every</~~lang~~>

smith=: #~ notprime * (=&sumdig q:)every</syntaxhighlight>

Task example:

<~~lang~~ J> #smith }.i.10000

<syntaxhighlight lang="j"> #smith }.i.10000

376

q:376

Line 2,059:

9598 9633 9634 9639 9648 9657 9684 9708

9717 9735 9742 9760 9778 9840 9843 9849

9861 9880 9895 9924 9942 9968 9975 9985</~~lang~~>

9861 9880 9895 9924 9942 9968 9975 9985</syntaxhighlight>

(first we count how many smith numbers are in our result, then we look at the prime factors of that count - turns out that 8 columns of 47 numbers each is perfect for this task.)

Line 2,065:

=={{header|Java}}==

<~~lang~~ java>import java.util.*;

<syntaxhighlight lang="java">import java.util.*;

public class SmithNumbers {

Line 2,109:

return sum;

}

}</~~lang~~>

}</syntaxhighlight>

<pre>4

22

Line 2,128:

<~~lang~~ ~~JavaScript~~>(() => {

<syntaxhighlight lang="javascript">(() => {

'use strict';

Line 2,297:

return main();

})();</~~lang~~>

})();</syntaxhighlight>

<pre>Count of Smith Numbers below 10k:

Line 2,313:

''' Preliminaries'''

<~~lang~~ jq>def is_prime:

<syntaxhighlight lang="jq">def is_prime:

. as $n

| if ($n < 2) then false

Line 2,341:

| select(($num % .) == 0 and is_prime)

| m(.));

</syntaxhighlight>

</lang>

'''The task'''

<~~lang~~ jq># input should be an integer

<syntaxhighlight lang="jq"># input should be an integer

def is_smith:

def sumdigits:

Line 2,352:

"Smith numbers up to 10000:\n",

(range(1; 10000) | select(is_smith))

</syntaxhighlight>

</lang>

<pre>

Line 2,369:

=={{header|Julia}}==

<~~lang~~ julia># v0.6

<syntaxhighlight lang="julia"># v0.6

function sumdigits(n::Integer)

Line 2,384:

smithnumbers = collect(n for n in 2:10000 if issmith(n))

println("Smith numbers up to 10000:\n$smithnumbers")</~~lang~~>

println("Smith numbers up to 10000:\n$smithnumbers")</syntaxhighlight>

Line 2,412:

=={{header|Kotlin}}==

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

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

fun getPrimeFactors(n: Int): MutableList<Int> {

Line 2,461:

}

println("\n\n$count numbers found")

}</~~lang~~>

}</syntaxhighlight>

Line 2,495:

=={{header|Lua}}==

Slightly long-winded prime factor function but it's a bit faster than the 'easy' way.

<~~lang~~ ~~Lua~~>-- Returns a boolean indicating whether n is prime

<syntaxhighlight lang="lua">-- Returns a boolean indicating whether n is prime

function isPrime (n)

if n < 2 then return false end

Line 2,545:

for n = 1, 10000 do

if isSmith(n) then io.write(n .. "\t") end

end</~~lang~~>

end</syntaxhighlight>

Seems silly to paste in all 376 numbers but rest assured the output agrees with https://oeis.org/A006753

Line 2,559:

At the end we get a list (an inventory object with keys only). Print statement prints all keys (normally data, but if key isn't paired with data,then key is read only data)

Module Checkit {

Set Fast !

Line 2,617:

}

Checkit

</syntaxhighlight>

</lang>

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

PRINT COMMENT$ SMITH NUMBERS$

Line 2,672:

TRANSFER TO LOOP

END OF FUNCTION

END OF PROGRAM</~~lang~~>

END OF PROGRAM</syntaxhighlight>

Line 3,054:

=={{header|Maple}}==

<~~lang~~ ~~Maple~~>isSmith := proc(n::posint)

<syntaxhighlight lang="maple">isSmith := proc(n::posint)

local factors, sumofDigits, sumofFactorDigits, x;

if isprime(n) then

Line 3,069:

end proc:

findSmith(10000);</~~lang~~>

findSmith(10000);</syntaxhighlight>

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

<~~lang~~ ~~Mathematica~~>smithQ[n_] := Not[PrimeQ[n]] &&

<syntaxhighlight lang="mathematica">smithQ[n_] := Not[PrimeQ[n]] &&

Total[IntegerDigits[n]] == Total[IntegerDigits /@ Flatten[ConstantArray @@@ FactorInteger[n]],2];

Select[Range[2, 10000], smithQ]</~~lang~~>

Select[Range[2, 10000], smithQ]</syntaxhighlight>

Line 3,082:

=={{header|Modula-2}}==

<~~lang~~ modula2>MODULE SmithNumbers;

<syntaxhighlight lang="modula2">MODULE SmithNumbers;

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

Line 3,141:

ReadChar;

END SmithNumbers.</~~lang~~>

END SmithNumbers.</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ nim>import strformat

<syntaxhighlight lang="nim">import strformat

func primeFactors(n: int): seq[int] =

Line 3,183:

cnt = 0

stdout.write("\n")

echo()</~~lang~~>

echo()</syntaxhighlight>

Line 3,227:

=={{header|Objeck}}==

<~~lang~~ objeck>use Collection;

<syntaxhighlight lang="objeck">use Collection;

class Test {

Line 3,276:

return sum;

}

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 3,294:

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

<~~lang~~ parigp>isSmith(n)=my(f=factor(n)); if(#f~==1 && f[1,2]==1, return(0)); sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n);

<syntaxhighlight lang="parigp">isSmith(n)=my(f=factor(n)); if(#f~==1 && f[1,2]==1, return(0)); sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n);

select(isSmith, [1..9999])</~~lang~~>

select(isSmith, [1..9999])</syntaxhighlight>

Line 3,301:

2.6.0 introduced the <code>forcomposite</code> iterator, removing the need to check each term for primality.

<~~lang~~ parigp>forcomposite(n=4,9999, f=factor(n); if(#f~==1 && f[1,2]==1, next); if(sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n), print1(n" ")))</~~lang~~>

<syntaxhighlight lang="parigp">forcomposite(n=4,9999, f=factor(n); if(#f~==1 && f[1,2]==1, next); if(sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n), print1(n" ")))</syntaxhighlight>

2.10.0 gave us <code>forfactored</code> which speeds the process up by sieving for factors.

<~~lang~~ parigp>forfactored(n=4,9999, f=n[2]; if(#f~==1 && f[1,2]==1, next); if(sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n[1]), print1(n[1]" ")))</~~lang~~>

<syntaxhighlight lang="parigp">forfactored(n=4,9999, f=n[2]; if(#f~==1 && f[1,2]==1, next); if(sum(i=1, #f~, sumdigits(f[i, 1])*f[i, 2]) == sumdigits(n[1]), print1(n[1]" ")))</syntaxhighlight>

=={{header|Pascal}}==

Line 3,314:

the function IncDgtSum delivers the next sum of digits very fast (2.6 s for 1 to 1e9 )

<~~lang~~ pascal>program SmithNum;

<syntaxhighlight lang="pascal">program SmithNum;

{$IFDEF FPC}

{$MODE objFPC} //result and useful for x64

Line 3,596:

write(s:8,' smith-numbers up to ',actualNo.dgtnum:10);

end.

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>64-Bit FPC 3.1.1 -O3 -Xs i4330 3.5 Ghz

6 smith-numbers up to 100

Line 3,614:

=={{header|Perl}}==

<~~lang~~ perl>use ntheory qw/:all/;

<syntaxhighlight lang="perl">use ntheory qw/:all/;

my @smith;

forcomposites {

Line 3,620:

} 10000-1;

say scalar(@smith), " Smith numbers below 10000.";

say "@smith";</~~lang~~>

say "@smith";</syntaxhighlight>

<pre>376 Smith numbers below 10000.

Line 3,627:

Version 0.71 of the <code>ntheory</code> module added <code>forfactored</code>, similar to Pari/GP's 2.10.0 addition. For large inputs this can halve the time taken compared to <code>forcomposites</code>.

<~~lang~~ perl>use ntheory ":all";

<syntaxhighlight lang="perl">use ntheory ":all";

my $t=0;

forfactored { $t++ if @_ > 1 && sumdigits($_) == sumdigits(join "",@_); } 10**8;

say $t;</~~lang~~>

say $t;</syntaxhighlight>

=={{header|Phix}}==

with javascript_semantics

function sum_digits(integer n, base=10)

Line 3,654:

sequence s = apply(filter(tagset(10000),smith),sprint)

printf(1,"%d smith numbers found: %s\n",{length(s),join(shorten(s,"",8),", ")})

<pre>

Line 3,661:

=={{header|PicoLisp}}==

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

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

(make

(let (D 2 L (1 2 2 . (4 2 4 2 4 6 2 6 .)) M (sqrt N))

Line 3,682:

(println 'first-10 (head 10 L))

(println 'last-10 (tail 10 L))

(println 'all (length L)) )</~~lang~~>

(println 'all (length L)) )</syntaxhighlight>

<pre>first-10 (4 22 27 58 85 94 121 166 202 265)

Line 3,689:

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

<~~lang~~ pli>smith: procedure options(main);

<syntaxhighlight lang="pli">smith: procedure options(main);

/* find the digit sum of N */

digitSum: procedure(nn) returns(fixed);

Line 3,748:

end;

put skip list('Found', cnt, 'Smith numbers.');

end smith;</~~lang~~>

end smith;</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 3,777:

=={{header|PL/M}}==

<~~lang~~ pli>100H:

<syntaxhighlight lang="pli">100H:

/* CP/M BDOS FUNCTIONS */

Line 3,866:

CALL PRINT(.' SMITH NUMBERS.$');

CALL EXIT;

EOF</~~lang~~>

EOF</syntaxhighlight>

<pre> 4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382

Line 3,895:

=={{header|PureBasic}}==

<~~lang~~ ~~PureBasic~~>DisableDebugger

<syntaxhighlight lang="purebasic">DisableDebugger

#ECHO=#True ; #True: Print all results

Global NewList f.i()

Line 3,975:

Print(~"\n"+Str(sn)+" Smith number up to "+Str(upto))

Return</~~lang~~>

Return</syntaxhighlight>

<pre>.

Line 4,011:

=={{header|Python}}==

===Procedural===

<~~lang~~ python>from sys import stdout

<syntaxhighlight lang="python">from sys import stdout

Line 4,058:

# entry point

list_smith_numbers(10_000)</~~lang~~>

list_smith_numbers(10_000)</syntaxhighlight>

{{out}}<pre>

4 22 27 58 85 94 121 166 202 265 274 319 346 355 378 382 391 438 454 483 517 526 535 562 576 588 627 634 636 645 648 654 663 666

Line 4,067:

===Functional===

<~~lang~~ python>'''Smith numbers'''

<syntaxhighlight lang="python">'''Smith numbers'''

from itertools import dropwhile

Line 4,177:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

<pre>Count of Smith Numbers below 10k:

Line 4,189:

=={{header|Racket}}==

<~~lang~~ racket>#lang racket

<syntaxhighlight lang="racket">#lang racket

(require math/number-theory)

Line 4,215:

(let-values (([l r] (split-at ns (min (length ns) 15))))

(displayln l)

(loop r)))))</~~lang~~>

(loop r)))))</syntaxhighlight>

Line 4,228:

=={{header|Raku}}==

(formerly Perl 6)

<lang ~~perl6~~>constant @primes = 2, |(3, 5, 7 ... *).grep: *.is-prime;

<syntaxhighlight lang="raku" line>constant @primes = 2, |(3, 5, 7 ... *).grep: *.is-prime;

multi factors ( 1 ) { 1 }

Line 4,256:

say "{@s.elems} Smith numbers below 10_000";

say 'First 10: ', @s[ ^10 ];

say 'Last 10: ', @s[ *-10 .. * ];</~~lang~~>

say 'Last 10: ', @s[ *-10 .. * ];</syntaxhighlight>

<pre>376 Smith numbers below 10_000

Line 4,264:

=={{header|REXX}}==

===unoptimized===

<~~lang~~ rexx>/*REXX program finds (and maybe displays) Smith (or joke) numbers up to a given N.*/

<syntaxhighlight lang="rexx">/*REXX program finds (and maybe displays) Smith (or joke) numbers up to a given N.*/

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

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

Line 4,294:

if z\==1 then do; f=f+1; $=$+sumD(z); end /*Residual? Then add Z*/

if f<2 then return 0 /*Prime? Not a Smith#*/

return $ /*else return sum digs.*/</~~lang~~>

return $ /*else return sum digs.*/</syntaxhighlight>

Line 4,316:

This REXX version uses a faster version of the   '''sumFactr'''   function;   it's over   '''20'''   times faster than the

unoptimized version using a (negative) one million for   '''N'''.

<~~lang~~ rexx>/*REXX program finds (and maybe displays) Smith (or joke) numbers up to a given N.*/

<syntaxhighlight lang="rexx">/*REXX program finds (and maybe displays) Smith (or joke) numbers up to a given N.*/

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

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

Line 4,353:

if z\==1 then do; f=f+1; $=$+sumD(z); end /*if a residual, then add Z*/

if f<2 then return 0 /*Is prime? It's not Smith#*/

return $ /*else, return sum of digs.*/</~~lang~~>

return $ /*else, return sum of digs.*/</syntaxhighlight>

{{out|output|text=  when using the input of (negative) one million:     <tt> -1000000 </tt>}}

<pre>

Line 4,363:

{{incorrect|Ring| This program does not find   (nor show)   all the Smith numbers <big> < </big> 10,000. }}

<~~lang~~ ring>

# Project : Smith numbers

Line 4,419:

end

return sum

</syntaxhighlight>

</lang>

Output:

<pre>

Line 4,427:

=={{header|Ruby}}==

<~~lang~~ ruby>require "prime"

<syntaxhighlight lang="ruby">require "prime"

class Integer

Line 4,442:

puts "#{res.size} smith numbers below #{n}:

#{res.first(5).join(", ")},... #{res.last(5).join(", ")}"</~~lang~~>

#{res.first(5).join(", ")},... #{res.last(5).join(", ")}"</syntaxhighlight>

<pre>

Line 4,450:

=={{header|Rust}}==

<~~lang~~ ~~Rust~~>fn main () {

<syntaxhighlight lang="rust">fn main () {

//We just need the primes below 100

let primes = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];

Line 4,477:

}

println!("Smith numbers below 10000 ({}) : {:?}",solution.len(), solution);

}</~~lang~~>

}</syntaxhighlight>

Line 4,487:

=={{header|Scala}}==

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

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

def sumDigits(_n: Int): Int = {

Line 4,528:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|Sidef}}==

<~~lang~~ ruby>var primes = Enumerator({ |callback|

<syntaxhighlight lang="ruby">var primes = Enumerator({ |callback|

static primes = Hash()

var p = 2

Line 4,567:

say "#{s.len} Smith numbers below 10_000"

say "First 10: #{s.first(10)}"

say "Last 10: #{s.last(10)}"</~~lang~~>

say "Last 10: #{s.last(10)}"</syntaxhighlight>

<pre>

Line 4,576:

=={{header|Stata}}==

<~~lang~~ stata>function factor(_n) {

<syntaxhighlight lang="stata">function factor(_n) {

n = _n

a = J(14, 2, .)

Line 4,648:

+-----------------------------------------------------------------------+

1 | 9843 9849 9861 9880 9895 9924 9942 9968 9975 9985 |

+-----------------------------------------------------------------------+</~~lang~~>

+-----------------------------------------------------------------------+</syntaxhighlight>

=={{header|Swift}}==

<~~lang~~ swift>extension BinaryInteger {

<syntaxhighlight lang="swift">extension BinaryInteger {

@inlinable

public var isSmith: Bool {

Line 4,699:

print("First 10 smith numbers: \(Array(smiths.prefix(10)))")

print("Last 10 smith numbers below 10,000: \(Array(smiths.suffix(10)))")

</syntaxhighlight>

</lang>

Line 4,708:

=={{header|Tcl}}==

<~~lang~~ ~~Tcl~~>proc factors {x} {

<syntaxhighlight lang="tcl">proc factors {x} {

# list the prime factors of x in ascending order

set result [list]

Line 4,749:

puts ...[lrange $smiths end-12 end]

puts "([llength $smiths] total)"

</syntaxhighlight>

</lang>

Line 4,758:

=={{header|Vlang}}==

<~~lang~~ vlang>fn num_prime_factors(xx int) int {

<syntaxhighlight lang="vlang">fn num_prime_factors(xx int) int {

mut p := 2

mut pf := 0

Line 4,841:

println('')

}

</syntaxhighlight>

</lang>

{{out}}<pre>

All the Smith Numbers less than 10000 are:

Line 4,851:

<~~lang~~ ecmascript>import "/math" for Int

<syntaxhighlight lang="ecmascript">import "/math" for Int

import "/fmt" for Fmt

import "/seq" for Lst

Line 4,874:

}

for (chunk in Lst.chunks(smiths, 16)) Fmt.print("$4d", chunk)</~~lang~~>

for (chunk in Lst.chunks(smiths, 16)) Fmt.print("$4d", chunk)</syntaxhighlight>

Line 4,906:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func SumDigits(N); \Return sum of digits in N

<syntaxhighlight lang="xpl0">func SumDigits(N); \Return sum of digits in N

int N, S;

[S:= 0;

Line 4,937:

if rem(C/20) = 0 then CrLf(0);

];

]</~~lang~~>

]</syntaxhighlight>

Line 4,964:

=={{header|zkl}}==

Uses the code (primeFactors) from [[Prime decomposition#zkl]].

<~~lang~~ zkl>fcn smithNumbers(N=0d10_000){ // -->(Smith numbers to N)

<syntaxhighlight lang="zkl">fcn smithNumbers(N=0d10_000){ // -->(Smith numbers to N)

[2..N].filter(fcn(n){

(pfs:=primeFactors(n)).len()>1 and

n.split().sum(0)==primeFactors(n).apply("split").flatten().sum(0)

})

}</~~lang~~>

}</syntaxhighlight>

<~~lang~~ zkl>sns:=smithNumbers();

<syntaxhighlight lang="zkl">sns:=smithNumbers();

sns.toString(*).println(" ",sns.len()," numbers");</~~lang~~>

sns.toString(*).println(" ",sns.len()," numbers");</syntaxhighlight>

<pre>