Sum of the digits of n is substring of n: Difference between revisions

From Rosetta Code
Content added Content deleted
(added Perl programming solution)
(→‎{{header|BASIC}}: fix the bugs)
Line 43: Line 43:


=={{header|BASIC}}==
=={{header|BASIC}}==
{{incorrect|BASIC|wrong output, last should be 919<br><br>suspect I mod 10 shd be K mod 10}}
<lang basic>10 DEFINT I,J,K
<lang basic>10 DEFINT I,J,K
20 FOR I=0 TO 999
20 FOR I=0 TO 999
30 J=0: K=I
30 J=0: K=I
40 IF K>0 THEN J=J+I MOD 10: K=K\10: GOTO 40
40 IF K>0 THEN J=J+K MOD 10: K=K\10: GOTO 40
50 IF INSTR(STR$(I),STR$(J)) THEN PRINT I,
41 I$=STR$(I): I$=RIGHT$(I$,LEN(I$)-1)
42 J$=STR$(J): J$=RIGHT$(J$,LEN(J$)-1)
50 IF INSTR(I$,J$) THEN PRINT I,
60 NEXT I</lang>
60 NEXT I</lang>
{{out}}
{{out}}
<pre> 0 1 2 3 4
<pre> 0 1 2 3 4
5 6 7 8 9
5 6 7 8 9
21 42 63 84 124
10 20 30 40 50
155 186 217 248 279
60 70 80 90 100
301 311 321 331 341
109 119 129 139 149
351 361 371 381 391
159 169 179 189 199
602 612 622 632 642
200 300 400 500 600
652 662 672 682 692
700 800 900 910 911
903 913 923 933 943
912 913 914 915 916
953 963 973 983 993</pre>
917 918 919
</pre>


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

Revision as of 19:29, 15 April 2021

Sum of the digits of n is substring of n 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.
Task

Find and show numbers n with property that the sum of the digits of n is substring of n, where n < 1000

ALGOL 68

ALGOL 68G has the procedure "string in string" in the prelude, for other compilers, a version is available here: ALGOL_68/prelude. <lang algol68>BEGIN # find n where the sum of the digits is a substring of the representaton of n # 

   INT max number = 1 000;
   INT n count   := 0;
   FOR n FROM 0 TO max number - 1 DO
       INT d sum := 0;
       INT v     := n;
       WHILE v > 0 DO
           d sum +:= v MOD 10;
           v  OVERAB 10
       OD;
       IF string in string( whole( d sum, 0 ), NIL, whole( n, 0 ) ) THEN
           # the string representaton of the digit sum is contained in the representation of n #
           print( ( " ", whole( n, -4 ) ) );
           n count +:= 1;
           IF n count MOD 8 = 0 THEN print( ( newline ) ) FI
       FI
   OD

END</lang>

Output:
    0    1    2    3    4    5    6    7
    8    9   10   20   30   40   50   60
   70   80   90  100  109  119  129  139
  149  159  169  179  189  199  200  300
  400  500  600  700  800  900  910  911
  912  913  914  915  916  917  918  919

APL

Works with: Dyalog APL

<lang APL>(⊢(/⍨)(∨/⍕∘(+/(⍎¨⍕))⍷⍕)¨)0,⍳999</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900
      910 911 912 913 914 915 916 917 918 919

BASIC

<lang basic>10 DEFINT I,J,K 20 FOR I=0 TO 999 30 J=0: K=I 40 IF K>0 THEN J=J+K MOD 10: K=K\10: GOTO 40 41 I$=STR$(I): I$=RIGHT$(I$,LEN(I$)-1) 42 J$=STR$(J): J$=RIGHT$(J$,LEN(J$)-1) 50 IF INSTR(I$,J$) THEN PRINT I, 60 NEXT I</lang>

Output:
 0             1             2             3             4
 5             6             7             8             9
 10            20            30            40            50
 60            70            80            90            100
 109           119           129           139           149
 159           169           179           189           199
 200           300           400           500           600
 700           800           900           910           911
 912           913           914           915           916
 917           918           919

C

<lang c>#include <stdio.h>

  1. include <string.h>

int digitSum(int n) { 

   int s = 0;
   do {s += n % 10;} while (n /= 10);
   return s;

}

int digitSumIsSubstring(int n) { 

   char s_n[32], s_ds[32];
   sprintf(s_n, "%d", n);
   sprintf(s_ds, "%d", digitSum(n));
   return strstr(s_n, s_ds) != NULL;

}

int main() { 

   int i;
   for (i=0; i<1000; i++)
       if (digitSumIsSubstring(i))
           printf("%d ",i);
   printf("\n");
   
   return 0;

}</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

C++

<lang cpp>#include <iostream>

int digitSum(int n) { 

   int s = 0;
   do {s += n % 10;} while (n /= 10);
   return s;

}

int main() { 

   for (int i=0; i<1000; i++) {
       auto s_i = std::to_string(i);
       auto s_ds = std::to_string(digitSum(i));
       if (s_i.find(s_ds) != std::string::npos) {
           std::cout << i << " ";
       }
   }
   std::cout << std::endl;
   return 0;

}</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Cowgol

<lang cowgol>include "cowgol.coh";

sub digitSum(n: uint16): (s: uint16) is 

   s := 0;
   while n != 0 loop
       s := s + n % 10;
       n := n / 10;
   end loop;

end sub;

sub contains(haystack: [uint8], needle: [uint8]): (r: uint8) is 

   r := 0;
   while [haystack] != 0 loop
       var h := haystack;
       var n := needle;
       while [h] == [n] and [h] != 0 and [n] != 0 loop
           h := @next h;
           n := @next n;
       end loop;
       if [n] == 0 then
           r := 1;
           return;
       end if;
       haystack := @next haystack;
   end loop;

end sub;

sub digitSumIsSubstring(n: uint16): (r: uint8) is 

   var s1: uint8[6];
   var s2: uint8[6];
   var dummy := UIToA(n as uint32, 10, &s1[0]);
   dummy := UIToA(digitSum(n) as uint32, 10, &s2[0]);
   r := contains(&s1[0], &s2[0]);

end sub;

var i: uint16 := 0; while i < 1000 loop 

   if digitSumIsSubstring(i) != 0 then
       print_i16(i);
       print_char(' ');
   end if;
   i := i + 1;

end loop; print_nl();</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Factor

Works with: Factor version 0.99 2021-02-05

<lang factor>USING: grouping kernel math.text.utils present prettyprint sequences ;

1000 <iota> [ [ 1 digit-groups sum present ] [ present ] bi subseq? ] filter 8 group simple-table.</lang>

Output:
0   1   2   3   4   5   6   7
8   9   10  20  30  40  50  60
70  80  90  100 109 119 129 139
149 159 169 179 189 199 200 300
400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919

FOCAL

<lang focal>01.10 F N=0,999;D 2;D 4 01.20 Q

02.10 S A=0 02.20 S B=N 02.30 S C=FITR(B/10) 02.40 S A=A+(B-C*10) 02.50 S B=C 02.60 I (-B)2.3

03.10 S B=1 03.20 S B=B*10 03.30 I (B-M)3.2,3.2 03.40 S B=B/10 03.50 S M=M-FITR(M/B)*B

04.10 S P=N 04.20 S M=P 04.30 I (M-A)4.4,4.9,4.4 04.40 D 3 04.50 I (M)4.3,4.6,4.3 04.60 S P=FITR(P/10) 04.70 I (P)4.2,4.8,4.2 04.80 R 04.90 T %3,N,!</lang>

Output:
=   0
=   1
=   2
=   3
=   4
=   5
=   6
=   7
=   8
=   9
=  10
=  20
=  30
=  40
=  50
=  60
=  70
=  80
=  90
= 100
= 109
= 119
= 129
= 139
= 149
= 159
= 169
= 179
= 189
= 199
= 200
= 300
= 400
= 500
= 600
= 700
= 800
= 900
= 910
= 911
= 912
= 913
= 914
= 915
= 916
= 917
= 918
= 919

FreeBASIC

<lang freebasic>function is_substring( s as string, j as string ) as boolean 

   dim as integer nj = len(j), ns = len(s)
   for i as integer = 1 to ns - nj + 1
       if mid(s,i,nj) = j then return true
   next i
   return false

end function

function sumdig( byval n as integer ) as integer 

   dim as integer sum
   do
       sum += n mod 10
       n \= 10
   loop until n = 0
   return sum

end function

for i as uinteger = 0 to 999 

   if is_substring( str(i), str(sumdig(i))) then print i;" ";

next i : print : end</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Go

Translation of: Wren
Library: Go-rcu

<lang go>package main

import ( 

   "fmt"
   "rcu"
   "strings"

)

func main() { 

   var numbers []int
   for n := 0; n < 1000; n++ {
       ns := fmt.Sprintf("%d", n)
       ds := fmt.Sprintf("%d", rcu.DigitSum(n, 10))
       if strings.Contains(ns, ds) {
           numbers = append(numbers, n)
       }
   }
   fmt.Println("Numbers under 1,000 whose sum of digits is a substring of themselves:")
   rcu.PrintTable(numbers, 8, 3, false)
   fmt.Println()
   fmt.Println(len(numbers), "such numbers found.")

}</lang>

Output:
Numbers under 1,000 whose sum of digits is a substring of themselves:
  0   1   2   3   4   5   6   7 
  8   9  10  20  30  40  50  60 
 70  80  90 100 109 119 129 139 
149 159 169 179 189 199 200 300 
400 500 600 700 800 900 910 911 
912 913 914 915 916 917 918 919 

48 such numbers found.

Haskell

<lang haskell>import Data.Char (digitToInt) import Data.List (isInfixOf) import Data.List.Split (chunksOf)

SUM OF THE DIGITS OF N IS A SUBSTRING OF N ------

digitSumIsSubString :: String -> Bool digitSumIsSubString = 

 isInfixOf
   =<< show . foldr ((+) . digitToInt) 0


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

main :: IO () main = 

 mapM_ putStrLn $
   showMatches digitSumIsSubString <$> [999, 10000]

showMatches :: (String -> Bool) -> Int -> String showMatches p limit = 

 ( show (length xs)
     <> " matches in [0.."
     <> show limit
     <> "]\n"
 )
   <> unlines
     ( unwords
         <$> chunksOf 10 (justifyRight w ' ' <$> xs)
     )
   <> "\n"
 where
   xs = filter p $ fmap show [0 .. limit]
   w = length (last xs)

justifyRight :: Int -> Char -> String -> String justifyRight n c = (drop . length) <*> (replicate n c <>)</lang>

Output:
48 matches in [0..999]
  0   1   2   3   4   5   6   7   8   9
 10  20  30  40  50  60  70  80  90 100
109 119 129 139 149 159 169 179 189 199
200 300 400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919


365 matches in [0..10000]
    0     1     2     3     4     5     6     7     8     9
   10    20    30    40    50    60    70    80    90   100
  109   119   129   139   149   159   169   179   189   199
  200   300   400   500   600   700   800   900   910   911
  912   913   914   915   916   917   918   919  1000  1009
 1018  1027  1036  1045  1054  1063  1072  1081  1090  1108
 1109  1118  1127  1128  1136  1138  1145  1148  1154  1158
 1163  1168  1172  1178  1181  1188  1190  1198  1209  1218
 1227  1236  1245  1254  1263  1272  1281  1290  1309  1318
 1327  1336  1345  1354  1363  1372  1381  1390  1409  1418
 1427  1436  1445  1454  1463  1472  1481  1490  1509  1518
 1527  1536  1545  1554  1563  1572  1581  1590  1609  1618
 1627  1636  1645  1654  1663  1672  1681  1690  1709  1718
 1727  1736  1745  1754  1763  1772  1781  1790  1809  1810
 1811  1812  1813  1814  1815  1816  1817  1818  1819  1827
 1836  1845  1854  1863  1872  1881  1890  1909  1918  1927
 1936  1945  1954  1963  1972  1981  1990  2000  2099  2107
 2117  2127  2137  2147  2157  2167  2177  2187  2197  2199
 2299  2399  2499  2599  2699  2710  2711  2712  2713  2714
 2715  2716  2717  2718  2719  2799  2899  2999  3000  3106
 3116  3126  3136  3146  3156  3166  3176  3186  3196  3610
 3611  3612  3613  3614  3615  3616  3617  3618  3619  4000
 4105  4115  4125  4135  4145  4155  4165  4175  4185  4195
 4510  4511  4512  4513  4514  4515  4516  4517  4518  4519
 5000  5104  5114  5124  5134  5144  5154  5164  5174  5184
 5194  5410  5411  5412  5413  5414  5415  5416  5417  5418
 5419  6000  6103  6113  6123  6133  6143  6153  6163  6173
 6183  6193  6310  6311  6312  6313  6314  6315  6316  6317
 6318  6319  7000  7102  7112  7122  7132  7142  7152  7162
 7172  7182  7192  7210  7211  7212  7213  7214  7215  7216
 7217  7218  7219  8000  8101  8110  8111  8112  8113  8114
 8115  8116  8117  8118  8119  8121  8131  8141  8151  8161
 8171  8181  8191  9000  9010  9011  9012  9013  9014  9015
 9016  9017  9018  9019  9100  9110  9120  9130  9140  9150
 9160  9170  9180  9190  9209  9219  9229  9239  9249  9259
 9269  9279  9289  9299  9920  9921  9922  9923  9924  9925
 9926  9927  9928  9929 10000

J

<lang j>([#~(":+./@E.~[:":+/@(10&#.^:_1))"0)i.999</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Julia

<lang julia>issumsub(n, base=10) = occursin(string(sum(digits(n, base=base)), base=base), string(n, base=base))

foreach(p -> print(rpad(p[2], 4), p[1] % 10 == 0 ? "\n" : ""), enumerate(filter(issumsub, 0:999)))

</lang>

Output:
0   1   2   3   4   5   6   7   8   9
10  20  30  40  50  60  70  80  90  100
109 119 129 139 149 159 169 179 189 199
200 300 400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919

MAD

<lang MAD> NORMAL MODE IS INTEGER 

           INTERNAL FUNCTION(A,B)
           ENTRY TO REM.
           FUNCTION RETURN A-A/B*B
           END OF FUNCTION
           
           INTERNAL FUNCTION(X)
           ENTRY TO DSUM.
           TEMP = X
           SUM = 0

SUML WHENEVER TEMP.NE.0 

               SUM = SUM + REM.(TEMP,10)
               TEMP = TEMP / 10
               TRANSFER TO SUML
           END OF CONDITIONAL
           FUNCTION RETURN SUM
           END OF FUNCTION
           
           INTERNAL FUNCTION(X)
           ENTRY TO DELFST.
           FDGT = 1

SIZE WHENEVER FDGT.LE.X 

               FDGT = FDGT * 10
               TRANSFER TO SIZE
           END OF CONDITIONAL
           FUNCTION RETURN REM.(X,FDGT/10)
           END OF FUNCTION
           
           INTERNAL FUNCTION(N,H)
           ENTRY TO INFIX.
           WHENEVER N.E.H, FUNCTION RETURN 1B
           PFX = H

PFXL WHENEVER PFX.NE.0 

               SFX = PFX

SFXL WHENEVER SFX.NE.0 

                   WHENEVER SFX.E.N, FUNCTION RETURN 1B
                   SFX = DELFST.(SFX)
                   TRANSFER TO SFXL
               END OF CONDITIONAL 
               PFX = PFX/10
               TRANSFER TO PFXL
           END OF CONDITIONAL
           FUNCTION RETURN 0B
           END OF FUNCTION
           
           THROUGH SHOW, FOR I=0, 1, I.GE.1000
           WHENEVER INFIX.(DSUM.(I),I)
               PRINT FORMAT FMT, I
           END OF CONDITIONAL

SHOW CONTINUE 

           VECTOR VALUES FMT = $I3*$
           END OF PROGRAM </lang>
Output:
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 20
 30
 40
 50
 60
 70
 80
 90
100
109
119
129
139
149
159
169
179
189
199
200
300
400
500
600
700
800
900
910
911
912
913
914
915
916
917
918
919

Perl

as one-liner .. <lang perl>// 20210415 Perl programming solution

perl -e 'for(0..999){my$n;s/(\d)/$n+=$1/egr;print"$_ "if/$n/}'</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Phix

function sdn(integer n)
    string sn = sprint(n)
    return match(sprint(sum(sq_sub(sn,'0'))),sn)
end function
for n=999 to 10000 by 10000-999 do
    sequence res = apply(filter(tagset(n,0),sdn),sprint)
    printf(1,"Found %d such numbers < %d: %s\n",{length(res),n+1,join(shorten(res,"",5),", ")})
end for
Output:
Found 48 such numbers < 1000: 0, 1, 2, 3, 4, ..., 915, 916, 917, 918, 919
Found 365 such numbers < 10001: 0, 1, 2, 3, 4, ..., 9926, 9927, 9928, 9929, 10000

PL/M

<lang plm>100H: DIGIT$SUM: PROCEDURE (N) BYTE; 

   DECLARE N ADDRESS, SUM BYTE;
   SUM = 0;
   DO WHILE N > 0;
       SUM = SUM + N MOD 10;
       N = N / 10;
   END;
   RETURN SUM;

END DIGIT$SUM;

ITOA: PROCEDURE (N) ADDRESS; 

   DECLARE S (6) BYTE INITIAL ('.....$');
   DECLARE (N, P) ADDRESS, C BASED P BYTE;
   P = .S(5);

DIGIT: 

   P = P - 1;
   C = N MOD 10 + '0';
   IF (N := N / 10) > 0 THEN GO TO DIGIT;
   RETURN P;

END ITOA;

COPY$STRING: PROCEDURE (IN, OUT); 

   DECLARE (IN, OUT) ADDRESS;
   DECLARE (I BASED IN, O BASED OUT) BYTE;
   DO WHILE I <> '$';
       O = I;
       IN = IN + 1;
       OUT = OUT + 1;
   END;
   O = '$';

END COPY$STRING;

CONTAINS: PROCEDURE (HAYSTACK, NEEDLE) BYTE; 

   DECLARE (NEEDLE, HAYSTACK, NPOS, HPOS) ADDRESS;
   DECLARE (N BASED NPOS, H BASED HPOS, HS BASED HAYSTACK) BYTE;
   
   DO WHILE HS <> '$';
       NPOS = NEEDLE;
       HPOS = HAYSTACK;
       DO WHILE N = H AND H <> '$' AND N <> '$';
           NPOS = NPOS + 1;
           HPOS = HPOS + 1;
       END;
       IF N = '$' THEN RETURN 1;
       HAYSTACK = HAYSTACK + 1;
   END;
   RETURN 0;

END CONTAINS;

BDOS: PROCEDURE (FN, ARG); 

   DECLARE FN BYTE, ARG ADDRESS;
   GO TO 5;

END BDOS;

PRINT: PROCEDURE (STRING); 

   DECLARE STRING ADDRESS;
   CALL BDOS(9, STRING);

END PRINT;

DECLARE N ADDRESS; DECLARE S1 (6) BYTE, S2 (6) BYTE; DO N = 0 TO 999; 

   CALL COPY$STRING(ITOA(N), .S1);
   CALL COPY$STRING(ITOA(DIGIT$SUM(N)), .S2);
   IF CONTAINS(.S1, .S2) THEN DO;
       CALL PRINT(.S1);
       CALL PRINT(.' $');
   END;

END;

CALL BDOS(0,0); EOF</lang>

Output:
0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 109 119 129 139 149 159 169 179 189 199 200 300 400 500 600 700 800 900 910 911 912 913 914 915 916 917 918 919

Python

Just using the command line:

<lang python>Python 3.9.0 (tags/v3.9.0:9cf6752, Oct 5 2020, 15:34:40) [MSC v.1927 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license()" for more information. >>> x = [n for n in range(1000) if str(sum(int(d) for d in str(n))) in str(n)] >>> len(x) 48 >>> for i in range(0, len(x), (stride:= 10)): print(str(x[i:i+stride])[1:-1])

0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 109, 119, 129, 139, 149, 159, 169, 179, 189, 199 200, 300, 400, 500, 600, 700, 800, 900, 910, 911 912, 913, 914, 915, 916, 917, 918, 919 >>> </lang>


or as a full script, taking an alternative route, and slightly reducing the number of str conversions required:

<lang python>Sum of the digits of n is substring of n

from functools import reduce from itertools import chain


  1. digitSumIsSubString :: String -> Bool

def digitSumIsSubString(s): 

   True if the sum of the decimal digits in s
      matches any contiguous substring of s.
   
   return str(
       reduce(lambda a, c: a + int(c), s, 0)
   ) in s


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

def main(): 

   Matches in [0..999]
   print(
       showMatches(
           digitSumIsSubString
       )(999)
   )


  1. ----------------------- DISPLAY ------------------------
  1. showMatches :: (String -> Bool) -> Int -> String

def showMatches(p): 

   A listing of the integer strings [0..limit]
      which match the predicate p.
   
   def go(limit):
       def triage(n):
           s = str(n)
           return [s] if p(s) else []

       xs = list(
           chain.from_iterable(
               map(triage, range(0, 1 + limit))
           )
       )
       w = len(xs[-1])
       return f'{len(xs)} matches < {limit}:\n' + (
           '\n'.join(
               ' '.join(cell.rjust(w, ' ') for cell in row)
               for row in chunksOf(10)(xs)
           )
       )

   return go


  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
      divible, 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. MAIN ---

if __name__ == '__main__': 

   main()

</lang>

Output:
48 matches < 1000:

  0   1   2   3   4   5   6   7   8   9
 10  20  30  40  50  60  70  80  90 100
109 119 129 139 149 159 169 179 189 199
200 300 400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919

Raku

<lang perl6>say "{+$_} matching numbers\n{.batch(10)».fmt('%3d').join: "\n"}" given (^1000).grep: { .contains: .comb.sum }</lang>

Output:
48 matching numbers
  0   1   2   3   4   5   6   7   8   9
 10  20  30  40  50  60  70  80  90 100
109 119 129 139 149 159 169 179 189 199
200 300 400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919

REXX

<lang rexx>/*REXX pgm finds integers whose sum of decimal digits is a substring of N, N < 1000. */ parse arg hi cols . /*obtain optional argument from the CL.*/ if hi== | hi=="," then hi= 1000 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 10 /* " " " " " " */ w= 10 /*width of a number in any column. */ @sdsN= ' integers whose sum of decimal digis of N is a substring of N, where N < ' , 

                                                                          commas(hi)

if cols>0 then say ' index │'center(@sdsN, 1 + cols*(w+1) ) if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─') finds= 0; idx= 1 /*initialize # of found numbers & index*/ $= /*a list of found integers (so far). */ 

    do j=0  for hi;     #= sumDigs(j)           /*obtain sum of the decimal digits of J*/
    if pos(#, j)==0     then iterate            /*Sum of dec. digs in J?  No, then skip*/
    finds= finds + 1                            /*bump the number of found integers.   */
    if cols==0          then iterate            /*Build the list  (to be shown later)? */
    $= $  right( commas( commas(j) ),  w)       /*add a found number ──► the  $  list. */
    if finds//cols\==0  then iterate            /*have we populated a line of output?  */
    say center(idx, 7)'│'  substr($, 2);   $=   /*display what we have so far  (cols). */
    idx= idx + cols                             /*bump the  index  count for the output*/
    end   /*j*/

if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─') say say 'Found ' commas(finds) @sdsN exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ? sumDigs:procedure; parse arg x 1 s 2;do j=2 for length(x)-1;s=s+substr(x,j,1);end;return s</lang>

output   when using the default inputs:
 index │              integers whose sum of decimal digis of  N  is a substring of  N,  where  N  <  1,000
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │          0          1          2          3          4          5          6          7          8          9
  11   │         10         20         30         40         50         60         70         80         90        100
  21   │        109        119        129        139        149        159        169        179        189        199
  31   │        200        300        400        500        600        700        800        900        910        911
  41   │        912        913        914        915        916        917        918        919
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  48  integers whose sum of decimal digis of  N  is a substring of  N,  where  N  <  1,000

Ring

<lang ring> load "stdlib.ring" see "working..." + nl see "Numbers n with property that the sum of the digits of n is substring of n are:" + nl see "p p+2 p+6" + nl row = 0 limit = 1000

for n = 0 to limit-1 

   str = 0
   strn = string(n)
   for m = 1 to len(strn)
       str = str + number(strn[m])        
   next
   str = string(str)
   ind = substr(strn,str)
   if ind > 0
      row = row + 1
      see "" + n + " "
      if row%10 = 0
         see nl
      ok
   ok

next

see nl + "Found " + row + " numbers" + nl see "done..." + nl </lang>

Output:
working...
Numbers n with property that the sum of the digits of n is substring of n are:
0 1 2 3 4 5 6 7 8 9 
10 20 30 40 50 60 70 80 90 100 
109 119 129 139 149 159 169 179 189 199 
200 300 400 500 600 700 800 900 910 911 
912 913 914 915 916 917 918 919 
Found 48 numbers
done...

SNOBOL4

<lang snobol4> define('digsum(n)')  :(digsum_end) digsum digsum = 0 dsloop digsum = digsum + remdr(n,10) 

       n = ne(n,0) n / 10              :s(dsloop)f(return)

digsum_end 

       define('sumsub(n)')             :(sumsub_end)

sumsub n digsum(n) :s(return)f(freturn) sumsub_end 

       i = 0

loop output = sumsub(i) i 

       i = lt(i,999) i + 1             :s(loop)

end</lang>

Output:
0
1
2
3
4
5
6
7
8
9
10
20
30
40
50
60
70
80
90
100
109
119
129
139
149
159
169
179
189
199
200
300
400
500
600
700
800
900
910
911
912
913
914
915
916
917
918
919

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 numbers = [] for (n in 0..999) { 

   var ns = n.toString
   var ds = Int.digitSum(n).toString
   if (ns.contains(ds)) numbers.add(n)

} System.print("Numbers under 1,000 whose sum of digits is a substring of themselves:") for (chunk in Lst.chunks(numbers, 8)) Fmt.print("$3d", chunk) System.print("\n%(numbers.count) such numbers found.")</lang>

Output:
Numbers under 1,000 whose sum of digits is a substring of themselves:
  0   1   2   3   4   5   6   7
  8   9  10  20  30  40  50  60
 70  80  90 100 109 119 129 139
149 159 169 179 189 199 200 300
400 500 600 700 800 900 910 911
912 913 914 915 916 917 918 919

48 such numbers found.
Retrieved from "https://rosettacode.org/wiki/Sum_of_the_digits_of_n_is_substring_of_n?oldid=311587"