Sum of the digits of n is substring of n: Difference between revisions
Not a robot (talk | contribs) Add C++ |
Not a robot (talk | contribs) Add Cowgol |
||
Line 112: | Line 112: | ||
{{out}} |
{{out}} |
||
<pre>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</pre> |
<pre>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</pre> |
||
=={{header|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> |
|||
{{out}} |
|||
<pre>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</pre> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2021-02-05}} |
{{works with|Factor|0.99 2021-02-05}} |
Revision as of 13:01, 15 April 2021
- 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
<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+I MOD 10: K=K\10: GOTO 40 50 IF INSTR(STR$(I),STR$(J)) THEN PRINT I, 60 NEXT I</lang>
- Output:
0 1 2 3 4 5 6 7 8 9 21 42 63 84 124 155 186 217 248 279 301 311 321 331 341 351 361 371 381 391 602 612 622 632 642 652 662 672 682 692 903 913 923 933 943 953 963 973 983 993
C
<lang c>#include <stdio.h>
- 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
<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
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
<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
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
- 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
- ------------------------- TEST -------------------------
- main :: IO ()
def main():
Matches in [0..999] print( showMatches( digitSumIsSubString )(999) )
- ----------------------- DISPLAY ------------------------
- 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
- ----------------------- GENERIC ------------------------
- 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
- 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...
Wren
<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.