Increasing gaps between consecutive Niven numbers: Difference between revisions

{{task}}

 

::::   They are also called    '''multidigital'''   numbers.

 

:*   [https://cs.uwaterloo.ca/journals/JIS/VOL6/Doyon/doyon.pdf (PDF) version of the (above) article by Doyon].

<br><br>

 

=={{header|AWK}}==

# syntax: GAWK -f INCREASING_GAPS_BETWEEN_CONSECUTIVE_NIVEN_NUMBERS.AWK

# converted from C

return(n % d == 0)

}

{{out}}

<pre>

22 108 3750017 49989744

</pre>

=={{header|C}}==

{{trans|C++}}

#include <stdbool.h>

#include <stdint.h>

}

return 0;

 

{{out}}

 

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

#include <iomanip>

#include <iostream>

}

return 0;

 

{{out}}

(the last one where the Niven number fits in the integer type).

 

 

# print uint32 right-aligned in column, with

end if;

niven := niven + 1;

 

{{out}}

27 153 179,838,772 2,998,895,823</pre>

 

 

=={{header|Fortran}}==

{{trans|C}}

implicit none

integer*8 prev /1/, gap /0/, sum /0/

go to 40

end if

 

{{out}}

31 258 547,594,831 9,879,997,824

32 276 1,039,028,518 18,879,988,824</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"

pn = n

}

 

{{out}}

 

=={{header|Haskell}}==

import Control.Monad (guard)

import Text.Printf (printf)

$ takeWhile (\(_, gapIndex, _) -> gapIndex < 10_000_000) findGaps

where

{{out}}

<pre>

 

=={{header|J}}==

tasks=: (gap , (,:~ index))@:niven

 

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

 

<pre>

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

 

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

 

=={{header|Java}}==

 

public class NivenNumberGaps {

 

 

}

 

{{out}}

276 1,039,028,518 18,879,988,824

</pre>

 

=={{header|Julia}}==

 

function findharshadgaps(N)

 

findharshadgaps(50_000_000_000)

<pre>

Gap Index Number Index Niven Number

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

LOOP CONTINUE

 

 

{{out}}

21 99 800054 9898956

22 108 3750017 49989744</pre>

 

=={{header|Nim}}==

{{trans|C++}}

 

func digitsSum(n, sum: uint64): uint64 =

inc gapIndex

previous = niven

 

{{out}}

{{works with|Free Pascal}}

As fast as [http://rosettacode.org/wiki/Increasing_gaps_between_consecutive_Niven_numbers#Go GO]

{$IFDEF FPC}

{$MODE DELPHI}

begin

FindGaps;

{{out}}

<pre>Gap Index of gap Starting Niven

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use List::Util 'sum';

$last = $count;

last if ++$index >= $threshold;

{{out}}

<pre>Gap Index of gap Starting Niven

=={{header|Phix}}==

Replaced sum(digits) in the original with sd, otherwise no great attempt to optimise

{{out}}

<pre>

 

=={{header|Python}}==

"""

 

niven_index += 1

niven += 1

 

{{out}}

{{works with|Rakudo|2019.11}}

 

 

unit sub MAIN (Int $threshold = 10000000);

$last = count;

last if $index >= $threshold;

{{out}}

<pre>Gap Index of gap Starting Niven

 

=={{header|REXX}}==

parse arg lim . /*obtain optional arguments from the CL*/

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

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

commas: parse arg _; do c=length(_)-3 to 1 by -3; _=insert(',', _, c); end; return _

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 20000000000 </tt> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <small> (which is &nbsp; '''20''' &nbsp; billion) </small> }}

<pre>

 

The "chunk" method is essentially a sum of several chunks, &nbsp; 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.*/

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

commas: parse arg _; do c=length(_)-3 to 1 by -3; _=insert(',', _, c); end; return _

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

 

=={{header|Rust}}==

// num-format = "0.4"

 

niven += 1;

}

 

{{out}}

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

var g = n - pn

if (g > pg) {

pg = g

}

i = i + 1

n = h.call()

 

{{out}}

</pre>

 

This program runs under Linux.

 

section .data

;;; Header

dec cl

jnz .pad

 

{{out}}

31 258 547,594,831 9,879,997,824

32 276 1,039,028,518 18,879,988,824</pre>

 

=={{header|zkl}}==

harshadW:=Walker.zero().tweak(fcn(go){ // faster than one liner, fewer calls

foreach h in ([go.value..]){ // spin

if(0 == h%s){ go.set(h+1); return(h) }

}

prev,gap := harshadW.next(),0;

while(harshadW.n<=10_000_000){

}

prev=h;

{{out}}

<pre>