Minimum multiple of m where digital sum equals m: Difference between revisions

From Rosetta Code
Content added Content deleted
(Realize in F#)
m (→‎{{header|Free Pascal}}: increased jumps. Now until 110 posssible on TIO.RUN. Ending in 0 is extrem time consumig.)
Line 718: Line 718:
=={{header|Pascal}}==
=={{header|Pascal}}==
==={{header|Free Pascal}}===
==={{header|Free Pascal}}===
over strechted limit to 100.
over strechted limit to 110.
Constructing minimal start number with sum of digits = m -> k+9+9+9+9+9+9 <BR>
Constructing minimal start number with sum of digits = m -> k+9+9+9+9+9+9 <BR>
Break up in parts of 4 digits.Could be more optimized.
Break up in parts of 4 digits.Could be more optimized.
<lang pascal>
<lang pascal>program m_by_n_sumofdgts_m;
program m_by_n_sumofdgts_m;
//Like https://oeis.org/A131382/b131382.txt
//Like https://oeis.org/A131382/b131382.txt
{$IFDEF FPC} {$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$ENDIF}
{$IFDEF FPC} {$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$ENDIF}
Line 730: Line 729:
BASE = 10;
BASE = 10;
BASE4 = BASE*BASE*BASE*BASE;
BASE4 = BASE*BASE*BASE*BASE;
MAXDGTSUM4 = 4*(BASE-1);
var
var
{$ALIGN 32}
SoD: array[0..BASE4-1] of byte;
{$ALIGN 32}
{$ALIGN 32}
DtgBase4 :array[0..7] of Uint32;
DtgBase4 :array[0..7] of Uint32;
DtgPartSums :array[0..7] of Uint32;
DtgPartSums :array[0..7] of Uint32;
DgtSumBefore :array[0..7] of Uint32;
DgtSumBefore :array[0..7] of Uint32;

SoD: array[0..BASE4-1] of byte;
procedure Init_SoD;
procedure Init_SoD;
var
var
Line 744: Line 747:
For d0 := 0 to BASE-1 do
For d0 := 0 to BASE-1 do
begin SoD[i]:= d1+d0;inc(i); end;
begin SoD[i]:= d1+d0;inc(i); end;

j := Base*Base;
j := Base*Base;
For i := 1 to Base*Base-1 do
For i := 1 to Base*Base-1 do
Line 754: Line 757:
end;
end;
end;
end;

procedure OutDgt;
procedure OutDgt;
var
var
Line 769: Line 772:
writeln;
writeln;
end;
end;

procedure InitDigitSums(n:NativeUint);
procedure InitDigitSums(m:NativeUint);
var
var
i,s: NativeUint;
n,i,s: NativeUint;
begin
begin
//constructing minimal number with sum of digits = m ;k+9+9+9+9+9+9
//21 -> 299
n := m;
if n>BASE then
begin
i := 1;
while n>BASE-1 do
begin
i *= BASE;
dec(n,BASE-1);
end;
n := i*(n+1)-1;
//make n multiple of m
n := (n div m)*m;
//m ending in 0
i := m;
while i mod BASE = 0 do
begin
n *= BASE;
i := i div BASE;
end;
end;
For i := 0 to 4 do
For i := 0 to 4 do
begin
begin
Line 779: Line 805:
DtgBase4[i] := s;
DtgBase4[i] := s;
DtgPartSums[i] := SoD[s];
DtgPartSums[i] := SoD[s];
n := n DIV BASE4;
n := (n-s) DIV BASE4;
end;
end;

s := 0;
s := 0;
For i := 3 downto 0 do
For i := 3 downto 0 do
Line 790: Line 816:
end;
end;


procedure CorrectSums(sum:NativeUint);
function CorrectSums(sum:NativeUint):NativeUint;
var
var
i : NativeInt;
i,q,carry : NativeInt;
begin
begin
sum -= Base4;
i := 0;
DtgBase4[0] := sum;
q := sum MOD Base4;
DtgPartSums[0] := SoD[sum];
sum := sum DIV Base4;
result := q;

i := 1;
DtgBase4[i] := q;
repeat
sum := DtgBase4[i]+1;
DtgPartSums[i] := SoD[q];
if sum < BASE4 then
carry := 0;
repeat
inc(i);
q := sum MOD Base4+DtgBase4[i]+carry;
sum := sum DIV Base4;
carry := 0;
if q >= BASE4 then
begin
begin
DtgBase4[i] := sum;
carry := 1;
DtgPartSums[i] := SoD[sum];
q -= BASE4;
BREAK;
end;
end;
sum -= Base4;
DtgBase4[i]:= q;
DtgBase4[i] := sum;
DtgPartSums[i] := SoD[q];
until (sum =0) AND( carry = 0);
DtgPartSums[i] := SoD[sum];
inc(i);
until i > 4;


sum := 0;
sum := 0;
Line 821: Line 852:
end;
end;


function CalcN(n,m:NativeUint):NativeUint;
function TakeJump(dgtSum,m:NativeUint):NativeUint;
var
var
dgtsum,sum,delta: NativeInt;
n,i,j,carry : nativeInt;
begin
begin
i := dgtsum div MAXDGTSUM4-1;
InitDigitSums(n);
n := 0;
j := 1;
for i := i downto 0 do
Begin
n:= n*BASE4+DtgBase4[i];
j:= j*BASE4;
end;
n := ((j-n) DIV m)*m;
// writeln(n:10,DtgBase4[i]:10);
i := 0;
carry := 0;
repeat
j := DtgBase4[i]+ n mod BASE4 +carry;
n := n div BASE4;
carry := 0;
IF j >=BASE4 then
begin
j -= BASE4;
carry := 1;
end;
DtgBase4[i] := j;
DtgPartSums[i]:= SoD[j];
inc(i);
until (n= 0) AND (carry=0);
j := 0;
For i := 3 downto 0 do
begin
j += DtgPartSums[i+1];
DgtSumBefore[i]:= j;
end;
result := DtgBase4[0];
end;

procedure CalcN(m:NativeUint);
var
dgtsum,sum: NativeInt;
begin
InitDigitSums(m);
sum := DtgBase4[0];
sum := DtgBase4[0];
dgtSum:= m-DgtSumBefore[0];
dgtSum:= m-DgtSumBefore[0];
Line 831: Line 901:
while dgtsum<>SoD[sum] do
while dgtsum<>SoD[sum] do
begin
begin
inc(n,m);
inc(sum,m);
inc(sum,m);
if sum >= BASE4 then
begin
If sum>=Base4 then
sum := CorrectSums(sum);
repeat
CorrectSums(sum);
dgtSum:= m-DgtSumBefore[0];
sum -= Base4;
if dgtSum > MAXDGTSUM4 then
begin
dgtSum:= m-DgtSumBefore[0];
IF dgtSum <= 36{SoD[BASE4-1])} then
sum := TakeJump(dgtSum,m);
BREAK;
dgtSum:= m-DgtSumBefore[0];
//now jump over 4 digits
end;
end;
{
IF dgtSum <= 72 (* 2*SoD[BASE4-1]) *) then
jump over 8 digits
}
//Base4-1< sum <Base4-1+m
delta := ((BASE4-1-sum) DIV m +1)*m;
n+=delta;
sum += delta;
until false
end;
end;
DtgPartSums[0] := SoD[sum];
DtgBase4[0] := sum;
DtgBase4[0] := sum;
result := n;
end;
end;

var
var
T0:INt64;
T0:INt64;
Line 863: Line 923:
T0 := GetTickCount64;
T0 := GetTickCount64;
Init_SoD;
Init_SoD;
for m := 1 to 100 do
for m := 1 to 70 do
begin
begin
n := m;
CalcN(m);
//constructing minimal number with sum of digits = m ;k+9+9+9+9+9+9
//Check sum of digits
//21 -> 299
n := SoD[DtgBase4[4]];
For i := 3 downto 0 do
if n>BASE then
n += SoD[DtgBase4[i]];
If n<>m then
begin
begin
i := 1;
writeln('ERROR at ',m);
while n>BASE-1 do
HALT(-1);
begin
end;
i *= BASE;
dec(n,BASE-1);
n := DtgBase4[4];
end;
For i := 3 downto 0 do
n := i*(n+1)-1;
n := n*BASE4+DtgBase4[i];
write(n DIV m :15);
//make n multiple of m
n := (n div m)*m;
//m ending in 0
i := m;
while i mod BASE = 0 do
begin
n *= BASE;
i := i div BASE;
end;
end;
n := CalcN(n,m);
write(n DIV m:14);
if m mod 10 = 0 then
if m mod 10 = 0 then
writeln;
writeln;
end;
end;
writeln(GetTickCount64-T0,' ms');
writeln;
writeln('Total runtime ',GetTickCount64-T0,' ms');
{$IFDEF WINDOWS} readln{$ENDIF}
{$IFDEF WINDOWS} readln{$ENDIF}
end.
end.</lang>
</lang>
{{out|@TIO.RUN}}
{{out|@TIO.RUN}}
<pre>
<pre>
Real time: 3.341 s CPU share: 99.49 %
Real time: 36.660 s CPU share: 99.48 %
1 1 1 1 1 1 1 1 1 19
1 1 1 1 1 1 1 1 1 19
19 4 19 19 13 28 28 11 46 199
19 4 19 19 13 28 28 11 46 199
19 109 73 37 199 73 37 271 172 1333
19 109 73 37 199 73 37 271 172 1333
289 559 1303 847 1657 833 1027 1576 1282 17497
289 559 1303 847 1657 833 1027 1576 1282 17497
4339 2119 2323 10909 11111 12826 14617 14581 16102 199999
4339 2119 2323 10909 11111 12826 14617 14581 16102 199999
17449 38269 56413 37037 1108909 142498 103507 154981 150661 1333333
17449 38269 56413 37037 1108909 142498 103507 154981 150661 1333333
163918 322579 315873 937342 1076923 1030303 880597 1469116 1157971 12842857
163918 322579 315873 937342 1076923 1030303 880597 1469116 1157971 12842857

4084507 5555554 6849163 37027027 13333333 11710513 11686987 11525641 12656962 374999986
Total runtime 4 ms
12345679 60852439 72168553 82142857 117647047 93022093 103445977 227272726 112247191 1111111111
..100
658010989 652173913 731172043 849893617 2947368421 2083333228 1030927834 3969377551 11101010101 199999999999
4084507 5555554 6849163 37027027 13333333 11710513 11686987 11525641 12656962 374999986
3205 ms
12345679 60852439 72168553 82142857 117647047 93022093 103445977 227272726 112247191 1111111111
</pre>
658010989 652173913 731172043 849893617 2947368421 2083333228 1030927834 3969377551 11101010101 199999999999

Total runtime 642 ms
..110
28900990099 5881372549 6796115533 18173076922 27619047619 18679245283 18691495327 36111111111 44862385321 1090909090909

Total runtime 36486 ms
@home
111 79009009009 17882 ms
112 80356249999 17906 ms
113 78761061946 17910 ms
114 87710526307 17916 ms
115 426086956513 18022 ms
116 258620688793 18033 ms
117 255547008547 18035 ms
118 414406779661 18039 ms
119 411756302521 18040 ms
120 4999999999999 26838 ms

121 2809909090909 27273 ms
122 811475409754 27290 ms
123 730081300813 27291 ms
124 2419193548387 27328 ms
125 5599999999999 29177 ms
126 2380873015873 29181 ms
127 3148818897637 29183 ms
128 5468749999921 29328 ms
129 5348836434031 29334 ms
130 46076923076923 32383 ms

131 6106793893129 32386 ms
132 28030303030303 32559 ms
133 6766917293233 32560 ms
134 22388058880597 32577 ms
135 37037037037037 32665 ms
136 44044117647058 32712 ms
137 56919700729927 32774 ms
138 36231884057971 32775 ms
139 49568345323741 32775 ms
140 571427857142857 58364 ms

141 63822694964539 58366 ms
142 140140838028169 58378 ms
143 391606993006993 58606 ms
144 277777777777777 58698 ms
145 482751724137931 58929 ms
146 471917801369863 58959 ms
147 401360544217687 58961 ms
148 1081081081081081 59207 ms
149 536912751677851 59213 ms
150 13333333333333333 728689 ms</pre>


=={{header|Perl}}==
=={{header|Perl}}==

Revision as of 19:28, 31 January 2022

Minimum multiple of m where digital sum equals m is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Generate the sequence a(n) when each element is the minimum integer multiple m such that the digit sum of n times m is equal to n.


Task
  • Find the first 40 elements of the sequence.


Stretch
  • Find the next 30 elements of the sequence.


See also



ALGOL 68

<lang algol68>BEGIN # find the smallest m where mn = digit sum of n, n in 1 .. 70 # 

   # returns the digit sum of n, n must be >= 0 #
   OP   DIGITSUM = ( INT n )INT:
        IF  n < 10 THEN n
        ELSE
           INT result := n MOD  10;
           INT v      := n OVER 10;
           WHILE v > 0 DO
               result +:= v MOD  10;
               v       := v OVER 10
           OD;
           result
        FI # DIGITSUM # ;
   # show the minimum multiples of n where the digit sum of the multiple is n #
   FOR n TO 70 DO
       BOOL found multiple := FALSE;
       FOR m WHILE NOT found multiple DO
           IF DIGITSUM ( m * n ) = n THEN
               found multiple := TRUE;
               print( ( " ", whole( m, -8 ) ) );
               IF n MOD 10 = 0 THEN print( ( newline ) ) FI
           FI
       OD
   OD

END</lang>

Output:
        1        1        1        1        1        1        1        1        1       19
       19        4       19       19       13       28       28       11       46      199
       19      109       73       37      199       73       37      271      172     1333
      289      559     1303      847     1657      833     1027     1576     1282    17497
     4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
    17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
   163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857


APL

Works with: Dyalog APL

<lang APL>{n←⍵ ⋄ (+∘1)⍣{n=+/10⊥⍣¯1⊢⍺×n}⊢0 } ¨ 7 10⍴⍳70</lang>

Output:
     1      1      1      1       1       1      1       1       1       19
    19      4     19     19      13      28     28      11      46      199
    19    109     73     37     199      73     37     271     172     1333
   289    559   1303    847    1657     833   1027    1576    1282    17497
  4339   2119   2323  10909   11111   12826  14617   14581   16102   199999
 17449  38269  56413  37037 1108909  142498 103507  154981  150661  1333333
163918 322579 315873 937342 1076923 1030303 880597 1469116 1157971 12842857

BASIC

BASIC256

<lang BASIC256>c = 0 n = 1 while c < 70 

   m = 1
   while 1
       nm = n*m

t = 0 

       while nm
           t += nm mod 10
           nm = floor(nm / 10)
       end while
       if t = n then exit while
       m += 1
   end while
   c += 1
   print rjust(string(m), 8); " ";
   if c mod 10 = 0 then print
   n += 1

end while end</lang>

Output:
Igual que la entrada de FreeBASIC.

FreeBASIC

Translation of: Phix

<lang freebasic>#define floor(x) ((x*2.0-0.5) Shr 1)

Dim As Integer c = 0, n = 1 Do While c < 70 

   Dim As Integer m = 1
   Do
       Dim As Integer nm = n*m, t = 0
       While nm
           t += nm Mod 10
           nm = floor(nm/10)
       Wend
       If t = n Then Exit Do : End If
       m += 1
   Loop
   c += 1
   Print Using "######## "; m;
   If c Mod 10 = 0 Then Print
   n += 1

Loop Sleep </lang>

Output:
       1        1        1        1        1        1        1        1        1       19
      19        4       19       19       13       28       28       11       46      199
      19      109       73       37      199       73       37      271      172     1333
     289      559     1303      847     1657      833     1027     1576     1282    17497
    4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
   17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
  163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

Yabasic

<lang yabasic>c = 0 n = 1 while c < 70 

   m = 1
   do
       nm = n*m

t = 0 

       while nm
           t = t + mod(nm, 10)
           nm = floor(nm / 10)
       wend
       if t = n then break : fi
       m = m + 1
   loop
   c = c + 1
   print m using "########", " ";
   if mod(c, 10) = 0 then print : fi
   n = n + 1

wend end</lang>

Output:
Igual que la entrada de FreeBASIC.

C

<lang c>#include <stdio.h>

unsigned digit_sum(unsigned n) { 

   unsigned sum = 0;
   do { sum += n % 10; }
   while(n /= 10);
   return sum;

}

unsigned a131382(unsigned n) { 

   unsigned m;
   for (m = 1; n != digit_sum(m*n); m++);
   return m;

}

int main() { 

   unsigned n;
   for (n = 1; n <= 70; n++) {
       printf("%9u", a131382(n));
       if (n % 10 == 0) printf("\n");
   }
   return 0;

}</lang>

Output:
        1        1        1        1        1        1        1        1        1       19
       19        4       19       19       13       28       28       11       46      199
       19      109       73       37      199       73       37      271      172     1333
      289      559     1303      847     1657      833     1027     1576     1282    17497
     4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
    17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
   163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

C++

<lang cpp>#include <iomanip>

  1. include <iostream>

int digit_sum(int n) { 

   int sum = 0;
   for (; n > 0; n /= 10)
       sum += n % 10;
   return sum;

}

int main() { 

   for (int n = 1; n <= 70; ++n) {
       for (int m = 1;; ++m) {
           if (digit_sum(m * n) == n) {
               std::cout << std::setw(8) << m << (n % 10 == 0 ? '\n' : ' ');
               break;
           }
       }
   }

}</lang>

Output:
       1        1        1        1        1        1        1        1        1       19
      19        4       19       19       13       28       28       11       46      199
      19      109       73       37      199       73       37      271      172     1333
     289      559     1303      847     1657      833     1027     1576     1282    17497
    4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
   17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
  163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

CLU

<lang clu>digit_sum = proc (n: int) returns (int) 

   sum: int := 0
   while n > 0 do
       sum := sum + n // 10
       n := n / 10
   end
   return(sum)

end digit_sum

a131382 = iter () yields (int) 

   n: int := 1
   while true do
       m: int := 1
       while digit_sum(m * n) ~= n do
           m := m + 1
       end
       yield(m)
       n := n + 1
   end

end a131382

start_up = proc () 

   po: stream := stream$primary_output()
   n: int := 0
   
   for m: int in a131382() do
       stream$putright(po, int$unparse(m), 9)
       n := n + 1
       if n = 70 then break end
       if n // 10 = 0 then stream$putl(po, "") end
   end

end start_up</lang>

Output:
        1        1        1        1        1        1        1        1        1       19
       19        4       19       19       13       28       28       11       46      199
       19      109       73       37      199       73       37      271      172     1333
      289      559     1303      847     1657      833     1027     1576     1282    17497
     4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
    17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
   163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

COBOL

<lang cobol> IDENTIFICATION DIVISION. 

      PROGRAM-ID. A131382.
      
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01 VARIABLES.
         03 MAXIMUM      PIC 99 VALUE 40.
         03 N            PIC 999.
         03 M            PIC 9(9).
         03 N-TIMES-M    PIC 9(9).
         03 DIGITS       PIC 9 OCCURS 9 TIMES,
                         REDEFINES N-TIMES-M,
                         INDEXED BY D.
         03 DIGITSUM     PIC 999 VALUE ZERO.
      01 OUTFMT.
         03 FILLER       PIC XX VALUE "A(".
         03 N-OUT        PIC Z9.
         03 FILLER       PIC X(4) VALUE ") = ".
         03 M-OUT        PIC Z(8)9.
      
      PROCEDURE DIVISION.
      BEGIN.
          PERFORM CALC-A131382 VARYING N FROM 1 BY 1
          UNTIL N IS GREATER THAN MAXIMUM.
          STOP RUN.
      
      CALC-A131382.
          PERFORM FIND-LEAST-M VARYING M FROM 1 BY 1
          UNTIL DIGITSUM IS EQUAL TO N.
          SUBTRACT 1 FROM M.
          MOVE N TO N-OUT.
          MOVE M TO M-OUT.
          DISPLAY OUTFMT.
          
      FIND-LEAST-M.
          MOVE ZERO TO DIGITSUM.
          MULTIPLY N BY M GIVING N-TIMES-M.
          PERFORM ADD-DIGIT VARYING D FROM 1 BY 1
          UNTIL D IS GREATER THAN 9.
      
      ADD-DIGIT.
          ADD DIGITS(D) TO DIGITSUM.</lang>
Output:
A( 1) =         1
A( 2) =         1
A( 3) =         1
A( 4) =         1
A( 5) =         1
A( 6) =         1
A( 7) =         1
A( 8) =         1
A( 9) =         1
A(10) =        19
A(11) =        19
A(12) =         4
A(13) =        19
A(14) =        19
A(15) =        13
A(16) =        28
A(17) =        28
A(18) =        11
A(19) =        46
A(20) =       199
A(21) =        19
A(22) =       109
A(23) =        73
A(24) =        37
A(25) =       199
A(26) =        73
A(27) =        37
A(28) =       271
A(29) =       172
A(30) =      1333
A(31) =       289
A(32) =       559
A(33) =      1303
A(34) =       847
A(35) =      1657
A(36) =       833
A(37) =      1027
A(38) =      1576
A(39) =      1282
A(40) =     17497

Cowgol

<lang cowgol>include "cowgol.coh";

sub digit_sum(n: uint32): (sum: uint8) is 

   sum := 0;
   while n != 0 loop
       sum := sum + (n % 10) as uint8;
       n := n / 10;
   end loop;

end sub;

sub a131382(n: uint8): (m: uint32) is 

   m := 1;
   while n != digit_sum(n as uint32 * m) loop
       m := m + 1;
   end loop;

end sub;

var n: uint8 := 1; while n <= 70 loop 

   print_i32(a131382(n));
   if n % 10 == 0 then print_nl(); 
   else print_char(' ');
   end if;
   n := n + 1;

end loop;</lang>

Output:
1 1 1 1 1 1 1 1 1 19
19 4 19 19 13 28 28 11 46 199
19 109 73 37 199 73 37 271 172 1333
289 559 1303 847 1657 833 1027 1576 1282 17497
4339 2119 2323 10909 11111 12826 14617 14581 16102 199999
17449 38269 56413 37037 1108909 142498 103507 154981 150661 1333333
163918 322579 315873 937342 1076923 1030303 880597 1469116 1157971 12842857

Draco

<lang draco>/* this is very slow even in emulation - if you're going to try it 

* on a real 8-bit micro I'd recommend setting this back to 40;
* it does, however, eventually get there */

byte MAX = 70;

/* note on types: 2^32 is a 10-digit number, 

* so the digit sum of an ulong is guaranteed
* to be <= 90 */

proc nonrec digitsum(ulong n) byte: 

   byte sum;
   sum := 0;
   while n /= 0 do
       sum := sum + make(n % 10, byte);
       n := n / 10
   od;
   sum

corp

proc nonrec a131382(ulong n) ulong: 

   ulong m;
   m := 1;
   while digitsum(m * n) /= n do
       m := m + 1
   od;
   m

corp

proc nonrec main() void: 

   byte n;
   for n from 1 upto MAX do
       write(a131382(n):9);
       if (n & 7) = 0 then writeln() fi
   od

corp</lang>

Output:
        1        1        1        1        1        1        1        1
        1       19       19        4       19       19       13       28
       28       11       46      199       19      109       73       37
      199       73       37      271      172     1333      289      559
     1303      847     1657      833     1027     1576     1282    17497
     4339     2119     2323    10909    11111    12826    14617    14581
    16102   199999    17449    38269    56413    37037  1108909   142498
   103507   154981   150661  1333333   163918   322579   315873   937342
  1076923  1030303   880597  1469116  1157971 12842857

F#

<lang fsharp> // Minimum multiple of m where digital sum equals m. Nigel Galloway: January 31st., 2022 let SoD n=let rec SoD n=function 0L->int n |g->SoD(n+g%10L)(g/10L) in SoD 0L n let A131382(g:int)=let rec fN i=match SoD(i*int64(g)) with 

                                n when n=g -> i
                               |n when n>g -> fN (i+1L)
                               |n -> fN (i+(int64(ceil(float(g-n)/float n))))
                  fN ((((pown 10L (g/9))-1L)+int64(g%9)*(pown 10L (g/9)))/int64 g)

Seq.initInfinite((+)1>>A131382)|>Seq.take 70|>Seq.chunkBySize 10|>Seq.iter(fun n->n|>Seq.iter(printf "%13d "); printfn "") </lang>

Output:
            1             1             1             1             1             1             1             1             1            19
           19             4            19            19            13            28            28            11            46           199
           19           109            73            37           199            73            37           271           172          1333
          289           559          1303           847          1657           833          1027          1576          1282         17497
         4339          2119          2323         10909         11111         12826         14617         14581         16102        199999
        17449         38269         56413         37037       1108909        142498        103507        154981        150661       1333333
       163918        322579        315873        937342       1076923       1030303        880597       1469116       1157971      12842857

FOCAL

<lang focal>01.10 F N=1,40;D 2 01.20 Q

02.10 S M=0 02.20 S M=M+1 02.30 S D=N*M 02.40 D 3 02.50 I (N-S)2.2,2.6,2.2 02.60 T "N",%2,N," M",%6,M,!

03.10 S S=0 03.20 S E=FITR(D/10) 03.30 S S=S+(D-E*10) 03.40 S D=E 03.50 I (-D)3.2</lang>

Output:
N=  1 M=      1
N=  2 M=      1
N=  3 M=      1
N=  4 M=      1
N=  5 M=      1
N=  6 M=      1
N=  7 M=      1
N=  8 M=      1
N=  9 M=      1
N= 10 M=     19
N= 11 M=     19
N= 12 M=      4
N= 13 M=     19
N= 14 M=     19
N= 15 M=     13
N= 16 M=     28
N= 17 M=     28
N= 18 M=     11
N= 19 M=     46
N= 20 M=    199
N= 21 M=     19
N= 22 M=    109
N= 23 M=     73
N= 24 M=     37
N= 25 M=    199
N= 26 M=     73
N= 27 M=     37
N= 28 M=    271
N= 29 M=    172
N= 30 M=   1333
N= 31 M=    289
N= 32 M=    559
N= 33 M=   1303
N= 34 M=    847
N= 35 M=   1657
N= 36 M=    833
N= 37 M=   1027
N= 38 M=   1576
N= 39 M=   1282
N= 40 M=  17497

Forth

Works with: Gforth

<lang forth>: digit-sum ( u -- u ) 

 dup 10 < if exit then
 10 /mod recurse + ;
main
 1+ 1 do
   0
   begin
     1+ dup i * digit-sum i =
   until
   8 .r i 10 mod 0= if cr else space then
 loop ;

70 main bye</lang>

Output:
       1        1        1        1        1        1        1        1        1       19
      19        4       19       19       13       28       28       11       46      199
      19      109       73       37      199       73       37      271      172     1333
     289      559     1303      847     1657      833     1027     1576     1282    17497
    4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
   17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
  163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

Haskell

<lang haskell>import Data.Bifunctor (first) import Data.List (elemIndex, intercalate, transpose) import Data.List.Split (chunksOf) import Data.Maybe (fromJust) import Text.Printf (printf)

A131382 ------------------------

a131382 :: [Int] a131382 = 

 fromJust . (elemIndex <*> productDigitSums)
   <$> [1 ..]

productDigitSums :: Int -> [Int] productDigitSums n = digitSum . (n *) <$> [0 ..]

TEST -------------------------

main :: IO () main = 

 (putStrLn . table " ") $
   chunksOf 10 $ show <$> take 40 a131382

GENERIC ------------------------

digitSum :: Int -> Int digitSum 0 = 0 digitSum n = uncurry (+) (first digitSum $ quotRem n 10)

table :: String -> String -> String table gap rows = 

 let ws = maximum . fmap length <$> transpose rows
     pw = printf . flip intercalate ["%", "s"] . show
  in unlines $ intercalate gap . zipWith pw ws <$> rows</lang>
Output:
  1   1    1   1    1   1    1    1    1    19
 19   4   19  19   13  28   28   11   46   199
 19 109   73  37  199  73   37  271  172  1333
289 559 1303 847 1657 833 1027 1576 1282 17497

J

Implementation:

<lang J> findfirst=: Template:($:@((+1+i.@+:)@

A131382=: {{y&Template:X = sumdigits x*y findfirst}}"0

sumdigits=: +/@|:@(10&#.inv)</lang>

Task example: <lang J> A131382 1+i.4 10 

 1   1    1   1    1   1    1    1    1    19
19   4   19  19   13  28   28   11   46   199
19 109   73  37  199  73   37  271  172  1333

289 559 1303 847 1657 833 1027 1576 1282 17497</lang>

Stretch example: <lang J> A131382 41+i.3 10 

 4339   2119   2323  10909   11111   12826  14617   14581   16102   199999
17449  38269  56413  37037 1108909  142498 103507  154981  150661  1333333

163918 322579 315873 937342 1076923 1030303 880597 1469116 1157971 12842857</lang>

Julia

<lang julia>minproddigsum(n) = findfirst(i -> sum(digits(n * i)) == n, 1:typemax(Int32))

for j in 1:70 

   print(lpad(minproddigsum(j), 10), j % 7 == 0 ? "\n" : "")

end

</lang>

Output:
         1         1         1         1         1         1         1
         1         1        19        19         4        19        19
        13        28        28        11        46       199        19
       109        73        37       199        73        37       271
       172      1333       289       559      1303       847      1657
       833      1027      1576      1282     17497      4339      2119
      2323     10909     11111     12826     14617     14581     16102
    199999     17449     38269     56413     37037   1108909    142498
    103507    154981    150661   1333333    163918    322579    315873
    937342   1076923   1030303    880597   1469116   1157971  12842857

MAD

<lang MAD> NORMAL MODE IS INTEGER 

           VECTOR VALUES FMT = $2HA(,I2,4H) = ,I8*$
           
           THROUGH NUMBER, FOR N = 1, 1, N.G.70

MULT THROUGH MULT, FOR M = 1, 1, N.E.DSUM.(M*N) NUMBER PRINT FORMAT FMT, N, M 

           INTERNAL FUNCTION(X)
           ENTRY TO DSUM.
           SUM = 0
           V = X

DIGIT WHENEVER V.E.0, FUNCTION RETURN SUM 

           W = V/10
           SUM = SUM + V - W*10
           V = W
           TRANSFER TO DIGIT
           END OF FUNCTION
           END OF PROGRAM</lang>
Output:
A( 1) =        1
A( 2) =        1
A( 3) =        1
A( 4) =        1
A( 5) =        1
A( 6) =        1
A( 7) =        1
A( 8) =        1
A( 9) =        1
A(10) =       19
A(11) =       19
A(12) =        4
A(13) =       19
A(14) =       19
A(15) =       13
A(16) =       28
A(17) =       28
A(18) =       11
A(19) =       46
A(20) =      199
A(21) =       19
A(22) =      109
A(23) =       73
A(24) =       37
A(25) =      199
A(26) =       73
A(27) =       37
A(28) =      271
A(29) =      172
A(30) =     1333
A(31) =      289
A(32) =      559
A(33) =     1303
A(34) =      847
A(35) =     1657
A(36) =      833
A(37) =     1027
A(38) =     1576
A(39) =     1282
A(40) =    17497
A(41) =     4339
A(42) =     2119
A(43) =     2323
A(44) =    10909
A(45) =    11111
A(46) =    12826
A(47) =    14617
A(48) =    14581
A(49) =    16102
A(50) =   199999
A(51) =    17449
A(52) =    38269
A(53) =    56413
A(54) =    37037
A(55) =  1108909
A(56) =   142498
A(57) =   103507
A(58) =   154981
A(59) =   150661
A(60) =  1333333
A(61) =   163918
A(62) =   322579
A(63) =   315873
A(64) =   937342
A(65) =  1076923
A(66) =  1030303
A(67) =   880597
A(68) =  1469116
A(69) =  1157971
A(70) = 12842857

Pascal

Free Pascal

over strechted limit to 110. Constructing minimal start number with sum of digits = m -> k+9+9+9+9+9+9
Break up in parts of 4 digits.Could be more optimized. <lang pascal>program m_by_n_sumofdgts_m; //Like https://oeis.org/A131382/b131382.txt {$IFDEF FPC} {$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$ENDIF} uses 

 sysutils;

const 

  BASE = 10;
  BASE4 = BASE*BASE*BASE*BASE;
  MAXDGTSUM4 = 4*(BASE-1);

var 

 {$ALIGN 32}
 SoD: array[0..BASE4-1] of byte;
 {$ALIGN 32}
 DtgBase4 :array[0..7] of Uint32;
 DtgPartSums :array[0..7] of Uint32;
 DgtSumBefore :array[0..7] of Uint32;


procedure Init_SoD; var 

 d0,d1,i,j : NativeInt;

begin 

 i := 0;
 For d1 := 0 to BASE-1 do
   For d0 := 0 to BASE-1 do
     begin SoD[i]:= d1+d0;inc(i); end;

 j := Base*Base;
 For i := 1 to Base*Base-1 do
   For d1 := 0 to BASE-1 do
     For d0 := 0 to BASE-1 do
     begin
       SoD[j] := SoD[i]+d1+d0;
       inc(j);
     end;

end;

procedure OutDgt; var 

  i : integer;

begin 

 for i := 5 downto 0 do
   write(DtgBase4[i]:4);
 writeln;
 for i := 5 downto 0 do
   write(DtgPartSums[i]:4);
 writeln;
 for i := 5 downto 0 do
   write(DgtSumBefore[i]:4);
 writeln;

end;

procedure InitDigitSums(m:NativeUint); var 

 n,i,s: NativeUint;

begin 

 //constructing minimal number with sum of digits = m ;k+9+9+9+9+9+9
 //21 -> 299
 n := m;
 if n>BASE then
 begin
   i := 1;
   while n>BASE-1 do
   begin
     i *= BASE;
     dec(n,BASE-1);
   end;
   n := i*(n+1)-1;
   //make n multiple of m
   n := (n div m)*m;
   //m ending in 0
   i := m;
   while i mod BASE = 0 do
   begin
     n *= BASE;
     i := i div BASE;
   end;
 end;
 
 For i := 0 to 4 do
 begin
   s := n MOD BASE4;
   DtgBase4[i] := s;
   DtgPartSums[i] := SoD[s];
   n := (n-s) DIV BASE4;
 end;

 s := 0;
 For i := 3 downto 0 do
 begin
   s += DtgPartSums[i+1];
   DgtSumBefore[i]:= s;
 end;

end;


function CorrectSums(sum:NativeUint):NativeUint; var i,q,carry : NativeInt; begin 

 i := 0;
 q := sum MOD Base4;
 sum := sum DIV Base4;  
 result := q; 
 
 DtgBase4[i] := q;
 DtgPartSums[i] := SoD[q];    
 
 carry := 0;
 repeat 
   inc(i);  
   q := sum MOD Base4+DtgBase4[i]+carry;  
   sum := sum DIV Base4;  
   carry := 0;
   if q >= BASE4 then 
   begin
     carry := 1;
     q -= BASE4;
   end;
   DtgBase4[i]:= q;
   DtgPartSums[i] := SoD[q];    
 until (sum =0) AND( carry = 0);

 sum := 0;
 For i := 3 downto 0 do
 begin
   sum += DtgPartSums[i+1];
   DgtSumBefore[i]:= sum;
 end;

end;

function TakeJump(dgtSum,m:NativeUint):NativeUint; var 

 n,i,j,carry : nativeInt;

begin 

 i := dgtsum div MAXDGTSUM4-1;
 n := 0;
 j := 1;
 for i := i downto 0 do
 Begin
   n:= n*BASE4+DtgBase4[i];
   j:= j*BASE4;
 end;  
 n := ((j-n) DIV m)*m;

// writeln(n:10,DtgBase4[i]:10); 

 i := 0;
 carry := 0;
 repeat
   j := DtgBase4[i]+ n mod BASE4 +carry;
   n := n div BASE4;
   carry := 0;
   IF j >=BASE4 then
   begin
     j -= BASE4;
     carry := 1;
   end;
   DtgBase4[i] := j;
   DtgPartSums[i]:= SoD[j];
   inc(i);
 until (n= 0) AND (carry=0);
 j := 0;
 For i := 3 downto 0 do
 begin
   j += DtgPartSums[i+1];
   DgtSumBefore[i]:= j;
 end;  
 result := DtgBase4[0];

end;

procedure CalcN(m:NativeUint); var 

 dgtsum,sum: NativeInt;

begin 

 InitDigitSums(m);
 
 sum := DtgBase4[0];
 dgtSum:= m-DgtSumBefore[0];
 //  while dgtsum+SoD[sum] <> m do
 while dgtsum<>SoD[sum] do
 begin
   inc(sum,m);  
   if sum >= BASE4 then
   begin
     sum := CorrectSums(sum);
     dgtSum:= m-DgtSumBefore[0];
     if dgtSum > MAXDGTSUM4 then
     begin 
       sum := TakeJump(dgtSum,m);   
       dgtSum:= m-DgtSumBefore[0];        
     end;  
   end;  
 end;
 DtgBase4[0] := sum;

end;

var 

 T0:INt64;
 i : NativeInt;
 m,n: NativeUint;

Begin 

 T0 := GetTickCount64;
 Init_SoD;
 for m := 1 to 70 do
 begin
   CalcN(m);
   //Check sum of digits
   n := SoD[DtgBase4[4]];
   For i := 3 downto 0 do
     n += SoD[DtgBase4[i]];
   If n<>m then
   begin
     writeln('ERROR at ',m);
     HALT(-1);
   end;       
      
   n := DtgBase4[4];
   For i := 3 downto 0 do
     n := n*BASE4+DtgBase4[i];
   write(n DIV m :15); 
   if m mod 10 = 0 then
     writeln;
 end;
 writeln;
 writeln('Total runtime  ',GetTickCount64-T0,' ms');
 {$IFDEF WINDOWS} readln{$ENDIF}

end.</lang>

@TIO.RUN:
Real time: 36.660 s CPU share: 99.48 %
              1              1              1              1              1              1              1              1              1             19
             19              4             19             19             13             28             28             11             46            199
             19            109             73             37            199             73             37            271            172           1333
            289            559           1303            847           1657            833           1027           1576           1282          17497
           4339           2119           2323          10909          11111          12826          14617          14581          16102         199999
          17449          38269          56413          37037        1108909         142498         103507         154981         150661        1333333
         163918         322579         315873         937342        1076923        1030303         880597        1469116        1157971       12842857

Total runtime  4 ms
..100
        4084507        5555554        6849163       37027027       13333333       11710513       11686987       11525641       12656962      374999986
       12345679       60852439       72168553       82142857      117647047       93022093      103445977      227272726      112247191     1111111111
      658010989      652173913      731172043      849893617     2947368421     2083333228     1030927834     3969377551    11101010101   199999999999

Total runtime  642 ms
..110 
    28900990099     5881372549     6796115533    18173076922    27619047619    18679245283    18691495327    36111111111    44862385321  1090909090909

Total runtime  36486 ms
@home
 111         79009009009  17882 ms
 112         80356249999  17906 ms
 113         78761061946  17910 ms
 114         87710526307  17916 ms
 115        426086956513  18022 ms
 116        258620688793  18033 ms
 117        255547008547  18035 ms
 118        414406779661  18039 ms
 119        411756302521  18040 ms
 120       4999999999999  26838 ms

 121       2809909090909  27273 ms
 122        811475409754  27290 ms
 123        730081300813  27291 ms
 124       2419193548387  27328 ms
 125       5599999999999  29177 ms
 126       2380873015873  29181 ms
 127       3148818897637  29183 ms
 128       5468749999921  29328 ms
 129       5348836434031  29334 ms
 130      46076923076923  32383 ms

 131       6106793893129  32386 ms
 132      28030303030303  32559 ms
 133       6766917293233  32560 ms
 134      22388058880597  32577 ms
 135      37037037037037  32665 ms
 136      44044117647058  32712 ms
 137      56919700729927  32774 ms
 138      36231884057971  32775 ms
 139      49568345323741  32775 ms
 140     571427857142857  58364 ms

 141      63822694964539  58366 ms
 142     140140838028169  58378 ms
 143     391606993006993  58606 ms
 144     277777777777777  58698 ms
 145     482751724137931  58929 ms
 146     471917801369863  58959 ms
 147     401360544217687  58961 ms
 148    1081081081081081  59207 ms
 149     536912751677851  59213 ms
 150   13333333333333333  728689 ms

Perl

<lang perl>#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Minimum_multiple_of_m_where_digital_sum_equals_m use warnings; use ntheory qw( sumdigits );

my @answers = map 

 {
 my $m = 1;
 $m++ until sumdigits($m*$_) == $_;
 $m;
 } 1 .. 70;

print "@answers\n\n" =~ s/.{65}\K /\n/gr;</lang>

Output:
1 1 1 1 1 1 1 1 1 19 19 4 19 19 13 28 28 11 46 199 19 109 73 37 199
73 37 271 172 1333 289 559 1303 847 1657 833 1027 1576 1282 17497
4339 2119 2323 10909 11111 12826 14617 14581 16102 199999 17449 38269
56413 37037 1108909 142498 103507 154981 150661 1333333 163918 322579
315873 937342 1076923 1030303 880597 1469116 1157971 12842857

Phix

Translation of: XPL0
with javascript_semantics
integer c = 0, n = 1
while c<70 do
    integer m = 1
    while true do
        integer nm = n*m, t = 0
        while nm do
            t += remainder(nm,10)
            nm = floor(nm/10)
        end while
        if t=n then exit end if
        m += 1
    end while
    c += 1
    printf(1,"%-8d%s",{m,iff(remainder(c,10)=0?"\n":"")})
    n += 1
end while
Output:
1       1       1       1       1       1       1       1       1       19
19      4       19      19      13      28      28      11      46      199
19      109     73      37      199     73      37      271     172     1333
289     559     1303    847     1657    833     1027    1576    1282    17497
4339    2119    2323    10909   11111   12826   14617   14581   16102   199999
17449   38269   56413   37037   1108909 142498  103507  154981  150661  1333333
163918  322579  315873  937342  1076923 1030303 880597  1469116 1157971 12842857

Prolog

Works with: SWI Prolog

<lang prolog>main:- 

   between(1, 40, N),
   min_mult_dsum(N, M),
   writef('%6r', [M]),
   (0 is N mod 10 -> nl ; true),
   fail.

main.

min_mult_dsum(N, M):- 

   min_mult_dsum(N, 1, M).

min_mult_dsum(N, M, M):- 

   P is M * N,
   digit_sum(P, N),
   !.

min_mult_dsum(N, K, M):- 

   L is K + 1,
   min_mult_dsum(N, L, M).

digit_sum(N, Sum):- 

   digit_sum(N, Sum, 0).

digit_sum(N, Sum, S1):- 

   N < 10,
   !,
   Sum is S1 + N.

digit_sum(N, Sum, S1):- 

   divmod(N, 10, M, Digit),
   S2 is S1 + Digit,
   digit_sum(M, Sum, S2).</lang>
Output:
     1     1     1     1     1     1     1     1     1    19
    19     4    19    19    13    28    28    11    46   199
    19   109    73    37   199    73    37   271   172  1333
   289   559  1303   847  1657   833  1027  1576  1282 17497

Python

<lang python>A131382

from itertools import count, islice


  1. a131382 :: [Int]

def a131382(): 

   An infinite series of the terms of A131382
   return (
       elemIndex(x)(
           productDigitSums(x)
       ) for x in count(1)
   )


  1. productDigitSums :: Int -> [Int]

def productDigitSums(n): 

   The sum of the decimal digits of n
   return (digitSum(n * x) for x in count(0))


  1. ------------------------- TEST -------------------------
  2. main :: IO ()

def main(): 

   First 40 terms of A131382

   print(
       table(10)([
           str(x) for x in islice(
               a131382(),
               40
           )
       ])
   )


  1. ----------------------- GENERIC ------------------------
  1. chunksOf :: Int -> [a] -> a

def chunksOf(n): 

   A series of lists of length n, subdividing the
      contents of xs. Where the length of xs is not evenly
      divisible, the final list will be shorter than n.
   
   def go(xs):
       return (
           xs[i:n + i] for i in range(0, len(xs), n)
       ) if 0 < n else None
   return go


  1. digitSum :: Int -> Int

def digitSum(n): 

   The sum of the digital digits of n.
   
   return sum(int(x) for x in list(str(n)))


  1. elemIndex :: a -> [a] -> (None | Int)

def elemIndex(x): 

   Just the first index of x in xs,
      or None if no elements match.
   
   def go(xs):
       try:
           return next(
               i for i, v in enumerate(xs) if x == v
           )
       except StopIteration:
           return None
   return go


  1. table :: Int -> [String] -> String

def table(n): 

   A list of strings formatted as
      right-justified rows of n columns.
   
   def go(xs):
       w = len(xs[-1])
       return '\n'.join(
           ' '.join(row) for row in chunksOf(n)([
               s.rjust(w, ' ') for s in xs
           ])
       )
   return go


  1. MAIN ---

if __name__ == '__main__': 

   main()</lang>
Output:
    1     1     1     1     1     1     1     1     1    19
   19     4    19    19    13    28    28    11    46   199
   19   109    73    37   199    73    37   271   172  1333
  289   559  1303   847  1657   833  1027  1576  1282 17497

Raku

<lang perl6>sub min-mult-dsum ($n) { (1..∞).first: (* × $n).comb.sum == $n }

say .fmt("%2d: ") ~ .&min-mult-dsum for flat 1..40, 41..70;</lang>

Output:
 1: 1
 2: 1
 3: 1
 4: 1
 5: 1
 6: 1
 7: 1
 8: 1
 9: 1
10: 19
11: 19
12: 4
13: 19
14: 19
15: 13
16: 28
17: 28
18: 11
19: 46
20: 199
21: 19
22: 109
23: 73
24: 37
25: 199
26: 73
27: 37
28: 271
29: 172
30: 1333
31: 289
32: 559
33: 1303
34: 847
35: 1657
36: 833
37: 1027
38: 1576
39: 1282
40: 17497
41: 4339
42: 2119
43: 2323
44: 10909
45: 11111
46: 12826
47: 14617
48: 14581
49: 16102
50: 199999
51: 17449
52: 38269
53: 56413
54: 37037
55: 1108909
56: 142498
57: 103507
58: 154981
59: 150661
60: 1333333
61: 163918
62: 322579
63: 315873
64: 937342
65: 1076923
66: 1030303
67: 880597
68: 1469116
69: 1157971
70: 12842857

Swift

<lang swift>import Foundation

func digitSum(_ num: Int) -> Int { 

   var sum = 0
   var n = num
   while n > 0 {
       sum += n % 10
       n /= 10
   }
   return sum

}

for n in 1...70 { 

   for m in 1... {
       if digitSum(m * n) == n {
           print(String(format: "%8d", m), terminator: n % 10 == 0 ? "\n" : " ")
           break
       }
   }

}</lang>

Output:
       1        1        1        1        1        1        1        1        1       19
      19        4       19       19       13       28       28       11       46      199
      19      109       73       37      199       73       37      271      172     1333
     289      559     1303      847     1657      833     1027     1576     1282    17497
    4339     2119     2323    10909    11111    12826    14617    14581    16102   199999
   17449    38269    56413    37037  1108909   142498   103507   154981   150661  1333333
  163918   322579   315873   937342  1076923  1030303   880597  1469116  1157971 12842857

Wren

Library: Wren-math
Library: Wren-seq
Library: Wren-fmt

<lang ecmascript>import "./math" for Int import "./seq" for Lst import "./fmt" for Fmt

var res = [] for (n in 1..70) { 

   var m = 1
   while (Int.digitSum(m * n) != n) m = m + 1
   res.add(m)

} for (chunk in Lst.chunks(res, 10)) Fmt.print("$,10d", chunk)</lang>

Output:
         1          1          1          1          1          1          1          1          1         19
        19          4         19         19         13         28         28         11         46        199
        19        109         73         37        199         73         37        271        172      1,333
       289        559      1,303        847      1,657        833      1,027      1,576      1,282     17,497
     4,339      2,119      2,323     10,909     11,111     12,826     14,617     14,581     16,102    199,999
    17,449     38,269     56,413     37,037  1,108,909    142,498    103,507    154,981    150,661  1,333,333
   163,918    322,579    315,873    937,342  1,076,923  1,030,303    880,597  1,469,116  1,157,971 12,842,857

XPL0

<lang XPL0>func SumDigits(N); \Return sum of digits in N int N, S; [S:= 0; while N do 

   [N:= N/10;
   S:= S + rem(0);
   ];

return S; ];

int C, N, M; [C:= 0; N:= 1; repeat M:= 1; 

       while SumDigits(N*M) # N do M:= M+1;
       IntOut(0, M);
       C:= C+1;
       if rem (C/10) then ChOut(0, 9\tab\) else CrLf(0);
       N:= N+1;

until C >= 40+30; ]</lang>

Output:
1       1       1       1       1       1       1       1       1       19
19      4       19      19      13      28      28      11      46      199
19      109     73      37      199     73      37      271     172     1333
289     559     1303    847     1657    833     1027    1576    1282    17497
4339    2119    2323    10909   11111   12826   14617   14581   16102   199999
17449   38269   56413   37037   1108909 142498  103507  154981  150661  1333333
163918  322579  315873  937342  1076923 1030303 880597  1469116 1157971 12842857
Retrieved from "https://rosettacode.org/wiki/Minimum_multiple_of_m_where_digital_sum_equals_m?oldid=319140"