Sum of the digits of n is substring of n
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 decimal digits of n is substring of n, where n < 1,000
Other tasks related to string operations:
- 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
11l
V count = 0
L(n) 1000
I String(sum(String(n).map(Int))) C String(n)
count++
print(f:‘{n:3}’, end' I count % 8 == 0 {"\n"} E ‘ ’)- 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
8080 Assembly
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- 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
Action!
INT FUNC SumDigits(INT num)
INT res,a
res=0
WHILE num#0
DO
res==+num MOD 10
num=num/10
OD
RETURN (res)
BYTE Func IsValidNumber(INT num)
CHAR ARRAY s(5),sub(5)
INT sum,v,len,start
sum=SumDigits(num)
StrI(num,s)
FOR len=1 TO s(0)
DO
FOR start=1 TO s(0)-len+1
DO
SCopyS(sub,s,start,start+len-1)
IF ValI(sub)=sum THEN
RETURN (1)
FI
OD
OD
RETURN (0)
PROC Main()
INT i,count=[0]
FOR i=0 TO 999
DO
IF IsValidNumber(i) THEN
PrintI(i) Put(32)
count==+1
FI
OD
PrintF("%E%EThere are %I numbers",count)
RETURN- Output:
Screenshot from Atari 8-bit computer
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 There are 48 numbers
ALGOL 68
ALGOL 68G has the procedure "string in string" in the prelude, for other compilers, a version is available here: ALGOL_68/prelude.
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- 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
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- 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
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 %
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.- 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
(⊢(/⍨)(∨/⍕∘(+/(⍎¨⍕))⍷⍕)¨)0,⍳999
- 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
Arturo
print select 1..999 'num ->
contains? to :string num
to :string sum digits num
- 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
AutoHotkey
result := "", cntr := 1
loop 1000{
n := A_Index-1, sum := 0
for i, v in StrSplit(n)
sum += v
if InStr(n, sum){
result .= n (mod(cntr, 8)?"`t":"`n")
if (++cntr = 50)
break
}
}
MsgBox % result
- 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
# 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)
}
- 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
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
- 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
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')
$)- 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
BQN
DigitSum ← +´•Fmt-'0'˙
Contains ← (∨´⍷˜ )○•Fmt
∘‿6⥊ (⊢ Contains DigitSum)¨⊸/↕1000
- 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
#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;
}
- 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++
#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;
}
- 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
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
digit_sum_is_substring = proc (n: int) returns (bool)
n_str: string := int$unparse(n)
ds_str: string := int$unparse(digit_sum(n))
return (string$indexs(ds_str, n_str) ~= 0)
end digit_sum_is_substring
match_range = iter (from, to: int, p: proctype (int) returns (bool))
yields (int)
for i: int in int$from_to(from,to) do
if p(i) then yield(i) end
end
end match_range
start_up = proc ()
po: stream := stream$primary_output()
col: int := 0
for i: int in match_range(0, 999, digit_sum_is_substring) do
stream$putright(po, int$unparse(i), 4)
col := col + 1
if col // 10 = 0 then stream$putc(po, '\n') end
end
end start_up- 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
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. SUM-SUBSTRING.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 CALCULATION.
02 N PIC 9999.
02 X PIC 9.
02 DSUM PIC 99.
02 N-DIGITS REDEFINES N.
03 ND PIC 9 OCCURS 4 TIMES.
02 S-DIGITS REDEFINES DSUM.
03 SUMD PIC 9 OCCURS 2 TIMES.
01 OUTPUT-FORMAT.
02 N-OUT PIC ZZZ9.
PROCEDURE DIVISION.
BEGIN.
PERFORM TESTNUMBER VARYING N FROM 0 BY 1
UNTIL N IS EQUAL TO 1000.
STOP RUN.
TESTNUMBER SECTION.
BEGIN.
PERFORM SUM-DIGITS.
SET X TO 1.
IF DSUM IS LESS THAN 10 GO TO ONE-DIGIT-CHECK.
TWO-DIGIT-CHECK.
IF X IS GREATER THAN 3 GO TO DONE.
IF ND(X) = SUMD(1) AND ND(X + 1) = SUMD(2) GO TO SHOW.
ADD 1 TO X.
GO TO TWO-DIGIT-CHECK.
ONE-DIGIT-CHECK.
IF X IS GREATER THAN 4 GO TO DONE.
IF ND(X) = SUMD(2) GO TO SHOW.
ADD 1 TO X.
GO TO ONE-DIGIT-CHECK.
SHOW.
MOVE N TO N-OUT.
DISPLAY N-OUT.
DONE. EXIT.
SUM-DIGITS SECTION.
BEGIN.
SET DSUM TO 0.
SET X TO 1.
LOOP.
ADD ND(X) TO DSUM.
ADD 1 TO X.
IF X IS LESS THAN 5 GO TO LOOP.
- 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
Comal
0010 FUNC digit'sum#(n#) CLOSED
0020 sum#:=0
0030 WHILE n# DO sum#:+n# MOD 10;n#:=n# DIV 10
0040 RETURN sum#
0050 ENDFUNC digit'sum#
0060 //
0070 col#:=0
0080 ZONE 4
0090 FOR i#:=0 TO 999 DO
0100 IF STR$(digit'sum#(i#)) IN STR$(i#) THEN
0110 PRINT i#,
0120 col#:+1
0130 IF col# MOD 15=0 THEN PRINT
0140 ENDIF
0150 ENDFOR i#
0160 PRINT
0170 END
- 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
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();- 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
D
import std.algorithm;
import std.conv;
import std.stdio;
int digitSum(int n) {
int s = 0;
do {
s += n % 10;
} while (n /= 10);
return s;
}
void main() {
foreach (i; 0 .. 1000) {
if (i.to!string.canFind(digitSum(i).to!string)) {
write(i, ' ');
}
}
writeln;
}
- 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
Delphi
{This code would normally be in a library, but is included here for clarity}
procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
{Numbers returned from least to most significant}
var T,I,DC: integer;
begin
DC:=Trunc(Log10(N))+1;
SetLength(IA,DC);
for I:=0 to DC-1 do
begin
T:=N mod 10;
N:=N div 10;
IA[I]:=T;
end;
end;
procedure SumDigitsSubstring(Memo: TMemo);
var N,J,Cnt,Sum: integer;
var Dg: TIntegerDynArray;
var NS,SS,S: string;
begin
S:='';
Cnt:=0;
for N:=0 to 1000-1 do
begin
GetDigits(N,Dg);
Sum:=0;
for J:=0 to High(Dg) do
Sum:=Sum+Dg[J];
NS:=IntToStr(N);
SS:=IntToStr(Sum);
if Pos(SS,NS)>0 then
begin
Inc(Cnt);
S:=S+Format('%4d',[N]);
if (Cnt mod 10)=0 then S:=S+CRLF;
end;
end;
Memo.Lines.Add(S);
end;
- 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 Elapsed Time: 1.433 ms.
Draco
\util.g
proc nonrec digit_sum(word n) word:
word sum;
sum := 0;
while n ~= 0 do
sum := sum + n % 10;
n := n / 10;
od;
sum
corp
proc nonrec itoa(word n; *char buf) void:
channel output text ch;
open(ch, buf);
write(ch; n);
close(ch)
corp
proc nonrec digit_sum_is_substring(word n) bool:
[10] char dstr, dsub;
itoa(n, &dstr[0]);
itoa(digit_sum(n), &dsub[0]);
CharsIndex(&dstr[0], &dsub[0]) ~= -1
corp
proc nonrec main() void:
word i, seen;
seen := 0;
for i from 0 upto 999 do
if digit_sum_is_substring(i) then
write(i:4);
seen := seen + 1;
if seen % 20 = 0 then writeln() fi
fi
od
corp- 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#
// 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 ""
- 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
USING: grouping kernel math.text.utils present prettyprint
sequences ;
1000 <iota>
[ [ 1 digit-groups sum present ] [ present ] bi subseq? ] filter
8 group simple-table.
- 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
Fermat
No string conversion.
Func Digsum(n, b) =
ds:=0; {digital sum of n in base b}
while n>0 do
ds:+(n|b);
n:=n\b;
od;
ds.;
Func Numdig(n, b) =
nd:=0; {number of digits of n in base b}
while n > 0 do
nd:+;
n:=n\b;
od;
nd.;
for n = 1 to 999 do
ds:=Digsum(n, 10); {digital sum of n}
nd:=Numdig(ds, 10); {how many digits does the digital sum itself have?}
nt:=n; {temporary copy of n}
while nt>0 do
if ds=(nt|(10^(nd))) then
!!n; {if the last nt digits of n are the digital sum, print and exit the loop}
&>;
fi;
nt:=nt\10;
od;
od;- 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
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,!- 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
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- 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ōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solution
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.")
}
- 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
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 <>)
- 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
([#~(":+./@E.~[:":+/@(10&#.^:_1))"0)i.999
- 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
jq
Works with gojq, the Go implementation of jq
def sum_of_digits_is_substring:
tostring
| . as $s
| (explode | map([.]|implode))
| (map(tonumber)|add|tostring) as $ss
| $s | index($ss);
[range(0;1000) | select(sum_of_digits_is_substring)]- 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
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)))
- 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
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()
}
- 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
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- 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
Mathematica/Wolfram Language
ClearAll[SumAsSubString]
SumAsSubString[n_Integer] := Module[{id, s},
id = IntegerDigits[n];
s = Total[id];
SequenceCount[id, IntegerDigits[s]] > 0
]
Select[Range[999], SumAsSubString]
- 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}
Miranda
main :: [sys_message]
main = [Stdout (table 5 10 taskresults)]
where taskresults = filter digit_sum_is_substring [0..999]
table :: num->num->[num]->[char]
table cw w ns = lay (map concat (split (map fmt ns)))
where split [] = []
split ls = take w ls : split (drop w ls)
fmt n = reverse (take cw ((reverse (shownum n)) ++ repeat ' '))
digit_sum_is_substring :: num->bool
digit_sum_is_substring n = (digitsum n) $infix n
digitsum :: num->num
digitsum 0 = 0
digitsum n = n mod 10 + digitsum (n div 10)
infix :: num->num->bool
infix n h = True, if n = h
= False, if h = 0
= True, if n $infix (h div 10)
= True, if n $infix (chop h)
= False, otherwise
chop :: num->num
chop n = 0, if n<10
= n mod mask, otherwise
where mask = last (takewhile (<n) (iterate (*10) 1))- 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
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: ' '
- 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 ..
// 20210415 Perl programming solution
perl -e 'for(0..999){my$n;s/(\d)/$n+=$1/egr;print"$_ "if/$n/}'
- 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/I
sumOfDigitsIsSubstring: procedure options(main);
digitSum: procedure(n) returns(fixed);
declare (ds, x, n) fixed;
ds = 0;
do x=n repeat(x/10) while(x>0);
ds = ds + mod(x, 10);
end;
return(ds);
end digitSum;
chop: procedure(n) returns(fixed);
declare (i, n) fixed;
i = 1;
do while(i<n);
i = i * 10;
end;
i = i/10;
if i=0 then return(0);
else return(mod(n, i));
end chop;
infix: procedure(n, h) returns(bit) recursive;
declare (n, h) fixed;
if n=h then return('1'b);
if h=0 then return('0'b);
if infix(n, h/10) then return('1'b);
return(infix(n, chop(h)));
end infix;
declare (i, col) fixed;
col = 0;
do i=0 to 999;
if infix(digitSum(i), i) then do;
put edit(i) (F(5));
col = col + 1;
if mod(col, 10)=0 then put skip;
end;
end;
put skip;
end sumOfDigitsIsSubstring;- 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
PL/M
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- 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:
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
>>>
or as a full script, taking an alternative route, and slightly reducing the number of str conversions required:
'''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()
- 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
Quackery
[ over findseq swap found ] is hasseq ( [ [ --> b )
[ [] swap
[ 10 /mod
rot join swap
dup 0 = until ]
drop ] is digits ( n --> [ )
[ digits
0 over witheach +
digits hasseq ] is subsum ( n --> b )
[] 1000 times
[ i^ subsum if
[ i^ join ] ]
dup echo
cr cr
say "There are " size echo say " numbers."- 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 ] There are 48 numbers.
Raku
say "{+$_} matching numbers\n{.batch(10)».fmt('%3d').join: "\n"}" given (^1000).grep: { .contains: .comb.sum }
- 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
/*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
- 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
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- 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...
RPL
≪ →STR 0 1 3 PICK SIZE FOR j
OVER j DUP SUB STR→ + NEXT
→STR POS
≫ ‘∑DIN?’ STO
≪ { } 1 1000 FOR j IF j ∑DIN? THEN j + END NEXT ≫ EVAL
- Output:
1: { 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 }
Ruby
p (0...1000).select{|n| n.to_s.match? n.digits.sum.to_s}
- 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, 1000]
Rust
fn sum_digits( mut num : u32 ) -> u32 {
let mut sum : u32 = 0 ;
while num != 0 {
sum += num % 10 ;
num /= 10 ;
}
sum
}
fn main() {
let solution : Vec<u32> = (0..1000).filter( | &d | {
let digit_sum : u32 = sum_digits( d ) ;
let sumstring = digit_sum.to_string( ) ;
let sumstr : &str = sumstring.as_str( ) ;
let numstring : String = d.to_string( ) ;
let numstr : &str = numstring.as_str( ) ;
numstr.contains( &sumstr )
}).collect( ) ;
println!("{:?}" , solution ) ;
}
- 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]
Sidef
var upto = 1000
var base = 10
var list = (^upto -> grep {
.digits(base).contains(.sumdigits(base).digits(base)...)
})
say "Numbers under #{upto} whose sum of digits is a substring of themselves:"
list.each_slice(8, {|*a|
say a.map { '%3s' % _ }.join(' ')
})
say "\n#{list.len} such numbers found."
- Output:
Numbers under 1000 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.
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- 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
import "./math" for Int
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:")
Fmt.tprint("$3d", numbers, 8)
System.print("\n%(numbers.count) such numbers found.")
- 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.
XPL0
func Check(N); \Return 'true' if sum of digits of N is a substring of N
int N, Sum, A, B, C;
[N:= N/10;
C:= rem(0);
N:= N/10;
B:= rem(0);
A:= N;
Sum:= A+B+C;
if Sum=A or Sum=B or Sum=C then return true;
if Sum = B*10 + C then return true;
if Sum = A*10 + B then return true;
return false;
];
int Count, N;
[Count:= 0;
for N:= 0 to 1000-1 do
if Check(N) then
[IntOut(0, N);
Count:= Count+1;
if rem(Count/10) = 0 then CrLf(0) else ChOut(0, 9\tab\);
];
CrLf(0);
IntOut(0, Count);
Text(0, " such numbers found below 1000.
");
]- 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 48 such numbers found below 1000.
Yabasic
// Rosetta Code problem: http://rosettacode.org/wiki/Sum_of_the_digits_of_n_is_substring_of_n
// by Galileo, 04/2022
for n = 0 to 999
if isSubstring(n) print n using "####";
next
print
sub isSubstring(n)
local n$, lon, i, p
n$ = str$(n)
lon = len(n$)
for i = 1 to lon
p = p + val(mid$(n$,i,1))
next
return instr(n$, str$(p))
end sub- 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 ---Program done, press RETURN---
Categories:
- Draft Programming Tasks
- 11l
- 8080 Assembly
- Action!
- ALGOL 68
- ALGOL-M
- ALGOL W
- APL
- Arturo
- AutoHotkey
- AWK
- BASIC
- BCPL
- BQN
- C
- C++
- CLU
- COBOL
- Comal
- Cowgol
- D
- Delphi
- SysUtils,StdCtrls
- Draco
- F Sharp
- Factor
- Fermat
- FOCAL
- FreeBASIC
- Fōrmulæ
- Go
- Go-rcu
- Haskell
- J
- Jq
- Julia
- Kotlin
- MAD
- Mathematica
- Wolfram Language
- Miranda
- Nim
- Perl
- Phix
- PL/I
- PL/M
- Python
- Quackery
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- Sidef
- SNOBOL4
- Wren
- Wren-math
- Wren-fmt
- XPL0
- Yabasic