Increasing gaps between consecutive Niven numbers: Difference between revisions

{{trans|Python}}

 

sum++

L n > 0 & n % 10 == 0

previous = niven

niven_index++

 

{{out}}

 

=={{header|ALGOL 68}}==

# ( numbers divisible by the sum of their digits ) #

INT n count := 0;

print( ( "Index Value Index Number Niven Number", newline ) );

print( ( "----- ----- -------- --------- ------------", newline ) );

FOR d0 FROM 0 TO 9 DO

FOR d1 FROM 0 TO 9 DO

FOR d2 FROM 0 TO 9 DO

FOR d3 FROM 0 TO 9 DO

FOR d4 FROM 0 TO 9 DO

FOR d5 FROM 0 TO 9 DO

FOR d6 FROM 0 TO 9 DO

FOR d7 FROM 0 TO 9 DO

FOR d8 FROM 0 TO 9 DO

INT s8 = s7 + d8;

IF s8 /= 0 THEN

IF t8 MOD s8 = 0 THEN

# have a Niven number #

FI

FI

OD # d0 #

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f INCREASING_GAPS_BETWEEN_CONSECUTIVE_NIVEN_NUMBERS.AWK

# converted from C

return(n % d == 0)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

function digit_sum(n, sum)

# devuelve la suma de los dígitos de n dada la suma de los dígitos de n - 1

next niven

end

 

 

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

Next niven

Sleep

{{out}}

<pre>

23 126 6,292,149 88,996,914

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

</pre>

'''Preliminaries'''

 

def digit_sum:

add(digits);

 

'''Niven Numbers'''

# output: a stream of informative JSON objects -

# {gap_index, gap, niven_index, previous}

"--------- --- ----------- ------------",

( 1E7 | nivens

 

{{out}}

 

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

 

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

$HistoryLength = 0;

NivenQ[n_Integer] := Divisible[n, Total[IntegerDigits[n]]]

nivennumber = Pick[Most[sel], i];

gap = sel[[nivenindex + 1]] - sel[[nivenindex]];

{{out}}

<pre>gap index gap niven index niven number

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

 

cur_gap = 0

end

end

{{out}}

<pre>Gap Index of gap Starting Niven

126 6292149 88996914

</pre>

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

This program runs under Linux.

 

section .data

;;; Header

dec cl

jnz .pad

 

{{out}}

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

 

 

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

sub digit_sum(n, sum)

// devuelve la suma de los dígitos de n dada la suma de los dígitos de n - 1

next niven

end

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

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>