Harshad or Niven series: Difference between revisions
add ABC
Drkameleon (talk | contribs) (Added Arturo implementation) |
Not a robot (talk | contribs) (add ABC) |
||
(31 intermediate revisions by 16 users not shown) | |||
Line 32:
=={{header|11l}}==
<
R n % sum(String(n).map(ch -> Int(ch))) == 0
Line 48:
I is_harshad(n)
print(n)
L.break</
{{out}}
Line 57:
=={{header|360 Assembly}}==
<
NIVEN CSECT
USING NIVEN,R13 base register
Line 113:
XDEC DS CL12 temp xdeco
REGEQU symbolic registers
END NIVEN</
{{out}}
<pre>
Line 121:
=={{header|8080 Assembly}}==
<
org 100h
section .text
Line 164:
section .data
db '*****'
buffer: db 13,10,'$'</
{{out}}
<pre>1
Line 188:
1002</pre>
=={{header|ABC}}==
<syntaxhighlight lang="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/</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Action!}}==
<
INT sum
Line 223 ⟶ 249:
a=Next(1000)
PrintIE(a)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Harshad_or_Niven_series.png Screenshot from Atari 8-bit computer]
Line 231 ⟶ 257:
=={{header|Ada}}==
<
procedure Harshad is
Line 256 ⟶ 282:
Current := 1000 + 1;
Ada.Text_IO.Put_Line(" ..." & Integer'Image(Next(Current)));
end Harshad;</
{{out}}
<pre> 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002</pre>
=={{header|ALGOL 68}}==
<
PROC digit sum = (INT i) INT :
BEGIN
Line 273 ⟶ 299:
FOR i FROM 1001 DO
(i %* digit sum (i) = 0 | printf (($g(0)l$, i)); stop) OD
END</
{{out}}
<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, 1002
Line 279 ⟶ 305:
=={{header|ALGOL-M}}==
<
integer function mod(a,b);
integer a,b;
Line 314 ⟶ 340:
write("First Harshad number above 1000:", nextharshad(1000));
end</
{{out}}
<pre>First 20 Harshad numbers:
Line 322 ⟶ 348:
=={{header|ALGOL W}}==
<
% returns the next member of the series above n %
integer procedure nextHarshad ( integer value n ) ;
Line 349 ⟶ 375:
end for_i ;
write( i_w := 1, s_w := 0, "First Harshad/Niven number > 1000: ", nextHarshad( 1000 ) );
end.</
{{out}}
<pre>
Line 358 ⟶ 384:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002</pre>
Line 364 ⟶ 390:
=={{header|AppleScript}}==
===Idiomatic===
<
if (n < 0) then set n to 0
repeat
Line 388 ⟶ 414:
set h to nextHarshad(1000)
return {harshads, h}</
{{output}}
<
===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 -----------------
Line 685 ⟶ 711:
set my text item delimiters to dlm
s
end unlines</
{{Out}}
<pre>First 20: -> [1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
Line 693 ⟶ 719:
=={{header|Arturo}}==
<
harshads: select 1..1100 => harshad?
Line 703 ⟶ 729:
break
]
]</
{{out}}
Line 711 ⟶ 737:
=={{header|AutoHotkey}}==
<
n := 1
Line 731 ⟶ 757:
n++, sum := ""
}
}</
{{out}}
<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42, . . . 1002</pre>
=={{header|AWK}}==
<
BEGIN {
k=0; n=0;
Line 757 ⟶ 783:
}
return !(n%s);
}</
{{out}}
<pre>First twenty Harshad numbers are:
Line 765 ⟶ 791:
=={{header|Batch File}}==
<
@echo off
setlocal enabledelayedexpansion
Line 802 ⟶ 828:
set /a tempcount+=1
goto strlengthloop
</syntaxhighlight>
{{out}}
<pre>
Line 829 ⟶ 855:
=={{header|BASIC}}==
<
20 PRINT "First 20 Harshad numbers:"
30 P=0
Line 843 ⟶ 869:
130 IF N<=1000 THEN 50
140 PRINT
150 PRINT "First Harshad number > 1000:";N</
{{out}}
<pre>First 20 Harshad numbers:
Line 856 ⟶ 882:
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<
function sumDigitos(n)
if n < 0 then return 0
Line 895 ⟶ 921:
until false
end
</syntaxhighlight>
{{out}}
<pre>
Line 907 ⟶ 933:
=={{header|BBC BASIC}}==
<
WHILE TRUE
IF FNHarshad(I%) THEN
Line 925 ⟶ 951:
tmp%/=10
ENDWHILE
=(num% MOD sum%)=0</
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002</pre>
=={{header|BCPL}}==
<
let dsum(n) = n=0 -> 0, n rem 10 + dsum(n/10)
Line 943 ⟶ 969:
$)
writef("*NFirst above 1000: %N*N", next(1000))
$)</
{{out}}
<pre>First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 949 ⟶ 975:
=={{header|Befunge}}==
<
>\1+^ + <|:/<+55<` :
^_>1-\:.v@1>\:0\`#v_+\^
>^1\,+55<.^_:#%$:#<"}"v
^!:\_ ^###< !`*8<</
{{out}}
Line 979 ⟶ 1,005:
=={{header|BQN}}==
<
Niven ← 0=SumDgt|⊢
nivens ← Niven¨⊸/↕1100
⟨20↑nivens, ⊑(⊢>1000˙)⊸/nivens⟩</
{{out}}
<pre>⟨ ⟨ 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ⟩ 1002 ⟩</pre>
=={{header|C}}==
<
static int digsum(int n)
Line 1,008 ⟶ 1,034:
return 0;
}</
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 1,014 ⟶ 1,040:
=={{header|C sharp|C#}}==
<
using System;
using System.Collections.Generic;
Line 1,076 ⟶ 1,102:
}
}
</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 1002</pre>
===Shorter solution===
<
using static System.Linq.Enumerable;
using static System.Console;
Line 1,102 ⟶ 1,128:
for (; n > 0; n /= 10) yield return n % 10;
}
}</
=={{header|C++}}==
<
#include <iostream>
Line 1,138 ⟶ 1,164:
std::cout << "The smallest Harshad number greater than 1000 : " << start << '\n' ;
return 0 ;
}</
{{out}}
<pre>
Line 1,147 ⟶ 1,173:
=={{header|Clojure}}==
<
(if (zero? n) acc
(digsum (quot n 10) (+ acc (mod n 10)))))
Line 1,155 ⟶ 1,181:
(iterate inc 1))]
(prn (take 20 harshads))
(prn (first (filter #(> % 1000) harshads))))</
{{out}}
<pre>(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)
Line 1,161 ⟶ 1,187:
=={{header|CLU}}==
<
sum: int := 0
while n > 0 do
Line 1,193 ⟶ 1,219:
break
end
end start_up</
{{out}}
<pre>First 20 Harshad numbers:
Line 1,201 ⟶ 1,227:
=={{header|COBOL}}==
{{works with|OpenCOBOL|1.1}}
<
program-id. harshad.
environment division.
Line 1,279 ⟶ 1,305:
*> end-if.
exit paragraph.
</
=={{header|ColdFusion}}==
<
<Cfset harshadNum = 0>
<Cfset counter = 0>
Line 1,322 ⟶ 1,348:
<Cfoutput>... #harshadNum# </Cfoutput>
</syntaxhighlight>
=={{header|Comal}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Common Lisp}}==
<
(zerop (rem n (digit-sum n))))
Line 1,336 ⟶ 1,390:
(cond ((= (length lst) n) (reverse lst))
((harshadp i) (list-harshad n (+ i 1) (cons i lst)))
(t (list-harshad n (+ i 1) lst))))</
<pre>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)
Line 1,344 ⟶ 1,398:
=={{header|Cowgol}}==
<
sub digitsum(n: uint16): (sum: uint8) is
Line 1,378 ⟶ 1,432:
print_nl();
print_i16(n);
print_nl();</
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002</pre>
=={{header|Craft Basic}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out| Output}}<pre>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</pre>
=={{header|Crystal}}==
{{trans|Ruby}}
<
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 } }"
</syntaxhighlight>
{{out}}
<pre>
Line 1,398 ⟶ 1,497:
=={{header|D}}==
<
import std.stdio, std.algorithm, std.range, std.conv;
Line 1,406 ⟶ 1,505:
harshads.take(20).writeln;
harshads.filter!(h => h > 1000).front.writeln;
}</
{{out}}
<pre>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42]
Line 1,414 ⟶ 1,513:
=={{header|Draco}}==
<
word r;
r := 0;
Line 1,443 ⟶ 1,542:
writeln();
write("First above 1000: ", next_harshad(1000))
corp</
{{out}}
<pre>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</pre>
=={{header|EasyLang}}==
{{trans|FreeBASIC}}
<syntaxhighlight>
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
</syntaxhighlight>
{{out}}
<pre>
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002
</pre>
=={{header|EchoLisp}}==
<
(define (harsh? n)
(zero? (modulo n
Line 1,464 ⟶ 1,598:
(for ((n H)) #:break (> n 1000) => n)
→ 1002
</syntaxhighlight>
=={{header|Eiffel}}==
<
note
description : "project application root class"
Line 1,545 ⟶ 1,679:
end
</syntaxhighlight>
{{out}}
Line 1,572 ⟶ 1,706:
=={{header|Elixir}}==
<
def series, do: Stream.iterate(1, &(&1+1)) |> Stream.filter(&(number?(&1)))
Line 1,583 ⟶ 1,717:
IO.inspect Harshad.series |> Enum.take(20)
IO.inspect Harshad.series |> Stream.drop_while(&(&1 <= 1000)) |> Enum.take(1) |> hd</
{{out}}
Line 1,592 ⟶ 1,726:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( harshad ).
Line 1,619 ⟶ 1,753:
sequence( _N, Found, {Found, Acc} ) -> lists:reverse( Acc );
sequence( N, Find, Acc ) -> sequence( N + 1, Find, acc(N, Acc) ).
</syntaxhighlight>
{{out}}
Line 1,632 ⟶ 1,766:
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.
<syntaxhighlight lang="erlang">
-module(harshad).
-export([main/0,harshad/1,seq/1]).
Line 1,663 ⟶ 1,797:
io:format("seq(20): ~w~n", [ seq(20) ]),
io:format("gt(1000): ~w~n", [ gt(1000,[]) ]).
</syntaxhighlight>
<pre>
Line 1,681 ⟶ 1,815:
{{Works with|Office 365 betas 2021}}
<
=LAMBDA(n,
UNTIL(
Line 1,707 ⟶ 1,841:
{1}
)
)</
and also assuming the following generic bindings in the Name Manager for the WorkBook:
<
=LAMBDA(xs,
LAMBDA(ys,
Line 1,769 ⟶ 1,903:
)
)
)</
{{Out}}
Line 1,891 ⟶ 2,025:
=={{header|F_Sharp|F#}}==
<
match bigint.DivRem(n, d) with
| (_, rest) -> rest = 0I
Line 1,910 ⟶ 2,044:
printfn ""
printfn "%A" (Seq.find (fun n -> n > 1000I) harshads)
0</
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002</pre>
=={{header|Factor}}==
<
: niven? ( n -- ? ) dup 1 digit-groups sum mod 0 = ;
Line 1,925 ⟶ 2,059:
20 first-n-niven .
1000 next-niven .</
{{out}}
<pre>
Line 1,934 ⟶ 2,068:
=={{header|FBSL}}==
The INITIALIZE routine fills a dynamic array with all we need, even the ellipsis.
<
CLASS harshad
Line 1,981 ⟶ 2,115:
PAUSE
</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002
Line 1,987 ⟶ 2,121:
=={{header|FOCAL}}==
<
01.20 S P=0
01.30 D 3
Line 2,006 ⟶ 2,140:
03.10 S N=N+1
03.20 D 2
03.30 I (FITR(N/A)*A-N)3.1</
{{out}}
<pre>= 1
Line 2,035 ⟶ 2,169:
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.
<syntaxhighlight lang="fortran">
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Tue May 21 13:15:59
Line 2,080 ⟶ 2,214:
end program Harshad
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
Function sumDigits(n As Integer) As Integer
Line 2,126 ⟶ 2,260:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 2,138 ⟶ 2,272:
=={{header|Frink}}==
<
isHarshad[n] := n mod sum[integerDigits[n]] == 0
Line 2,161 ⟶ 2,295:
println[i]
</syntaxhighlight>
{{out}}
Line 2,188 ⟶ 2,322:
1002
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="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
</syntaxhighlight>
{{output}}
<pre>
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
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Harshad_numbers}}
'''Solution'''
[[File:Fōrmulæ - Harshad numbers 01.png]]
'''Test case 1.''' List the first 20 members of the sequence
[[File:Fōrmulæ - Harshad numbers 02.png]]
[[File:Fōrmulæ - Harshad numbers 03.png]]
'''Test case 2.''' List the first Harshad number greater than 1,000
[[File:Fōrmulæ - Harshad numbers 04.png]]
[[File:Fōrmulæ - Harshad numbers 05.png]]
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=9d814ce9936ed7fdce2a084004c437f4 Click this link to run this code]'''
<
Dim siCount, siLoop, siTotal, siCounter As Short
Dim sNo, sTemp As String
Line 2,226 ⟶ 2,409:
Print sNiven.Join(", ")
End</
Output:
<pre>
Line 2,234 ⟶ 2,417:
=={{header|Go}}==
<
import "fmt"
Line 2,280 ⟶ 2,463:
}
fmt.Println(n)
}</
{{out}}
<pre>
Line 2,288 ⟶ 2,471:
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">
class HarshadNiven{ public static boolean find(int x)
{
Line 2,326 ⟶ 2,509:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,335 ⟶ 2,518:
=={{header|Haskell}}==
<
harshads :: [Int]
Line 2,343 ⟶ 2,526:
main :: IO ()
main = mapM_ print [take 20 harshads, [(head . filter (> 1000)) harshads]]</
{{out}}
<pre>[1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
Line 2,350 ⟶ 2,533:
Or, as an alternative to string operations:
<
import Data.Tuple (swap)
import Data.Bool (bool)
Line 2,362 ⟶ 2,545:
main :: IO ()
main = mapM_ print $ [take 20, take 1 . dropWhile (<= 1000)] <*> [harshads]</
{{Out}}
<pre>
Line 2,370 ⟶ 2,553:
=={{header|Icon}} and {{header|Unicon}}==
<
limit := integer(A[1]) | 20
every writes(niven(seq())\limit," ")
Line 2,380 ⟶ 2,563:
n ? {s := 0; while s +:= move(1)}
if (n%s) = 0 then return n
end</
{{out}}
Line 2,390 ⟶ 2,573:
=={{header|IS-BASIC}}==
<
110 LET I=1:LET CNT=0
120 PRINT "First 20 Harshad numbers are:"
Line 2,409 ⟶ 2,592:
270 LOOP
280 LET HARSHAD=MOD(NUM,SUM)=0
290 END DEF</
=={{header|J}}==
<
isHarshad =: 0 = ] |~ [: +/ #.inv NB. BASE isHarshad N
assert 1 0 -: 10 isHarshad&> 42 38
Line 2,427 ⟶ 2,610:
' '-.~":6#.inv nextHarshad_base_6 6b23235
23253
</syntaxhighlight>
=={{header|Java}}==
{{works with|Java|1.5+}}
<
private static long sumDigits(long n){
long sum = 0;
Line 2,454 ⟶ 2,637:
}
}
}</
{{out}}
<pre>1
Line 2,481 ⟶ 2,664:
=={{header|JavaScript}}==
===ES5===
<
var s = 0;
var n_str = new String(n);
Line 2,505 ⟶ 2,688:
while (!isHarshad(++h));
console.log(h);
</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 2,511 ⟶ 2,694:
===ES6 with generator===
<
for (let n = start; true; n++) {
const sum = [...n.toString()].map(Number).reduce((a, b) => a + b)
Line 2,527 ⟶ 2,710:
const firstAfter1000 = harshads(1001).next().value
console.log("First after 1000:", firstAfter1000)</
{{out}}
<pre>First 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 2,534 ⟶ 2,717:
===ES6===
One possible approach to functional composition:
<
'use strict';
Line 2,602 ⟶ 2,785:
firstOver1000: head(dropWhile(x => x <= 1000, nHarshads(1000)))
});
})();</
{{Out}}
<pre>{
Line 2,631 ⟶ 2,814:
=={{header|jq}}==
<
def digits: tostring | [explode[] | ([.]| implode) | tonumber];
if . >= 1 then (. % (digits|add)) == 0
Line 2,657 ⟶ 2,840:
# Task:
[ harshads(20), "...", harshad_greater_than(1000)]</
{{Out}}
$ jq -n -c -f harshad.jq
Line 2,664 ⟶ 2,847:
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
nextharshad(x) = begin while !isharshad(x+1) x += 1 end; return x + 1 end
Line 2,677 ⟶ 2,860:
println("First 20 harshad numbers: ", join(harshads(20), ", "))
println("First harshad number after 1001: ", nextharshad(1000))</
{{out}}
Line 2,684 ⟶ 2,867:
=={{header|K}}==
<syntaxhighlight lang="k">
/ sum of digits of an integer
sumdig: {d::(); (0<){d::d,x!10; x%:10}/x; +/d}
Line 2,691 ⟶ 2,874:
/ 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}
</syntaxhighlight>
{{out}}
Line 2,702 ⟶ 2,885:
=={{header|Kotlin}}==
<
fun sumDigits(n: Int): Int = when {
Line 2,740 ⟶ 2,923:
}
}
}</
{{out}}
Line 2,750 ⟶ 2,933:
1002
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def harshad?
{def harshad?.sum
{lambda {:n}
{if {W.empty? {W.rest :n}}
then {W.first :n}
else {+ {W.first :n}
{harshad?.sum {W.rest :n}}} }}}
{lambda {:n}
{= {% :n {harshad?.sum :n}} 0} }}
-> harshad?
{harshad? 12}
-> true
{harshad? 13}
-> false
{def harshads
{def harshads.loop
{lambda {:a :n :i}
{if {> {A.length :a} :n}
then :a
else {harshads.loop {if {harshad? :i}
then {A.addlast! :i :a}
else :a}
:n
{+ :i 1}} }}}
{lambda {:n}
{harshads.loop {A.new} :n 0} }}
-> harshads
{harshads 20}
-> [0,1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
{def firstharshadafter
{def firstharshadafter.loop
{lambda {:i}
{if {harshad? :i}
then :i
else {firstharshadafter.loop {+ :i 1}} }}}
{lambda {:n}
{firstharshadafter.loop {+ :n 1}} }}
-> firstharshadafter
{firstharshadafter 1000}
-> 1002
</syntaxhighlight>
=={{header|LOLCODE}}==
<
HOW IZ I digsummin YR num
Line 2,786 ⟶ 3,018:
IM OUTTA YR finder
KTHXBYE</
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 2,792 ⟶ 3,024:
=={{header|Lua}}==
<
local s=0
local n_str=tostring(n)
Line 2,820 ⟶ 3,052:
end
print(h)
</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 2,826 ⟶ 3,058:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
NestWhile[# + 1 &, # + 1, ! Divisible[#, Total@IntegerDigits@#] &] &;
Print@Rest@NestList[nextHarshad, 0, 20];
Print@nextHarshad@1000;</
{{out}}
<pre>{1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42}
Line 2,835 ⟶ 3,067:
=={{header|MAD}}==
<
INTERNAL FUNCTION(A,B)
Line 2,876 ⟶ 3,108:
0 $34HFIRST HARSHAD NUMBER ABOVE 1000 = ,I4*$
END OF PROGRAM </
{{out}}
<pre>FIRST 20 HARSHAD NUMBERS:
Line 2,903 ⟶ 3,135:
=={{header|MATLAB}} / {{header|Octave}}==
Define a testing function whether n is harshad or not
<
v = isinteger(n) && ~mod(n,sum(num2str(n)-'0'));
end; </
Check numbers
<
while (k<=20)
if isharshad(n)
Line 2,919 ⟶ 3,151:
n=n+1;
end;
printf('\nFirst harshad number larger than 1000 is %i\n',n);</
<pre>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</pre>
=={{header|Maxima}}==
<syntaxhighlight lang="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)));
</syntaxhighlight>
{{out}}
<pre>
[1,2,3,4,5,6,7,8,9,10,12,18,20,21,24,27,30,36,40,42]
1002
</pre>
=={{header|MMBasic}}==
<syntaxhighlight lang="bbcbasic">
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
function isHarshad(num)
isHarshad = num MOD digitSum(num)
end function
</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Modula-2}}==
<
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
Line 2,959 ⟶ 3,271:
WriteCard(NextHarshad(1000), 4);
WriteLn();
END Harshad.</
{{out}}
<pre>First 20 Harshad numbers:
Line 2,967 ⟶ 3,279:
=={{header|min}}==
{{works with|min|0.19.3}}
<
:n () =list
(n 0 >) (
Line 2,987 ⟶ 3,299:
0 (next-harshad print " " print!) 20 times newline
1000 next-harshad print!</
{{out}}
<pre>
Line 2,994 ⟶ 3,306:
</pre>
=={{header|Miranda}}==
<syntaxhighlight lang="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 :: num->bool
isharshad n = n mod digitsum n = 0
digitsum :: num->num
digitsum 0 = 0
digitsum n = n mod 10 + digitsum (n div 10)</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|MLite}}==
<
(0, n) = n
| (m, n) = sumdigits (m div 10, m rem 10) + n
Line 3,021 ⟶ 3,354:
print "first twenty harshad numbers = "; println ` harshad 20;
print "first harshad number after 1000 = "; println ` next_harshad_after 1000;</
=={{header|NetRexx}}==
<
* 21.01.2014 Walter Pachl translated from ooRexx (from REXX version 1)
*--------------------------------------------------------------------*/
Line 3,058 ⟶ 3,391:
sum=sum+n.substr(k,1)
End
Return sum</
'''output''' same as ooRexx's
=={{header|Nim}}==
<
var i = 0
for n in iter():
Line 3,082 ⟶ 3,415:
if n > 1000:
echo n
break</
{{out}}
<pre>@[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42]
Line 3,088 ⟶ 3,421:
=={{header|Objeck}}==
<
class Harshad {
function : Main(args : String[]) ~ Nil {
Line 3,117 ⟶ 3,450:
}
}
</syntaxhighlight>
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="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]</syntaxhighlight>
{{out}}
<pre>
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42
1002
</pre>
=={{header|Oforth}}==
<
: isHarshad dup sumDigits mod 0 == ;
1100 seq filter(#isHarshad) dup left(20) println dup filter(#[ 1000 > ]) first println</
{{out}}
Line 3,134 ⟶ 3,484:
=={{header|ooRexx}}==
<
* 21.01.2014 Walter Pachl modi-(simpli-)fied from REXX version 1
*--------------------------------------------------------------------*/
Line 3,166 ⟶ 3,516:
sum=sum+substr(n,k,1)
End
Return sum</
{{out}}
<pre>first 20 Niven numbers: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 3,173 ⟶ 3,523:
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.6.0 and above}}
<
n=0;k=20;while(k,if(isHarshad(n++),k--;print1(n", ")));
n=1000;while(!isHarshad(n++),);print("\n"n)</
{{out}}
<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42,
Line 3,185 ⟶ 3,535:
Optimized for speed, by using the state before in IncSumDigit.
<
{$IFDEF FPC}
Line 3,331 ⟶ 3,681:
~ 24 Cpu-cycles per test i3- 4330 1..2^32-1}
{$IFNDEF LINUX}readln;{$ENDIF}
end.</
output:
<pre>1.2.3.4.5.6.7.8.9.10.12.18.20.21.24.27.30.36.40.42.....1002.</pre>
=={{header|Perl}}==
<syntaxhighlight lang="perl">use v5.36;
use
sub createHarshads ($limit) {
my
$number++;
if ( $number % sum ( split ( // , $number ) ) == 0 ) {
push @harshads , $number
}
} until $
}
my @harshadnumbers = createHarshads my $limit = 1000;
say "The first Harshad number greater than $limit is $harshadnumbers[ -1 ]!" ;</syntaxhighlight>
{{out}}
<pre>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!</pre>
=={{header|Phix}}==
<!--<
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">digits</span><span style="color: #0000FF;">={</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}</span>
Line 3,413 ⟶ 3,740:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">n</span>
<!--</
{{out}}
<pre>
Line 3,420 ⟶ 3,747:
</pre>
Alternative version
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">isHarshad</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">)))=</span><span style="color: #000000;">0</span>
Line 3,436 ⟶ 3,763:
<span style="color: #008080;">while</span> <span style="color: #008080;">not</span> <span style="color: #000000;">isHarshad</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">&</span><span style="color: #000000;">n</span>
<!--</
{{out}}
<pre>
Line 3,443 ⟶ 3,770:
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">
#if niven number, return it.
(de niven (N)
Line 3,459 ⟶ 3,786:
(printsp ~(list ~(head 20
(nivGen 1 1000) ) (max ~(nivGen 1001 1010)) ) )
</syntaxhighlight>
{{out}}
<pre>
Line 3,466 ⟶ 3,793:
=={{header|PILOT}}==
<
:i=0
*first20
Line 3,487 ⟶ 3,814:
J (r):*digit
J (n<>s*(n/s)):*harshad
E :</
{{out}}
<pre>1: 1
Line 3,512 ⟶ 3,839:
=={{header|PL/I}}==
<
niven: Proc Options(main);
/*********************************************************************
Line 3,563 ⟶ 3,890:
End;
End;</
{{out}}
Line 3,570 ⟶ 3,897:
=={{header|PL/M}}==
<
/* FIND THE SUM OF THE DIGITS OF A 16-BIT NUMBER */
Line 3,635 ⟶ 3,962:
CALL BDOS(0,0);
EOF</
{{out}}
<pre>FIRST 20: 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 3,643 ⟶ 3,970:
{{works with|PowerShell|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.
<syntaxhighlight lang="powershell">
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
</syntaxhighlight>
{{out}}
<pre>
Line 3,672 ⟶ 3,999:
</pre>
But if we do have a need for the code to be reusable, we can do that.
<syntaxhighlight lang="powershell">
function Get-HarshadNumbers
{
Line 3,714 ⟶ 4,041:
}
}
</syntaxhighlight>
<syntaxhighlight lang="powershell">
Get-HarshadNumbers -Count 20
Get-HarshadNumbers -Minimum 1001 -Count 1
</syntaxhighlight>
{{out}}
<pre>
Line 3,746 ⟶ 4,073:
=={{header|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.
<
niven :-
Line 3,788 ⟶ 4,115:
sum_list(LN, S).
</syntaxhighlight>
{{out}}
<pre> ?- niven.
Line 3,816 ⟶ 4,143:
=={{header|PureBasic}}==
<
Procedure.i Niven(v.i)
Line 3,831 ⟶ 4,158:
ForEver
Input()</
{{out}}<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002 </pre>
=={{header|Python}}==
===Python: Procedural===
<
>>> def harshad():
for n in itertools.count(1):
Line 3,852 ⟶ 4,179:
1002
>>> </
===Python: Functional===
The for loop above [http://paddy3118.blogspot.co.uk/2013/03/itertoolsfirst.html 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:
<
>>> harshad = (n for n in count(1) if n % sum(int(ch) for ch in str(n)) == 0)
>>> list(islice(harshad, 0, 20))
Line 3,862 ⟶ 4,189:
>>> 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|3.7}}
<
from itertools import count, dropwhile, islice
Line 3,979 ⟶ 4,306:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Harshad or Niven series:
Line 3,987 ⟶ 4,314:
=={{header|Quackery}}==
<
witheach
[ join $ " + " join ]
Line 4,011 ⟶ 4,338:
again ]
cr
</syntaxhighlight>
'''Output:'''
<pre>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
Line 4,021 ⟶ 4,348:
=={{header|Racket}}==
<
(define (digsum n)
Line 4,033 ⟶ 4,360:
; First harshad greater than 1000
(displayln (for/first ([h harshads] #:when(> h 1000)) h))</
{{out}}
Line 4,041 ⟶ 4,368:
Different to the Scheme implementation in that it illustrates Racket's native iterators,
and ''let-values'' with ''quotient/remainder'':
<
(require math/number-theory)
(define (digital-sum n)
Line 4,060 ⟶ 4,387:
;; find 1st Harshad number > 1000
(displayln (for/first ((h (sequence-filter harshad-number? (in-naturals 1001)))) h))</
{{out}}
<pre>#1 1
Line 4,088 ⟶ 4,415:
{{works with|Rakudo|2016.08}}
<syntaxhighlight lang="raku"
say @harshad[^20];
say @harshad.first: * > 1000;</
{{out}}
<pre>(1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42)
1002</pre>
=={{header|Refal}}==
<syntaxhighlight lang="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>;
};
};
Harshad {
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>>;
};</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|REXX}}==
Line 4,102 ⟶ 4,462:
Also, gihugeic integers are supported (essentially no limit).
===generic===
<
parse arg A B . /*obtain optional arguments from the CL*/
if A=='' | A==',' then A= 20 /*Not specified? Then use the default.*/
Line 4,117 ⟶ 4,477:
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</
{{out|output|text= when using the default inputs:}}
<pre>
Line 4,126 ⟶ 4,486:
===idiomatic===
This REXX version idiomatically uses a '''isNiven''' function.
<
parse arg A B . /*obtain optional arguments from the CL*/
if A=='' | A==',' then A= 20 /*Not specified? Then use the default.*/
Line 4,142 ⟶ 4,502:
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</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br>
Line 4,148 ⟶ 4,508:
This REXX version optimizes the '''isNiven''' function by using '''parse''' statements instead of the '''substr''' BIF,
<br>yielding a faster algorithm.
<
parse arg A B . /*obtain optional arguments from the CL*/
if A=='' | A==',' then A= 20 /*Not specified? Then use the default.*/
Line 4,167 ⟶ 4,527:
do length(q); parse var q _ 2 q; sum= sum + _
end /*length(q)*/ /* ↑ */
return x // sum == 0 /* └──────◄ is destructively parsed. */</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br>
Line 4,174 ⟶ 4,534:
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.
<
parse arg A B . /*obtain optional arguments from the CL*/
if A=='' | A==',' then A= 20 /*Not specified? Then use the default.*/
Line 4,199 ⟶ 4,559:
do while q\==''; parse var q _ 2 q; sum= sum + _
end /*while*/ /* ↑ */
return x // sum == 0 /* └──────◄ is destructively parsed.*/</
{{out|output|text= when the input used is: <tt> -1000000 66777888 </tt>}}
<pre>
Line 4,208 ⟶ 4,568:
=={{header|Ring}}==
<
i = 1
count = 0
Line 4,226 ⟶ 4,586:
niv = ((nr % sum) = 0)
return niv
</syntaxhighlight>
Output:
<pre>
Line 4,250 ⟶ 4,610:
42 is a Niven number
1002 is a Niven number
</pre>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! 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
|}
{{out}}
<pre>
2: { 1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 }
1: 1002
</pre>
Line 4,255 ⟶ 4,660:
{{works with|Ruby|2.4}}
Ruby 2.4 gave Integers a '''digits''' method, and Arrays a '''sum''' method.
<
puts "The first 20 harshard numbers are: \n#{ harshad.first(20) }"
puts "The first harshard number > 1000 is #{ harshad.find { |n| n > 1000 } }"
</syntaxhighlight>
{{out}}
<pre>
Line 4,268 ⟶ 4,673:
=={{header|Run BASIC}}==
<
h = h + 1
if neven(h) = 0 then
Line 4,291 ⟶ 4,696:
next i
neven = h mod d
end function</
{{out}}
<pre>
Line 4,318 ⟶ 4,723:
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn is_harshad (n : u32) -> bool {
let sum_digits = n.to_string()
Line 4,335 ⟶ 4,740:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 4,362 ⟶ 4,767:
=={{header|Scala}}==
<
val harshads = Stream.from(1).filter(i => i % i.toString.map(_.asDigit).sum == 0)
println(harshads.take(20).toList)
println(harshads.filter(_ > 1000).head)
}</
{{out}}
<pre>List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42)
Line 4,374 ⟶ 4,779:
=={{header|Scheme}}==
<
;; Show the first 20 niven numbers and the
Line 4,399 ⟶ 4,804:
(apply + (map string->number (map string (string->list (number->string n))))))
</syntaxhighlight>
{{out}}
Line 4,408 ⟶ 4,813:
=={{header|Seed7}}==
<
const func integer: sumOfDigits (in var integer: num) is func
Line 4,441 ⟶ 4,846:
current := 1001;
writeln(" ... " <& nextHarshadNum(current));
end func;</
{{out}}
Line 4,447 ⟶ 4,852:
1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42 ... 1002
</pre>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program harshad;
print("First 20 Harshad numbers:", [n := next(n) : i in [1..20]]);
print("First Harshad number >1000:", next(1000));
proc next(n);
(until harshad(n)) n +:= 1; end;
return n;
end proc;
proc harshad(n);
return n mod +/[val d : d in str n] = 0;
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Sidef}}==
<
var n = 0
{
++n while !
n
}
}
var iter = harshad()
say 20.of { iter.run }
var n
do {
n = iter.run
} while (n <= 1000)
say n
{{out}}
<pre>
Line 4,474 ⟶ 4,897:
=={{header|Sinclair ZX81 BASIC}}==
Works with 1k of RAM. <code>FAST</code> isn't all that fast.
<
20 LET N=0
30 LET H=0
Line 4,488 ⟶ 4,911:
130 IF N>1000 THEN GOTO 150
140 GOTO 40
150 SLOW</
{{out}}
<pre>1
Line 4,514 ⟶ 4,937:
=={{header|Swift}}==
<
private var i = 0
Line 4,529 ⟶ 4,952:
print("First 20: \(Array(Harshad().prefix(20)))")
print("First over a 1000: \(Harshad().first(where: { $0 > 1000 })!)")</
{{out}}
Line 4,537 ⟶ 4,960:
=={{header|Tcl}}==
<
proc isHarshad {n} {
if {$n < 1} {return false}
Line 4,554 ⟶ 4,977:
# Get the first value greater than 1000 that satisfies the condition
for {set n 1000} {![isHarshad [incr n]]} {} {}
puts "First Harshad > 1000 = $n"</
{{out}}
<pre>
Line 4,562 ⟶ 4,985:
=={{header|uBasic/4tH}}==
<syntaxhighlight lang="text">C=0
For I = 1 Step 1 Until C = 20 ' First 20 Harshad numbers
Line 4,584 ⟶ 5,007:
Loop
Return ((a@ % b@) = 0)</
{{out}}
<pre>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</pre>
=={{header|UNIX Shell}}==
{{works with|Bourne Again SHell}}
{{works with|Korn Shell}}
{{works with|Z Shell}}
<syntaxhighlight lang="bash">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
}
function is_harshad {
local -i sum=0 n=$1 i
for (( i=0; i<${#n}; ++i )); do
(( sum += ${n:$i:1} ))
done
(( n % sum == 0 ))
}
function gen_harshad {
local -i i=1
while true; do
if is_harshad $i; then
printf '%d\n' "$i"
fi
(( i++ ))
done
}
main "$@"</syntaxhighlight>
{{Out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
1002
</pre>
=={{header|VBA}}==
<
Sub Main()
Line 4,615 ⟶ 5,083:
Next i
IsHarshad = sNumber Mod Summ = 0
End Function</
{{out}}
Line 4,623 ⟶ 5,091:
=={{header|VBScript}}==
<
m = 1
first20 = ""
Line 4,658 ⟶ 5,126:
IsHarshad = True
End If
End Function</
{{out}}
Line 4,667 ⟶ 5,135:
=={{header|Visual FoxPro}}==
<
LOCAL lnCount As Integer, k As Integer
CLEAR
Line 4,697 ⟶ 5,165:
RETURN n % d = 0
ENDFUNC
</syntaxhighlight>
{{out}}
<pre>
Line 4,723 ⟶ 5,191:
First such number > 1000: 1002
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="Zig">
fn main() {
mut count, mut i := 0, 0
print("The first 20 Harshad numbers: ")
for {
i++
if is_harshad(i) == true {
if count < 20 {print("${i} ") count++}
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
}
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl2">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 #=;</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|Whitespace}}==
<syntaxhighlight lang="whitespace">
Line 4,787 ⟶ 5,319:
</syntaxhighlight>
This solution was generated from the pseudo-Assembly below.
A [http://ideone.com/AKxEMY live run] is available for the inquiring skeptic.
<
push 0 ; counter
Line 4,815 ⟶ 5,347:
3: ; Print the > 1000 Harshad number on its own line and exit clean.
push 10 ochr onum pop push 10 ochr exit</
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 12 18 20 21 24 27 30 36 40 42
Line 4,821 ⟶ 5,353:
=={{header|Wren}}==
<
var n = 1
while (true) {
Line 4,846 ⟶ 5,378:
break
}
}</
{{out}}
Line 4,857 ⟶ 5,389:
=={{header|XPL0}}==
<
int H, C, N, S; \Harshad number, Counter, Number, Sum
[H:= 1; C:= 0;
Line 4,870 ⟶ 5,402:
H:= H+1;
];
]</
{{out}}
Line 4,880 ⟶ 5,412:
=={{header|Yabasic}}==
{{trans|BASIC256}}
<syntaxhighlight lang="yabasic">
sub sumDigits(n)
if n < 0 then return 0 : endif
Line 4,920 ⟶ 5,452:
print
end
</syntaxhighlight>
{{out}}
<pre>
Line 4,928 ⟶ 5,460:
=={{header|zkl}}==
<
[1..].tweak(fcn(n){ if(not harshad(n)) return(Void.Skip); n })
.walk(20).println();
[1..].filter(20,harshad).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.
Line 4,945 ⟶ 5,477:
=={{header|ZX Spectrum Basic}}==
{{trans|AWK}}
<
20 IF k=20 THEN GO TO 60
30 LET n=n+1: GO SUB 1000
Line 4,961 ⟶ 5,493:
1050 LET isHarshad=NOT FN m(n,s)
1060 RETURN
1100 DEF FN m(a,b)=a-INT (a/b)*b</
|