Sum of the digits of n is substring of n: Difference between revisions
→{{header|ALGOL W}}: spell isContained properly... |
|||
Line 912:
918
919</pre>
=={{header|Nim}}==
<lang Nim>import strutils
func digitsum(n: Natural): int =
if n == 0: return 0
var n = n
while n != 0:
result += n mod 10
n = n div 10
var count = 0
for n in 0..<1000:
let sn = $n
if $digitsum(n) in sn:
inc count
stdout.write sn.align(3), if count mod 8 == 0: '\n' else: ' '</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|Perl}}==
|
Revision as of 17:57, 20 June 2021
- Task
Find and show numbers n with property that the sum of the digits of n is substring of n, where n < 1000
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contains most consonants
- Find words which contains more than 3 vowels
- Find words which first and last three letters are equals
- Find words which odd letters are consonants and even letters are vowels or vice_versa
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 Bottles of Beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
8080 Assembly
<lang 8080asm>puts: equ 9 org 100h lxi h,-1 ; Number loop: inx h push h ; Keep number lxi d,-1000 ; Are we there yet? dad d pop d rc ; If so, stop push d ; Keep number lxi h,buf0 call digits ; Get digits push h ; Keep pointer to digits call dgsum ; Sum digits lxi h,buf1 call digits ; Get digits for sum pop d ; Retrieve pointer to digits of original push d call find ; Does the original contain the sum of the digits? pop d ; Retrieve digit pointer pop h ; And number jc loop ; If the sum of the digits is not found, try next push h call print ; Otherwise, print it pop h jmp loop ;;; Find digits of number in DE, store at HL. ;;; Beginning of string returned in HL. digits: lxi b,-10 ; Divisor mvi m,'$' ; String terminator push h ; Output pointer on stack digit: xchg ; Number in HL lxi d,-1 ; Quotient dgtdiv: inx d ; Trial subtaction dad b jc dgtdiv mvi a,10 ; Calculate value of digit add l pop h ; Store digit dcx h mov m,a push h mov a,d ; Done? ora e jnz digit ; If not, find next digit pop h ; Remove pointer from stack ret ;;; Calculate sum of digits starting at HL dgsum: lxi d,0 dgloop: mov a,m cpi '$' rz add e mov e,a inx h jmp dgloop ;;; See if the string at DE contains the string at HL find: ldax d ; Load character from haystack cpi '$' ; Reached the end? stc ; Then it is not found rz push d ; Save pointers push h xchg ; Swap pointers floop: ldax d ; Load character from needle cpi '$' ; Reached the end? jz found ; Then we found it cmp m ; Compare to haystack inx h ; Increment the pointers inx d jz floop ; If equal, keep going pop h ; Restore pointers pop d inx d ; Try next position jmp find found: pop h ; Clean up stack pop d ret ;;; Print number print: push d ploop: ldax d cpi '$' jz pdone adi '0' stax d inx d jmp ploop pdone: xchg mvi m,13 inx h mvi m,10 inx h mvi m,'$' pop d mvi c,puts jmp 5 buf0: equ $+32 buf1: equ $+64</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
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
ALGOL-M
<lang algolm>begin integer function mod(a,b); integer a,b; mod := a-a/b*b;
integer function digitsum(n); integer n; digitsum :=
if n=0 then 0 else mod(n,10) + digitsum(n/10);
integer function chop(n); integer n; begin
integer i; i := 1; while i<n do i := i * 10; i := i/10; chop := if i=0 then 0 else mod(n, i);
end;
integer function infix(n,h); integer n,h; begin
integer pfx, sfx, r; r := if n=h then 1 else 0; pfx := h; while pfx <> 0 do begin sfx := pfx; while sfx <> 0 do begin if sfx = n then begin r := 1; go to stop; end; sfx := chop(sfx); end; pfx := pfx/10; end;
stop:
infix := r;
end;
integer i, n, d; n := 0; for i := 0 step 1 until 999 do begin
d := digitsum(i); if infix(d, i) = 1 then begin if (n-1)/10 <> n/10 then write(i) else writeon(i); n := n + 1; end;
end; 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
ALGOL W
<lang algolw>begin % find numbers n, where the sum of the digits is a substring of n %
% returns true if the digits of s contains the digits of t, false otherwise % % s and t are assumed to be blank-padded, left-justified numeric strings % logical procedure containsDigits( integer value s, t ) ; if s = t then true else begin integer tPower, v, u; logical isContained; % find the lowest power of 10 that is greater then t % tPower := 10; v := abs t; while v > 9 do begin tPower := tPower * 10; v := v div 10 end while_v_gt_9 ; isContained := false; v := abs t; u := abs s; while not isContained and u > 0 do begin isContained := ( u rem tPower ) = v; u := u div 10 end while_not_isContained_and_u_gt_0 ; isContained end containsDigits ; % find and show the matching numbers up to 1000 % integer nCount; nCount := 0; for n := 0 until 999 do begin integer dSum, v; dSum := 0; v := n; while v > 0 do begin dSum := dSum + ( v rem 10 ); v := v div 10 end while_v_gt_0 ; if containsDigits( n, dSum ) then begin writeon( i_w := 5, s_w := 0, n ); nCount := nCount + 1; if nCount rem 8 = 0 then write() end if_n_contains_dSum end for_n
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
AWK
<lang AWK>
- syntax: GAWK -f SUM_OF_THE_DIGITS_OF_N_IS_SUBSTRING_OF_N.AWK
BEGIN {
start = 0 stop = 999 for (i=start; i<=stop; i++) { if (i ~ ""sum_digits(i)) { # TAWK needs the "" printf("%4d%1s",i,++count%10?"":"\n") } } printf("\nSum of the digits of n is substring of n %d-%d: %d\n",start,stop,count) exit(0)
} function sum_digits(n, i,sum) {
for (i=1; i<=length(n); i++) { sum += substr(n,i,1) } return(sum)
} </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 Sum of the digits of n is substring of n 0-999: 48
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
BCPL
<lang bcpl>get "libhdr"
let dsum(n) = n=0 -> 0, n rem 10 + dsum(n/10)
let chop(n) = valof $( let i=1
while i<n do i := i * 10 i := i / 10 resultis i=0 -> 0, n rem i
$)
let infix(n,h) =
n = h -> true, h = 0 -> false, infix(n,h/10) -> true, infix(n,chop(h)) -> true, false
let start() be $( let c=0
for i=0 to 999 do $( if infix(dsum(i),i) then $( writef("%I5",i) c := c + 1 if c rem 10=0 then wrch('*N') $) $) wrch('*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
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
F#
<lang fsharp> // Sum digits of n is substring of n: Nigel Galloway. April 16th., 2021 let rec fG n g=match (n/10,n%(if g<10 then 10 else 100)) with (_,n) when n=g->true |(0,_)->false |(n,_)->fG n g let rec fN g=function n when n<10->n+g |n->fN(g+n%10)(n/10) {1..999}|>Seq.filter(fun n->fG n (fN 0 n))|>Seq.iter(printf "%d "); printfn "" </lang>
- Output:
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 Real: 00:00:00.003
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
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
<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
Kotlin
<lang scala>fun digitSum(n: Int): Int {
var nn = n var sum = 0 while (nn > 0) { sum += (nn % 10) nn /= 10 } return sum
}
fun main() {
var c = 0 for (i in 0 until 1000) { val ds = digitSum(i) if (i.toString().contains(ds.toString())) { print("%3d ".format(i))
c += 1 if (c == 8) { println() c = 0 } } } println()
}</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
Nim
<lang Nim>import strutils
func digitsum(n: Natural): int =
if n == 0: return 0 var n = n while n != 0: result += n mod 10 n = n div 10
var count = 0 for n in 0..<1000:
let sn = $n if $digitsum(n) in sn: inc count stdout.write sn.align(3), if count mod 8 == 0: '\n' else: ' '</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
- 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...
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
<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.