Rosetta Code

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

Page Discussion

Sum of the digits of n is substring of n (view source)

Revision as of 17:50, 28 August 2022

1,425 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 12:
{{trans|Nim}}
 
<langsyntaxhighlight lang="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 ‘ ’)</langsyntaxhighlight>
 
{{out}}
Line 29:
 
=={{header|8080 Assembly}}==
<langsyntaxhighlight lang="8080asm">puts: equ 9
org 100h
lxi h,-1 ; Number
Line 126:
jmp 5
buf0: equ $+32
buf1: equ $+64</langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'>0
Line 178:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">INT FUNC SumDigits(INT num)
INT res,a
 
Line 218:
OD
PrintF("%E%EThere are %I numbers",count)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_the_digits_of_n_is_substring_of_n.png Screenshot from Atari 8-bit computer]
Line 230:
=={{header|ALGOL 68}}==
ALGOL 68G has the procedure "string in string" in the prelude, for other compilers, a version is available here: [[ALGOL_68/prelude]].
<langsyntaxhighlight 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;
Line 247:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 259:
 
=={{header|ALGOL-M}}==
<langsyntaxhighlight lang="algolm">begin
integer function mod(a,b);
integer a,b;
Line 316:
end;
end;
end</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 325:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight 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 %
logical procedure containsDigits( integer value s, t ) ;
Line 365:
end if_n_contains_dSum
end for_n
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 378:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(⊢(/⍨)(∨/⍕∘(+/(⍎¨⍕))⍷⍕)¨)0,⍳999</langsyntaxhighlight>
{{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
Line 385:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">print select 1..999 'num ->
contains? to :string num
to :string sum digits num</langsyntaxhighlight>
 
{{out}}
Line 394:
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">result := "", cntr := 1
loop 1000{
n := A_Index-1, sum := 0
Line 405:
}
}
MsgBox % result</langsyntaxhighlight>
{{out}}
<pre>0 1 2 3 4 5 6 7
Line 415:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SUM_OF_THE_DIGITS_OF_N_IS_SUBSTRING_OF_N.AWK
BEGIN {
Line 434:
return(sum)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 446:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 DEFINT I,J,K
20 FOR I=0 TO 999
30 J=0: K=I
Line 453:
42 J$=STR$(J): J$=RIGHT$(J$,LEN(J$)-1)
50 IF INSTR(I$,J$) THEN PRINT I,
60 NEXT I</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4
Line 468:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let dsum(n) = n=0 -> 0, n rem 10 + dsum(n/10)
Line 496:
$)
wrch('*N')
$)</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 505:
 
=={{header|BQN}}==
<langsyntaxhighlight lang="bqn">DigitSum ← +´•Fmt-'0'˙
Contains ← (∨´⍷˜ )○•Fmt
∘‿6⥊ (⊢ Contains DigitSum)¨⊸/↕1000</langsyntaxhighlight>
{{out}}
<pre>┌─
Line 520:
┘</pre>
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
 
Line 544:
return 0;
}</langsyntaxhighlight>
{{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|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
 
int digitSum(int n) {
Line 567:
std::cout << std::endl;
return 0;
}</langsyntaxhighlight>
{{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|CLU}}==
<langsyntaxhighlight lang="clu">digit_sum = proc (n: int) returns (int)
sum: int := 0
while n > 0 do
Line 602:
if col // 10 = 0 then stream$putc(po, '\n') end
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 611:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. SUM-SUBSTRING.
Line 663:
ADD ND(X) TO DSUM.
ADD 1 TO X.
IF X IS LESS THAN 5 GO TO LOOP.</langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'> 0
Line 715:
 
=={{header|Comal}}==
<langsyntaxhighlight lang="comal">0010 FUNC digit'sum#(n#) CLOSED
0020 sum#:=0
0030 WHILE n# DO sum#:+n# MOD 10;n#:=n# DIV 10
Line 731:
0150 ENDFOR i#
0160 PRINT
0170 END</langsyntaxhighlight>
{{out}}
<pre>0 1 2 3 4 5 6 7 8 9 10 20 30 40 50
Line 739:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub digitSum(n: uint16): (s: uint16) is
Line 782:
i := i + 1;
end loop;
print_nl();</langsyntaxhighlight>
{{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>
Line 788:
=={{header|D}}==
{{trans|C++}}
<langsyntaxhighlight lang="d">import std.algorithm;
import std.conv;
import std.stdio;
Line 807:
}
writeln;
}</langsyntaxhighlight>
{{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|Draco}}==
<langsyntaxhighlight lang="draco">\util.g
 
proc nonrec digit_sum(word n) word:
Line 848:
fi
od
corp</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100
Line 855:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight 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 ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 869:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight 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.</langsyntaxhighlight>
{{out}}
<pre>
Line 887:
=={{header|Fermat}}==
No string conversion.
<langsyntaxhighlight lang="fermat">Func Digsum(n, b) =
ds:=0; {digital sum of n in base b}
while n>0 do
Line 914:
nt:=nt\10;
od;
od;</langsyntaxhighlight>
{{out}}<pre>
1
Line 966:
 
=={{header|FOCAL}}==
<langsyntaxhighlight lang="focal">01.10 F N=0,999;D 2;D 4
01.20 Q
 
Line 990:
04.70 I (P)4.2,4.8,4.2
04.80 R
04.90 T %3,N,!</langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'>= 0
Line 1,042:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight 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
Line 1,061:
for i as uinteger = 0 to 999
if is_substring( str(i), str(sumdig(i))) then print i;" ";
next i : print : end</langsyntaxhighlight>
{{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>
 
Line 1,075:
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,096:
fmt.Println()
fmt.Println(len(numbers), "such numbers found.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,112:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.Char (digitToInt)
import Data.List (isInfixOf)
import Data.List.Split (chunksOf)
Line 1,147:
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre>48 matches in [0..999]
Line 1,197:
 
=={{header|J}}==
<langsyntaxhighlight lang="j">([#~(":+./@E.~[:":+/@(10&#.^:_1))"0)i.999</langsyntaxhighlight>
{{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>
Line 1,204:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
<lang jq>
def sum_of_digits_is_substring:
tostring
Line 1,212:
| $s | index($ss);
 
[range(0;1000) | select(sum_of_digits_is_substring)]</langsyntaxhighlight>
{{out}}
<pre>
Line 1,219:
 
=={{header|Julia}}==
<langsyntaxhighlight 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)))
</langsyntaxhighlight>{{out}}
<pre>
0 1 2 3 4 5 6 7 8 9
Line 1,233:
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">fun digitSum(n: Int): Int {
var nn = n
var sum = 0
Line 1,258:
}
println()
}</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7
Line 1,268:
 
=={{header|MAD}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
INTERNAL FUNCTION(A,B)
Line 1,321:
 
VECTOR VALUES FMT = $I3*$
END OF PROGRAM </langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'> 0
Line 1,373:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[SumAsSubString]
SumAsSubString[n_Integer] := Module[{id, s},
id = IntegerDigits[n];
Line 1,379:
SequenceCount[id, IntegerDigits[s]] > 0
]
Select[Range[999], SumAsSubString]</langsyntaxhighlight>
{{out}}
<pre>{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|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strutils
 
func digitsum(n: Natural): int =
Line 1,398:
if $digitsum(n) in sn:
inc count
stdout.write sn.align(3), if count mod 8 == 0: '\n' else: ' '</langsyntaxhighlight>
 
{{out}}
Line 1,410:
=={{header|Perl}}==
as one-liner ..
<langsyntaxhighlight lang="perl">// 20210415 Perl programming solution
 
perl -e 'for(0..999){my$n;s/(\d)/$n+=$1/egr;print"$_ "if/$n/}'</langsyntaxhighlight>
{{out}}
<pre>
Line 1,419:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">sdn</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">sn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
Line 1,428:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Found %d such numbers &lt; %d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #000000;">n</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,436:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">sumOfDigitsIsSubstring: procedure options(main);
digitSum: procedure(n) returns(fixed);
declare (ds, x, n) fixed;
Line 1,475:
end;
put skip;
end sumOfDigitsIsSubstring;</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 1,484:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="plm">100H:
DIGIT$SUM: PROCEDURE (N) BYTE;
DECLARE N ADDRESS, SUM BYTE;
Line 1,556:
 
CALL BDOS(0,0);
EOF</langsyntaxhighlight>
{{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>
Line 1,563:
Just using the command line:
 
<langsyntaxhighlight 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)]
Line 1,575:
200, 300, 400, 500, 600, 700, 800, 900, 910, 911
912, 913, 914, 915, 916, 917, 918, 919
>>> </langsyntaxhighlight>
 
 
or as a full script, taking an alternative route, and slightly reducing the number of str conversions required:
 
<langsyntaxhighlight lang="python">'''Sum of the digits of n is substring of n'''
 
from functools import reduce
Line 1,653:
if __name__ == '__main__':
main()
</syntaxhighlight>
</lang>
{{Out}}
<pre>48 matches < 1000:
Line 1,664:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>say "{+$_} matching numbers\n{.batch(10)».fmt('%3d').join: "\n"}" given (^1000).grep: { .contains: .comb.sum }</langsyntaxhighlight>
{{out}}
<pre>48 matching numbers
Line 1,674:
 
=={{header|REXX}}==
<langsyntaxhighlight 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.*/
Line 1,702:
/*──────────────────────────────────────────────────────────────────────────────────────*/
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</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,718:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 1,745:
see nl + "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,760:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var upto = 1000
var base = 10
 
Line 1,773:
})
 
say "\n#{list.len} such numbers found."</langsyntaxhighlight>
{{out}}
<pre>
Line 1,788:
 
=={{header|SNOBOL4}}==
<langsyntaxhighlight lang="snobol4"> define('digsum(n)') :(digsum_end)
digsum digsum = 0
dsloop digsum = digsum + remdr(n,10)
Line 1,801:
loop output = sumsub(i) i
i = lt(i,999) i + 1 :s(loop)
end</langsyntaxhighlight>
{{out}}
<pre style='height:50ex'>0
Line 1,856:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/math" for Int
import "/seq" for Lst
import "/fmt" for Fmt
Line 1,868:
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.")</langsyntaxhighlight>
 
{{out}}
Line 1,884:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="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;
Line 1,910:
Text(0, " such numbers found below 1000.
");
]</langsyntaxhighlight>
 
{{out}}
Line 1,923:
 
=={{header|Yabasic}}==
<langsyntaxhighlight Yabasiclang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sum_of_the_digits_of_n_is_substring_of_n
// by Galileo, 04/2022
 
Line 1,941:
return instr(n$, str$(p))
end sub</langsyntaxhighlight>
{{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
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328544"