You are encouraged to solve this task according to the task description, using any language you may know.

The Harshad or Niven numbers are positive integers ≥ 1 that are divisible by the sum of their digits.

For example,   42   is a Harshad number as   42   is divisible by   (4 + 2)   without remainder.

Assume that the series is defined as the numbers in increasing order.

The task is to create a function/method/procedure to generate successive members of the Harshad sequence.

Use it to:

•   list the first 20 members of the sequence,   and
•   list the first Harshad number greater than 1000.

## 11l

F is_harshad(n)
R n % sum(String(n).map(ch -> Int(ch))) == 0

[Int] r
L(n) 1..
r [+]= n
I r.len == num
R r

L(n) 1001..
print(n)
L.break
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42]
1002


## 360 Assembly

*        Harshad or Niven series - 01/05/2019
NIVEN    CSECT
USING  NIVEN,R13          base register
B      72(R15)            skip savearea
DC     17F'0'             savearea
SAVE   (14,12)            save previous context
LA     R7,2               j=2
LOOP     MVC    PG,=CL80' '        clear buffer
LA     R10,PG             @pg
LA     R8,0               n=0
IF C,R7,EQ,=A(2) THEN       if j=2
LA     R9,20                nn=20
LA     R6,1                 i=1
ELSE     ,                  else
LA     R9,1                 nn=1
LA     R6,1001              i=1001
ENDIF    ,                  end if
DO WHILE=(CR,R8,LT,R9)      do i=1 by 1 while(n<nn)
IF   LTR,R1,Z,R1 THEN         if rc=0 then
LA     R8,1(R8)               n++
XDECO  R6,XDEC                edit i
MVC    0(4,R10),XDEC+8        output i
LA     R10,4(R10)             @pg+=4
ENDIF    ,                    end if
LA     R6,1(R6)             i++
ENDDO    ,                  enddo i
XPRNT  PG,L'PG            print buffer
BCT    R7,LOOP            j=j-1; loop if j<>0
L      R13,4(0,R13)       restore previous savearea pointer
RETURN (14,12),RC=0       restore registers from calling sav
CVD    R6,PACKED          convert to packed   PL8
UNPK   ZONED,PACKED       packed PL8 to zoned ZL16
LA     R1,ZONED           @c
XR     R4,R4              sum=0; m=1
DO WHILE=(C,R1,LE,=A(ZONED+15)) do m=1 to 16
NI     0(R1),X'0F'          c(m) : character to integer
XR     R2,R2                ~
IC     R2,0(R1)             c(m)
AR     R4,R2                sum=sum+c(m)
LA     R1,1(R1)             @c++
ENDDO    ,                  enddo m
XR     R2,R2              ~
LR     R3,R6              i
DR     R2,R4              i/sum
LR     R1,R2              rc=mod(i,sum)
PACKED   DS     PL8                packed decimal (15num)
ZONED    DS     ZL16               zoned  decimal (16num)
PG       DS     CL80               buffer
XDEC     DS     CL12               temp xdeco
REGEQU                    symbolic registers
END    NIVEN
Output:
   1   2   3   4   5   6   7   8   9  10  12  18  20  21  24  27  30  36  40  42
1002


## 8080 Assembly

	cpu	8086
org	100h
section	.text
mov	di,10 		; DI is the divisor to find digits
xor 	bp,bp		; Find first 20 Harshad numbers
mov	cx,20
first:	call	next
mov	ax,bp
call	print
loop	first
mov	bp,1000		; Find first Harshad number > 1000
call	next		; .. fall through (print and stop)
mov	ax,bp
;;;	Print the number in AX
print:	mov 	bx,buffer	; String buffer
.digit:	xor	dx,dx		; Divide by 10
div	di
dec	bx
mov	[bx],dl		; Store ASCII number
test	ax,ax		; More digits?
jnz	.digit
mov	ah,9		; Print string using DOS
mov	dx,bx
int	21h
ret
;;;	Let BP be the first Harshad number above BP
next:	inc	bp
mov	ax,bp		; Keep a copy
xor	bx,bx		; Sum
.digit:	xor	dx,dx		; Divide by 10
div	di
test	ax,ax		; More digits?
jnz	.digit
mov	ax,bp		; Is it a Harshad number?
xor	dx,dx
div	bx
test	dx,dx		; If not, try next number
jnz	next
ret
section	.data
db	'*****'
buffer:	db	13,10,'$'  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## ABC HOW TO RETURN digit.sum n: PUT 0 IN sum WHILE n>0: PUT sum + (n mod 10) IN sum PUT floor (n/10) IN n RETURN sum HOW TO REPORT harshad n: REPORT n mod digit.sum n = 0 HOW TO RETURN next.harshad n: PUT n+1 IN n WHILE NOT harshad n: PUT n+1 IN n RETURN n PUT 0 IN n WRITE "First 20 Harshad numbers:" FOR i IN {1..20}: PUT next.harshad n IN n WRITE n WRITE / WRITE "First Harshad number > 1000:", next.harshad 1000/ Output: First 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number > 1000: 1002 ## Action! INT FUNC SumOfDigits(INT a) INT sum sum=0 WHILE a#0 DO sum==+a MOD 10 a==/10 OD RETURN (sum) INT FUNC Next(INT a) INT sum DO a==+1 sum=SumOfDigits(a) UNTIL a MOD sum=0 OD RETURN (a) PROC Main() INT i,a a=0 FOR i=1 TO 20 DO a=Next(a) PrintI(a) Put(32) OD Print("... ") a=Next(1000) PrintIE(a) RETURN Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002  ## Ada with Ada.Text_IO; procedure Harshad is function Next(N: in out Positive) return Positive is function Sum_Of_Digits(N: Natural) return Natural is ( if N = 0 then 0 else ((N mod 10) + Sum_Of_Digits(N / 10)) ); begin while not (N mod Sum_Of_Digits(N) = 0) loop N := N + 1; end loop; return N; end Next; Current: Positive := 1; begin for I in 1 .. 20 loop Ada.Text_IO.Put(Integer'Image(Next(Current))); Current := Current + 1; end loop; Current := 1000 + 1; Ada.Text_IO.Put_Line(" ..." & Integer'Image(Next(Current))); end Harshad;  Output:  1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002 ## ALGOL 68 BEGIN PROC digit sum = (INT i) INT : BEGIN INT res := i %* 10, h := i; WHILE (h %:= 10) > 0 DO res +:= h %* 10 OD; res END; INT found := 0; FOR i WHILE found < 20 DO (i %* digit sum (i) = 0 | found +:= 1; printf (($g(0)", "$, i)) ) OD; FOR i FROM 1001 DO (i %* digit sum (i) = 0 | printf (($g(0)l$, i)); stop) OD END Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, 1002  ## ALGOL-M begin integer function mod(a,b); integer a,b; mod := a-(a/b)*b; integer function digitsum(n); integer n; digitsum := if n = 0 then 0 else mod(n,10) + digitsum(n/10); integer function nextharshad(n); integer n; begin integer ds; loop: n := n + 1; ds := digitsum(n); if mod(n, ds) <> 0 then go to loop; nextharshad := n; end; integer i, n; write("First 20 Harshad numbers:"); n := 0; for i := 1 step 1 until 20 do begin n := nextharshad(n); if mod(i,10)=1 then write(n) else writeon(n); end; write("First Harshad number above 1000:", nextharshad(1000)); end Output: First 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number above 1000: 1002 ## ALGOL W begin % find members of the Harshad/Niven series - numbers divisible by the sum of their digits % % returns the next member of the series above n % integer procedure nextHarshad ( integer value n ) ; begin integer h, s; h := n; while begin integer v; v := h := h + 1; s := 0; while v > 0 do begin s := s + v rem 10; v := v div 10 end while_v_gt_0 ; h rem s not = 0 end do begin end; h end nextHarshad ; integer h; % show the first 20 members of the seuence % write( "First 20 Harshad/Niven numbers:" ); h := 0; for i := 1 until 20 do begin h := nextHarshad( h ); writeon( i_w := 1, s_w := 0, " ", h ) end for_i ; write( i_w := 1, s_w := 0, "First Harshad/Niven number > 1000: ", nextHarshad( 1000 ) ); end. Output: First 20 Harshad/Niven numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad/Niven number > 1000: 1002  ## APL Works with: Dyalog APL (20∘↑,¯1∘↑)∘((⊢,((+∘1)⍣((0=+/∘(⍎¨⍕)|⊢)⊣)⊃∘⌽))⍣(1∊1000<⊣)),1  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## AppleScript ### Idiomatic on nextHarshad(n) if (n < 0) then set n to 0 repeat set n to n + 1 set temp to n set sum to 0 repeat until (temp is 0) set sum to sum + temp mod 10 set temp to temp div 10 end repeat if (n mod sum is 0) then return n end repeat end nextHarshad -- Test code: set harshads to {} set h to 0 repeat 20 times set h to nextHarshad(h) set end of harshads to h end repeat set h to nextHarshad(1000) return {harshads, h}  Output: {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42}, 1002}  ### Functional Clicking together some generic functions, for a little more productivity and for easier refactoring, we can define the Harshad series as a filter over an infinite stream of integers. ------------------ HARSHAD OR NIVEN SERIES ----------------- -- harshads :: () -> [Int] on harshads() -- Non finite stream of Harshad numbers script p on |λ|(x) 0 = x mod (digitSum(x)) end |λ| end script filterGen(p, enumFrom(1)) end harshads -- digitSum :: Int -> Int on digitSum(n) sum(baseDigits(10, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], n)) end digitSum ---------------------------- TEST -------------------------- on run script gtk on |λ|(x) 1000 < x end |λ| end script set hs to harshads() unlines({"First 20: -> " & ¬ showList(take(20, hs)), ¬ "", ¬ "First over 1000: -> " & ¬ str(item 1 of take(1, filterGen(gtk, hs)))}) end run -------------------------- GENERIC ------------------------- -- Just :: a -> Maybe a on Just(x) -- Constructor for an inhabited Maybe (option type) value. -- Wrapper containing the result of a computation. {type:"Maybe", Nothing:false, Just:x} end Just -- Nothing :: Maybe a on Nothing() -- Constructor for an empty Maybe (option type) value. -- Empty wrapper returned where a computation is not possible. {type:"Maybe", Nothing:true} end Nothing -- Tuple (,) :: a -> b -> (a, b) on Tuple(a, b) -- Constructor for a pair of values, possibly of two different types. {type:"Tuple", |1|:a, |2|:b, length:2} end Tuple -- baseDigits :: Int -> [a] -> [a] on baseDigits(intBase, digits, n) script on |λ|(v) if 0 = v then Nothing() else Just(Tuple(item (1 + (v mod intBase)) of digits, ¬ v div intBase)) end if end |λ| end script unfoldr(result, n) end baseDigits -- enumFrom :: Enum a => a -> [a] on enumFrom(x) script property v : missing value property blnNum : class of x is not text on |λ|() if missing value is not v then if blnNum then set v to 1 + v else set v to succ(v) end if else set v to x end if return v end |λ| end script end enumFrom -- intercalate :: String -> [String] -> String on intercalate(delim, xs) set {dlm, my text item delimiters} to ¬ {my text item delimiters, delim} set s to xs as text set my text item delimiters to dlm s end intercalate -- filterGen :: (a -> Bool) -> Gen [a] -> Gen [a] on filterGen(p, gen) -- Non-finite stream of values which are -- drawn from gen, and satisfy p script property mp : mReturn(p)'s |λ| on |λ|() set v to gen's |λ|() repeat until mp(v) set v to gen's |λ|() end repeat return v end |λ| end script end filterGen -- foldl :: (a -> b -> a) -> a -> [b] -> a on foldl(f, startValue, xs) tell mReturn(f) set v to startValue set lng to length of xs repeat with i from 1 to lng set v to |λ|(v, item i of xs, i, xs) end repeat return v end tell end foldl -- fst :: (a, b) -> a on fst(tpl) if class of tpl is record then |1| of tpl else item 1 of tpl end if end fst -- map :: (a -> b) -> [a] -> [b] on map(f, xs) -- The list obtained by applying f -- to each element of xs. tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell end map -- min :: Ord a => a -> a -> a on min(x, y) if y < x then y else x end if end min -- mReturn :: First-class m => (a -> b) -> m (a -> b) on mReturn(f) -- 2nd class handler function lifted into 1st class script wrapper. if script is class of f then f else script property |λ| : f end script end if end mReturn -- showList :: [a] -> String on showList(xs) "[" & intercalate(",", map(my str, xs)) & "]" end showList -- snd :: (a, b) -> b on snd(tpl) if class of tpl is record then |2| of tpl else item 2 of tpl end if end snd -- str :: a -> String on str(x) x as string end str -- sum :: [Num] -> Num on sum(xs) script add on |λ|(a, b) a + b end |λ| end script foldl(add, 0, xs) end sum -- take :: Int -> [a] -> [a] -- take :: Int -> String -> String on take(n, xs) set c to class of xs if list is c then if 0 < n then items 1 thru min(n, length of xs) of xs else {} end if else if string is c then if 0 < n then text 1 thru min(n, length of xs) of xs else "" end if else if script is c then set ys to {} repeat with i from 1 to n set v to |λ|() of xs if missing value is v then return ys else set end of ys to v end if end repeat return ys else missing value end if end take -- unfoldr :: (b -> Maybe (a, b)) -> b -> [a] on unfoldr(f, v) -- A list obtained from a simple value. -- Dual to foldr. -- unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10 -- -> [10,9,8,7,6,5,4,3,2,1] set xr to {v, v} -- (value, remainder) set xs to {} tell mReturn(f) repeat -- Function applied to remainder. set mb to |λ|(snd(xr)) if Nothing of mb then exit repeat else -- New (value, remainder) tuple, set xr to Just of mb -- and value appended to output list. set end of xs to fst(xr) end if end repeat end tell return xs end unfoldr -- unlines :: [String] -> String on unlines(xs) -- A single string formed by the intercalation -- of a list of strings with the newline character. set {dlm, my text item delimiters} to ¬ {my text item delimiters, linefeed} set s to xs as text set my text item delimiters to dlm s end unlines  Output: First 20: -> [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42] First over 1000: -> 1002 ## Arturo harshad?: function [n] -> zero? n % sum digits n harshads: select 1..1100 => harshad? print ["First 20 harshad numbers:" first.n:20 harshads] loop harshads 'h [ if h > 1000 [ print ["First harshad > 1000:" h] break ] ]  Output: First 20 harshad numbers: [1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42] First harshad > 1000: 1002 ## AutoHotkey H := [] n := 1 Loop n := (H[A_Index] := NextHarshad(n)) + 1 until H[H.MaxIndex()] > 1000 Loop, 20 Out .= H[A_Index] ", " MsgBox, % Out ". . . " H[H.MaxIndex()] NextHarshad(n) { Loop, { Loop, Parse, n sum += A_LoopField if (!Mod(n, sum)) return n n++, sum := "" } }  Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, . . . 1002 ## AWK #!/usr/bin/awk -f BEGIN { k=0; n=0; printf("First twenty Harshad numbers are:\n "); while (k<20) { if (isharshad(++n)) { printf("%i ",n); ++k; } } n = 1000; while (!isharshad(++n)); printf("\nFirst Harshad number larger than 1000 is \n %i\n",n); } function isharshad(n) { s = 0; for (i=0; i<length(n); ) { s+=substr(n,++i,1); } return !(n%s); }  Output: First twenty Harshad numbers are: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number larger than 1000 is 1002 ## Batch File @echo off setlocal enabledelayedexpansion for /l %%i in (1,1,20) do ( call:harshad echo Harshad number %%i - !errorlevel! ) :loop call:harshad if %errorlevel% leq 1000 goto loop echo First Harshad number greater than 1000: %errorlevel% pause>nul exit /b :harshad if "%harshadnum%"=="" set harshadnum=0 set /a harshadnum+=1 call:strlength %harshadnum% set harshadsum=0 for /l %%i in (0,1,%errorlevel%) do set /a harshadsum+=!harshadnum:~%%i,1! set /a isharshad=%harshadnum% %% %harshadsum% if %isharshad%==0 exit /b %harshadnum% goto harshad :strlength setlocal enabledelayedexpansion set tempcount=1 set str=%1 :strlengthloop set /a length=%tempcount%-1 if "!str:~%tempcount%,1!"=="" endlocal && exit /b %length% set /a tempcount+=1 goto strlengthloop  Output: Harshad number 1 - 1 Harshad number 2 - 2 Harshad number 3 - 3 Harshad number 4 - 4 Harshad number 5 - 5 Harshad number 6 - 6 Harshad number 7 - 7 Harshad number 8 - 8 Harshad number 9 - 9 Harshad number 10 - 10 Harshad number 11 - 12 Harshad number 12 - 18 Harshad number 13 - 20 Harshad number 14 - 21 Harshad number 15 - 24 Harshad number 16 - 27 Harshad number 17 - 30 Harshad number 18 - 36 Harshad number 19 - 40 Harshad number 20 - 42 First Harshad number greater than 1000: 1002  ## BASIC 10 DEFINT P,N,I,S 20 PRINT "First 20 Harshad numbers:" 30 P=0 40 N=0 50 N=N+1 60 S=0 70 I=N 80 S=S+I MOD 10 90 I=I\10 100 IF I THEN 80 110 IF N MOD S THEN 50 120 IF P<20 THEN P=P+1: PRINT N, 130 IF N<=1000 THEN 50 140 PRINT 150 PRINT "First Harshad number > 1000:";N  Output: First 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number > 1000: 1002 ## BASIC256 Translation of: FreeBASIC function sumDigitos(n) if n < 0 then return 0 suma = 0 while n > 0 suma = suma + (n mod 10) n = n \ 10 end while return suma end function function isHarshad(n) return n mod sumDigitos(n) = 0 end function print "Los primeros 20 números de Harshad o Niven son:" cuenta = 0 i = 1 do if isHarshad(i) then print i; " "; cuenta += 1 end if i += 1 until cuenta = 20 print : print print "El primero de esos números por encima de 1000 es:" i = 1001 do if isHarshad(i) then print i; " " exit do end if i += 1 until false end  Output: Los primeros 20 números de Harshad o Niven son: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 El primero de esos números por encima de 1000 es: 1002  ## BBC BASIC  I%=1:CNT%=0 WHILE TRUE IF FNHarshad(I%) THEN IF CNT%<20 PRINT ;I%;" ";:CNT%+=1 IF I%>1000 PRINT ;I%:EXIT WHILE ENDIF I%+=1 ENDWHILE END DEF FNHarshad(num%) LOCAL sum%,tmp% tmp%=num% sum%=0 WHILE (tmp%>0) sum%+=tmp% MOD 10 tmp%/=10 ENDWHILE =(num% MOD sum%)=0  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## BCPL get "libhdr" let dsum(n) = n=0 -> 0, n rem 10 + dsum(n/10) let next(n) = harshad(n+1) and harshad(n) = n rem dsum(n)=0 -> n, next(n) let start() be$(  let n = 0
writes("First 20:")
for i = 1 to 20 do
$( n := next(n) writef(" %N", n)$)
writef("*NFirst above 1000: %N*N", next(1000))
$) Output: First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First above 1000: 1002 ## Befunge 45*1>::01-\>:55+%\vv\0< >\1+^ + <|:/<+55< : ^_>1-\:.v@1>\:0\#v_+\^ >^1\,+55<.^_:#%$:#<"}"v
^!:\_    ^###<    !*8<

Output:
1
2
3
4
5
6
7
8
9
10
12
18
20
21
24
27
30
36
40
42
1002

## BQN

SumDgt ← +´•Fmt-'0'˙
Niven ← 0=SumDgt|⊢
nivens ← Niven¨⊸/↕1100
⟨20↑nivens, ⊑(⊢>1000˙)⊸/nivens⟩

Output:
⟨ ⟨ 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ⟩ 1002 ⟩

## C

#include <stdio.h>

static int digsum(int n)
{
int sum = 0;
do { sum += n % 10; } while (n /= 10);
return sum;
}

int main(void)
{
int n, done, found;

for (n = 1, done = found = 0; !done; ++n) {
if (n % digsum(n) == 0) {
if (found++ < 20) printf("%d ", n);
if (n > 1000) done = printf("\n%d\n", n);
}
}

return 0;
}

Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002

## C#

using System;
using System.Collections.Generic;

{
class Program
{
{
char[] inputChars = n.ToString().ToCharArray();
IList<byte> digits = new List<byte>();

foreach (char digit in inputChars)
{
}

if (n < 1)
{
return false;
}

int sum = 0;

foreach (byte digit in digits)
{
sum += digit;
}

return n % sum == 0;
}

static void Main(string[] args)
{
int i = 1;
int count = 0;

while (true)
{
{
count++;

if (count <= 20)
{
Console.Write(string.Format("{0} ", i));
}
else if (i > 1000)
{
Console.Write(string.Format("{0} ", i));
break;
}
}

i++;
}

}
}
}

Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002

### Shorter solution

using System.Collections.Generic;
using static System.Linq.Enumerable;
using static System.Console;

public static class Program
{
public static void Main()
{
}

static bool IsHarshad(this int i) => i % i.Digits().Sum() == 0;

static IEnumerable<int> From(int start) {
for (int i = start; ; i++) yield return i;
}

static IEnumerable<int> Digits(this int n) {
for (; n > 0; n /= 10) yield return n % 10;
}
}


## C++

#include <vector>
#include <iostream>

int sumDigits ( int number ) {
int sum = 0 ;
while ( number != 0 ) {
sum += number % 10 ;
number /= 10 ;
}
return sum ;
}

bool isHarshad ( int number ) {
return number % ( sumDigits ( number ) ) == 0 ;
}

int main( ) {
int i = 0 ;
while ( harshads.size( ) != 20 ) {
i++ ;
if ( isHarshad ( i ) )
}
std::cout << "The first 20 Harshad numbers:\n" ;
for ( int number : harshads )
std::cout << number << " " ;
std::cout << std::endl ;
int start = 1001 ;
while ( ! ( isHarshad ( start ) ) )
start++ ;
std::cout << "The smallest Harshad number greater than 1000 : " << start << '\n' ;
return 0 ;
}

Output:
The first 20 Harshad numbers:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
The smallest Harshad number greater than 1000 : 1002


## Clojure

(defn digsum [n acc]
(if (zero? n) acc
(digsum (quot n 10) (+ acc (mod n 10)))))

#(zero? (mod % (digsum % 0)))
(iterate inc 1))]
(prn (first (filter #(> % 1000) harshads))))

Output:
(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)
1002

## CLU

digit_sum = proc (n: int) returns (int)
sum: int := 0
while n > 0 do
sum := sum + n // 10
n := n / 10
end
return (sum)
end digit_sum

harshads = iter (n: int) yields (int)
while true do
n := n + 1
if n // digit_sum(n) = 0 then yield(n) end
end

start_up = proc ()
po: stream := stream$primary_output() count: int := 0 stream$putl(po, "First 20 Harshad numbers: ")
for h: int in harshads(0) do
stream$putright(po, int$unparse(h), 3)
count := count + 1
if count = 20 then break end
end

stream$puts(po, "\nFirst Harshad number above 1000: ") for h: int in harshads(1000) do stream$putl(po, int$unparse(h)) break end end start_up Output: First 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number above 1000: 1002 ## COBOL Works with: OpenCOBOL version 1.1 identification division. program-id. harshad. environment division. data division. working-storage section. *> for storing first 20 harshad-niven numbers 01 harshads. 03 harshad pic 9(5) occurs 20 times indexed by niven. *> numbers tested for harshad-niven-ness. 01 first-num pic 9(5). 01 second-num pic 9(5). *> loop counter 01 i pic 9(5). *> for calculating sum of digits 01 div pic 9(5). 01 mod pic 9(5). 01 tot pic 9(5). *> for harshad-niven calculation and display 01 harshad-div pic 9(5). 01 harshad-mod pic 9(5). 88 evenly-divisible value 0. 01 harshad-disp pic zzzz9. 01 harshad-result pic 9(5). *> for selecting what to do with results of harshad calculation 01 pass pic 9. 88 first-pass value 1. 88 second-pass value 2. procedure division. 10-main section. move 1 to pass. set niven to 1. perform 20-calculate-harshad with test before varying first-num from 1 by 1 until niven = 21. move 2 to pass. move first-num to second-num. perform 20-calculate-harshad with test after varying first-num from second-num by 1 until harshad-result > 1000. perform with test after varying i from 1 by 1 until i = 20 move harshad(i) to harshad-disp display function trim(harshad-disp) space with no advancing end-perform. move harshad-result to harshad-disp. display "... " function trim(harshad-disp). stop run. 20-calculate-harshad. move first-num to div. move zero to harshad-result. perform 100-calculate-sum-of-digits. divide first-num by tot giving harshad-div remainder harshad-mod. if evenly-divisible if first-pass move first-num to harshad(niven) set niven up by 1 else move first-num to harshad-result end-if end-if. exit paragraph. 100-calculate-sum-of-digits. move zero to tot. perform with test after until div = 0 divide div by 10 giving div remainder mod add mod to tot end-perform. *> if tot >= 10 *> move tot to div *> go to 100-calculate-sum-of-digits *> end-if. exit paragraph.  ## ColdFusion <Cfset harshadNum = 0> <Cfset counter = 0> <Cfloop condition="harshadNum lte 1000"> <Cfset startnum = harshadNum + 1> <Cfset digits = 0> <Cfset harshad = 0> <Cfloop condition="Harshad eq 0"> <Cfset current_i = startnum> <Cfset digits = 0> <cfloop condition="len(current_i) gt 1"> <Cfset digit = left(current_i, 1)> <Cfset current_i = right(current_i, len(current_i)-1)> <Cfset digits = digits + digit> </cfloop> <Cfset digits = digits + current_i> <Cfif Startnum MOD digits eq 0> <Cfset harshad = 1> <Cfelse> <cfset startnum = startnum + 1> </Cfif> </Cfloop> <cfset harshadNum = startnum> <Cfset counter = counter + 1> <Cfif counter lte 20> <Cfoutput>#harshadNum# </Cfoutput> </Cfif> </Cfloop> <Cfoutput>... #harshadNum# </Cfoutput>  ## Comal 0010 FUNC digit'sum(n) 0020 sum:=0 0030 WHILE n>0 DO sum:+n MOD 10;n:=n DIV 10 0040 RETURN sum 0050 ENDFUNC digit'sum 0060 // 0070 FUNC next'harshad(n) 0080 REPEAT 0090 n:+1 0100 UNTIL n MOD digit'sum(n)=0 0110 RETURN n 0120 ENDFUNC next'harshad 0130 // 0140 PRINT "First 20 Harshad numbers: " 0150 n:=0 0160 FOR i:=1 TO 20 DO 0170 n:=next'harshad(n) 0180 PRINT n; 0190 ENDFOR i 0200 PRINT 0210 PRINT "First Harshad number above 1000:";next'harshad(1000) 0220 END  Output: First 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First Harshad number above 1000: 1002 ## Common Lisp (defun harshadp (n) (zerop (rem n (digit-sum n)))) (defun digit-sum (n &optional (a 0)) (cond ((zerop n) a) (t (digit-sum (floor n 10) (+ a (rem n 10)))))) (defun list-harshad (n &optional (i 1) (lst nil)) "list the first n Harshad numbers starting from i (default 1)" (cond ((= (length lst) n) (reverse lst)) ((harshadp i) (list-harshad n (+ i 1) (cons i lst))) (t (list-harshad n (+ i 1) lst))))  Output: CL-USER> (list-harshad 20) (1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42) CL-USER> (list-harshad 1 1001) (1002)  ## Cowgol include "cowgol.coh"; sub digitsum(n: uint16): (sum: uint8) is sum := 0; while n != 0 loop sum := sum + (n % 10) as uint8; n := n / 10; end loop; end sub; sub nextHarshad(m: uint16): (n: uint16) is n := m; loop n := n + 1; if n % digitsum(n) as uint16 == 0 then return; end if; end loop; end sub; var n: uint16 := 0; var i: uint16 := 0; while n <= 1000 loop n := nextHarshad(n); i := i + 1; if i <= 20 then print_i16(n); print(" "); end if; end loop; print_nl(); print_i16(n); print_nl(); Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## Craft Basic for i = 1 to 1002 let t = i let s = 0 do let s = s + t % 10 let t = int(t / 10) wait loop t > 0 if i % s = 0 and (c < 20 or i > 1000) then let c = c + 1 print c, " : ", i endif next i  Output: 1 : 1 2 : 2 3 : 3 4 : 4 5 : 5 6 : 6 7 : 7 8 : 8 9 : 9 10 : 10 11 : 12 12 : 18 13 : 20 14 : 21 15 : 24 16 : 27 17 : 30 18 : 36 19 : 40 20 : 42 21 : 1002 ## Crystal Translation of: Ruby harshad = 1.step.select { |n| n % n.to_s.chars.sum(&.to_i) == 0 } puts "The first 20 harshard numbers are: \n#{ harshad.first(20).to_a }" puts "The first harshard number > 1000 is #{ harshad.find { |n| n > 1000 } }"  Output: The first 20 harshard numbers are: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] The first harshard number > 1000 is 1002  ## D void main() { import std.stdio, std.algorithm, std.range, std.conv; enum digSum = (int n) => n.text.map!(d => d - '0').sum; enum harshads = iota(1, int.max).filter!(n => n % digSum(n) == 0); harshads.take(20).writeln; harshads.filter!(h => h > 1000).front.writeln; }  Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] 1002 ## Delphi See Pascal. ## Draco proc nonrec dsum(word n) word: word r; r := 0; while n ~= 0 do r := r + n % 10; n := n / 10 od; r corp proc nonrec next_harshad(word n) word: while n := n + 1; n % dsum(n) ~= 0 do od; n corp proc nonrec main() void: word n; byte i; write("First 20:"); n := 0; for i from 1 upto 20 do n := next_harshad(n); write(" ", n) od; writeln(); write("First above 1000: ", next_harshad(1000)) corp Output: First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First above 1000: 1002 ## EasyLang Translation of: FreeBASIC func digsum n . while n > 0 sum += n mod 10 n = n div 10 . return sum . func isHarshad n . return if n mod digsum n = 0 . i = 1 repeat if isHarshad i = 1 write i & " " cnt += 1 . until cnt = 20 i += 1 . print "" i = 1001 while isHarshad i = 0 i += 1 . print i  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## EchoLisp (define (harsh? n) (zero? (modulo n (apply + (map string->number (string->list (number->string n))))))) (harsh? 42) → #t (define H (stream-filter harsh? (in-naturals 1))) (take H 20) → (1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42) (for ((n H)) #:break (> n 1000) => n) → 1002  ## Eiffel note description : "project application root class" date : "$October 10, 2014$" revision : "$Revision$" class NIVEN_SERIES create make feature make local number : INTEGER count : INTEGER last : BOOLEAN do number := 1 from number := 1 last := false until last = true loop if (number \\ sum_of_digits(number) = 0) then count := count + 1 if (count <= 20 ) then print("%N") print(number) end if (number > 1000) then print("%N") print(number) last := true end end number := number + 1 end end sum_of_digits(no:INTEGER):INTEGER local sum : INTEGER num : INTEGER do sum := 0 from num := no until num = 0 loop sum := sum + num \\ 10 num := num // 10 end Result := sum end end  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## Elixir defmodule Harshad do def series, do: Stream.iterate(1, &(&1+1)) |> Stream.filter(&(number?(&1))) def number?(n), do: rem(n, digit_sum(n, 0)) == 0 defp digit_sum(0, sum), do: sum defp digit_sum(n, sum), do: digit_sum(div(n, 10), sum + rem(n, 10)) end IO.inspect Harshad.series |> Enum.take(20) IO.inspect Harshad.series |> Stream.drop_while(&(&1 <= 1000)) |> Enum.take(1) |> hd  Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] 1002  ## Erlang -module( harshad ). -export( [greater_than/1, sequence/1, task/0] ). greater_than( N ) when N >= 1 -> greater_than( 2, N, acc(1, {0, []}) ). sequence( Find_this_many ) when Find_this_many >= 1 -> sequence( 2, Find_this_many, acc(1, {0, []}) ). task() -> io:fwrite( "~p~n", [sequence(20)] ), io:fwrite( "~p~n", [greater_than(1000)] ). acc( N, Acc ) -> acc( N rem lists:sum([X -$0|| X <- erlang:integer_to_list(N)]), N, Acc ).

acc( 0, N, {Found, Acc} ) -> {Found + 1, [N | Acc]};
acc( _Reminder, _N, Acc ) -> Acc.

greater_than( _N, Find, {_, [Found | _T]} ) when Found > Find -> Found;
greater_than( N, Find, Acc ) ->	greater_than( N + 1, Find, acc(N, Acc) ).

sequence( _N, Found, {Found, Acc} ) -> lists:reverse( Acc );
sequence( N, Find, Acc ) -> sequence( N + 1, Find, acc(N, Acc) ).

Output:
39> harshad:task().
[1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
1002


Erlang 2

A somewhat more simple approach. Somewhat more efficient since it produces the partial list 23 times for the 20 element case whereas the above does so 36 or 37 times.

-module(harshad).

% We return the number R if harshad, else 0
case R
rem lists:sum([X - $0|| X <- erlang:integer_to_list(R)]) of 0 -> R; _ -> 0 end. % build a list of harshads retrieving input from harshad(R) % filter out the nulls and return hlist(A,B) -> RL = [ harshad(X) || X <- lists:seq(A,B) ], lists:filter( fun(X) -> X > 0 end, RL). seq(Total) -> seq(Total, [], 0). seq(Total,L,_) when length(L) == Total-> L; seq(Total,L,Acc) when length(L) < Total -> NL = hlist(1,Total + Acc), seq(Total,NL,Acc+1). gt(_,L) when length(L) == 1 -> hd(L); gt(X,_) -> NL = hlist(X+1,X+2), gt(X+2,NL). main() -> io:format("seq(20): ~w~n", [ seq(20) ]), io:format("gt(1000): ~w~n", [ gt(1000,[]) ]).  2> harshad:main(). seq(20): [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42] gt(1000): 1002 ok  ## Excel ### LAMBDA Binding the names nextHarshad, and harshads to the following lambda expressions in the Name Manager of the Excel WorkBook: nextHarshad =LAMBDA(n, UNTIL( LAMBDA(x, 0 = MOD(x, decDigitSum(x)) ) )( LAMBDA(x, 1 + x) )(1 + n) ) harshads =LAMBDA(n, UNTIL( LAMBDA(xs, n = ROWS(xs)) )( LAMBDA(xs, APPENDROWS(xs)( nextHarshad( INDEX(LASTROW(xs), 1) ) ) ) )( {1} ) )  and also assuming the following generic bindings in the Name Manager for the WorkBook: APPENDROWS =LAMBDA(xs, LAMBDA(ys, LET( nx, ROWS(xs), rowIndexes, SEQUENCE(nx + ROWS(ys)), colIndexes, SEQUENCE( 1, MAX(COLUMNS(xs), COLUMNS(ys)) ), IFERROR( IF(rowIndexes <= nx, INDEX(xs, rowIndexes, colIndexes), INDEX(ys, rowIndexes - nx, colIndexes) ), NA() ) ) ) ) CHARSROW =LAMBDA(s, MID(s, SEQUENCE(1, LEN(s), 1, 1), 1 ) ) decDigitSum =LAMBDA(n, SUM(VALUE(CHARSROW(n))) ) LASTROW =LAMBDA(xs, INDEX( xs, ROWS(xs), SEQUENCE(1, COLUMNS(xs), 1, 1) ) ) UNTIL =LAMBDA(p, LAMBDA(f, LAMBDA(x, IF(p(x), x, UNTIL(p)(f)(f(x)) ) ) ) )  Output: Next Harshad after lower limit:  =nextHarshad(A2) fx A B 1 First above Harshad term 2 1000 1002 Sequence of Harshads: (The single formula in cell B2 defines an array which populates the whole range B2:B21)  =harshads(20) fx A B 1 Number of terms Harshads 2 20 1 3 2 4 3 5 4 6 5 7 6 8 7 9 8 10 9 11 10 12 12 13 18 14 20 15 21 16 24 17 27 18 30 19 36 20 40 21 42 ## F# let divides d n = match bigint.DivRem(n, d) with | (_, rest) -> rest = 0I let splitToInt (str:string) = List.init str.Length (fun i -> ((int str.[i]) - (int "0".[0]))) let harshads = let rec loop n = seq { let sum = List.fold (+) 0 (splitToInt (n.ToString())) if divides (bigint sum) n then yield n yield! loop (n + 1I) } loop 1I [<EntryPoint>] let main argv = for h in (Seq.take 20 harshads) do printf "%A " h printfn "" printfn "%A" (Seq.find (fun n -> n > 1000I) harshads) 0  1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## Factor USING: math.text.utils lists lists.lazy ; : niven? ( n -- ? ) dup 1 digit-groups sum mod 0 = ; : first-n-niven ( n -- seq ) 1 lfrom [ niven? ] lfilter ltake list>array ; : next-niven ( n -- m ) 1 + [ dup niven? ] [ 1 + ] until ; 20 first-n-niven . 1000 next-niven .  Output: { 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 } 1002  ## FBSL The INITIALIZE routine fills a dynamic array with all we need, even the ellipsis. #APPTYPE CONSOLE CLASS harshad PRIVATE: memo[] SUB INITIALIZE() DIM i = 1, c DO IF isNiven(i) THEN c = c + 1 memo[c] = i END IF i = i + 1 IF c = 20 THEN EXIT DO LOOP memo[] = "..." i = 1000 WHILE NOT isNiven(INCR(i)): WEND memo[] = i END SUB FUNCTION isNiven(n) RETURN NOT (n MOD sumdigits(n)) END FUNCTION FUNCTION sumdigits(n) DIM num = n, m, sum WHILE num sum = sum + num MOD 10 num = num \ 10 WEND RETURN sum END FUNCTION PUBLIC: METHOD Yield() FOREACH DIM e IN memo PRINT e, " "; NEXT END METHOD END CLASS DIM niven AS NEW harshad niven.Yield() PAUSE  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002 Press any key to continue... ## FOCAL 01.10 S N=0 01.20 S P=0 01.30 D 3 01.40 I (19-P)1.7 01.50 T %4,N,! 01.60 S P=P+1 01.70 I (N-1001)1.3 01.80 T N,! 01.90 Q 02.10 S A=0 02.20 S B=N 02.30 S C=FITR(B/10) 02.40 S A=A+B-C*10 02.50 S B=C 02.60 I (-B)2.3 03.10 S N=N+1 03.20 D 2 03.30 I (FITR(N/A)*A-N)3.1 Output: = 1 = 2 = 3 = 4 = 5 = 6 = 7 = 8 = 9 = 10 = 12 = 18 = 20 = 21 = 24 = 27 = 30 = 36 = 40 = 42 = 1002 ## Fortran Please observe compilation on GNU/linux system and output from run are in the comments at the START of the FORTRAN 2003 source. The 1--20 loop idea was stolen from the ada solution. Thank you. !-*- mode: compilation; default-directory: "/tmp/" -*- !Compilation started at Tue May 21 13:15:59 ! !a=./f && make$a && $a < unixdict.txt !gfortran -std=f2003 -Wall -ffree-form f.f03 -o f ! 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ! !Compilation finished at Tue May 21 13:15:59 program Harshad integer :: i, h = 0 do i=1, 20 call nextHarshad(h) write(6, '(i5)', advance='no') h enddo h = 1000 call nextHarshad(h) write(6, '(i5)') h contains subroutine nextHarshad(h) ! alter input integer h to be the next greater Harshad number. integer, intent(inout) :: h h = h+1 ! bigger do while (.not. isHarshad(h)) h = h+1 end do end subroutine nextHarshad logical function isHarshad(a) integer, intent(in) :: a integer :: mutable, digit_sum isHarshad = .false. if (a .lt. 1) return ! false if a < 1 mutable = a digit_sum = 0 do while (mutable /= 0) digit_sum = digit_sum + mod(mutable, 10) mutable = mutable / 10 end do isHarshad = 0 .eq. mod(a, digit_sum) end function isHarshad end program Harshad  ## FreeBASIC ' FB 1.05.0 Win64 Function sumDigits(n As Integer) As Integer If n < 0 Then Return 0 Dim sum As Integer While n > 0 sum += n Mod 10 n \= 10 Wend Return sum End Function Function isHarshad(n As Integer) As Boolean Return n Mod sumDigits(n) = 0 End Function Print "The first 20 Harshad or Niven numbers are :" Dim count As Integer = 0 Dim i As Integer = 1 Do If isHarshad(i) Then Print i; " "; Count += 1 If count = 20 Then Exit Do End If i += 1 Loop Print : Print Print "The first such number above 1000 is :" i = 1001 Do If isHarshad(i) Then Print i; " " Exit Do End If i += 1 Loop Print Print "Press any key to quit" Sleep  Output: The first 20 Harshad or Niven numbers are : 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 The first such number above 1000 is : 1002  ## Frink isHarshad[n] := n mod sum[integerDigits[n]] == 0 c = 0 i = 1 while c<20 { if isHarshad[i] { c = c + 1 println[i] } i = i + 1 } println[] i = 1000 do i = i + 1 while ! isHarshad[i] println[i] Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## FutureBasic local fn Harshad( num as long ) as long long sum = 0, tmp = num while ( tmp > 0 ) sum += tmp mod 10 tmp = tmp / 10 wend end fn = (num mod sum) = 0 local fn DoIt long i = 1, cnt = 0 print "First 20 in series: "; while (1) if fn Harshad( i ) if ( cnt < 20 ) then print ; i; " "; : cnt++ if ( i > 1000 ) then print : print "First above 1000: "; i : exit while end if i++ wend end fn fn Doit HandleEvents Output: First 20 in series: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 First above 1000: 1002  ## Fōrmulæ Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition. Programs in Fōrmulæ are created/edited online in its website. In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation. Solution Test case 1. List the first 20 members of the sequence Test case 2. List the first Harshad number greater than 1,000 ## Gambas Public Sub Main() Dim siCount, siLoop, siTotal, siCounter As Short Dim sNo, sTemp As String Dim sHold, sNiven As New String[] For siCount = 1 To 1500 sNo = Str(siCount) For siLoop = 1 To Len(sNo) sHold.Add(Mid(sNo, siLoop, 1)) Next For Each sTemp In sHold siTotal += Val(sTemp) Next If siCount Mod siTotal = 0 Then Inc siCounter If siCounter < 21 Or siCount > 1000 Then sNiven.Add(Str(siCount)) If siCount > 1000 Then Break Endif Endif siTotal = 0 sHold.Clear Next Print "First twenty Harshad numbers and the first Harshad number greater than 1000" Print sNiven.Join(", ") End  Output: First twenty Harshad numbers and the first Harshad number greater than 1000 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, 1002  ## Go package main import "fmt" type is func() int func newSum() is { var ms is ms = func() int { ms = newSum() return ms() } var msd, d int return func() int { if d < 9 { d++ } else { d = 0 msd = ms() } return msd + d } } func newHarshard() is { i := 0 sum := newSum() return func() int { for i++; i%sum() != 0; i++ { } return i } } func main() { h := newHarshard() fmt.Print(h()) for i := 1; i < 20; i++ { fmt.Print(" ", h()) } fmt.Println() h = newHarshard() n := h() for ; n <= 1000; n = h() { } fmt.Println(n) }  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## Groovy ​class HarshadNiven{ public static boolean find(int x) { int sum = 0,temp,var; var = x; while(x>0) { temp = x%10; sum = sum + temp; x = x/10; } if(var%sum==0) temp = 1; else temp = 0; return temp; } public static void main(String[] args) { int t,i; t = 0; for(i=1;t<20;i++) { if(find(i)) { print(i + " "); t++; } } int x = 0; int y = 1000; while(x!=1) { if(find(y)) x = 1; y++; } println(); println(y+1); } }  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## Haskell import Data.Char (digitToInt) harshads :: [Int] harshads = let digsum = sum . map digitToInt . show in filter ((0 ==) . (mod <*> digsum)) [1 ..] main :: IO () main = mapM_ print [take 20 harshads, [(head . filter (> 1000)) harshads]]  Output: [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42] 1002 Or, as an alternative to string operations: import Data.List (unfoldr) import Data.Tuple (swap) import Data.Bool (bool) harshads :: [Int] harshads = filter ((0 ==) . (rem <*> digitSum)) [1 ..] digitSum :: Int -> Int digitSum = sum . unfoldr ((bool Nothing . Just . swap . flip quotRem 10) <*> (0 <)) main :: IO () main = mapM_ print$ [take 20, take 1 . dropWhile (<= 1000)] <*> [harshads]

Output:
[1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
[1002]

## Icon and Unicon

procedure main(A)
limit := integer(A[1]) | 20
every writes(niven(seq())\limit," ")
writes("... ")
write(niven(seq(1001))\1)
end

procedure niven(n)
n ? {s := 0; while s +:= move(1)}
if (n%s) = 0 then return n
end

Output:
->ns
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002
->


## IS-BASIC

100 PROGRAM "Harshad.bas"
110 LET I=1:LET CNT=0
120 PRINT "First 20 Harshad numbers are:"
130 DO
140   IF HARSHAD(I) THEN PRINT I;:LET CNT=CNT+1
150   LET I=I+1
160 LOOP UNTIL CNT=20
170 PRINT :PRINT :PRINT "First Harshad number larger than 1000 is";:LET I=1001
180 DO
190   IF HARSHAD(I) THEN PRINT I:EXIT DO
200   LET I=I+1
210 LOOP
230   LET TMP=NUM:LET SUM=0
240   DO WHILE TMP>0
250     LET SUM=SUM+MOD(TMP,10)
260     LET TMP=INT(TMP/10)
270   LOOP
290 END DEF

## J

Until =: 2 : 'u^:(-.@:v)^:_'
isHarshad =: 0 = ] |~ [: +/ #.inv  NB. BASE isHarshad N
assert 1 0 -: 10 isHarshad&> 42 38
assert 3 4 5 -: nextHarshad&> 2 3 4
assert 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 -: (, nextHarshad@:{:)Until (20 = #) 1

NB. next Harshad number in base 6.  Input and output are in base 6.
NB. Verification left to you, gentle programmer.
23253


## Java

Works with: Java version 1.5+
public class Harshad{
private static long sumDigits(long n){
long sum = 0;
for(char digit:Long.toString(n).toCharArray()){
sum += Character.digit(digit, 10);
}
return sum;
}
public static void main(String[] args){
for(int count = 0, i = 1; count < 20;i++){
if(i % sumDigits(i) == 0){
System.out.println(i);
count++;
}
}
System.out.println();
for(int i = 1001; ; i++){
if(i % sumDigits(i) == 0){
System.out.println(i);
break;
}
}
}
}

Output:
1
2
3
4
5
6
7
8
9
10
12
18
20
21
24
27
30
36
40
42

1002

## JavaScript

### ES5

function isHarshad(n) {
var s = 0;
var n_str = new String(n);
for (var i = 0; i < n_str.length; ++i) {
s += parseInt(n_str.charAt(i));
}
return n % s === 0;
}

var count = 0;

for (var n = 1; count < 20; ++n) {
count++;
}
}

var h = 1000;
console.log(h);

Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002

### ES6 with generator

function* harshads (start) {
for (let n = start; true; n++) {
const sum = [...n.toString()].map(Number).reduce((a, b) => a + b)
if (n % sum === 0) {
yield n
}
}
}

const first20 = (() => {
return [...Array(20)].map(() => hs.next().value)
})()
console.log("First 20:", ...first20)

console.log("First after 1000:", firstAfter1000)

Output:
First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
First after 1000: 1002

### ES6

One possible approach to functional composition:

(() => {
'use strict';

// nHarshads :: Int -> [Int]
const nHarshads = n => {

// isHarshad :: Int -> Bool
const isHarshad = n => 0 === n % sum(digitList(n));

return until(
dct => dct.nth === n,
dct => {
const
next = succ(dct.i),
return {
i: next,
hs: blnHarshad ? dct.hs.concat(next) : dct.hs,
nth: dct.nth + (blnHarshad ? 1 : 0)
};
}, {
i: 0,
hs: [],
nth: 0
}
)
.hs;
};

// GENERIC FUNCTIONS ------------------------------------------------------

// digitList :: Int -> [Int]
const digitList = n =>
n > 0 ? [n % 10].concat(digitList(Math.floor(n / 10))) : [];

// dropWhile :: (a -> Bool) -> [a] -> [a]
const dropWhile = (p, xs) => {
let i = 0;
for (let lng = xs.length;
(i < lng) && p(xs[i]); i++) {}
return xs.slice(i);
};

// head :: [a] -> a
const head = xs => xs.length ? xs[0] : undefined;

// a -> String
const show = x => JSON.stringify(x, null, 2);

// succ :: Int -> Int
const succ = x => x + 1

// sum :: (Num a) => [a] -> a
const sum = xs => xs.reduce((a, x) => a + x, 0);

// until :: (a -> Bool) -> (a -> a) -> a -> a
const until = (p, f, x) => {
const go = x => p(x) ? x : go(f(x));
return go(x);
};

// TEST -------------------------------------------------------------------
return show({
});
})();

Output:
{
"firstTwenty": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
12,
18,
20,
21,
24,
27,
30,
36,
40,
42
],
"firstOver1000": 1002
}

## jq

def is_harshad:
def digits: tostring | [explode[] | ([.]| implode) | tonumber];
if . >= 1 then (. % (digits|add)) == 0
else false
end ;

# produce a stream of n Harshad numbers
# [candidate, count]
elif .[1] > 0 then [.[0]+1, .[1]] | _harshads
else empty
end;

# First Harshad greater than n where n >= 0
# input: next candidate
end;

[ harshads(20), "...", harshad_greater_than(1000)]
Output:
$jq -n -c -f harshad.jq [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42,"...",1002]  ## Julia Works with: Julia version 0.6 isharshad(x) = x % sum(digits(x)) == 0 nextharshad(x) = begin while !isharshad(x+1) x += 1 end; return x + 1 end function harshads(n::Integer) h = Vector{typeof(n)}(n) h[1] = 1 for j in 2:n h[j] = nextharshad(h[j-1]) end return h end println("First 20 harshad numbers: ", join(harshads(20), ", ")) println("First harshad number after 1001: ", nextharshad(1000))  Output: First 20 harshad numbers: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42 First harshad number after 1001: 1002 ## K / sum of digits of an integer sumdig: {d::(); (0<){d::d,x!10; x%:10}/x; +/d} / Test if an integer is a Harshad number isHarshad: {:[x!(sumdig x); 0; 1]} / Returns 1 if Harshad / Generate x Harshad numbers starting from y and display the list hSeries: {harshad::();i:y;while[(x-#harshad)>0;:[isHarshad i; harshad::(harshad,i)]; i+:1];harshad}  Output:  hSeries[20;1] 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 hSeries[1; 1001] ,1002  ## Kotlin // version 1.1 fun sumDigits(n: Int): Int = when { n <= 0 -> 0 else -> { var sum = 0 var nn = n while (nn > 0) { sum += nn % 10 nn /= 10 } sum } } fun isHarshad(n: Int): Boolean = (n % sumDigits(n) == 0) fun main(args: Array<String>) { println("The first 20 Harshad numbers are:") var count = 0 var i = 0 while (true) { if (isHarshad(++i)) { print("$i ")
if (++count == 20) break
}
}

println("\n\nThe first Harshad number above 1000 is:")
i = 1000

while (true) {
println(i)
return
}
}
}

Output:
The first 20 Harshad numbers are:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42

The first Harshad number above 1000 is:
1002


## Lambdatalk

{def harshad?
{lambda {:n}
{if {W.empty? {W.rest :n}}
then {W.first :n}
else {+ {W.first :n}
{lambda {:n}
{= {% :n {harshad?.sum :n}} 0} }}

-> true
-> false

{lambda {:a :n :i}
{if {> {A.length :a} :n}
then :a
else :a}
:n
{+ :i 1}} }}}
{lambda {:n}

-> [0,1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]

{lambda {:i}
then :i
else {firstharshadafter.loop {+ :i 1}} }}}
{lambda {:n}

-> 1002


## LOLCODE

HAI 1.3

HOW IZ I digsummin YR num
I HAS A digsum ITZ 0
IM IN YR loop
num, O RLY?
YA RLY
digsum R SUM OF digsum AN MOD OF num AN 10
num R QUOSHUNT OF num AN 10
NO WAI, FOUND YR digsum
OIC
IM OUTTA YR loop
IF U SAY SO

I HAS A found ITZ 0

IM IN YR finder UPPIN YR n
I HAS A n ITZ SUM OF n AN 1
I HAS A digsum ITZ I IZ digsummin YR n MKAY

NOT MOD OF n AN digsum, O RLY?
YA RLY
DIFFRINT found AN BIGGR OF found AN 20, O RLY?
YA RLY
VISIBLE n " "!
found R SUM OF found AN 1
OIC

DIFFRINT n AN SMALLR OF n AN 1000, O RLY?
YA RLY, VISIBLE ":)" n, GTFO
OIC
OIC
IM OUTTA YR finder

KTHXBYE
Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002

## Lua

function isHarshad(n)
local s=0
local n_str=tostring(n)
for i=1,#n_str do
s=s+tonumber(n_str:sub(i,i))
end
return n%s==0
end

local count=0
local n=1

while count<20 do
count=count+1
end
n=n+1
end

local h=1001
h=h+1
end
print(h)

Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002

## Mathematica / Wolfram Language

nextHarshad =
NestWhile[# + 1 &, # + 1, ! Divisible[#, Total@IntegerDigits@#] &] &;

Output:
{1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42}
1002

            NORMAL MODE IS INTEGER

INTERNAL FUNCTION(A,B)
ENTRY TO REM.
FUNCTION RETURN A-A/B*B
END OF FUNCTION

INTERNAL FUNCTION(I)
ENTRY TO DSUM.
SUM = 0
REST = I
DIGIT       WHENEVER REST.NE.0
SUM = SUM + REM.(REST,10)
REST = REST/10
TRANSFER TO DIGIT
END OF CONDITIONAL
FUNCTION RETURN SUM
END OF FUNCTION

INTERNAL FUNCTION(I)
ENTRY TO NEXT.
LOOP        THROUGH LOOP, FOR NX=I+1, 1, REM.(NX,DSUM.(NX)).E.0
FUNCTION RETURN NX
END OF FUNCTION

PRINT COMMENT $FIRST 20 HARSHAD NUMBERS:$
H = 0
N = 0
HARSHD      WHENEVER N.LE.1000
N = NEXT.(N)
H = H + 1
WHENEVER H.LE.20, PRINT FORMAT HSHD, H, N
TRANSFER TO HARSHD
END OF CONDITIONAL

PRINT FORMAT THSND, N

VECTOR VALUES HSHD = $8HHARSHAD(,I2,4H) = ,I2*$
VECTOR VALUES THSND =
0     $34HFIRST HARSHAD NUMBER ABOVE 1000 = ,I4*$

END OF PROGRAM
Output:
FIRST 20 HARSHAD NUMBERS:
FIRST HARSHAD NUMBER ABOVE 1000 = 1002

## MATLAB / Octave

Define a testing function whether n is harshad or not

function v = isharshad(n)
v = isinteger(n) && ~mod(n,sum(num2str(n)-'0'));
end;


Check numbers

k=1; n=1;
while (k<=20)
printf('%i ',n);
k=k+1;
end;
n=n+1;
end
n = 1001;
n=n+1;
end;
printf('\nFirst harshad number larger than 1000 is %i\n',n);

1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
First harshad number larger than 1000 is 1002

## Maxima

/* Function that returns a list of digits given a nonnegative integer */
decompose(num) := block([digits, remainder],
digits: [],
while num > 0 do
(remainder: mod(num, 10),
digits: cons(remainder, digits),
num: floor(num/10)),
digits
)$/* Function that returns a list of the first len Harshad numbers */ harshad_count(len):=block( [i:1,count:0,result:[]], while count<len do (if map(lambda([x],if mod(x,apply("+",decompose(x)))=0 then true),[i])=[true] then (result:endcons(i,result),count:count+1),i:i+1), result)$

/* Function that returns a list of the Harshad numbers up to len */
first_count(len):=block(
[i:1,count:0,result:[]],
while i<=len do (if map(lambda([x],if mod(x,apply("+",decompose(x)))=0 then true),[i])=[true] then (result:endcons(i,result),count:count+1),i:i+1),
length(result))$/* Test cases */ harshad_count(20); block(first_count(1000),last(harshad_count(%%+1)));  Output: [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42] 1002  ## MMBasic number = 1 tally = 0 print "First 20 Harshad numbers:" do while tally < 20 if isHarshad(number) = 0 then print number; tally = tally + 1 endif number = number + 1 loop number = 1001 endloop = 0 print "" do if isHarshad(number) = 0 then print "The first Harshad number greater than 1000 is"; number endloop = 1 endif number = number + 1 loop until endloop = 1 function digitSum(x) let y$ = str$(x) for i = 1 to len(y$)
digitSum = digitSum + val(mid$(y$,i,1))
next i
end function

end function

Output:
First 20 Harshad numbers:
1  2  3  4  5  6  7  8  9 10 12 18 20 21 24 27 30 36 40 42
The first Harshad number greater than 1000 is 1002

## Modula-2

MODULE Harshad;
FROM InOut IMPORT WriteString, WriteCard, WriteLn;

VAR n, i: CARDINAL;

PROCEDURE DigitSum(n: CARDINAL): CARDINAL;
VAR sum: CARDINAL;
BEGIN
sum := 0;
WHILE n > 0 DO;
sum := sum + n MOD 10;
n := n DIV 10;
END;
RETURN sum;
END DigitSum;

BEGIN
REPEAT INC(n);
UNTIL n MOD DigitSum(n) = 0;
RETURN n;

BEGIN
n := 0;
WriteLn();
FOR i := 1 TO 20 DO
WriteCard(n, 3);
END;
WriteLn();
WriteString("First Harshad number above 1000: ");
WriteLn();

Output:
First 20 Harshad numbers:
1  2  3  4  5  6  7  8  9 10 12 18 20 21 24 27 30 36 40 42
First Harshad number above 1000: 1002

## min

Works with: min version 0.19.3
(
:n () =list
(n 0 >) (
n 10 mod list prepend #list
n 10 div @n
) while
list
) :digits

(dup digits sum mod 0 ==) :harshad?

(
succ :n
n succ @n
) while
n

0 (next-harshad print " " print!) 20 times newline
1000 next-harshad print!
Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002


## Miranda

main :: [sys_message]
main = [Stdout ("First 20: " ++ show first20 ++ "\n"),
Stdout ("First above 1000: " ++ show above1000 ++ "\n")]

first20 :: [num]
first20 = take 20 (filter isharshad [1..])

above1000 :: num
above1000 = hd (filter isharshad [1001..])

isharshad n = n mod digitsum n = 0

digitsum :: num->num
digitsum 0 = 0
digitsum n = n mod 10 + digitsum (n div 10)
Output:
First 20: [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
First above 1000: 1002

## MLite

fun sumdigits
(0, n) = n
|        (m, n) = sumdigits (m div 10, m rem 10) + n
|        n      = sumdigits (n div 10, n rem 10)

fun is_harshad n = (n rem (sumdigits n) = 0)

(n, ~1) = if is_harshad n then
n
else
| 	n = next_harshad_after (n + 1, ~1)

(max, _, count > max, accum) = rev accum
|       (max, here, count, accum) =
harshad (max, here + 1, count + 1, here :: accum)
else
harshad (max, here + 1, count, accum)
|       max = harshad (max, 1, 1, [])

;

print "first twenty harshad numbers = "; println  harshad 20;


## NetRexx

/* NetRexx ------------------------------------------------------------
* 21.01.2014 Walter Pachl  translated from ooRexx (from REXX version 1)
*--------------------------------------------------------------------*/

options replace format comments java crossref symbols nobinary

Parse Arg x y .                   /* get optional arguments:  X  Y */
If x='' Then x=20                 /* Not specified?  Use default   */
If y='' Then y=1000               /* "      "        "     "       */
n=0                               /* Niven count                   */
nl=''                             /* Niven list.                   */

Loop j=1 By 1 Until n=x           /* let's go Niven number hunting.*/
If j//sumdigs(j)=0 Then Do      /* j is a Niven number           */
n=n+1                         /* bump Niven count              */
nl=nl j                       /* add to list.                  */
End
End

Say 'first' n 'Niven numbers:'nl

If j//sumdigs(j)=0 Then         /* j is a Niven number           */
Leave
End

Say 'first Niven number >' y 'is:' j
Exit

method sumdigs(n) public static returns Rexx
sum=n.left(1)
Loop k=2 To n.length()
sum=sum+n.substr(k,1)
End
Return sum


output same as ooRexx's

## Nim

proc slice[T](iter: iterator(): T {.closure.}; sl: Slice[T]): seq[T] =
var i = 0
for n in iter():
if i > sl.b: break
inc i

for n in 1 ..<  int.high:
var sum = 0
for ch in $n: sum += ord(ch) - ord('0') if n mod sum == 0: yield n echo harshad.slice 0 ..< 20 for n in harshad(): if n > 1000: echo n break  Output: @[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] 1002 ## Objeck class Harshad { function : Main(args : String[]) ~ Nil { count := 0; for(i := 1; count < 20; i += 1;) { if(i % SumDigits(i) = 0){ "{$i} "->Print();
count += 1;
};
};

for(i := 1001; true; i += 1;) {
if(i % SumDigits(i) = 0){
"... {$i}"->PrintLine(); break; }; }; } function : SumDigits(n : Int) ~ Int { sum := 0; do { sum += n % 10; n /= 10; } while(n <> 0); return sum; } } 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002 ## OCaml let is_harshad x = let rec dsum n = if n < 10 then n else dsum (n / 10) + n mod 10 in x mod dsum x = 0 let () = let print_seq (x, n) = Seq.(ints x |> filter is_harshad |> take n |> map string_of_int) |> List.of_seq |> String.concat ", " |> print_endline in List.iter print_seq [1, 20; 1001, 1]  Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42 1002  ## Oforth : sumDigits(n) 0 while(n) [ n 10 /mod ->n + ] ; : isHarshad dup sumDigits mod 0 == ; 1100 seq filter(#isHarshad) dup left(20) println dup filter(#[ 1000 > ]) first println Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] 1002  ## ooRexx /* REXX --------------------------------------------------------------- * 21.01.2014 Walter Pachl modi-(simpli-)fied from REXX version 1 *--------------------------------------------------------------------*/ Parse Arg x y . /* get optional arguments: X Y */ If x='' Then x=20 /* Not specified? Use default */ If y='' Then y=1000 /* " " " " */ n=0 /* Niven count */ nl='' /* Niven list. */ Do j=1 Until n=x /* let's go Niven number hunting.*/ If j//sumdigs(j)=0 Then Do /* j is a Niven number */ n=n+1 /* bump Niven count */ nl=nl j /* add to list. */ End End Say 'first' n 'Niven numbers:'nl Do j=y+1 /* start with first candidate */ If j//sumdigs(j)=0 Then /* j is a Niven number */ Leave End Say 'first Niven number >' y 'is:' j Exit sumdigs: Procedure /* compute sum of n's digits */ Parse Arg n sum=left(n,1) Do k=2 To length(n) sum=sum+substr(n,k,1) End Return sum  Output: first 20 Niven numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 first Niven number > 1000 is: 1002 ## PARI/GP Works with: PARI/GP version 2.6.0 and above isHarshad(n)=n%sumdigits(n)==0 n=0;k=20;while(k,if(isHarshad(n++),k--;print1(n", "))); n=1000;while(!isHarshad(n++),);print("\n"n) Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, 1002 ## Pascal Works with: Free Pascal Works with: Delphi Optimized for speed, by using the state before in IncSumDigit. program Niven; {$IFDEF FPC}
{$MODE DELPHI} {$ENDIF}

const
base = 10;

type
tNum = longword; {Uint64}
{$IFDEF FPC} const cntbasedigits = trunc(ln(High(tNum)) / ln(base)) + 1; {$ELSE}

var
cntbasedigits: Integer = 0;
{$ENDIF} type tSumDigit = record sdNumber: tNum; {$IFDEF FPC}
sdDigits: array[0..cntbasedigits - 1] of byte;
{$ELSE} sdDigits: TArray<Byte>; {$ENDIF}
sdSumDig: byte;
sdIsNiven: boolean;
end;

function InitSumDigit(n: tNum): tSumDigit;
var
sd: tSumDigit;
qt: tNum;
i: integer;
begin
with sd do
begin
sdNumber := n;
{$IFDEF FPC} fillchar(sdDigits, SizeOf(sdDigits), #0); {$ELSE}
SetLength(sdDigits,cntbasedigits);
fillchar(sdDigits[0], SizeOf(sdDigits), #0);
{$ENDIF} sdSumDig := 0; sdIsNiven := false; i := 0; // calculate Digits und sum them up while n > 0 do begin qt := n div base; {n mod base} sdDigits[i] := n - qt * base; inc(sdSumDig, sdDigits[i]); n := qt; inc(i); end; if sdSumDig > 0 then sdIsNiven := (sdNumber mod sdSumDig = 0); end; InitSumDigit := sd; end; procedure IncSumDigit(var sd: tSumDigit); var i, d: integer; begin i := 0; with sd do begin inc(sdNumber); repeat d := sdDigits[i]; inc(d); inc(sdSumDig); //base-1 times the repeat is left here if d < base then begin sdDigits[i] := d; BREAK; end else begin sdDigits[i] := 0; dec(sdSumDig, base); inc(i); end; until i > high(sdDigits); sdIsNiven := (sdNumber mod sdSumDig) = 0; end; end; var MySumDig: tSumDigit; lnn: tNum; cnt: integer; begin {$IFNDEF FPC}
cntbasedigits := trunc(ln(High(tNum)) / ln(base)) + 1;
{$ENDIF} MySumDig := InitSumDigit(0); cnt := 0; repeat IncSumDigit(MySumDig); if MySumDig.sdIsNiven then begin write(MySumDig.sdNumber, '.'); inc(cnt); end; until cnt >= 20; write('....'); MySumDig := InitSumDigit(1000); repeat IncSumDigit(MySumDig); until MySumDig.sdIsNiven; writeln(MySumDig.sdNumber, '.'); // searching for big gaps between two niven-numbers // MySumDig:=InitSumDigit(18879989100-276); MySumDig := InitSumDigit(1); cnt := 0; lnn := MySumDig.sdNumber; repeat IncSumDigit(MySumDig); if MySumDig.sdIsNiven then begin if cnt < (MySumDig.sdNumber - lnn) then begin cnt := (MySumDig.sdNumber - lnn); writeln(lnn, ' --> ', MySumDig.sdNumber, ' d=', cnt); end; lnn := MySumDig.sdNumber; end; until MySumDig.sdNumber = High(tNum); { 689988915 --> 689989050 d=135 879987906 --> 879988050 d=144 989888823 --> 989888973 d=150 2998895823 --> 2998895976 d=153 ~ 24 Cpu-cycles per test i3- 4330 1..2^32-1} {$IFNDEF LINUX}readln;{$ENDIF} end.  output: 1.2.3.4.5.6.7.8.9.10.12.18.20.21.24.27.30.36.40.42.....1002. ## PascalABC.NET ## uses School; function IsHarshad(n: integer) := n.Divs(n.Digits.Sum); 1.Step.Where(IsHarshad).Take(20).Println; 1.Step.Where(i -> (i > 1000) and IsHarshad(i)).First.Println;  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## Perl use v5.36; use List::Util 'sum'; sub createHarshads ($limit) {
my(@harshads,$number); do {$number++;
if ( $number % sum ( split ( // ,$number ) ) == 0 ) {
push @harshads , $number; } } until$harshads[ -1 ] > $limit; return @harshads; } my @harshadnumbers = createHarshads my$limit = 1000;
say "The first Harshad number greater than $limit is$harshadnumbers[ -1 ]!" ;

Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
The first Harshad number greater than 1000 is 1002!

## Phix

integer n = 0
sequence digits={0}

procedure nNiven()
while 1 do
n += 1
for i=length(digits) to 0 by -1 do
if i=0 then
digits = prepend(digits,1)
exit
end if
if digits[i]<9 then
digits[i] += 1
exit
end if
digits[i] = 0
end for
if remainder(n,sum(digits))=0 then exit end if
end while
end procedure

sequence s = {}
for i=1 to 20 do
nNiven()
s &= n
end for
?s
while n<=1000 do
nNiven()
end while
?n

Output:
{1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42}
1002


Alternative version

function isHarshad(integer n)
return remainder(n,sum(sq_sub(sprint(n),'0')))=0
end function

sequence s = {}
integer n = 0
while length(s)<20 do
n += 1
s &= n
end if
end while
n = 1001
while not isHarshad(n) do n += 1 end while
?s&n

Output:
{1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42,1002}


## PicoLisp

#if niven number, return it.
(de niven (N)
(if (=0 (% N (apply + (getN N)))) N) )

#function which creates a list of numbers from input
(de getN (N)
(mapcar format (chop N)) )

#This function generates niven number list
(de nivGen (R N)
(extract niven (range R N)) )

#print 1st 20 niven numbers and 1st niven number greater than 1000
(nivGen 1 1000) ) (max ~(nivGen 1001 1010)) ) )
Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002


## PILOT

C :n=0
:i=0
*first20
C :i=i+1
T :#i: #n
J (i<20):*first20
C :n=1000
T :First Harshad number greater than 1000: #n
E :
C :n=n+1
:r=n
:s=0
*digit
C :a=r/10
:s=s+(r-a*10)
:r=a
J (r):*digit
E :
Output:
1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: 10
11: 12
12: 18
13: 20
14: 21
15: 24
16: 27
17: 30
18: 36
19: 40
20: 42
First Harshad number greater than 1000: 1002

## PL/I

*process source or(!) xref attributes;
niven: Proc Options(main);
/*********************************************************************
* 08-06.2013 Walter Pachl translated from Rexx
*                         with a slight improvement:  Do j=y+1 By 1;
*********************************************************************/
Dcl SYSPRINT Print;

Dcl (x,y) dec fixed(8);
x=20;
y=1000;
Begin;
Dcl (n(x),j) Dec Fixed(8);
Dcl ni Bin Fixed(31) Init(0);
Dcl result Char(100) Var Init('');
loop:
Do j=1 By 1;
If mod(j,sumdigs(j))=0 Then Do;
ni+=1;
n(ni)=j;
result=result!!' '!!d2c(j);
If ni=x Then Leave loop;
End;
End;
Put Edit('first 20 Niven numbers: ',result)(Skip,a,a);
Do j=y+1 By 1;
If mod(j,sumdigs(j))=0 Then
Leave;
End;
Put Edit('first Niven number > ',d2c(y),' is: ',d2c(j))(Skip,4(a));
End;

sumDigs: proc(z) Returns(Dec Fixed(3));
Dcl z Pic'(8)9';
Dcl i Bin Fixed(31);
Dcl sd Dec Fixed(3) Init(0);
Do i=1 To hbound(d);
sd+=d(i);
End;
Return(sd);
End;

d2c: Proc(z) Returns(char(8) Var);
Dcl z Pic'(8)z';
Dcl p Bin Fixed(31);
p=verify(z,' ');
Return(substr(z,p));
End;

End;
Output:
first 20 Niven numbers:  1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
first Niven number > 1000 is: 1002

## PL/M

100H:

/* FIND THE SUM OF THE DIGITS OF A 16-BIT NUMBER */
DIGIT$SUM: PROCEDURE(N) BYTE; DECLARE N ADDRESS, SUM BYTE; SUM = 0; DO WHILE N > 0; SUM = SUM + (N MOD 10); N = N / 10; END; RETURN SUM; END DIGIT$SUM;

/* FIND THE NEXT HARSHAD NUMBER ABOVE N */
NEXT$HARSHAD: PROCEDURE(N) ADDRESS; DECLARE N ADDRESS; NEXT: N = N + 1; IF N MOD DIGIT$SUM(N) = 0 THEN
RETURN N;
ELSE
GO TO NEXT;
END NEXT$HARSHAD; /* CP/M SYSCALL */ BDOS: PROCEDURE(FUNC, ARG); DECLARE FUNC BYTE, ARG ADDRESS; GO TO 5; END BDOS; /* PRINT A STRING */ PRINT$STRING: PROCEDURE(STRING);
CALL BDOS(9, STRING);
END PRINT$STRING; /* PRINT A NUMBER */ PRINT$NUMBER: PROCEDURE(N);
DECLARE S (7) BYTE INITIAL ('..... $'); DECLARE (N, P) ADDRESS, (C BASED P) BYTE; P = .S(5); DIGIT: P = P - 1; C = (N MOD 10) + '0'; N = N / 10; IF N > 0 THEN GO TO DIGIT; CALL PRINT$STRING(P);
END PRINT$NUMBER; DECLARE CRLF DATA (13,10,'$');
DECLARE N ADDRESS INITIAL (0), S BYTE;

/* PRINT FIRST 20 HARSHADS */
CALL PRINT$STRING(.'FIRST 20:$');
DO S = 1 TO 20;
CALL PRINT$NUMBER(N := NEXT$HARSHAD(N));
END;
CALL PRINT$STRING(.CRLF); /* PRINT HARSHAD NUMBER ABOVE 1000 */ CALL PRINT$STRING(.'FIRST ABOVE 1000: $'); CALL PRINT$NUMBER(NEXT$HARSHAD(1000)); CALL PRINT$STRING(.CRLF);

CALL BDOS(0,0);
EOF
Output:
FIRST 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
FIRST ABOVE 1000: 1002

## PowerShell

Works with: PowerShell version 2

In PowerShell, we generally don't wrap every little thing in a function. If you have something simple to do, you just do it.

   1..1000 | Where { $_ % ( [int[]][string[]][char[]][string]$_ | Measure -Sum ).Sum -eq 0 } | Select -First 20
1001..2000 | Where { $_ % ( [int[]][string[]][char[]][string]$_ | Measure -Sum ).Sum -eq 0 } | Select -First 1

Output:
1
2
3
4
5
6
7
8
9
10
12
18
20
21
24
27
30
36
40
42
1002


But if we do have a need for the code to be reusable, we can do that.

function Get-HarshadNumbers
{
<#
.SYNOPSIS
Returns numbers in the Harshad or Niven series.

.DESCRIPTION
Returns all integers in the given range that are evenly divisible by the sum of their digits
in ascending order.

.PARAMETER Minimum
Lower bound of the range to search for Harshad numbers. Defaults to 1.

.PARAMETER Maximum
Upper bound of the range to search for Harshad numbers. Defaults to 2,147,483,647

.PARAMETER Count
Maximum number of Harshad numbers to return.
#>

[cmdletbinding()]
Param (
[int]$Minimum = 1, [int]$Maximum = [int]::MaxValue,
[int]$Count ) # Skip any non-positive numbers in the specified range$Minimum = [math]::Max( 1, $Minimum ) # If the adjusted range has any numbers in it... If ($Maximum -ge $Minimum ) { # If a count was specified, build a parameter for the Select statement to kill the pipeline when the count is achieved. If ($Count ) { $SelectParam = @{ First =$Count } }
Else          { $SelectParam = @{} } # For each number in the range, test the remainder of it divided it by iteself (converted to a string, # then a character array, then a string array, then an integer array, then summed).$Minimum..$Maximum | Where {$_ % ( [int[]][string[]][char[]][string]$_ | Measure -Sum ).Sum -eq 0 } | Select @SelectParam } }  Get-HarshadNumbers -Count 20 Get-HarshadNumbers -Minimum 1001 -Count 1  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002  ## Prolog Works with SWI-Prolog and module lambda.pl written by Ulrich Neumerkel, it can be found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl. :- use_module(library(lambda)). niven :- nb_setval(go, 1), L = [1 | _], print_niven(L, 1), gen_niven(1, L). print_niven([X|T], N) :- when(ground(X), ( ( nb_getval(go, 1) -> ( N < 20 -> writeln(X), N1 is N+1, print_niven(T, N1) ; ( X > 1000 -> writeln(X), nb_setval(go, 0) ; N1 is N+1, print_niven(T, N1))) ; true))). gen_niven(X, [N | T]) :- ( nb_getval(go, 1) -> X1 is X+1, sum_of_digit(X, S), ( X mod S =:= 0 -> N = X, gen_niven(X1, T) ; gen_niven(X1, [N | T])) ; true). sum_of_digit(N, S) :- number_chars(N, LC), maplist(\X^Y^number_chars(Y, [X]), LC, LN), sum_list(LN, S).  Output:  ?- niven. 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 1002 true.  ## PureBasic If OpenConsole()=0 : End 1 : EndIf Procedure.i Niven(v.i) w=v While v : s+v%10 : v/10 : Wend If w%s=0 : ProcedureReturn w : EndIf EndProcedure Repeat i+1 If Niven(i) : c+1 : Print(Str(i)+" ") : EndIf If c=20 And i<1000 : Print("... ") : i=1000 : EndIf If c=21 : Break : EndIf ForEver Input()  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002  ## Python ### Python: Procedural >>> import itertools >>> def harshad(): for n in itertools.count(1): if n % sum(int(ch) for ch in str(n)) == 0: yield n >>> list(itertools.islice(harshad(), 0, 20)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] >>> for n in harshad(): if n > 1000: print(n) break 1002 >>>  ### Python: Functional The for loop above could be changed to the following to find the number > 1000; in fact the harshad generator function could become a generator expression creating this more functional version: >>> from itertools import count, islice >>> harshad = (n for n in count(1) if n % sum(int(ch) for ch in str(n)) == 0) >>> list(islice(harshad, 0, 20)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] >>> next(x for x in harshad if x > 1000) 1002 >>>  And we could also sum digits more directly (without string coercion) while still preserving functional composition: Works with: Python version 3.7 '''Harshad or Niven series''' from itertools import count, dropwhile, islice # harshads :: () -> [Int] def harshads(): '''Harshad series''' return ( x for x in count(1) if 0 == x % digitSum(x) ) # digitSum :: Int -> Int def digitSum(n): '''Sum of the decimal digits of n.''' def go(x): return None if 0 == x else divmod(x, 10) return sum(unfoldl(go)(n)) # ------------------------- TEST ------------------------- # main :: IO () def main(): '''First 20, and first above 1000.''' def firstTwenty(xs): return take(20)(xs) def firstAbove1000(xs): return take(1)( dropwhile(lambda x: 1000 >= x, xs) ) print( fTable(__doc__ + ':\n')( lambda x: x.__name__ )(showList)(lambda f: f(harshads()))([ firstTwenty, firstAbove1000 ]) ) # ----------------------- GENERIC ------------------------ # take :: Int -> [a] -> [a] # take :: Int -> String -> String def take(n): '''The prefix of xs of length n, or xs itself if n > length xs. ''' return lambda xs: ( xs[0:n] if isinstance(xs, (list, tuple)) else list(islice(xs, n)) ) # unfoldl :: (b -> Maybe (b, a)) -> b -> [a] def unfoldl(f): '''A lazy (generator) list unfolded from a seed value by repeated application of f until no residue remains. Dual to fold/reduce. f returns either None or just (residue, value). For a strict output list, wrap the result with list() ''' def go(v): residueValue = f(v) while residueValue: yield residueValue[1] residueValue = f(residueValue[0]) return go # ----------------------- DISPLAY ------------------------ # fTable :: String -> (a -> String) -> # (b -> String) -> (a -> b) -> [a] -> String def fTable(s): '''Heading -> x display function -> fx display function -> f -> xs -> tabular string. ''' def gox(xShow): def gofx(fxShow): def gof(f): def goxs(xs): ys = [xShow(x) for x in xs] w = max(map(len, ys)) def arrowed(x, y): return y.rjust(w, ' ') + ' -> ' + ( fxShow(f(x)) ) return s + '\n' + '\n'.join( map(arrowed, xs, ys) ) return goxs return gof return gofx return gox # showList :: [a] -> String def showList(xs): '''Stringification of a list.''' return '[' + ','.join(repr(x) for x in xs) + ']' # MAIN --- if __name__ == '__main__': main()  Output: Harshad or Niven series: firstTwenty -> [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42] firstAbove1000 -> [1002] ## Quackery [ number$ $"0 " swap witheach [ join$ " + " join ]
quackery ]               is digitsum  ( n --> n )

[ dup digitsum
mod 0 = ]                is isharshad ( n --> b )

say "The first 20 Harshad numbers are: "

0 1
[ dup echo sp dip 1+ ]
1+
over 20 = until ]
2drop
cr
cr
say "The first Harshad number greater than 1000 is: "

iff echo done
again ]
cr

Output:

The first 20 Harshad numbers are: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42

The first Harshad number greater than 1000 is: 1002



## Racket

#lang racket

(define (digsum n)
(for/sum ([c (number->string n)]) (string->number [string c])))

(stream-filter (λ (n) (= (modulo n (digsum n)) 0)) (in-naturals 1)))

(displayln (for/list ([i 20]) (stream-ref harshads i)))

; First harshad greater than 1000
(displayln (for/first ([h harshads] #:when(> h 1000)) h))

Output:
(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)
1002

Different to the Scheme implementation in that it illustrates Racket's native iterators, and let-values with quotient/remainder:

#lang racket
(require math/number-theory)
(define (digital-sum n)
(let inner
((n n) (s 0))
(if (zero? n) s
(let-values ([(q r) (quotient/remainder n 10)])
(inner q (+ s r))))))

(and (>= n 1)
(divides? (digital-sum n) n)))

;; find 1st 20 Harshad numbers
(for ((i (in-range 1 (add1 20)))
(printf "#~a ~a~%" i h))

;; find 1st Harshad number > 1000
(displayln (for/first ((h (sequence-filter harshad-number? (in-naturals 1001)))) h))

Output:
#1 1
#2 2
#3 3
#4 4
#5 5
#6 6
#7 7
#8 8
#9 9
#10 10
#11 12
#12 18
#13 20
#14 21
#15 24
#16 27
#17 30
#18 36
#19 40
#20 42
1002

## Raku

(formerly Perl 6)

Works with: Rakudo version 2016.08
constant @harshad = grep { $_ %% .comb.sum }, 1 .. *; say @harshad[^20]; say @harshad.first: * > 1000;  Output: (1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42) 1002 ## Refal $ENTRY Go {
= <Prout 'First 20: ' <GetFirst 20 Harshad>>
<Prout 'First > 1000: ' <Next Harshad 1000>>;
};

GetFirst {
s.N s.F = <GetFirst s.N s.F 0>;
0 s.F s.Cur = ;
s.N s.F s.Cur, <Next s.F s.Cur>: s.Next
= s.Next <GetFirst <- s.N 1> s.F s.Next>;
};

Next {
s.F s.N, <+ 1 s.N>: s.Next, <Mu s.F s.Next>: {
T = s.Next;
F = <Next s.F s.Next>;
};
};

s.N, <DigSum s.N>: s.Dsum, <Mod s.N s.Dsum>: 0 = T;
s.N = F;
};

DigSum {
0 = 0;
s.N, <Divmod s.N 10>: (s.Rest) s.Dgt = <+ s.Dgt <DigSum s.Rest>>;
};
Output:
First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
First > 1000: 1002

## REXX

These REXX examples allow the user to specify how many Niven numbers to list,
as well as find the first Niven number greater than a specified positive integer.

Also, gihugeic integers are supported   (essentially no limit).

### generic

/*REXX program finds the first  A  Niven numbers;  it also finds first Niven number > B.*/
parse arg A B .                                  /*obtain optional arguments from the CL*/
if A=='' | A==','  then A=   20                  /*Not specified?  Then use the default.*/
if B=='' | B==','  then B= 1000                  /* "      "         "   "    "     "   */
numeric digits 1+max(8, length(A), length(B) )   /*enable the use of any sized numbers. */
#= 0;      $= /*set Niven numbers count; Niven list.*/ do j=1 until #==A /*◄───── let's go Niven number hunting.*/ if j // sumDigs(j)==0 then do; #= #+1;$= $j; end end /*j*/ /* [↑] bump count; append J ──► list.*/ say 'first' A 'Niven numbers:'$           /*display list of Niven numbers──►term.*/
do t=B+1  until t//sumDigs(t)==0 /*hunt for a Niven (or Harshad) number.*/
end   /*t*/
say 'first Niven number >'   B    " is: "     t  /*display 1st Niven number >   B.      */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
sumDigs: parse arg x 1 s 2 q;   do k=1  for length(q); s= s+substr(q,k,1); end;   return s

output   when using the default inputs:
first 20 Niven numbers:  1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
first Niven number > 1000  is:  1002


### idiomatic

This REXX version idiomatically uses a   isNiven   function.

/*REXX program finds the first  A  Niven numbers;  it also finds first Niven number > B.*/
parse arg A B .                                  /*obtain optional arguments from the CL*/
if A=='' | A==','  then A=   20                  /*Not specified?  Then use the default.*/
if B=='' | B==','  then B= 1000                  /* "      "         "   "    "     "   */
numeric digits 1+max(8, length(A), length(B))    /*enable the use of any sized numbers. */
#= 0;      $= /*set Niven numbers count; Niven list.*/ do j=1 until #==A /*◄───── let's go Niven number hunting.*/ if isNiven(j) then do; #= #+1;$= $j; end end /*j*/ /* [↑] bump count; append J ──► list.*/ say 'first' A 'Niven numbers:'$           /*display list of Niven numbers──►term.*/

do t=B+1  until  isNiven(t)   /*hunt for a Niven (or Harshad) number.*/
end   /*t*/
say 'first Niven number >'   B    " is: "     t  /*display 1st Niven number >   B.      */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
isNiven: parse arg x 1 s 2 q; do k=1 for length(q); s=s+substr(q,k,1); end; return x//s==0

output   is identical to the 1st REXX version.

### esoteric

This REXX version optimizes the   isNiven   function by using   parse   statements instead of the   substr   BIF,
yielding a faster algorithm.

/*REXX program finds the first  A  Niven numbers;  it also finds first Niven number > B.*/
parse arg A B .                                  /*obtain optional arguments from the CL*/
if A=='' | A==','  then A=   20                  /*Not specified?  Then use the default.*/
if B=='' | B==','  then B= 1000                  /* "      "         "   "    "     "   */
numeric digits 1+max(8, length(A), length(B) )   /*enable the use of any sized numbers. */
#= 0;      $= /*set Niven numbers count; Niven list.*/ do j=1 until #==A /*◄───── let's go Niven number hunting.*/ if isNiven(j) then do; #= #+1;$= $j; end end /*j*/ /* [↑] bump count; append J ──► list.*/ say 'first' A 'Niven numbers:'$           /*display list of Niven numbers──►term.*/

do t=B+1  until  isNiven(t)   /*hunt for a Niven (or Harshad) number.*/
end
say 'first Niven number >'   B    " is: "     t  /*display 1st Niven number >   B.      */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
isNiven: parse arg x 1 sum 2 q                   /*use the 1st decimal digit for  SUM.  */
do length(q);              parse var q _ 2 q;          sum= sum + _
end   /*length(q)*/             /*   ↑                                 */
return x // sum == 0                    /*   └──────◄ is destructively parsed. */

output   is identical to the 1st REXX version.

### array of numbers

This REXX version builds an   array   of numbers instead of a   list   (building an array is much faster than building a list, especially if the list is very long).

In addition, if the   A   number is negative, the numbers in the array aren't displayed, but the   last   number in the array is displayed.

/*REXX program finds the first  A  Niven numbers;  it also finds first Niven number > B.*/
parse arg A B .                                  /*obtain optional arguments from the CL*/
if A=='' | A==','  then A=   20                  /*Not specified?  Then use the default.*/
if B=='' | B==','  then B= 1000                  /* "      "         "   "    "     "   */
tell= A>0;              A= abs(A)                /*flag for showing a Niven numbers list*/
A= abs(a)
numeric digits 1+max(8, length(A), length(B) )   /*enable the use of any sized numbers. */
#= 0;    $= /*set Niven numbers count; Niven list.*/ do j=1 until #==A /*◄───── let's go Niven number hunting.*/ if isNiven(j) then do; #= #+1; !.#= j; end end /*j*/ /* [↑] bump count; append J ──► list.*/ w= length(!.w) /*W: is the width of largest Niven #.*/ if tell then do say 'first' A 'Niven numbers:'; do k=1 for #; say right(!.k, w); end /*k*/ end else say 'last of the' A 'Niven numbers: ' !.# say do t=B+1 until isNiven(t) /*hunt for a Niven (or Harshad) number.*/ end say 'first Niven number >' B " is: " t exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ isNiven: parse arg x 1 sum 2 q /*use the first decimal digit for SUM.*/ do while q\==''; parse var q _ 2 q; sum= sum + _ end /*while*/ /* ↑ */ return x // sum == 0 /* └──────◄ is destructively parsed.*/  output when the input used is: -1000000 66777888 last of the 1000000 Niven numbers: 12150510 first Niven number > 66777888 is: 66777900  ## Ring i = 1 count = 0 while true sum = 0 if niven(i) = 1 if count < 20 see "" + i + " is a Niven number" + nl count +=1 ok if i > 1000 see "" + i + " is a Niven number" exit ok ok i + =1 end func niven nr nrString = string(nr) for j = 1 to len(nrString) sum = sum + number(nrString[j]) next niv = ((nr % sum) = 0) return niv Output: 1 is a Niven number 2 is a Niven number 3 is a Niven number 4 is a Niven number 5 is a Niven number 6 is a Niven number 7 is a Niven number 8 is a Niven number 9 is a Niven number 10 is a Niven number 12 is a Niven number 18 is a Niven number 20 is a Niven number 21 is a Niven number 24 is a Niven number 27 is a Niven number 30 is a Niven number 36 is a Niven number 40 is a Niven number 42 is a Niven number 1002 is a Niven number  ## RPL Works with: Halcyon Calc version 4.2.7 Code Comments ≪ DO 1 + DUP DUP →STR DUP SIZE → n len ≪ 0 1 len FOR j n j DUP SUB NUM + NEXT len 48 * - ≫ UNTIL MOD NOT END ≫ 'NXTHR' STO ≪ {} 0 1 20 START NXTHR SWAP OVER + SWAP NEXT DROP 1000 NXTHR ≫ EVAL  ( n -- next_Harshad_number) Increment n and initialize local variables Add ASCII codes Remove offset 48 = NUM("0") Create list of first 20 Harshad numbers Get first Harshad number > 1000  Output: 2: { 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 } 1: 1002  ## Ruby Works with: Ruby version 2.4 Ruby 2.4 gave Integers a digits method, and Arrays a sum method. harshad = 1.step.lazy.select { |n| n % n.digits.sum == 0 } puts "The first 20 harshard numbers are: \n#{ harshad.first(20) }" puts "The first harshard number > 1000 is #{ harshad.find { |n| n > 1000 } }"  Output: The first 20 harshard numbers are: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42] The first harshard number > 1000 is 1002  > ## Run BASIC while count < 20 h = h + 1 if neven(h) = 0 then count = count + 1 print count;": ";h end if wend h = 1000 while 1 = 1 h = h + 1 if neven(h) = 0 then print h exit while end if wend function neven(h) h$ = str$(h) for i = 1 to len(h$)
d = d + val(mid$(h$,i,1))
next i
neven = h mod d
end function
Output:
1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7
8: 8
9: 9
10: 10
11: 12
12: 18
13: 20
14: 21
15: 24
16: 27
17: 30
18: 36
19: 40
20: 42
1002


## Rust

fn is_harshad (n : u32) -> bool {
let sum_digits = n.to_string()
.chars()
.map(|c| c.to_digit(10).unwrap())
.fold(0, |a, b| a+b);
n % sum_digits == 0
}

fn main() {
for i in (1u32..).filter(|num| is_harshad(*num)).take(20) {
}
for i in (1_001u32..).filter(|num| is_harshad(*num)).take(1) {
println!("First Harshad bigger than 1_000 : {}", i);
}
}

Output:
Harshad : 1
First Harshad bigger than 1_000 : 1002


## Scala

object Harshad extends App {
val harshads = Stream.from(1).filter(i => i % i.toString.map(_.asDigit).sum == 0)

}

Output:
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42)
1002

## Scheme

#!/usr/local/bin/gosh

;; Show the first 20 niven numbers and the
;; first one greater than 1000.
(define (main args)
(display (iota-filtered 20 1 niven?))(newline)
(display (iota-filtered 1 1001 niven?))(newline))

;; Return a list of length n
;; for numbers starting at start
;; that satisfy the predicate fn.
(define (iota-filtered n start fn)
(let loop ((num start)(lst (list)))
(if (= (length lst) n)
lst
(loop (+ 1 num) (if (fn num) (append lst (list num)) lst)))))

;; Is a number a niven number?
(define (niven? n)
(and (> n 0) (= 0 (remainder n (sum-of-digits n)))))

;; Get the sum of the digits of a number.
(define (sum-of-digits n)
(apply + (map string->number (map string (string->list (number->string n))))))

Output:
(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)
(1002)


80 LET SD=SD+VAL N$(I) 90 NEXT I 100 IF N/SD<>INT (N/SD) THEN GOTO 40 110 LET H=H+1 120 IF H<=20 OR N>1000 THEN PRINT N 130 IF N>1000 THEN GOTO 150 140 GOTO 40 150 SLOW  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 ## Swift struct Harshad: Sequence, IteratorProtocol { private var i = 0 mutating func next() -> Int? { while true { i += 1 if i % Array(String(i)).map(String.init).compactMap(Int.init).reduce(0, +) == 0 { return i } } } } print("First 20: \(Array(Harshad().prefix(20)))") print("First over a 1000: \(Harshad().first(where: {$0 > 1000 })!)")

Output:
First 20: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42]
First over a 1000: 1002

## Tcl

# Determine if the given number is a member of the class of Harshad numbers
if {$n < 1} {return false} set sum [tcl::mathop::+ {*}[split$n ""]]
return [expr {$n%$sum == 0}]
}

# Get the first 20 numbers that satisfy the condition
for {set n 1; set harshads {}} {[llength $harshads] < 20} {incr n} { if {[isHarshad$n]} {
lappend harshads $n } } puts [format "First twenty Harshads: %s" [join$harshads ", "]]

# Get the first value greater than 1000 that satisfies the condition
for {set n 1000} {![isHarshad [incr n]]} {} {}
puts "First Harshad > 1000 = $n"  Output: First twenty Harshads: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42 First Harshad > 1000 = 1002  ## uBasic/4tH C=0 For I = 1 Step 1 Until C = 20 ' First 20 Harshad numbers If FUNC(_FNHarshad(I)) Then Print I;" "; : C = C + 1 Next For I = 1001 Step 1 ' First Harshad greater than 1000 If FUNC(_FNHarshad(I)) Then Print I;" " : Break Next End _FNHarshad Param(1) Local(2) c@ = a@ b@ = 0 Do While (c@ > 0) b@ = b@ + (c@ % 10) c@ = c@ / 10 Loop Return ((a@ % b@) = 0)  Output: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002 0 OK, 0:185 ## UNIX Shell Works with: Bourne Again SHell Works with: Korn Shell Works with: Z Shell function main { local -i i=0 n gen_harshad | while read n; do if (( !i )); then printf '%d' "$n"
elif (( i < 20 )); then
printf ' %d' "$n" elif (( i == 20 )); then printf '\n' elif (( n > 1000 )); then printf '%d\n' "$n"
return
fi
(( i++ ))
done
}

local -i sum=0 n=$1 i for (( i=0; i<${#n}; ++i )); do
(( sum += ${n:$i:1} ))
done
(( n % sum == 0 ))
}

local -i i=1
while true; do
if is_harshad $i; then printf '%d\n' "$i"
fi
(( i++ ))
done
}

if i > 1000 {print("\nThe first Harshad number above 1000: ${i}") break} } } } fn sum_digits(number int) int { mut num, mut sum := number, 0 if number <= 0 {return 0} for num > 0 { sum += num % 10 num /= 10 } return sum } fn is_harshad(n int) bool { if n % sum_digits(n) == 0 {return true} return false }  Output: The first 20 Harshad numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 The first Harshad number above 1000: 1002  ## VTL-2 10 ?="First 20: "; 20 N=0 30 I=0 40 #=200 50 ?=N 60$=32
70 I=I+1
80 #=I<20*40
90 ?=""
100 ?="First above 1000: ";
110 N=1000
120 #=200
130 ?=N
140 #=999
200 ;=!
210 N=N+1
220 K=N
230 S=0
240 K=K/10
250 S=S+%
260 #=0<K*240
270 #=N/S*0+0<%*210
280 #=;
Output:
First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
First above 1000: 1002

## Whitespace

This solution was generated from the pseudo-Assembly below. A live run is available for the inquiring skeptic.

push 0 ; Harshad numbers found
push 0 ; counter

0:  ; Increment the counter, call "digsum", branch on the modulus.
push 0 call 1 mod
jz 2
jump 0

1:  ; [n 0] => [digsum(n)]
copy 1
push 10 div swap
push 0 copy 2 sub
jn 1
slide 1 ret

2:  ; Should we print this Harshad number?
push 1000 copy 1 sub jn 3 ; We're done if it's greater than 1000.
swap push 1 add swap      ; Increment how many we've found so far.
push 20 copy 2 sub jn 0   ; If we've already got 20, go back to the top.
dup onum push 32 ochr     ; Otherwise, print it and a space.
jump 0                    ; And /then/ go back to the top.

3:  ; Print the > 1000 Harshad number on its own line and exit clean.
push 10 ochr onum pop push 10 ochr exit
Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002

## Wren

var niven = Fiber.new {
var n = 1
while (true) {
var i = n
var sum = 0
while (i > 0) {
sum = sum + i%10
i = (i/10).floor
}
if (n%sum == 0) Fiber.yield(n)
n = n + 1
}
}

System.print("The first 20 Niven numbers are:")
for (i in 1..20) {
System.write("%(niven.call()) ")
}
System.write("\n\nThe first Niven number greater than 1000 is: ")
while (true) {
var niv = niven.call()
if (niv > 1000) {
System.print(niv)
break
}
}
Output:
The first 20 Niven numbers are:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42

The first Niven number greater than 1000 is: 1002


## XPL0

include c:\cxpl\codes;          \intrinsic 'code' declarations
int H, C, N, S;                 \Harshad number, Counter, Number, Sum
[H:= 1;  C:= 0;
loop    [N:= H;  S:= 0;         \sum digits
repeat  N:= N/10;
S:= S + rem(0);
until   N = 0;
if rem(H/S) = 0 then    \Harshad no.is evenly divisible by sum of digits
[if C < 20 then [IntOut(0, H);  ChOut(0, ^ );  C:= C+1];
if H > 1000 then [IntOut(0, H);  CrLf(0);  quit];
];
H:= H+1;
];
]
Output:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002


## Yabasic

Translation of: BASIC256
sub sumDigits(n)
if n < 0 then return 0 : endif
local sum
while n > 0
sum = sum + mod(n, 10)
n = int(n / 10)
wend
return sum
end sub

return mod(n, sumDigits(n)) = 0
end sub

print "Los primeros 20 numeros de Harshad o Niven son:"
contar = 0
i = 1

repeat
print i, " ",
contar = contar + 1
end if
i = i + 1
until contar = 20

print : print
print "El primero de esos numeros por encima de 1000 es:"
i = 1001

do
print i, " "
break
end if
i = i + 1
loop
print
end
Output:
Igual que la entrada de BASIC256.


## zkl

fcn harshad(n){ 0==n%(n.split().sum(0)) }
[1..].tweak(fcn(n){ if(not harshad(n)) return(Void.Skip); n })
.walk(20).println();
[1001..].filter1(harshad).println();

Walkers are zkl iterators. [a..b] is a Walker from a to b. Walkers can be tweaked to transform the sequence they are walking. In this case, ignore non Harshad numbers. Then tell the walker to get 20 items from that [modified] sequence.

In this case, filters are the better solution.

Output:
L(1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42)
L(1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42)
L(1002)


## ZX Spectrum Basic

Translation of: AWK
10 LET k=0: LET n=0
20 IF k=20 THEN GO TO 60
30 LET n=n+1: GO SUB 1000
40 IF isHarshad THEN PRINT n;" ";: LET k=k+1
50 GO TO 20
60 LET n=1001
70 GO SUB 1000: IF NOT isHarshad THEN LET n=n+1: GO TO 70
80 PRINT '"First Harshad number larger than 1000 is ";n
90 STOP
1010 LET s=0: LET n$=STR$ n
1020 FOR i=1 TO LEN n$1030 LET s=s+VAL n$(i)
1100 DEF FN m(a,b)=a-INT (a/b)*b`