Harshad or Niven series: Difference between revisions

 

=={{header|11l}}==

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

 

I is_harshad(n)

print(n)

 

{{out}}

 

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

NIVEN CSECT

USING NIVEN,R13 base register

XDEC DS CL12 temp xdeco

REGEQU symbolic registers

{{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|Ada}}==

 

procedure Harshad is

Current := 1000 + 1;

Ada.Text_IO.Put_Line(" ..." & Integer'Image(Next(Current)));

{{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

FOR i FROM 1001 DO

(i %* digit sum (i) = 0 | printf (($g(0)l$, i)); stop) OD

{{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|AppleScript}}==

===Idiomatic===

if (n < 0) then set n to 0

repeat

set h to nextHarshad(1000)

 

 

{{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 -----------------

 

set my text item delimiters to dlm

s

{{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 over 1000: -> 1002</pre>

 

=={{header|AutoHotkey}}==

n := 1

 

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;

}

return !(n%s);

{{out}}

<pre>First twenty Harshad numbers are:

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

set /a tempcount+=1

goto strlengthloop

{{out}}

<pre>

First Harshad number greater than 1000: 1002

</pre>

 

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

WHILE TRUE

IF FNHarshad(I%) THEN

tmp%/=10

ENDWHILE

{{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|Befunge}}==

>\1+^ + <|:/<+55<` :

^_>1-\:.v@1>\:0\`#v_+\^

>^1\,+55<.^_:#%$:#<"}"v

 

{{out}}

42

1002</pre>

 

=={{header|C}}==

 

static int digsum(int n)

 

return 0;

{{out}}

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

 

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

using System;

using System.Collections.Generic;

}

}

{{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;

for (; n > 0; n /= 10) yield return n % 10;

}

 

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

#include <iostream>

 

std::cout << "The smallest Harshad number greater than 1000 : " << start << '\n' ;

return 0 ;

{{out}}

<pre>

 

=={{header|Clojure}}==

(if (zero? n) acc

(digsum (quot n 10) (+ acc (mod n 10)))))

(iterate inc 1))]

(prn (take 20 harshads))

{{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|COBOL}}==

{{works with|OpenCOBOL|1.1}}

program-id. harshad.

environment division.

*> end-if.

exit paragraph.

 

=={{header|ColdFusion}}==

<Cfset harshadNum = 0>

<Cfset counter = 0>

 

<Cfoutput>... #harshadNum# </Cfoutput>

 

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

(zerop (rem n (digit-sum n))))

 

(cond ((= (length lst) n) (reverse lst))

((harshadp i) (list-harshad n (+ i 1) (cons i 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)

(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 } }"

{{out}}

<pre>

 

=={{header|D}}==

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

 

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]

1002</pre>

 

=={{header|EchoLisp}}==

(define (harsh? n)

(zero? (modulo n

(for ((n H)) #:break (> n 1000) => n)

→ 1002

 

=={{header|Eiffel}}==

note

description : "project application root class"

end

 

 

{{out}}

 

=={{header|Elixir}}==

def series, do: Stream.iterate(1, &(&1+1)) |> Stream.filter(&(number?(&1)))

IO.inspect Harshad.series |> Enum.take(20)

 

 

{{out}}

 

=={{header|Erlang}}==

-module( harshad ).

 

sequence( _N, Found, {Found, Acc} ) -> lists:reverse( Acc );

sequence( N, Find, Acc ) -> sequence( N + 1, Find, acc(N, Acc) ).

 

{{out}}

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).

-export([main/0,harshad/1,seq/1]).

io:format("seq(20): ~w~n", [ seq(20) ]),

io:format("gt(1000): ~w~n", [ gt(1000,[]) ]).

<pre>

 

</pre>

 

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

match bigint.DivRem(n, d) with

| (_, rest) -> rest = 0I

printfn ""

printfn "%A" (Seq.find (fun n -> n > 1000I) harshads)

<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 = ;

 

20 first-n-niven .

{{out}}

<pre>

=={{header|FBSL}}==

The INITIALIZE routine fills a dynamic array with all we need, even the ellipsis.

 

CLASS harshad

 

PAUSE

{{out}}

<pre>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...</pre>

 

=={{header|Fortran}}==

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

 

end program Harshad

 

=={{header|FreeBASIC}}==

 

Function sumDigits(n As Integer) As Integer

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

isHarshad[n] := n mod sum[integerDigits[n]] == 0

 

 

println[i]

 

{{out}}

1002

</pre>

 

=={{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

Print sNiven.Join(", ")

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println(n)

{{out}}

<pre>

 

=={{header|Groovy}}==

​class HarshadNiven{ public static boolean find(int x)

{

}

}

{{out}}

<pre>

 

=={{header|Haskell}}==

 

harshads :: [Int]

 

main :: IO ()

{{out}}

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

Or, as an alternative to string operations:

 

import Data.Tuple (swap)

import Data.Bool (bool)

 

main :: IO ()

{{Out}}

<pre>

=={{header|Icon}} and {{header|Unicon}}==

 

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

every writes(niven(seq())\limit," ")

n ? {s := 0; while s +:= move(1)}

if (n%s) = 0 then return n

 

{{out}}

 

=={{header|IS-BASIC}}==

110 LET I=1:LET CNT=0

120 PRINT "First 20 Harshad numbers are:"

270 LOOP

280 LET HARSHAD=MOD(NUM,SUM)=0

 

=={{header|J}}==

isHarshad =: 0 = ] |~ [: +/ #.inv NB. BASE isHarshad N

assert 1 0 -: 10 isHarshad&> 42 38

' '-.~":6#.inv nextHarshad_base_6 6b23235

23253

 

=={{header|Java}}==

{{works with|Java|1.5+}}

private static long sumDigits(long n){

long sum = 0;

}

}

{{out}}

<pre>1

=={{header|JavaScript}}==

===ES5===

var s = 0;

var n_str = new String(n);

while (!isHarshad(++h));

console.log(h);

{{out}}

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

1002</pre>

 

===ES6===

One possible approach to functional composition:

'use strict';

 

firstOver1000: head(dropWhile(x => x <= 1000, nHarshads(1000)))

});

{{Out}}

<pre>{

 

=={{header|jq}}==

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

if . >= 1 then (. % (digits|add)) == 0

 

# Task:

{{Out}}

$ jq -n -c -f harshad.jq

=={{header|Julia}}==

{{works with|Julia|0.6}}

nextharshad(x) = begin while !isharshad(x+1) x += 1 end; return x + 1 end

 

 

println("First 20 harshad numbers: ", join(harshads(20), ", "))

 

{{out}}

 

=={{header|K}}==

/ sum of digits of an integer

sumdig: {d::(); (0<){d::d,x!10; x%:10}/x; +/d}

/ 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}

 

{{out}}

 

=={{header|Kotlin}}==

 

fun sumDigits(n: Int): Int = when {

}

}

 

{{out}}

1002

</pre>

 

=={{header|LOLCODE}}==

 

HOW IZ I digsummin YR num

IM OUTTA YR finder

 

{{out}}

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

 

=={{header|Lua}}==

local s=0

local n_str=tostring(n)

end

print(h)

{{out}}

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

 

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

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

Print@Rest@NestList[nextHarshad, 0, 20];

{{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|MATLAB}} / {{header|Octave}}==

Define a testing function whether n is harshad or not

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

Check numbers

while (k<=20)

if isharshad(n)

n=n+1;

end;

<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|min}}==

{{works with|min|0.19.3}}

:n () =list

(n 0 >) (

 

0 (next-harshad print " " print!) 20 times newline

{{out}}

<pre>

</pre>

 

=={{header|MLite}}==

(0, n) = n

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

 

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

 

=={{header|NetRexx}}==

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

*--------------------------------------------------------------------*/

sum=sum+n.substr(k,1)

End

'''output''' same as ooRexx's

 

=={{header|Nim}}==

var i = 0

for n in iter():

if n > 1000:

echo n

{{out}}

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

 

=={{header|Objeck}}==

class Harshad {

function : Main(args : String[]) ~ Nil {

}

}

<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 == ;

 

 

{{out}}

 

=={{header|ooRexx}}==

* 21.01.2014 Walter Pachl modi-(simpli-)fied from REXX version 1

*--------------------------------------------------------------------*/

sum=sum+substr(n,k,1)

End

{{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

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

{{works with|PARI/GP|2.6.0 and above}}

n=0;k=20;while(k,if(isHarshad(n++),k--;print1(n", ")));

{{out}}

<pre>1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 18, 20, 21, 24, 27, 30, 36, 40, 42,

=={{header|Pascal}}==

{{works with|Free Pascal}}

Optimized for speed, by using the state before in IncSumDigit.

const

base = 10;

type

const

type

tSumDigit = record

 

var

begin

with sd do

begin

sdIsNiven := false;

i := 0;

qt := n div base;

{n mod base}

inc(i);

end;

end;

end;

 

var

begin

i := 0;

begin

sdDigits[i] := 0;

inc(i);

end;

end;

end;

 

var

cnt: integer;

begin

cnt := 0;

repeat

IncSumDigit(MySumDig);

begin

inc(cnt);

end;

until cnt >= 20;

write('....');

repeat

IncSumDigit(MySumDig);

until MySumDig.sdIsNiven;

// searching for big gaps between two niven-numbers

// MySumDig:=InitSumDigit(18879989100-276);

cnt := 0;

repeat

IncSumDigit(MySumDig);

if MySumDig.sdIsNiven then

begin

begin

end;

end;

{

689988915 --> 689989050 d=135

2998895823 --> 2998895976 d=153

~ 24 Cpu-cycles per test i3- 4330 1..2^32-1}

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}}==

 

}

{{out}}

The first Harshad number greater than 1000 is 1002!</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

Alternative version

{{out}}

<pre>

 

=={{header|PicoLisp}}==

#if niven number, return it.

(de niven (N)

(printsp ~(list ~(head 20

(nivGen 1 1000) ) (max ~(nivGen 1001 1010)) ) )

{{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|PL/I}}==

niven: Proc Options(main);

/*********************************************************************

End;

 

 

{{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

first Niven number > 1000 is: 1002</pre>

 

=={{header|PowerShell}}==

{{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.

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

{{out}}

<pre>

</pre>

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

function Get-HarshadNumbers

{

}

}

Get-HarshadNumbers -Count 20

Get-HarshadNumbers -Minimum 1001 -Count 1

{{out}}

<pre>

=={{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 :-

sum_list(LN, S).

 

{{out}}

<pre> ?- niven.

 

</pre>

 

=={{header|Python}}==

===Python: Procedural===

>>> def harshad():

for n in itertools.count(1):

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))

>>> next(x for x in harshad if x > 1000)

1002

 

 

{{Works with|Python|3.7}}

 

 

 

def harshads():

'''Harshad series'''

)

 

'''Sum of the decimal digits of n.'''

def go(x):

return sum(unfoldl(go)(n))

 

 

# main :: IO ()

def main():

 

 

 

# take :: Int -> [a] -> [a]

 

 

# unfoldl :: (b -> Maybe (b, a)) -> b -> [a]

def unfoldl(f):

'''

def go(v):

 

 

 

# fTable :: String -> (a -> String) ->

def fTable(s):

'''

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>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]</pre>

 

=={{header|Racket}}==

 

(define (digsum n)

; First harshad greater than 1000

 

{{out}}

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)

 

;; find 1st Harshad number > 1000

{{out}}

<pre>#1 1

 

{{works with|Rakudo|2016.08}}

say @harshad[^20];

{{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|REXX}}==

Also, gihugeic integers are supported &nbsp; (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.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

===idiomatic===

This REXX version idiomatically uses a &nbsp; '''isNiven''' &nbsp; function.

parse arg A B . /*obtain optional arguments from the CL*/

if A=='' | A==',' then A= 20 /*Not specified? Then use the default.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

 

This REXX version optimizes the &nbsp; '''isNiven''' &nbsp; function by using &nbsp; '''parse''' &nbsp; statements instead of the &nbsp; '''substr''' &nbsp; 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.*/

do length(q); parse var q _ 2 q; sum= sum + _

end /*length(q)*/ /* ↑ */

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

 

 

In addition, if the &nbsp; '''A''' &nbsp; number is negative, the numbers in the array aren't displayed, but the &nbsp; ''last'' &nbsp; 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.*/

do while q\==''; parse var q _ 2 q; sum= sum + _

end /*while*/ /* ↑ */

{{out|output|text=&nbsp; when the input used is: &nbsp; &nbsp; <tt> -1000000 &nbsp; 66777888 </tt>}}

<pre>

 

=={{header|Ring}}==

i = 1

count = 0

niv = ((nr % sum) = 0)

return niv

Output:

<pre>

42 is a Niven number

1002 is a Niven number

</pre>

 

{{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 } }"

{{out}}

<pre>

 

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

h = h + 1

if neven(h) = 0 then

next i

neven = h mod d

{{out}}

<pre>

 

=={{header|Rust}}==

let sum_digits = n.to_string()

.chars()

 

fn main() {

}

}

}

{{out}}

<pre>

</pre>

 

=={{header|Scala}}==

 

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)

=={{header|Scheme}}==

 

 

;; Show the first 20 niven numbers and the

(apply + (map string->number (map string (string->list (number->string n))))))

 

 

{{out}}

 

=={{header|Seed7}}==

 

const func integer: sumOfDigits (in var integer: num) is func

current := 1001;

writeln(" ... " <& nextHarshadNum(current));

 

{{out}}

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

</pre>

 

=={{header|Sidef}}==

{

}

}

 

 

do {

n = iter.run

 

{{out}}

<pre>

=={{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

130 IF N>1000 THEN GOTO 150

140 GOTO 40

{{out}}

<pre>1

=={{header|Swift}}==

 

private var i = 0

 

 

print("First 20: \(Array(Harshad().prefix(20)))")

 

{{out}}

 

=={{header|Tcl}}==

proc isHarshad {n} {

if {$n < 1} {return false}

# Get the first value greater than 1000 that satisfies the condition

for {set n 1000} {![isHarshad [incr n]]} {} {}

{{out}}

<pre>

 

=={{header|uBasic/4tH}}==

 

For I = 1 Step 1 Until C = 20 ' First 20 Harshad numbers

Loop

 

{{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|VBA}}==

 

Sub Main()

Next i

IsHarshad = sNumber Mod Summ = 0

 

{{out}}

 

=={{header|VBScript}}==

m = 1

first20 = ""

IsHarshad = True

End If

 

{{out}}

 

=={{header|Visual FoxPro}}==

LOCAL lnCount As Integer, k As Integer

CLEAR

RETURN n % d = 0

ENDFUNC

{{out}}

<pre>

First such number > 1000: 1002

</pre>

 

=={{header|Whitespace}}==

 

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

 

 

3: ; Print the > 1000 Harshad number on its own line and exit clean.

{{out}}

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

 

=={{header|Wren}}==

var n = 1

while (true) {

break

}

 

{{out}}

 

=={{header|XPL0}}==

int H, C, N, S; \Harshad number, Counter, Number, Sum

[H:= 1; C:= 0;

H:= H+1;

];

 

{{out}}

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

</pre>

 

=={{header|zkl}}==

[1..].tweak(fcn(n){ if(not harshad(n)) return(Void.Skip); n })

.walk(20).println();

[1..].filter(20,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.

 

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

{{trans|AWK}}

20 IF k=20 THEN GO TO 60

30 LET n=n+1: GO SUB 1000

1050 LET isHarshad=NOT FN m(n,s)

1060 RETURN