Rosetta Code

Inconsummate numbers in base 10: Difference between revisions

Page Discussion

Inconsummate numbers in base 10 (view source)

Revision as of 20:25, 15 December 2023

26,494 bytes added ,  5 months ago
Added Sidef
(Added Perl)
(Added Sidef)
 
(28 intermediate revisions by 17 users not shown)
Line 1:
{{draft task}}
A consummate number is a non-negative integer that can be formed by some integer '''N''' divided by the the digital sum of '''N'''.
 
Line 29:
;* [https://www.numbersaplenty.com/set/inconsummate_number/ Numbers Aplenty - Inconsummate numbers]
;* [[oeis:A003635|OEIS:A003635 - Inconsummate numbers in base 10]]
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">
F digitalsum(num)
‘ Return sum of digits of a number in base 10 ’
R sum(String(num).map(d -> Int(d)))
 
F generate_inconsummate(max_wanted)
‘ generate the series of inconsummate numbers up to max_wanted ’
V minimum_digitsums = (1..14).map(i -> (Int64(10) ^ i, Int((Int64(10) ^ i - 1) / (9 * i))))
V limit = 20 * Int(min(minimum_digitsums.filter(p -> p[1] > @max_wanted).map(p -> p[0])))
V arr = [1] [+] [0] * (limit - 1)
 
L(dividend) 1 .< limit
V (quo, rem) = divmod(dividend, digitalsum(dividend))
I rem == 0 & quo < limit
arr[quo] = 1
[Int] r
L(flag) arr
I flag == 0
r.append(L.index)
R r
 
L(n) generate_inconsummate(100000)
V i = L.index
I i < 50
print(f:‘{n:6}’, end' I (i + 1) % 10 == 0 {"\n"} E ‘’)
E I i == 999
print("\nThousandth inconsummate number: "n)
E I i == 9999
print("\nTen-thousanth inconsummate number: "n)
E I i == 99999
print("\nHundred-thousanth inconsummate number: "n)
L.break
</syntaxhighlight>
 
{{out}}
<pre>
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
Thousandth inconsummate number: 6996
 
Ten-thousanth inconsummate number: 59853
 
Hundred-thousanth inconsummate number: 536081
</pre>
 
=={{header|Action!}}==
Line 199 ⟶ 251:
Inconsummate number 10000: 59853
Inconsummate number 100000: 536081
</pre>
 
=={{header|APL}}==
<syntaxhighlight lang="apl">task←{
gen ← ⍳~(⊢(/⍨)⌊=⊢)∘(⊢÷(+/⍎¨∘⍕)¨)∘⍳∘(⊢×9×≢∘⍕)
incons ← gen 9999
⎕←'The first 50 inconsummate numbers:'
⎕←5 10⍴50↑incons
⎕←'The 1000th inconsummate number:',incons[1000]
}</syntaxhighlight>
{{out}}
<pre>The first 50 inconsummate numbers:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
The 1000th inconsummate number: 6996</pre>
 
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">on inconsummateNumbers(numberRequired)
set limit to numberRequired * 1000 -- Seems to be enough.
script o
property lst : makeList(limit, true)
end script
repeat with n from 11 to limit -- 1 to 10 obviously can't be inconsummate.
set digitSum to n mod 10
set temp to n div 10
repeat while (temp > 9)
set digitSum to digitSum + temp mod 10
set temp to temp div 10
end repeat
set digitSum to digitSum + temp
tell (n div digitSum) to if (it = n / digitSum) then set o's lst's item it to false
end repeat
set i to 0
repeat with n from 11 to limit
if (o's lst's item n) then
set i to i + 1
set o's lst's item i to n
if (i = numberRequired) then return o's lst's items 1 thru i
end if
end repeat
return {}
end inconsummateNumbers
 
on makeList(limit, filler)
if (limit < 1) then return {}
script o
property lst : {filler}
end script
set counter to 1
repeat until (counter + counter > limit)
set o's lst to o's lst & o's lst
set counter to counter + counter
end repeat
if (counter < limit) then set o's lst to o's lst & o's lst's items 1 thru (limit - counter)
return o's lst
end makeList
 
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
 
on task()
script o
property inconsummates : inconsummateNumbers(100000)
end script
set output to {"First 50 inconsummate numbers:"}
set row to {}
repeat with i from 1 to 50
set row's end to text -5 thru -1 of (" " & o's inconsummates's item i)
if (i mod 10 = 0) then
set output's end to join(row, "")
set row to {}
end if
end repeat
set output's end to linefeed & "1,000th inconsummate number: " & o's inconsummates's item 1000
set output's end to "10,000th inconsummate number: " & o's inconsummates's item 10000
set output's end to "100,000th inconsummate number: " & o's inconsummates's end
return join(output, linefeed)
end task
 
task()</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"First 50 inconsummate numbers:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
1,000th inconsummate number: 6996
10,000th inconsummate number: 59853
100,000th inconsummate number: 536081"</syntaxhighlight>
 
=={{header|BASIC}}==
{{works with|QBasic}}
<syntaxhighlight lang="basic">10 DEFINT A-Z
20 M=999
30 DIM C(M)
40 Z=M*9*(LEN(STR$(M))-1)
50 FOR I=10 TO Z
60 J=I:S=0
70 S=S+J MOD 10:J=J\10:IF J GOTO 70
80 IF I MOD S=0 THEN J=I\S:IF J<=M THEN C(J)=-1
90 NEXT
100 J=0
110 FOR I=10 TO M
120 IF J=50 THEN END
130 IF NOT C(I) THEN J=J+1:PRINT I,
140 NEXT</syntaxhighlight>
{{out}}
<pre> 62 63 65 75 84
95 161 173 195 216
261 266 272 276 326
371 372 377 381 383
386 387 395 411 416
422 426 431 432 438
441 443 461 466 471
476 482 483 486 488
491 492 493 494 497
498 516 521 522 527</pre>
 
==={{header|BASIC256}}===
{{trans|BASIC}}
<syntaxhighlight lang="qbasic">m = 999
dim c(m) fill false
z = m * 9 * (length(string(m))-1)
 
for i = 10 to z
j = i
s = 0
while j <> 0
s += (j % 10)
j /= 10
end while
if i % s = 0 then j = i \ s : if j <= m then c[j] = true
next i
 
cont = 0
print "The first 50 inconsummate numbers:"
for i = 10 to m
if cont = 50 then end
if not c[i] then cont += 1 : print rjust(string(i), 4);
next i</syntaxhighlight>
 
==={{header|Chipmunk Basic}}===
{{trans|BASIC}}
{{works with|Chipmunk Basic|3.6.4}}
{{works with|GW-BASIC}}
{{works with|Just BASIC}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">110 m = 999
120 dim c(m)
130 z = m*9*(len(str$(m))-1)
140 for i = 10 to z
150 j = i : s = 0
160 s = s+j mod 10 : j = int(j/10) : if j then goto 160
170 if i mod s = 0 then j = int(i/s) : if j <= m then c(j) = -1
180 next i
190 j = 0
200 for i = 10 to m
210 if j = 50 then end
220 if c(i) <> -1 then j = j+1 : print i,
230 next i</syntaxhighlight>
 
==={{header|GW-BASIC}}===
{{works with|PC-BASIC|any}}
{{works with|BASICA}}
The [[#Chipmunk Basic|Chipmunk Basic]] solution works without any changes.
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
The [[#BASIC|BASIC]] solution works without any changes.
 
==={{header|True BASIC}}===
{{trans|BASIC}}
<syntaxhighlight lang="qbasic">LET m = 999
DIM c(0)
MAT REDIM c(m)
LET z = m * 9 * (LEN(STR$(m))-1)
FOR i = 10 TO z
LET j = i
LET s = 0
DO
LET s = s + REMAINDER(j,10)
LET j = INT(j/10)
LOOP WHILE j <> 0
IF REMAINDER(i,s) = 0 THEN
LET j = INT(i/s)
IF j <= m THEN LET c(j) = -1
END IF
NEXT i
 
LET cont = 0
PRINT "The first 50 inconsummate numbers:"
FOR i = 10 TO m
IF cont = 50 THEN EXIT FOR
IF c(i) <> -1 THEN
LET cont = cont + 1
PRINT i;
END IF
NEXT i
END</syntaxhighlight>
 
==={{header|XBasic}}===
{{trans|BASIC256}}
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Inconsummate numbers in base 10"
VERSION "0.0000"
 
DECLARE FUNCTION Entry ()
 
FUNCTION Entry ()
m = 999
DIM c[m]
x$ = STRING$(m)
z = m * 9 * LEN(x$) - 1
 
FOR i = 10 TO z
j = i
s = 0
DO WHILE j <> 0
s = s + (j MOD 10)
j = INT(j / 10)
LOOP
IF i MOD s = 0 THEN
j = INT(i / s)
IF j <= m THEN c[j] = $$TRUE
END IF
NEXT i
 
cont = 0
PRINT "The first 50 inconsummate numbers:"
FOR i = 10 TO m
IF cont = 50 THEN EXIT FOR
IF NOT c[i] THEN INC cont : PRINT FORMAT$("####",i);
NEXT i
END FUNCTION
END PROGRAM</syntaxhighlight>
 
==={{header|Yabasic}}===
{{trans|BASIC}}
<syntaxhighlight lang="vb">m = 999
dim c(m)
z = m * 9 * (len(str$(m))-1)
 
for i = 10 to z
j = i
s = 0
while j <> 0
s = s + mod(j, 10)
j = int(j / 10)
wend
if mod(i, s) = 0 then j = int(i / s) : if j <= m then c(j) = true : fi : fi
next i
 
cont = 0
print "The first 50 inconsummate numbers:"
for i = 10 to m
if cont = 50 end
if not c(i) then cont = cont + 1 : print i using("####"); : fi
next i
print</syntaxhighlight>
 
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
 
const uint32_t sieve_size = 10'000;
const uint32_t maximum = 9 * std::to_string(sieve_size).length() * sieve_size;
 
std::vector<bool> is_consummate(sieve_size + 1, false);
 
uint32_t digital_sum(const uint32_t& number) {
uint32_t result = 0;
const std::string text = std::to_string(number);
for ( const char ch : text ) {
result += ch - (int) '0';
}
return result;
}
 
void create_is_consummate() {
for ( uint32_t n = 1; n < maximum; ++n ) {
uint32_t sum = digital_sum(n);
if ( n % sum == 0 ) {
uint32_t quotient = n / sum;
if ( quotient <= sieve_size ) {
is_consummate[quotient] = true;
}
}
}
}
 
int main() {
create_is_consummate();
std::vector<uint32_t> inconsummates;
for ( uint32_t i = 0; i <= sieve_size; ++i ) {
if ( ! is_consummate[i] ) {
inconsummates.emplace_back(i);
}
}
 
std::cout << "The first 50 inconsummate numbers in base 10:" << std::endl;
for ( uint32_t i = 1; i <= 50; ++i ) {
std::cout << std::setw(3) << inconsummates[i] << ( i % 10 == 0 ? "\n" : " " );
}
std::cout << "\n" << "The 1,000 inconsummate number is " << inconsummates[1'000] << std::endl;
}
</syntaxhighlight>
{{ out }}
<pre>
The first 50 inconsummate numbers in base 10:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
The 1,000 inconsummate number is 6996
</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
 
 
function IsCosumate(N: integer): boolean;
{Test is number is consumate = V / SumDigits(V) = N}
var I, V: integer;
begin
Result:=True;
for I:=1 to High(integer) do
begin
{Test values for V that are multiples of N}
V:= I * N;
{Satisfy - V / SumDigits(V) = N? then exit}
if V = (N * SumDigits(V)) then exit;
{This value derrive by trial and error}
if V>=29000000 then break;
end;
Result:=False;
end;
 
 
procedure InconsummateNumbers(Memo: TMemo);
var S: string;
var N,I: integer;
begin
{Display first 50 inconsummate numbers}
N:=1; S:='';
for I:=1 to 50 do
begin
while IsCosumate(N) do Inc(N);
S:=S+Format('%5D',[N]);
if (I mod 10)=0 then S:=S+CRLF_Char;
Inc(N);
end;
Memo.Lines.Add(S);
{Then display 1,000th, 10,000th and 100,000th}
N:=1;
for I:=1 to 100000 do
begin
while IsCosumate(N) do Inc(N);
if I=1000 then Memo.Lines.Add( Format(' 1,000th = %7.0n',[N+0.0]));
if I=10000 then Memo.Lines.Add( Format(' 10,000th = %7.0n',[N+0.0]));
if I=100000 then Memo.Lines.Add(Format('100,000th = %7.0n',[N+0.0]));
Inc(N);
end;
end;
 
 
 
</syntaxhighlight>
{{out}}
<pre>
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
1,000th = 6,996
10,000th = 59,853
100,000th = 536,081
 
Elapsed Time: 3.564 Sec.
 
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight lang=easylang>
limit = 10000
maxn = 10000 * 9 * 4
#
len consummate[] limit
#
func digsum i .
res = 0
while i > 0
res += i mod 10
i = i div 10
.
return res
.
for d = 1 to maxn
ds = digsum d
if d mod ds = 0
q = d / ds
if q <= limit
consummate[q] = 1
.
.
.
d = 1
repeat
if d > len consummate[]
print "error - increase limit"
break 1
.
if consummate[d] = 0
cnt += 1
if cnt <= 50
write d & " "
.
.
until cnt = 1000
d += 1
.
print ""
print ""
print d
</syntaxhighlight>
 
=={{header|FreeBASIC}}==
{{trans|Action!}}
<syntaxhighlight lang="freebasic">Dim As Boolean consummate(0 To 999999)
For j As Integer = Lbound(consummate) To Ubound(consummate)
consummate(j) = False
Next j
consummate(1) = True
 
Dim As Integer maxSum = 9
Dim As Integer ub = Ubound(consummate)
While ub > 10
maxSum += 9
ub /= 10
Wend
 
Dim As Integer maxNumber = Ubound(consummate) * maxSum
 
Dim As Integer tn = 1, hn = 0, th = 0, tt = 0, ht = 0, mi = 0, tm = 0
Dim As Integer sumD, n, d, dRatio
For n = 10 To maxNumber Step 10
sumD = tm + mi + ht + tt + th + hn + tn
For d = n To n + 9
If d Mod sumD = 0 Then ' d is comsummate
dRatio = d / sumD
If dRatio <= Ubound(consummate) Then consummate(dRatio) = True
End If
sumD += 1
Next d
tn += 1
If tn > 9 Then
tn = 0
hn += 1
If hn > 9 Then
hn = 0
th += 1
If th > 9 Then
th = 0
tt += 1
If tt > 9 Then
tt = 0
ht += 1
If ht > 9 Then
ht = 0
mi += 1
If mi > 9 Then
mi = 0
tm += 1
End If
End If
End If
End If
End If
End If
Next n
 
Dim As Integer i = 0, count = 0
Print "The first 50 inconsummate numbers:"
While i < Ubound(consummate) And count < 100000
i += 1
If Not consummate(i) Then
count += 1
If count < 51 Then
Print Using "######"; i;
If count Mod 10 = 0 Then Print
Elseif count = 1000 Or count = 10000 Or count = 100000 Then
Print Using !"\nInconsummate number ######: ######"; count; i;
End If
End If
Wend
Sleep</syntaxhighlight>
{{out}}
<pre>The first 50 inconsummate numbers:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
Inconsummate number 1000: 6996
Inconsummate number 10000: 59853
Inconsummate number 100000: 536081</pre>
 
=={{header|J}}==
With:
<syntaxhighlight lang=J>dsum=: [: +/"(1) 10&#.inv NB. digital sum
incons=: (-. (% dsum))&(1+i.) (90* 10 >.&.^. ]) NB. exclude many digital sum ratios</syntaxhighlight>
We get:
<syntaxhighlight lang=J> 5 10$incons 1000
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
999 { incons 10000
6996
9999 { incons 100000
59853
99999 { incons 1000000
536081</syntaxhighlight>
 
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.stream.IntStream;
 
public final class InconsummateNumbersInBase10 {
 
public static void main(String[] args) {
createIsConsummate();
int[] inconsummates = IntStream.rangeClosed(0, sieveSize).filter( i -> ! isConsummate[i] ).toArray();
System.out.println("The first 50 inconsummate numbers in base 10:");
for ( int i = 1; i <= 50; i++ ) {
System.out.print(String.format("%3d%s", inconsummates[i], ( i % 10 == 0 ? "\n" : " " )));
}
System.out.println();
System.out.println("The 1,000 inconsummate number is " + inconsummates[1_000]);
}
private static void createIsConsummate() {
isConsummate = new boolean[sieveSize + 1];
for ( int n = 1; n < maximum; n++ ) {
int digitalSum = digitalSum(n);
if ( n % digitalSum == 0 ) {
int quotient = n / digitalSum;
if ( quotient <= sieveSize ) {
isConsummate[quotient] = true;
}
}
}
}
private static int digitalSum(int number) {
return String.valueOf(number).chars().map( i -> i - (int) '0' ).sum();
}
private static boolean[] isConsummate;
private static final int sieveSize = 10_000;
private static final int maximum = 9 * String.valueOf(sieveSize).length() * sieveSize;
}
</syntaxhighlight>
{{ out }}
<pre>
The first 50 inconsummate numbers in base 10:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
The 1,000 inconsummate number is 6996
</pre>
 
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]'''
 
'''Works with jq, the C implementation of jq'''
<syntaxhighlight lang=jq>
def digitSum:
def add(s): reduce s as $_ (0; .+$_);
add(tostring | explode[] | . - 48);
 
# Maximum ratio for 6 digit numbers is 100,000
def cons:
reduce range(1; 1000000) as $i ([];
($i | digitSum) as $ds
| ($i/$ds) as $ids
| if $ids|floor == $ids then .[$ids] = true else . end);
 
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
def task($n; $nth):
cons as $cons
| reduce range(1; $cons|length) as $i ([];
if ($cons[$i]|not) then . + [$i] else . end)
| "First \($n) inconsummate numbers in base 10:",
(.[0:50] | _nwise(10) | map(lpad(3)) | join(" ")),
"\nThe \($nth)th:",
.[$nth - 1];
 
task(50; 1000)
</syntaxhighlight>
{{output}}
<pre>
First 50 inconsummate numbers in base 10:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
The 1000th:
6996
</pre>
 
=={{header|Julia}}==
{{trans|Python}}
<syntaxhighlight lang="julia">using ResumableFunctions
 
@resumable function gen_inconsummate(maxwanted)
mindigitsums = map(i -> (10^i, (10^(i-2) * 11 - 1) ÷ (9 * i - 17)), 2:14)
limit = minimum(p[1] for p in mindigitsums if p[2] > maxwanted)
arr = zeros(Int, limit)
arr[1] = 1
for dividend in 1:limit-1
dsum = sum(digits(dividend))
quo, rem = divrem(dividend, dsum)
rem == 0 && quo < limit && (arr[quo] = 1)
end
for j in eachindex(arr)
arr[j] == 0 && @yield(j)
end
end
 
println("The first 50 inconsummate numbers in base 10:")
for (i, j) in enumerate(gen_inconsummate(100000))
if i <= 50
print(rpad(j, 6), i % 10 == 0 ? "\n" : "")
elseif i == 1000
println("\nThe one-thousandth inconsummate number in base 10 is $j")
elseif i == 10000
println("The ten-thousandth inconsummate number in base 10 is $j")
elseif i == 100000
println("The hundred-thousandth inconsummate number in base 10 is $j")
break
end
end
</syntaxhighlight>{{out}}
<pre>
The first 50 inconsummate numbers in base 10:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
The one-thousandth inconsummate number in base 10 is 6996
The ten-thousandth inconsummate number in base 10 is 59853
The hundred-thousandth inconsummate number in base 10 is 536081
</pre>
 
=={{header|Lua}}==
Tested with Lua 5.1.2
<syntaxhighlight lang="lua">
do --[[ find some incomsummate numbers: integers that cannot be expressed as
an integer divided by the sum of its digits
--]]
 
local maxConsummate = 999999
local consummate = {} -- table of numbers that can be formed by n / digit sum n
--[[ calculate the maximum number we must consider to find consummate numbers
up to maxConsummate - which is 9 * the number of digits in maxConsummate
--]]
local maxSum = 9
local v = math.floor( maxConsummate / 10 )
while v > 0 do
maxSum = maxSum + 9
v = math.floor( v / 10 )
end
local maxNumber = maxConsummate * maxSum
-- construct the digit sums of the numbers up to maxNumber and find the consumate numbers
consummate[ 1 ] = true
local tn, hn, th, tt, ht, mi, tm = 1, 0, 0, 0, 0, 0, 0
for n = 10, maxNumber, 10 do
local sumd = tm + mi + ht + tt + th + hn + tn
for d = n, n + 9 do
if d % sumd == 0 then -- d is comsummate
local dRatio = math.floor( d / sumd )
if dRatio <= maxConsummate then
consummate[ dRatio ] = true
end
end
sumd = sumd + 1
end
tn = tn + 1
if tn > 9 then
tn = 0
hn = hn + 1
if hn > 9 then
hn = 0
th = th + 1
if th > 9 then
th = 0
tt = tt + 1
if tt > 9 then
tt = 0
ht = ht + 1
if ht > 9 then
ht = 0
mi = mi + 1
if mi > 9 then
mi = 0
tm = tm + 1
end
end
end
end
end
end
end
local count = 0
io.write( "The first 50 inconsummate numbers:\n" )
for i = 1, maxConsummate do
if count >= 100000 then break end
if not consummate[ i ] then
count = count + 1
if count < 51 then
io.write( string.format( "%6d", i ), ( count % 10 == 0 and "\n" or "" ) )
elseif count == 1000 or count == 10000 or count == 100000 then
io.write( "Inconsummate number ", string.format( "%6d", count )
, ": ", string.format( "%8d", i ), "\n"
)
end
end
end
end
</syntaxhighlight>
{{out}}
<pre>
The first 50 inconsummate numbers:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
Inconsummate number 1000: 6996
Inconsummate number 10000: 59853
Inconsummate number 100000: 536081
</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang=Nim>import std/[math, strformat, sugar]
 
const
D = 4 # Sufficient to find the one thousandth first, as required.
N = 10^D # Size of sieve.
M = 9 * (D + 1) * N # Maximum value for the number to divide.
 
func digitalSum(n: Natural): int =
## Return the digital sum of "n".
var n = n
while n != 0:
inc result, n mod 10
n = n div 10
 
# Fill a sieve to find consummate numbers.
var isConsummate: array[1..N, bool]
for n in 1..M:
let ds = n.digitalSum
if n mod ds == 0:
let q = n div ds
if q <= N:
isConsummate[q] = true
 
# Build list of inconsummate numbers.
let inconsummateNums = collect:
for n, c in isConsummate:
if not c: n
 
echo "First 50 inconsummate numbers in base 10:"
for i in 0..49:
stdout.write &"{inconsummateNums[i]:3}"
stdout.write if i mod 10 == 9: '\n' else: ' '
 
echo &"\nOne thousandth is {inconsummateNums[999]}."
</syntaxhighlight>
 
{{out}}
<pre>First 50 inconsummate numbers in base 10:
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
 
One thousandth is 6996.
</pre>
 
=={{header|Pascal}}==
==={{header|Free Pascal}}===
Inconsummate numbers are not a divisor of a niven number.<br>
Therefore I tried a solution [[Harshad_or_Niven_series | niven number]].<br>
There is only a small increase in the needed factor in count of Inconsummate numbers
<syntaxhighlight lang=pascal>
program Inconsummate;
 
{$IFDEF FPC}
{$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$CODEALIGN proc=8,loop=1}
{$ENDIF}
 
uses
SysUtilssysutils;
 
const
base = 10;
DgtSumLmt = base*base*base*base*base;
 
type
// tNumtDgtSum = array[0..250DgtSumLmt-1] *of 1000byte;// 6996
var
// tNum = 0..260 * 10000;// 59837
DgtSUm : tDgtSum;
// tNum = 0..290 * 100000;//536081
max: Uint64;
tNum = 0..319 * 1000000;//5073249
procedure Init(var ds:tDgtSum);
var
i,l,k0,k1: NativeUint;
Begin
For i := 0 to base-1 do
ds[i] := i;
k0 := base;
repeat
k1 := k0-1;
For i := 1 to base-1 do
For l := 0 to k1 do
begin
ds[k0] := ds[l]+i;
inc(k0);
end;
until k0 >= High(ds);
end;
 
const
cntbasedigits = 16;//trunc(ln(High(tNum)) / ln(base)) + 1;
 
function GetSumOfDecDigits(n:Uint64):NativeUint;
type
tSumDigit = record
sdDigits: array[0..cntbasedigits - 1] of byte;
sdSumDig: uint32;
sdNumber: tNum;
sdDiv: tNum;
sdIsNiven: boolean;
end;
var
r,d: NativeUint;
isN: array[0..High(tNUm) div 1 + 1] of boolean;
begin
result := 0;
repeat
r := n DIv DgtSumLmt;
d := n-r* DgtSumLmt;
result +=DgtSUm[d];
n := r;
until r = 0;
end;
 
function InitSumDigitOneTest(n: tNumNativeint): tSumDigitBoolean;
var
i,d sd: tSumDigitNativeInt;
begin
qt: tNum;
result i:= integertrue;
d := n;
For i := 1 TO 121 DO
begin
IF GetSumOfDecDigits(n)= i then
with sd do
beginBegin
sdNumberif :=i n;> max then
max := i;
fillchar(sdDigits, SizeOf(sdDigits), #0);
Exit(false);
 
sdSumDig := 0;
sdIsNiven := False;
i := 0;
// calculate Digits und sum them up
while n > 0 do
begin
qt := n div base;
{n mod base}
sdDigits[i] := n - qt * base;
Inc(sdSumDig, sdDigits[i]);
n := qt;
Inc(i);
end;
if sdSumDig > 0 then
sdIsNiven := (sdNumber mod sdSumDig = 0);
end;
InitSumDigit := sd;
end;
 
procedure IncSumDigit(var sd: tSumDigit);
var
pD: pbyte;
i, d, s: uint32;
begin
i := 0;
pD := @sd.sdDigits[0];
with sd do
begin
s := sdSumDig;
Inc(sdNumber);
repeat
d := pD[i];
Inc(d);
Inc(s);
//base-1 times the repeat is left here
if d < base then
begin
pD[i] := d;
BREAK;
end
else
begin
pD[i] := 0;
Dec(s, base);
Inc(i);
end;
until i > high(sdDigits);
sdSumDig := s;
i := sdNumber div s;
sdDiv := i;
sdIsNiven := (sdNUmber - i * s) = 0;
end;
n +=d;
end;
end;
 
var
d,
MySumDig: tSumDigit;
lnncnt,lmt: tNumUint64;
Limit, cnt: integer;
 
begin
Init(DgtSUm);
{$IFNDEF FPC}
cntbasedigits := trunc(ln(High(tNum)) / ln(base)) + 1;
{$ENDIF}
MySumDig := InitSumDigit(0);
cnt := 0;
For d := 1 to 527 do//5375540350 do
with MySumDig do
begin
repeat
if IncSumDigitOneTest(MySumDigd); then
if sdIsNiven then
isN[sdDiv] := True;
until sdnumber > High(tNum) - 1;
 
limit := 10;
for lnn := 1 to High(isN) - 1 do
if not (isN[lnn]) then
begin
Incinc(cnt);
Writewrite(lnnd: 5);
if (cnt mod 10 = limit)0 then writeln;
begin
writeln;
Inc(limit, 10);
end;
if cnt >= 50 then
BREAK;
end;
end;
writeln;
writeln('Count Number(count) Maxfactor needed');
 
limitcnt := 1000;
max := 0;
for lnn := lnn + 1 to High(isN) - 1 do
lmt := 10;
if not (isN[lnn]) then
For d := 1 to 50332353 do // 5260629551 do
begin
if OneTest(d) then
begin
Incinc(cnt);
if cnt = limitlmt then
begin
Writelnwriteln(limitcnt: 10, lnnd: 1012,max:5);
limitlmt *= 10;
if limit > 1000 * 1000 then
EXIT;
end;
end;
writelnend;
writeln(cnt);
end.
</syntaxhighlight>
{{out|@TIO.RUN}}
<pre>
<pre> 62 63 65 75 84 95 161 173 195 216
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
Line 362 ⟶ 1,196:
491 492 493 494 497 498 516 521 522 527
 
Count Number(count) Maxfactor needed
100 936
1000 10 6996 216 27
10000 100 59853 936 36
100000 1000 536081 6996 36
10000 59853 54
1000000 5073249
100000 536081 63
1000000 5073249 69
10000000 50332353 81
10000000
Real time: 23.898 s
 
@Home AMD 5600G 4.4 Ghz:
Count Number(count) Maxfactor needed
10 216 27
100 936 36
1000 6996 36
10000 59853 54
100000 536081 63
1000000 5073249 69
10000000 50332353 81 //real 0m6,395s
100000000 517554035 87
1000000000 5260629551 96
1000000000
 
real 15m54,915s
Real time: 3.342 s CPU share: 99.16 %
</pre>
 
Line 566 ⟶ 1,418:
minimum_digitsums = [(10**i, int((10**i - 1) / (9 * i)))
for i in range(1, 15)]
limit = 20 * min(p[0] for p in minimum_digitsums if p[1] > max_wanted)
arr = [1] + [0] * (limit - 1)
 
Line 600 ⟶ 1,452:
Ten-thousanth inconsummate number: 59853
 
Hundred-thousanth inconsummate number: 375410 536081
</pre>
 
Line 621 ⟶ 1,473:
 
One thousandth: 6996</pre>
 
=={{header|RPL}}==
<code>∑DIGITS</code> is defined at [[Sum digits of an integer#RPL|Sum digits of an integer]]
{{trans|BASIC}}
« 999 DUP { } + 0 CON
10 ROT DUP XPON 1 + 9 * * '''FOR''' n
n DUP <span style="color:blue">∑DIGITS</span>
'''IF''' DUP2 MOD NOT '''THEN'''
/ '''IFERR''' 1 PUT '''THEN''' DROP2 '''END'''
'''ELSE''' DROP2 '''END'''
'''NEXT'''
{ } SWAP 10
'''WHILE''' 3 PICK SIZE 50 < '''REPEAT'''
'''IF''' GETI NOT '''THEN''' ROT OVER 1 - + ROT ROT '''END'''
'''END''' DROP2
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 62 63 65 75 84 95 161 173 195 216 261 266 272 276 326 371 372 377 381 383 386 387 395 411 416 422 426 431 432 438 441 443 461 466 471 476 482 483 486 488 491 492 493 494 497 498 516 521 522 527 }
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var gen_inconsummate = Enumerator({|callback|
 
for n in (1..Inf) {
for k in (1..Inf) {
 
if (9*k*n < 10**(k-1)) {
callback(n)
break
}
 
var check = false
10.combinations_with_repetition(k, {|*d|
var s = d.sum || next
if (Str(s*n).sort == d.join) {
check = true
break
}
})
check || next
break
}
}
})
 
with (50) {|n|
say "First #{n} inconsummate numbers (in base 10):"
gen_inconsummate.first(n).each_slice(10, {|*s|
say s.map{ '%3s' % _ }.join(' ')
})
}</syntaxhighlight>
{{out}}
<pre>
First 50 inconsummate numbers (in base 10):
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
</pre>
 
=={{header|Wren}}==
Line 626 ⟶ 1,539:
{{libheader|Wren-fmt}}
It appears to be more than enough to calculate ratios for all numbers up to 999,999 (which only takes about 0.4 seconds on my machine) to be sure of finding the 1,000th inconsummate number.
 
<syntaxhighlight lang="ecmascript">import "./math" for Int
In fact it still finds the 1,000th number if you limit the search to the first 249,999 (but not 248,999) numbers which may be where the first magic number of '250' comes from in the Pascal/Phix entries.
<syntaxhighlight lang="wren">import "./math" for Int
import "./fmt" for Fmt
 
Line 658 ⟶ 1,573:
Alternatively and more generally:
{{trans|Python}}
...though much quicker as I'm using lower figures for the second component of the minDigitSums tuples.
Though I think the Python version is in fact wrong for the 100,000th number since if you enumerate up to 10,000 you get the 10,000th inconsummate number to be 42,171 rather than 59,853.
<syntaxhighlight lang="wren">import "./math" for Int, Nums
 
The problem seems to be that the minimum divisor for (say) 6 digit numbers is not 999999/54 = 18518 but 109999/37 = 2972. I've corrected for that in the following translation.
<syntaxhighlight lang="ecmascript">import "./math" for Int, Nums
import "./fmt" for Fmt
 
var generateInconsummate = FnFiber.new { |maxWanted|
var minDigitSums = (2..14).map { |i| [10.pow(i), ((10.pow(i-2) * 11 - 1) / (9 * i - 17)).floor] }
var limit = Nums.min(minDigitSums.where { |p| p[1] > maxWanted }.map { |p| p[0] })
var arr = List.filled(limit, 0)
arr[0] = 1
for (dividend in 1...limit) {
var ds = Int.digitSum(dividend)
var quo = (dividend/ds).floor
Line 680 ⟶ 1,593:
}
 
var gi = Fiber.new(generateInconsummate)
var incons = List.filled(50, 0)
var incons1k
var incons10k
var incons100k
System.print("First 50 inconsummate numbers in base 10:")
 
for (i in 1..100000) {
var j = gigenerateInconsummate.call(100000)
if (i <= 50) {
incons[i-1] = j
if (i == 50) Fmt.tprint("$3d", incons, 10)
} else if (i == 1000) {
incons1kFmt.print("\nOne =thousandth $,d", j)
} else if (i == 10000) {
incons10kFmt.print("Ten =thousandth $,d", j)
} else if (i == 100000) {
incons100kFmt.print("100 =thousandth $,d", j)
}
}</syntaxhighlight>
}
Fmt.tprint("$3d", incons, 10)
Fmt.print("\nOne thousandth $,d", incons1k)
Fmt.print("Ten thousandth $,d", incons10k)
Fmt.print("100 thousandth $,d", incons100k)</syntaxhighlight>
 
{{out}}
Line 716 ⟶ 1,621:
Ten thousandth 59,853
100 thousandth 536,081
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">func DigSum(Num); \Return sum of digits of a number in base 10
int Num, Sum;
[Sum:= 0;
repeat Num:= Num/10;
Sum:= Sum + rem(0);
until Num = 0;
return Sum;
];
 
func Consum(N); \Return 'true' if N is a consummate number
int N, M, P;
[M:= 1;
repeat P:= M*N;
if P = N*DigSum(P) then return true;
M:= M+1;
until P >= 1000000; \8-)
return false;
];
 
int C, N;
[C:= 0; N:= 1;
Format(4, 0);
repeat if not Consum(N) then
[C:= C+1;
if C <= 50 then
[RlOut(0, float(N));
if rem(C/10) = 0 then CrLf(0);
];
if C = 1000 then
[Text(0, "One thousandth inconsummate number: ");
IntOut(0, N);
CrLf(0);
];
];
N:= N+1;
until C >= 1000;
]</syntaxhighlight>
{{out}}
<pre>
62 63 65 75 84 95 161 173 195 216
261 266 272 276 326 371 372 377 381 383
386 387 395 411 416 422 426 431 432 438
441 443 461 466 471 476 482 483 486 488
491 492 493 494 497 498 516 521 522 527
One thousandth inconsummate number: 6996
</pre>
Trizen
2,747

edits

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