Increasing gaps between consecutive Niven numbers: Difference between revisions
Content deleted Content added
Increasing gaps between consecutive Niven numbers en BASIC256 |
Added Sidef |
||
(14 intermediate revisions by 13 users not shown) | |||
Line 32:
:* [https://cs.uwaterloo.ca/journals/JIS/VOL6/Doyon/doyon.pdf (PDF) version of the (above) article by Doyon].
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F digit_sum(=n, =sum)
sum++
L n > 0 & n % 10 == 0
sum -= 9
n /= 10
R sum
V previous = 1
V gap = 0
V s = 0
V niven_index = 0
V gap_index = 1
print(‘Gap index Gap Niven index Niven number’)
V niven = 1
L gap_index <= 22
s = digit_sum(niven, s)
I niven % s == 0
I niven > previous + gap
gap = niven - previous
print(‘#9 #4 #13 #11’.format(gap_index, gap, niven_index, previous))
gap_index++
previous = niven
niven_index++
niven++</syntaxhighlight>
{{out}}
<pre>
Gap index Gap Niven index Niven number
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
22 108 3750017 49989744
</pre>
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN # show where the gaps increase in the series of Niven numbers #
# ( numbers divisible by the sum of their digits ) #
INT n count := 0;
INT g count := 0;
INT n gap := 0;
INT this n := 1;
print( ( " Gap Gap Niven Niven Next", newline ) );
print( ( "Index Value Index Number Niven Number", newline ) );
print( ( "----- ----- -------- --------- ------------", newline ) );
INT t8 := 0;
FOR d0 FROM 0 TO 9 DO
FOR d1 FROM 0 TO 9 DO
INT s1 = d0 + d1;
FOR d2 FROM 0 TO 9 DO
INT s2 = s1 + d2;
FOR d3 FROM 0 TO 9 DO
INT s3 = s2 + d3;
FOR d4 FROM 0 TO 9 DO
INT s4 = s3 + d4;
FOR d5 FROM 0 TO 9 DO
INT s5 = s4 + d5;
FOR d6 FROM 0 TO 9 DO
INT s6 = s5 + d6;
FOR d7 FROM 0 TO 9 DO
INT s7 = s6 + d7;
FOR d8 FROM 0 TO 9 DO
INT s8 = s7 + d8;
IF s8 /= 0 THEN
t8 +:= 1;
IF t8 MOD s8 = 0 THEN
# have a Niven number #
INT this gap = t8 - this n;
IF this gap > n gap THEN
# found a larger gap #
g count +:= 1;
n gap := this gap;
print( ( whole( g count, -5 )
, whole( n gap, -6 )
, whole( n count, -9 )
, whole( this n, -10 )
, " "
, whole( t8, 0 )
, newline
)
)
FI;
n count +:= 1;
this n := t8
FI
FI
OD # d8 #
OD # d7 #
OD # d6 #
OD # d5 #
OD # d4 #
OD # d3 #
OD # d2 #
OD # d1 #
OD # d0 #
END</syntaxhighlight>
{{out}}
<pre>
Gap Gap Niven Niven Next
Index Value Index Number Niven Number
----- ----- -------- --------- ------------
1 1 1 1 2
2 2 10 10 12
3 6 11 12 18
4 7 26 63 70
5 8 28 72 80
6 10 32 90 100
7 12 83 288 300
8 14 102 378 392
9 18 143 558 576
10 23 561 2889 2912
11 32 716 3784 3816
12 36 1118 6480 6516
13 44 2948 19872 19916
14 45 4194 28971 29016
15 54 5439 38772 38826
16 60 33494 297864 297924
17 66 51544 478764 478830
18 72 61588 589860 589932
19 88 94748 989867 989955
20 90 265336 2879865 2879955
21 99 800054 9898956 9899055
22 108 3750017 49989744 49989852
23 126 6292149 88996914 88997040
24 135 44194186 689988915 689989050
25 144 55065654 879987906 879988050
26 150 61074615 989888823 989888973
</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f INCREASING_GAPS_BETWEEN_CONSECUTIVE_NIVEN_NUMBERS.AWK
# converted from C
Line 70 ⟶ 222:
return(n % d == 0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 98 ⟶ 250:
22 108 3750017 49989744
</pre>
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">
function digit_sum(n, sum)
# devuelve la suma de los dígitos de n dada la suma de los dígitos de n - 1
Line 141 ⟶ 292:
next niven
end
</syntaxhighlight>
=={{header|C}}==
{{trans|C++}}
<
#include <stdbool.h>
#include <stdint.h>
Line 188 ⟶ 339:
}
return 0;
}</
{{out}}
Line 228 ⟶ 379:
=={{header|C++}}==
<
#include <iomanip>
#include <iostream>
Line 272 ⟶ 423:
}
return 0;
}</
{{out}}
Line 317 ⟶ 468:
(the last one where the Niven number fits in the integer type).
<
# print uint32 right-aligned in column, with
Line 388 ⟶ 539:
end if;
niven := niven + 1;
end loop;</
{{out}}
Line 421 ⟶ 572:
27 153 179,838,772 2,998,895,823</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|Windows,SysUtils,StdCtrls}}
Because the code requires almost two minutes to run, it has optional callback that supplies information that can be used to power a progress bar.
<syntaxhighlight lang="Delphi">
function SumDigits(N: integer): integer;
{Sum the integers in a number}
var T: integer;
begin
Result:=0;
repeat
begin
T:=N mod 10;
N:=N div 10;
Result:=Result+T;
end
until N<1;
end;
function IsNiven(N: integer): boolean;
{Test if N is evenly divisible by sum}
{i.e. is it a Niven Number}
var Sum: integer;
begin
Sum:=SumDigits(N);
Result:=(N mod Sum)=0;
end;
function GetNextNiven(Start: integer): integer;
{Get the next Niven number after Start}
begin
repeat Inc(Start)
until IsNiven(Start);
Result:=Start;
end;
procedure ShowNivenGaps(Memo: TMemo; Prog: TProgress);
{Show when gaps between sucessive Niven Numbers changes}
var I: integer;
var N1,N2,Gap: integer;
var Cnt: integer;
const Limit = 65000000;
begin
Memo.Lines.Add(' Gap Gap Niven Niven Next');
Memo.Lines.Add('Index Value Index Number Niven Number');
Memo.Lines.Add('----- ----- -------- --------- ------------');
Gap:=0; Cnt:=0;
N1:=GetNextNiven(0);
for I:=1 to Limit do
begin
{Get next Niven and test if Gap has changed}
N2:=GetNextNiven(N1);
if (N2-N1)>Gap then
begin
Gap:=N2-N1;
Inc(Cnt);
Memo.Lines.Add(Format('%5d%6d%15.0n%15.0n%15.0n',[Cnt,Gap,I+0.0,N1+0.0,N2+0.0]));
end;
N1:=N2;
if Assigned(Prog) and ((I mod 100000)=0) then Prog(MulDiv(100,I,Limit));
end;
end;
</syntaxhighlight>
{{out}}
<pre>
Gap Gap Niven Niven Next
Index Value Index Number Niven Number
----- ----- -------- --------- ------------
1 1 1 1 2
2 2 10 10 12
3 6 11 12 18
4 7 26 63 70
5 8 28 72 80
6 10 32 90 100
7 12 83 288 300
8 14 102 378 392
9 18 143 558 576
10 23 561 2,889 2,912
11 32 716 3,784 3,816
12 36 1,118 6,480 6,516
13 44 2,948 19,872 19,916
14 45 4,194 28,971 29,016
15 54 5,439 38,772 38,826
16 60 33,494 297,864 297,924
17 66 51,544 478,764 478,830
18 72 61,588 589,860 589,932
19 88 94,748 989,867 989,955
20 90 265,336 2,879,865 2,879,955
21 99 800,054 9,898,956 9,899,055
22 108 3,750,017 49,989,744 49,989,852
23 126 6,292,149 88,996,914 88,997,040
24 135 44,194,186 689,988,915 689,989,050
25 144 55,065,654 879,987,906 879,988,050
26 150 61,074,615 989,888,823 989,888,973
</pre>
=={{header|EasyLang}}==
{{trans|C}}
<syntaxhighlight>
func digsum n sum .
sum += 1
while n > 0 and n mod 10 = 0
sum -= 9
n = n div 10
.
return sum
.
func divisible n d .
if d mod 2 = 0 and n mod 2 = 1
return 0
.
return if n mod d = 0
.
numfmt 0 8
previous = 1
print " Gap index Gap Niven index Niven number"
print " --------- --- ----------- ------------"
for niven = 1 to 10000000
sum = digsum niven sum
if divisible niven sum = 1
if niven > previous + gap
gap_index += 1
gap = niven - previous
print gap_index & gap & " " & niven_index & " " & previous
.
previous = niven
niven_index += 1
.
.
</syntaxhighlight>
{{out}}
<pre>
Gap index Gap Niven index Niven number
--------- --- ----------- ------------
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
</pre>
=={{header|Fortran}}==
{{trans|C}}
<
implicit none
integer*8 prev /1/, gap /0/, sum /0/
Line 499 ⟶ 811:
go to 40
end if
end subroutine</
{{out}}
Line 537 ⟶ 849:
31 258 547,594,831 9,879,997,824
32 276 1,039,028,518 18,879,988,824</pre>
=={{header|FreeBASIC}}==
{{trans|AWK}}
<
Function digit_sum(n As Uinteger, sum As Ulong) As Ulong
' devuelve la suma de los dígitos de n dada la suma de los dígitos de n - 1
Line 579 ⟶ 890:
Next niven
Sleep
</syntaxhighlight>
{{out}}
<pre>
Line 608 ⟶ 919:
23 126 6,292,149 88,996,914
</pre>
=={{header|FutureBasic}}==
Note: Computation time rises exponentially after the first 22 iterations.
<syntaxhighlight lang="futurebasic">
local fn DigitSum( n as UInt64, sum as UInt64 ) as UInt64
sum++
while ( n > 0 and n mod 10 == 0 )
sum -= 9
n = n / 10
wend
end fn = sum
local fn IsDivisible( n as UInt64, d as UInt64 ) as BOOL
BOOL result
if ( ( d and 1 ) == 0 and ( n and 1 ) == 1 ) then result = NO : exit fn
result = n mod d == 0
end fn = result
local fn DoIt
UInt64 niven, previous = 1, gap = 0, sum = 0
long niven_index = 0, gap_index = 1
printf( @"Index Gap Niven index Niven number" )
printf( @"----- --- ----------- ------------" )
for niven = 1 to gap_index <= 24
sum = fn DigitSum( niven, sum )
if ( fn IsDivisible( niven, sum ) )
if ( niven > previous + gap )
gap = niven - previous
printf @"%3d %6llu %13d %15llu", gap_index, gap, niven_index, previous
gap_index++
end if
previous = niven
niven_index++
end if
next
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Index Gap Niven index Niven number
----- --- ----------- ------------
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
22 108 3750017 49989744
23 126 6292149 88996914
24 135 44194186 689988915
</pre>
=={{header|Go}}==
This reuses code from the [[https://rosettacode.org/wiki/Harshad_or_Niven_series#Go Harshad or Niven series]] task though converted to use 'uint64' rather than 'int' in case anyone is running Go on a 32-bit platform.
<
import "fmt"
Line 669 ⟶ 1,059:
pn = n
}
}</
{{out}}
Line 710 ⟶ 1,100:
=={{header|Haskell}}==
<
import Control.Monad (guard)
import Text.Printf (printf)
Line 742 ⟶ 1,132:
$ takeWhile (\(_, gapIndex, _) -> gapIndex < 10_000_000) findGaps
where
row = "%5s%15s%15s\n"</
{{out}}
<pre>
Line 772 ⟶ 1,162:
=={{header|J}}==
<syntaxhighlight lang="j">
tasks=: (gap , (,:~ index))@:niven
Line 783 ⟶ 1,173:
assert 1 = +/ 10 12 E. niven 100 NB. the sublist 10 12 occurs once in niven numbers less than 100
assert 0 1 6 90 -: gap 1 2 8 98 NB. show infix swapped subtractions
</syntaxhighlight>
<pre>
Line 806 ⟶ 1,196:
</pre>
J tokens are either isolated ASCII symbols or end with a suffix either `.' or ':' . Verbs return nouns. The sentence of nouns and verbs ~.>./\2-~/\A evaluate from right to left.
<
Given that <syntaxhighlight lang
`2 -~/\ A' finds the difference between successive pairs of A. In 2 -~/\ A the verb -~/\ surrounded by nouns is dyadic, which is to do -~/ on the length 2 infixes of A. Consuming the 2 and A, infix adverb \ passes length 2 vectors of items of A to the verb -~/ . Adverb / inserts the verb - between the items of the vector, which it then evaluates since there's no more...except that we want a[i+1]-a[i], which explains the passive ~ adverb to swap the arguments.
Line 817 ⟶ 1,207:
=={{header|Java}}==
<
public class NivenNumberGaps {
Line 851 ⟶ 1,241:
}
</syntaxhighlight>
{{out}}
Line 889 ⟶ 1,279:
276 1,039,028,518 18,879,988,824
</pre>
=={{header|jq}}==
'''Adapted from [[#C|C]]'''
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
In this entry, computation continues in accordance with the task description,
that is until a specified Niven number is reached.
To have computation continue indefinitely, call the `nivens` generator with `null` or `infinite` as input,
e.g.:
<pre>
infinite | nivens
</pre>
'''Preliminaries'''
<syntaxhighlight lang="jq">def add(s): reduce s as $x (null; . + $x);
def digit_sum:
def digits: tostring | explode[] | [.] | implode | tonumber;
add(digits);
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .; </syntaxhighlight>
'''Niven Numbers'''
<syntaxhighlight lang="jq"># input: the largest Niven number to be considered (null => infinite)
# output: a stream of informative JSON objects -
# {gap_index, gap, niven_index, previous}
def nivens:
(. // infinite) as $limit
| { gap: 0,
gap_index: 1,
niven: 1,
niven_index: 1}
| foreach range(2; $limit+1) as $n (.;
.emit = false
| if $n % ($n | digit_sum) == 0
then if $n > .niven + .gap
then .gap = $n - .niven
| .emit = {gap_index, gap, niven_index, niven}
| .gap_index += 1
else .
end
| .niven = $n
| .niven_index += 1
else .
end;
select(.emit).emit );
"Gap index Gap Niven index Niven number",
"--------- --- ----------- ------------",
( 1E7 | nivens
| "\(.gap_index|lpad(9)) \(.gap|lpad(4)) \(.niven_index|lpad(12)) \(.niven|lpad(13))" )</syntaxhighlight>
{{out}}
<pre>
Gap index Gap Niven index Niven number
--------- --- ----------- ------------
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
22 108 3750017 49989744
</pre>
=={{header|Julia}}==
<
function findharshadgaps(N)
Line 910 ⟶ 1,381:
findharshadgaps(50_000_000_000)
</
<pre>
Gap Index Number Index Niven Number
Line 957 ⟶ 1,428:
MAD does not have bitwise operations. It's possible to fake them using division,
but that would not be much of an optimization.
<
INTERNAL FUNCTION REM.(A,B) = A-A/B*B
Line 990 ⟶ 1,461:
LOOP CONTINUE
END OF PROGRAM </
{{out}}
Line 1,018 ⟶ 1,489:
21 99 800054 9898956
22 108 3750017 49989744</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[NivenQ]
$HistoryLength = 0;
NivenQ[n_Integer] := Divisible[n, Total[IntegerDigits[n]]]
sel = Select[Range[100000000], NivenQ];
i = FoldPairList[{#2 > #1, Max[#1, #2]} &, 0, Differences[sel]];
gapindex = Range[Count[i, True]];
nivenindex = Pick[Range[Length[i]], i];
nivennumber = Pick[Most[sel], i];
gap = sel[[nivenindex + 1]] - sel[[nivenindex]];
Grid[{gapindex, gap, nivenindex, nivennumber} // Transpose // Prepend[{"gap index", "gap", "niven index", "niven number"}], Frame -> All]</syntaxhighlight>
{{out}}
<pre>gap index gap niven index niven number
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
22 108 3750017 49989744
23 126 6292149 88996914</pre>
=={{header|Nim}}==
{{trans|C++}}
<
func digitsSum(n, sum: uint64): uint64 =
Line 1,053 ⟶ 1,562:
inc gapIndex
previous = niven
inc nivenIndex</
{{out}}
Line 1,093 ⟶ 1,602:
{{works with|Free Pascal}}
As fast as [http://rosettacode.org/wiki/Increasing_gaps_between_consecutive_Niven_numbers#Go GO]
<
{$IFDEF FPC}
{$MODE DELPHI}
Line 1,220 ⟶ 1,729:
begin
FindGaps;
end.</
{{out}}
<pre>Gap Index of gap Starting Niven
Line 1,291 ⟶ 1,800:
=={{header|Perl}}==
{{trans|Raku}}
<
use warnings;
use List::Util 'sum';
Line 1,310 ⟶ 1,819:
$last = $count;
last if ++$index >= $threshold;
}</
{{out}}
<pre>Gap Index of gap Starting Niven
Line 1,339 ⟶ 1,848:
=={{header|Phix}}==
Replaced sum(digits) in the original with sd, otherwise no great attempt to optimise
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">g</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">gap</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sd</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">digits</span><span style="color: #0000FF;">={</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">nNiven</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">1</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;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">digits</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">0</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">digits</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prepend</span><span style="color: #0000FF;">(</span><span style="color: #000000;">digits</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">digits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]<</span><span style="color: #000000;">9</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">digits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">digits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #000000;">sd</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">9</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">sd</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">if</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: #000000;">sd</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"gap size Niven index Niven #\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">10_000_000</span><span style="color: #0000FF;">:</span><span style="color: #000000;">1_000_000_000</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">nNiven</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">g</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">prev</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">g</span><span style="color: #0000FF;">></span><span style="color: #000000;">gap</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%,5d %,14d %,15d (%s)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">g</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">prev</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">gap</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">g</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,407 ⟶ 1,919:
=={{header|Python}}==
<
"""
Line 1,448 ⟶ 1,960:
niven_index += 1
niven += 1
</syntaxhighlight>
{{out}}
Line 1,481 ⟶ 1,993:
{{works with|Rakudo|2019.11}}
<syntaxhighlight lang="raku"
unit sub MAIN (Int $threshold = 10000000);
Line 1,500 ⟶ 2,012:
$last = count;
last if $index >= $threshold;
}</
{{out}}
<pre>Gap Index of gap Starting Niven
Line 1,528 ⟶ 2,040:
=={{header|REXX}}==
<
parse arg lim . /*obtain optional arguments from the CL*/
if lim=='' | lim==',' then lim= 10000000 /*Not specified? Then use the default.*/
Line 1,554 ⟶ 2,066:
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do c=length(_)-3 to 1 by -3; _=insert(',', _, c); end; return _
tell: say arg(1); return</
{{out|output|text= when using the input of: <tt> 20000000000 </tt> <small> (which is '''20''' billion) </small> }}
<pre>
Line 1,600 ⟶ 2,112:
The "chunk" method is essentially a sum of several chunks, the sums are found by a table lookup (associative array in REXX).
<
parse arg lim . /*obtain optional arguments from the CL*/
if lim=='' | lim==',' then lim= 1000000000000 /*Not specified? Then use the default.*/
Line 1,637 ⟶ 2,149:
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do c=length(_)-3 to 1 by -3; _=insert(',', _, c); end; return _
tell: say arg(1); return</
{{out|output|text= is identical to the 1<sup>st</sup> REXX version.}} <br><br> !-->
=={{header|RPL}}==
{{works with|RPL|HP49-C}}
« →STR 0.
1. PICK3 SIZE '''FOR''' j
OVER j DUP SUB STR→ +
'''NEXT''' NIP
» '<span style="color:blue">∑DIG</span>' STO
« '''DO''' 1 + '''UNTIL''' DUPDUP <span style="color:blue">∑DIG</span> / FP NOT '''END'''
» '<span style="color:blue">NEXTNIVEN</span>' STO
« { { 1 1 1 1 } } 1 1 1 → res gap gapindex nivindex
« 1
'''WHILE''' res SIZE 15 < '''REPEAT'''
DUP <span style="color:blue">NEXTNIVEN</span> DUP2 SWAP -
'''IF''' DUP gap >
'''THEN''' DUP 'gap' STO 'gapindex' INCR SWAP nivindex 5 ROLL
4 →LIST 1 →LIST 'res' SWAP STO+
'''ELSE''' ROT DROP2 '''END'''
'nivindex' 1 STO+
'''END'''
DROP res
» » '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { { 1 1 1 1 } { 2 2 10 10 } { 3 6 11 12 } { 4 7 26 63 } { 5 8 28 72 } { 6 10 32 90 } { 7 12 83 288 } { 8 14 102 378 } { 9 18 143 558 } { 10 23 561 2889 } { 11 32 716 3784 } { 12 36 1118 6480 } { 13 44 2948 19872 } { 14 45 4194 28971 } { 15 54 5439 38772 } }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">nivens = Enumerator.new {|y| (1..).each {|n| y << n if n.remainder(n.digits.sum).zero?} }
cur_gap = 0
puts 'Gap Index of gap Starting Niven'
nivens.each_cons(2).with_index(1) do |(n1, n2), i|
break if i > 10_000_000
if n2-n1 > cur_gap then
printf "%3d %15s %15s\n", n2-n1, i, n1
cur_gap = n2-n1
end
end
</syntaxhighlight>
{{out}}
<pre>Gap Index of gap Starting Niven
1 1 1
2 10 10
6 11 12
7 26 63
8 28 72
10 32 90
12 83 288
14 102 378
18 143 558
23 561 2889
32 716 3784
36 1118 6480
44 2948 19872
45 4194 28971
54 5439 38772
60 33494 297864
66 51544 478764
72 61588 589860
88 94748 989867
90 265336 2879865
99 800054 9898956
108 3750017 49989744
126 6292149 88996914
</pre>
=={{header|Rust}}==
<
// num-format = "0.4"
Line 1,690 ⟶ 2,271:
niven += 1;
}
}</
{{out}}
Line 1,727 ⟶ 2,308:
31 258 547,594,831 9,879,997,824
32 276 1,039,028,518 18,879,988,824
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var threshold = 10_000_000
say "Gap Index of gap Starting Niven"
for (var (n=1, index=0, gap=0, prev=1); index <= threshold; ++n) {
n.is_div(n.digits_sum) || next
if ((var diff = (n - prev)) > gap) {
gap = diff
printf("%3d %15s %15s\n", gap, index, prev)
}
prev = n
++index
}</syntaxhighlight>
{{out}}
<pre>
Gap Index of gap Starting Niven
1 1 1
2 10 10
6 11 12
7 26 63
8 28 72
10 32 90
12 83 288
14 102 378
18 143 558
23 561 2889
32 716 3784
36 1118 6480
44 2948 19872
45 4194 28971
54 5439 38772
60 33494 297864
66 51544 478764
72 61588 589860
88 94748 989867
90 265336 2879865
99 800054 9898956
108 3750017 49989744
126 6292149 88996914
</pre>
Line 1,733 ⟶ 2,355:
{{libheader|Wren-fmt}}
Limited to Niven numbers up to 1 billion in order to finish in a reasonable time (a little under 2 minutes on my machine).
<
var newSum // recursive
Line 1,775 ⟶ 2,397:
var g = n - pn
if (g > pg) {
pg = g
}
Line 1,781 ⟶ 2,403:
i = i + 1
n = h.call()
}</
{{out}}
Line 1,818 ⟶ 2,440:
This program runs under Linux.
<
section .data
;;; Header
Line 1,936 ⟶ 2,558:
dec cl
jnz .pad
.out: ret</
{{out}}
Line 1,975 ⟶ 2,597:
32 276 1,039,028,518 18,879,988,824</pre>
=={{header|XPL0}}==
{{trans|11l}}
<syntaxhighlight lang "XPL0">func DigitSum(N, Sum); \Return sum of digits in N given sum of digits in N-1
int N, Sum;
[Sum:= Sum+1;
while N > 0 and rem(N/10) = 0 do
[Sum:= Sum -9;
N:= N/10;
];
return Sum;
];
int Previous, Gap, S, NivenIndex, GapIndex, Niven;
def Tab = 9;
[Previous:= 1;
Gap:= 0;
S:= 0;
NivenIndex:= 0;
GapIndex:= 1;
Text(0, "Index Gap Index Niven^m^j");
Niven:= 1;
while GapIndex <= 23 do
[S:= DigitSum(Niven, S);
if rem(Niven/S) = 0 then
[if Niven > Previous + Gap then
[Gap:= Niven - Previous;
IntOut(0, GapIndex); ChOut(0, Tab);
IntOut(0, Gap); ChOut(0, Tab);
IntOut(0, NivenIndex); ChOut(0, Tab);
IntOut(0, Previous); CrLf(0);
GapIndex:= GapIndex+1;
];
Previous:= Niven;
NivenIndex:= NivenIndex+1;
];
Niven:= Niven+1;
];
]</syntaxhighlight>
{{out}}
<pre>
Index Gap Index Niven
1 1 1 1
2 2 10 10
3 6 11 12
4 7 26 63
5 8 28 72
6 10 32 90
7 12 83 288
8 14 102 378
9 18 143 558
10 23 561 2889
11 32 716 3784
12 36 1118 6480
13 44 2948 19872
14 45 4194 28971
15 54 5439 38772
16 60 33494 297864
17 66 51544 478764
18 72 61588 589860
19 88 94748 989867
20 90 265336 2879865
21 99 800054 9898956
22 108 3750017 49989744
23 126 6292149 88996914
</pre>
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">
sub digit_sum(n, sum)
// devuelve la suma de los dígitos de n dada la suma de los dígitos de n - 1
Line 2,014 ⟶ 2,705:
next niven
end
</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
=={{header|zkl}}==
<
harshadW:=Walker.zero().tweak(fcn(go){ // faster than one liner, fewer calls
foreach h in ([go.value..]){ // spin
Line 2,028 ⟶ 2,718:
if(0 == h%s){ go.set(h+1); return(h) }
}
}.fp(Ref(1)));</
<
prev,gap := harshadW.next(),0;
while(harshadW.n<=10_000_000){
Line 2,037 ⟶ 2,727:
}
prev=h;
}</
{{out}}
<pre>
|