Colorful numbers: Difference between revisions
m (→{{header|Python}}: import) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 36: | Line 36: | ||
=={{header|C}}== |
=={{header|C}}== |
||
The <code>count_colorful</code> function is based on [[#Phix|Phix]]. |
The <code>count_colorful</code> function is based on [[#Phix|Phix]]. |
||
< |
<syntaxhighlight lang="c">#include <locale.h> |
||
#include <stdbool.h> |
#include <stdbool.h> |
||
#include <stdio.h> |
#include <stdio.h> |
||
Line 126: | Line 126: | ||
(end - start + 0.0) / CLOCKS_PER_SEC); |
(end - start + 0.0) / CLOCKS_PER_SEC); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 158: | Line 158: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2021-06-02}} |
{{works with|Factor|0.99 2021-06-02}} |
||
< |
<syntaxhighlight lang="factor">USING: assocs grouping grouping.extras io kernel literals math |
||
math.combinatorics math.ranges prettyprint project-euler.common |
math.combinatorics math.ranges prettyprint project-euler.common |
||
sequences sequences.extras sets ; |
sequences sequences.extras sets ; |
||
Line 187: | Line 187: | ||
"Count of colorful numbers by number of digits:" print |
"Count of colorful numbers by number of digits:" print |
||
8 [1..b] [ oom-count ] zip-with dup . |
8 [1..b] [ oom-count ] zip-with dup . |
||
"Total: " write values sum .</ |
"Total: " write values sum .</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 219: | Line 219: | ||
{{trans|Phix}} |
{{trans|Phix}} |
||
{{libheader|Go-rcu}} |
{{libheader|Go-rcu}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 338: | Line 338: | ||
} |
} |
||
fmt.Printf("\nTotal colorful numbers: %s\n", rcu.Commatize(sum)) |
fmt.Printf("\nTotal colorful numbers: %s\n", rcu.Commatize(sum)) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 369: | Line 369: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
{{incorrect|Haskell|10 is not a Colorful number; nor is 98765432: <nowiki>6×5×4 == 5×4×3×2 == 120</nowiki>}} |
{{incorrect|Haskell|10 is not a Colorful number; nor is 98765432: <nowiki>6×5×4 == 5×4×3×2 == 120</nowiki>}} |
||
< |
<syntaxhighlight lang="haskell">import Data.List ( nub ) |
||
import Data.List.Split ( divvy ) |
import Data.List.Split ( divvy ) |
||
import Data.Char ( digitToInt ) |
import Data.Char ( digitToInt ) |
||
Line 391: | Line 391: | ||
solution2 :: Integer |
solution2 :: Integer |
||
solution2 = head $ filter isColourful [98765432, 98765431 ..]</ |
solution2 = head $ filter isColourful [98765432, 98765431 ..]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>[0,1,2,3,4,5,6,7,8,9,10,23,24,25,26,27,28,29,32,34,35,36,37,38,39,42,43,45,46,47,48,49,52,53,54,56,57,58,59,62,63,64,65,67,68,69,72,73,74,75,76,78,79,82,83,84,85,86,87,89,92,93,94,95,96,97,98](solution1) |
<pre>[0,1,2,3,4,5,6,7,8,9,10,23,24,25,26,27,28,29,32,34,35,36,37,38,39,42,43,45,46,47,48,49,52,53,54,56,57,58,59,62,63,64,65,67,68,69,72,73,74,75,76,78,79,82,83,84,85,86,87,89,92,93,94,95,96,97,98](solution1) |
||
Line 398: | Line 398: | ||
=={{header|Haskell (alternate version)}}== |
=={{header|Haskell (alternate version)}}== |
||
An alternate Haskell version, which some may consider to be in a more idiomatic style. No attempt at optimization has been made, so we don't attempt the stretch goals. |
An alternate Haskell version, which some may consider to be in a more idiomatic style. No attempt at optimization has been made, so we don't attempt the stretch goals. |
||
< |
<syntaxhighlight lang="haskell">import Data.List (inits, nub, tails, unfoldr) |
||
-- Non-empty subsequences containing only consecutive elements from the |
-- Non-empty subsequences containing only consecutive elements from the |
||
Line 429: | Line 429: | ||
let start = 98765432 |
let start = 98765432 |
||
largest = head $ dropWhile (not . isColorful) [start, start-1 ..] |
largest = head $ dropWhile (not . isColorful) [start, start-1 ..] |
||
putStrLn $ "Largest colorful number: " ++ show largest</ |
putStrLn $ "Largest colorful number: " ++ show largest</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 439: | Line 439: | ||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j"> colorful=: {{(-:~.);<@(*/\)\. 10 #.inv y}}"0 |
||
I.colorful i.100 |
I.colorful i.100 |
||
0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 |
0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 |
||
Line 456: | Line 456: | ||
7 14256 |
7 14256 |
||
#C |
#C |
||
57256</ |
57256</syntaxhighlight> |
||
(Note that 0, here is a different order of magnitude than 1.) |
(Note that 0, here is a different order of magnitude than 1.) |
||
Line 462: | Line 462: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
{{trans|C}} |
{{trans|C}} |
||
< |
<syntaxhighlight lang="java">public class ColorfulNumbers { |
||
private int count[] = new int[8]; |
private int count[] = new int[8]; |
||
private boolean used[] = new boolean[10]; |
private boolean used[] = new boolean[10]; |
||
Line 545: | Line 545: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 574: | Line 574: | ||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">largest = 0 |
||
function iscolorful(n, base=10) |
function iscolorful(n, base=10) |
||
Line 610: | Line 610: | ||
testcolorfuls() |
testcolorfuls() |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: |
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: |
||
Line 630: | Line 630: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">ClearAll[ColorfulNumberQ] |
||
ColorfulNumberQ[n_Integer?NonNegative] := Module[{digs, parts}, |
ColorfulNumberQ[n_Integer?NonNegative] := Module[{digs, parts}, |
||
If[n > 98765432, |
If[n > 98765432, |
||
Line 652: | Line 652: | ||
Tally[IntegerDigits/*Length /@ cns] // Grid |
Tally[IntegerDigits/*Length /@ cns] // Grid |
||
Length[cns]</ |
Length[cns]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>1 2 3 4 5 6 7 8 |
<pre>1 2 3 4 5 6 7 8 |
||
Line 679: | Line 679: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{trans|Raku}} |
{{trans|Raku}} |
||
< |
<syntaxhighlight lang="perl">use strict; |
||
use warnings; |
use warnings; |
||
use feature 'say'; |
use feature 'say'; |
||
Line 710: | Line 710: | ||
my $total= 10; |
my $total= 10; |
||
map { is_colorful(join '', @$_) and $total++ } map { permutations $_ } combinations [2..9], $_ for 2..8; |
map { is_colorful(join '', @$_) and $total++ } map { permutations $_ } combinations [2..9], $_ for 2..8; |
||
say "Total colorful numbers: $total";</ |
say "Total colorful numbers: $total";</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Colorful numbers less than 100: |
<pre>Colorful numbers less than 100: |
||
Line 728: | Line 728: | ||
{{libheader|Phix/online}} |
{{libheader|Phix/online}} |
||
You can run this online [http://phix.x10.mx/p2js/colourful.htm here]. |
You can run this online [http://phix.x10.mx/p2js/colourful.htm here]. |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
||
<span style="color: #008080;">function</span> <span style="color: #000000;">colourful</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: #008080;">function</span> <span style="color: #000000;">colourful</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> |
||
Line 792: | Line 792: | ||
<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;">"\nTotal colourful numbers: %,d\n"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">count</span><span style="color: #0000FF;">))</span> |
<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;">"\nTotal colourful numbers: %,d\n"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">count</span><span style="color: #0000FF;">))</span> |
||
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span> |
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 820: | Line 820: | ||
=={{header|Picat}}== |
=={{header|Picat}}== |
||
< |
<syntaxhighlight lang="picat">colorful_number(N) => |
||
N < 10 ; |
N < 10 ; |
||
(X = N.to_string, |
(X = N.to_string, |
||
Line 830: | Line 830: | ||
distinct(L) => |
distinct(L) => |
||
L.len == L.remove_dups.len.</ |
L.len == L.remove_dups.len.</syntaxhighlight> |
||
'''All colorful numbers <= 100.''' |
'''All colorful numbers <= 100.''' |
||
< |
<syntaxhighlight lang="picat">main => |
||
Colorful = [N : N in 0..100, colorful_number(N)], |
Colorful = [N : N in 0..100, colorful_number(N)], |
||
Len = Colorful.len, |
Len = Colorful.len, |
||
Line 840: | Line 840: | ||
end, |
end, |
||
nl, |
nl, |
||
println(len=Len)</ |
println(len=Len)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 853: | Line 853: | ||
'''Largest colorful number.''' |
'''Largest colorful number.''' |
||
< |
<syntaxhighlight lang="picat">main => |
||
N = 98765431, |
N = 98765431, |
||
Found = false, |
Found = false, |
||
Line 862: | Line 862: | ||
end, |
end, |
||
N := N - 1 |
N := N - 1 |
||
end.</ |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 868: | Line 868: | ||
'''Count of colorful numbers in each magnitude and of total colorful numbers.''' |
'''Count of colorful numbers in each magnitude and of total colorful numbers.''' |
||
< |
<syntaxhighlight lang="picat">main => |
||
TotalC = 0, |
TotalC = 0, |
||
foreach(I in 1..8) |
foreach(I in 1..8) |
||
Line 887: | Line 887: | ||
% For N=3: lb=123 and ub=987 |
% For N=3: lb=123 and ub=987 |
||
lb(N) = cond(N < 2, 0, [I.to_string : I in 1..N].join('').to_int). |
lb(N) = cond(N < 2, 0, [I.to_string : I in 1..N].join('').to_int). |
||
ub(N) = [I.to_string : I in 9..-1..9-N+1].join('').to_int.</ |
ub(N) = [I.to_string : I in 9..-1..9-N+1].join('').to_int.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 901: | Line 901: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">from math import prod |
||
largest = [0] |
largest = [0] |
||
Line 939: | Line 939: | ||
print(f'The largest possible colorful number is {largest[0]}.') |
print(f'The largest possible colorful number is {largest[0]}.') |
||
print(f'The total number of colorful numbers is {csum}.') |
print(f'The total number of colorful numbers is {csum}.') |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: |
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: |
||
Line 959: | Line 959: | ||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
<lang |
<syntaxhighlight lang="raku" line>sub is-colorful (Int $n) { |
||
return True if 0 <= $n <= 9; |
return True if 0 <= $n <= 9; |
||
return False if $n.contains(0) || $n.contains(1) || $n < 0; |
return False if $n.contains(0) || $n.contains(1) || $n < 0; |
||
Line 990: | Line 990: | ||
} |
} |
||
say "\nTotal colorful numbers: $total";</ |
say "\nTotal colorful numbers: $total";</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Colorful numbers less than 100: |
<pre>Colorful numbers less than 100: |
||
Line 1,021: | Line 1,021: | ||
{{libheader|Wren-seq}} |
{{libheader|Wren-seq}} |
||
{{libheader|Wren-fmt}} |
{{libheader|Wren-fmt}} |
||
< |
<syntaxhighlight lang="ecmascript">import "./math" for Int, Nums |
||
import "./set" for Set |
import "./set" for Set |
||
import "./seq" for Lst |
import "./seq" for Lst |
||
Line 1,093: | Line 1,093: | ||
} |
} |
||
Fmt.print("\nTotal colorful numbers: $,d", Nums.sum(count))</ |
Fmt.print("\nTotal colorful numbers: $,d", Nums.sum(count))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,123: | Line 1,123: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">func IPow(A, B); \A^B |
||
int A, B, T, I; |
int A, B, T, I; |
||
[T:= 1; |
[T:= 1; |
||
Line 1,194: | Line 1,194: | ||
IntOut(0, Total); |
IntOut(0, Total); |
||
CrLf(0); |
CrLf(0); |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
Revision as of 20:06, 26 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
A colorful number is a non-negative base 10 integer where the product of every sub group of consecutive digits is unique.
- E.G.
24753 is a colorful number. 2, 4, 7, 5, 3, (2×4)8, (4×7)28, (7×5)35, (5×3)15, (2×4×7)56, (4×7×5)140, (7×5×3)105, (2×4×7×5)280, (4×7×5×3)420, (2×4×7×5×3)840
Every product is unique.
2346 is not a colorful number. 2, 3, 4, 6, (2×3)6, (3×4)12, (4×6)24, (2×3×4)48, (3×4×6)72, (2×3×4×6)144
The product 6 is repeated.
Single digit numbers are considered to be colorful. A colorful number larger than 9 cannot contain a repeated digit, the digit 0 or the digit 1. As a consequence, there is a firm upper limit for colorful numbers; no colorful number can have more than 8 digits.
- Task
- Write a routine (subroutine, function, procedure, whatever it may be called in your language) to test if a number is a colorful number or not.
- Use that routine to find all of the colorful numbers less than 100.
- Use that routine to find the largest possible colorful number.
- Stretch
- Find and display the count of colorful numbers in each order of magnitude.
- Find and show the total count of all colorful numbers.
Colorful numbers have no real number theory application. They are more a recreational math puzzle than a useful tool.
C
The count_colorful
function is based on Phix.
#include <locale.h>
#include <stdbool.h>
#include <stdio.h>
#include <time.h>
bool colorful(int n) {
// A colorful number cannot be greater than 98765432.
if (n < 0 || n > 98765432)
return false;
int digit_count[10] = {};
int digits[8] = {};
int num_digits = 0;
for (int m = n; m > 0; m /= 10) {
int d = m % 10;
if (n > 9 && (d == 0 || d == 1))
return false;
if (++digit_count[d] > 1)
return false;
digits[num_digits++] = d;
}
// Maximum number of products is (8 x 9) / 2.
int products[36] = {};
for (int i = 0, product_count = 0; i < num_digits; ++i) {
for (int j = i, p = 1; j < num_digits; ++j) {
p *= digits[j];
for (int k = 0; k < product_count; ++k) {
if (products[k] == p)
return false;
}
products[product_count++] = p;
}
}
return true;
}
static int count[8];
static bool used[10];
static int largest = 0;
void count_colorful(int taken, int n, int digits) {
if (taken == 0) {
for (int d = 0; d < 10; ++d) {
used[d] = true;
count_colorful(d < 2 ? 9 : 1, d, 1);
used[d] = false;
}
} else {
if (colorful(n)) {
++count[digits - 1];
if (n > largest)
largest = n;
}
if (taken < 9) {
for (int d = 2; d < 10; ++d) {
if (!used[d]) {
used[d] = true;
count_colorful(taken + 1, n * 10 + d, digits + 1);
used[d] = false;
}
}
}
}
}
int main() {
setlocale(LC_ALL, "");
clock_t start = clock();
printf("Colorful numbers less than 100:\n");
for (int n = 0, count = 0; n < 100; ++n) {
if (colorful(n))
printf("%2d%c", n, ++count % 10 == 0 ? '\n' : ' ');
}
count_colorful(0, 0, 0);
printf("\n\nLargest colorful number: %'d\n", largest);
printf("\nCount of colorful numbers by number of digits:\n");
int total = 0;
for (int d = 0; d < 8; ++d) {
printf("%d %'d\n", d + 1, count[d]);
total += count[d];
}
printf("\nTotal: %'d\n", total);
clock_t end = clock();
printf("\nElapsed time: %f seconds\n",
(end - start + 0.0) / CLOCKS_PER_SEC);
return 0;
}
- Output:
Colorful numbers less than 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest colorful number: 98,746,253 Count of colorful numbers by number of digits: 1 10 2 56 3 328 4 1,540 5 5,514 6 13,956 7 21,596 8 14,256 Total: 57,256 Elapsed time: 0.024598 seconds
Factor
USING: assocs grouping grouping.extras io kernel literals math
math.combinatorics math.ranges prettyprint project-euler.common
sequences sequences.extras sets ;
CONSTANT: digits $[ 2 9 [a..b] ]
: (colorful?) ( seq -- ? )
all-subseqs [ product ] map all-unique? ;
: colorful? ( n -- ? )
[ t ] [ number>digits (colorful?) ] if-zero ;
: table. ( seq cols -- )
[ "" pad-groups ] keep group simple-table. ;
: (oom-count) ( n -- count )
digits swap <k-permutations> [ (colorful?) ] count ;
: oom-count ( n -- count )
dup 1 = [ drop 10 ] [ (oom-count) ] if ;
"Colorful numbers under 100:" print
100 <iota> [ colorful? ] filter 10 table. nl
"Largest colorful number:" print
digits <permutations> [ (colorful?) ] find-last nip digits>number . nl
"Count of colorful numbers by number of digits:" print
8 [1..b] [ oom-count ] zip-with dup .
"Total: " write values sum .
- Output:
Colorful numbers under 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest colorful number: 98746253 Count of colorful numbers by number of digits: { { 1 10 } { 2 56 } { 3 328 } { 4 1540 } { 5 5514 } { 6 13956 } { 7 21596 } { 8 14256 } } Total: 57256
Go
package main
import (
"fmt"
"rcu"
"strconv"
)
func isColorful(n int) bool {
if n < 0 {
return false
}
if n < 10 {
return true
}
digits := rcu.Digits(n, 10)
for _, d := range digits {
if d == 0 || d == 1 {
return false
}
}
set := make(map[int]bool)
for _, d := range digits {
set[d] = true
}
dc := len(digits)
if len(set) < dc {
return false
}
for k := 2; k <= dc; k++ {
for i := 0; i <= dc-k; i++ {
prod := 1
for j := i; j <= i+k-1; j++ {
prod *= digits[j]
}
if ok := set[prod]; ok {
return false
}
set[prod] = true
}
}
return true
}
var count = make([]int, 9)
var used = make([]bool, 11)
var largest = 0
func countColorful(taken int, n string) {
if taken == 0 {
for digit := 0; digit < 10; digit++ {
dx := digit + 1
used[dx] = true
t := 1
if digit < 2 {
t = 9
}
countColorful(t, string(digit+48))
used[dx] = false
}
} else {
nn, _ := strconv.Atoi(n)
if isColorful(nn) {
ln := len(n)
count[ln]++
if nn > largest {
largest = nn
}
}
if taken < 9 {
for digit := 2; digit < 10; digit++ {
dx := digit + 1
if !used[dx] {
used[dx] = true
countColorful(taken+1, n+string(digit+48))
used[dx] = false
}
}
}
}
}
func main() {
var cn []int
for i := 0; i < 100; i++ {
if isColorful(i) {
cn = append(cn, i)
}
}
fmt.Println("The", len(cn), "colorful numbers less than 100 are:")
for i := 0; i < len(cn); i++ {
fmt.Printf("%2d ", cn[i])
if (i+1)%10 == 0 {
fmt.Println()
}
}
countColorful(0, "")
fmt.Println("\n\nThe largest possible colorful number is:")
fmt.Println(rcu.Commatize(largest))
fmt.Println("\nCount of colorful numbers for each order of magnitude:")
pow := 10
for dc := 1; dc < len(count); dc++ {
cdc := rcu.Commatize(count[dc])
pc := 100 * float64(count[dc]) / float64(pow)
fmt.Printf(" %d digit colorful number count: %6s - %7.3f%%\n", dc, cdc, pc)
if pow == 10 {
pow = 90
} else {
pow *= 10
}
}
sum := 0
for _, c := range count {
sum += c
}
fmt.Printf("\nTotal colorful numbers: %s\n", rcu.Commatize(sum))
}
- Output:
The 66 colorful numbers less than 100 are: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 The largest possible colorful number is: 98,746,253 Count of colorful numbers for each order of magnitude: 1 digit colorful number count: 10 - 100.000% 2 digit colorful number count: 56 - 62.222% 3 digit colorful number count: 328 - 36.444% 4 digit colorful number count: 1,540 - 17.111% 5 digit colorful number count: 5,514 - 6.127% 6 digit colorful number count: 13,956 - 1.551% 7 digit colorful number count: 21,596 - 0.240% 8 digit colorful number count: 14,256 - 0.016% Total colorful numbers: 57,256
Haskell
import Data.List ( nub )
import Data.List.Split ( divvy )
import Data.Char ( digitToInt )
isColourful :: Integer -> Bool
isColourful n
|n >= 0 && n <= 10 = True
|n > 10 && n < 100 = ((length s) == (length $ nub s)) &&
(not $ any (\c -> elem c "01") s)
|n >= 100 = ((length s) == (length $ nub s)) && (not $ any (\c -> elem c "01") s)
&& ((length products) == (length $ nub products))
where
s :: String
s = show n
products :: [Int]
products = map (\p -> (digitToInt $ head p) * (digitToInt $ last p))
$ divvy 2 1 s
solution1 :: [Integer]
solution1 = filter isColourful [0 .. 100]
solution2 :: Integer
solution2 = head $ filter isColourful [98765432, 98765431 ..]
- Output:
[0,1,2,3,4,5,6,7,8,9,10,23,24,25,26,27,28,29,32,34,35,36,37,38,39,42,43,45,46,47,48,49,52,53,54,56,57,58,59,62,63,64,65,67,68,69,72,73,74,75,76,78,79,82,83,84,85,86,87,89,92,93,94,95,96,97,98](solution1) 98765432(solution2)
Haskell (alternate version)
An alternate Haskell version, which some may consider to be in a more idiomatic style. No attempt at optimization has been made, so we don't attempt the stretch goals.
import Data.List (inits, nub, tails, unfoldr)
-- Non-empty subsequences containing only consecutive elements from the
-- argument. For example:
--
-- consecs [1,2,3] => [[1],[1,2],[1,2,3],[2],[2,3],[3]]
consecs :: [a] -> [[a]]
consecs = drop 1 . ([] :) . concatMap (drop 1 . inits) . tails
-- The list of digits in the argument, from least to most significant. The
-- number 0 is represented by the empty list.
toDigits :: Int -> [Int]
toDigits = unfoldr step
where step 0 = Nothing
step n = let (q, r) = n `quotRem` 10 in Just (r, q)
-- True if and only if all the argument's elements are distinct.
allDistinct :: [Int] -> Bool
allDistinct ns = length ns == length (nub ns)
-- True if and only if the argument is a colorful number.
isColorful :: Int -> Bool
isColorful = allDistinct . map product . consecs . toDigits
main :: IO ()
main = do
let smalls = filter isColorful [0..99]
putStrLn $ "Small colorful numbers: " ++ show smalls
let start = 98765432
largest = head $ dropWhile (not . isColorful) [start, start-1 ..]
putStrLn $ "Largest colorful number: " ++ show largest
- Output:
$ colorful Small colorful numbers: [0,1,2,3,4,5,6,7,8,9,23,24,25,26,27,28,29,32,34,35,36,37,38,39,42,43,45,46,47,48,49,52,53,54,56,57,58,59,62,63,64,65,67,68,69,72,73,74,75,76,78,79,82,83,84,85,86,87,89,92,93,94,95,96,97,98] Largest colorful number: 98746253
J
colorful=: {{(-:~.);<@(*/\)\. 10 #.inv y}}"0
I.colorful i.100
0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98
C=: I.colorful <.i.1e8
>./C
98746253
(~.,. #/.~) 10 <.@^. C
__ 1
0 9
1 56
2 328
3 1540
4 5514
5 13956
6 21596
7 14256
#C
57256
(Note that 0, here is a different order of magnitude than 1.)
Java
public class ColorfulNumbers {
private int count[] = new int[8];
private boolean used[] = new boolean[10];
private int largest = 0;
public static void main(String[] args) {
System.out.printf("Colorful numbers less than 100:\n");
for (int n = 0, count = 0; n < 100; ++n) {
if (isColorful(n))
System.out.printf("%2d%c", n, ++count % 10 == 0 ? '\n' : ' ');
}
ColorfulNumbers c = new ColorfulNumbers();
System.out.printf("\n\nLargest colorful number: %,d\n", c.largest);
System.out.printf("\nCount of colorful numbers by number of digits:\n");
int total = 0;
for (int d = 0; d < 8; ++d) {
System.out.printf("%d %,d\n", d + 1, c.count[d]);
total += c.count[d];
}
System.out.printf("\nTotal: %,d\n", total);
}
private ColorfulNumbers() {
countColorful(0, 0, 0);
}
public static boolean isColorful(int n) {
// A colorful number cannot be greater than 98765432.
if (n < 0 || n > 98765432)
return false;
int digit_count[] = new int[10];
int digits[] = new int[8];
int num_digits = 0;
for (int m = n; m > 0; m /= 10) {
int d = m % 10;
if (n > 9 && (d == 0 || d == 1))
return false;
if (++digit_count[d] > 1)
return false;
digits[num_digits++] = d;
}
// Maximum number of products is (8 x 9) / 2.
int products[] = new int[36];
for (int i = 0, product_count = 0; i < num_digits; ++i) {
for (int j = i, p = 1; j < num_digits; ++j) {
p *= digits[j];
for (int k = 0; k < product_count; ++k) {
if (products[k] == p)
return false;
}
products[product_count++] = p;
}
}
return true;
}
private void countColorful(int taken, int n, int digits) {
if (taken == 0) {
for (int d = 0; d < 10; ++d) {
used[d] = true;
countColorful(d < 2 ? 9 : 1, d, 1);
used[d] = false;
}
} else {
if (isColorful(n)) {
++count[digits - 1];
if (n > largest)
largest = n;
}
if (taken < 9) {
for (int d = 2; d < 10; ++d) {
if (!used[d]) {
used[d] = true;
countColorful(taken + 1, n * 10 + d, digits + 1);
used[d] = false;
}
}
}
}
}
}
- Output:
Colorful numbers less than 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest colorful number: 98,746,253 Count of colorful numbers by number of digits: 1 10 2 56 3 328 4 1,540 5 5,514 6 13,956 7 21,596 8 14,256 Total: 57,256
Julia
largest = 0
function iscolorful(n, base=10)
0 <= n < 10 && return true
dig = digits(n, base=base)
(1 in dig || 0 in dig || !allunique(dig)) && return false
products = Set(dig)
for i in 2:length(dig), j in 1:length(dig)-i+1
p = prod(dig[j:j+i-1])
p in products && return false
push!(products, p)
end
if n > largest
global largest = n
end
return true
end
function testcolorfuls()
println("Colorful numbers for 1:25, 26:50, 51:75, and 76:100:")
for i in 1:100
iscolorful(i) && print(rpad(i, 5))
i % 25 == 0 && println()
end
csum = 0
for i in 0:7
j, k = i == 0 ? 0 : 10^i, 10^(i+1) - 1
n = count(i -> iscolorful(i), j:k)
csum += n
println("The count of colorful numbers between $j and $k is $n.")
end
println("The largest possible colorful number is $largest.")
println("The total number of colorful numbers is $csum.")
end
testcolorfuls()
- Output:
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 The count of colorful numbers between 0 and 9 is 10. The count of colorful numbers between 10 and 99 is 56. The count of colorful numbers between 100 and 999 is 328. The count of colorful numbers between 1000 and 9999 is 1540. The count of colorful numbers between 10000 and 99999 is 5514. The count of colorful numbers between 100000 and 999999 is 13956. The count of colorful numbers between 1000000 and 9999999 is 21596. The count of colorful numbers between 10000000 and 99999999 is 14256. The largest possible colorful number is 98746253. The total number of colorful numbers is 57256.
Mathematica/Wolfram Language
ClearAll[ColorfulNumberQ]
ColorfulNumberQ[n_Integer?NonNegative] := Module[{digs, parts},
If[n > 98765432,
False
,
digs = IntegerDigits[n];
parts = Partition[digs, #, 1] & /@ Range[1, Length[digs]];
parts //= Catenate;
parts = Times @@@ parts;
DuplicateFreeQ[parts]
]
]
Multicolumn[Select[Range[99], ColorfulNumberQ], Appearance -> "Horizontal"]
sel = Union[FromDigits /@ Catenate[Permutations /@ Subsets[Range[2, 9], {1, \[Infinity]}]]];
sel = Join[sel, {0, 1}];
cns = Select[sel, ColorfulNumberQ];
Max[cns]
Tally[IntegerDigits/*Length /@ cns] // Grid
Length[cns]
- Output:
1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 98746253 1 10 2 56 3 328 4 1540 5 5514 6 13956 7 21596 8 14256 57256
Perl
use strict;
use warnings;
use feature 'say';
use enum qw(False True);
use List::Util <max uniqint product>;
use Algorithm::Combinatorics qw(combinations permutations);
sub table { my $t = shift() * (my $c = 1 + length max @_); ( sprintf( ('%'.$c.'d')x@_, @_) ) =~ s/.{1,$t}\K/\n/gr }
sub is_colorful {
my($n) = @_;
return True if 0 <= $n and $n <= 9;
return False if $n =~ /0|1/ or $n < 0;
my @digits = split '', $n;
return False unless @digits == uniqint @digits;
my @p;
for my $w (0 .. @digits) {
push @p, map { product @digits[$_ .. $_+$w] } 0 .. @digits-$w-1;
return False unless @p == uniqint @p
}
True
}
say "Colorful numbers less than 100:\n" . table 10, grep { is_colorful $_ } 0..100;
my $largest = 98765432;
1 while not is_colorful --$largest;
say "Largest magnitude colorful number: $largest\n";
my $total= 10;
map { is_colorful(join '', @$_) and $total++ } map { permutations $_ } combinations [2..9], $_ for 2..8;
say "Total colorful numbers: $total";
- Output:
Colorful numbers less than 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest magnitude colorful number: 98746253 Total colorful numbers: 57256
Phix
You can run this online here.
with javascript_semantics function colourful(integer n) if n<10 then return n>=0 end if sequence digits = sq_sub(sprintf("%d",n),'0'), ud = unique(deep_copy(digits)) integer ln = length(digits) if ud[1]<=1 or length(ud)!=ln then return false end if for i=1 to ln-1 do for j=i+1 to ln do atom prod = product(digits[i..j]) if find(prod,ud) then return false end if ud &= prod end for end for return true end function atom t0 = time() sequence cn = apply(true,sprintf,{{"%2d"},filter(tagset(100,0),colourful)}) printf(1,"The %d colourful numbers less than 100 are:\n%s\n", {length(cn),join_by(cn,1,10," ")}) sequence count = repeat(0,8), used = repeat(false,10) integer largestcn = 0 procedure count_colourful(integer taken=0, string n="") if taken=0 then for digit='0' to '9' do integer dx = digit-'0'+1 used[dx] = true count_colourful(iff(digit<'2'?9:1),""&digit) used[dx] = false end for else integer nn = to_integer(n) if colourful(nn) then integer ln = length(n) count[ln] += 1 if nn>largestcn then largestcn = nn end if end if if taken<9 then for digit='2' to '9' do integer dx = digit-'0'+1 if not used[dx] then used[dx] = true count_colourful(taken+1,n&digit) used[dx] = false end if end for end if end if end procedure count_colourful() printf(1,"The largest possible colourful number is: %,d\n\n",largestcn) atom pow = 10 for dc=1 to length(count) do printf(1," %d digit colourful number count: %,6d - %7.3f%%\n", {dc, count[dc], 100*count[dc]/pow}) pow = iff(pow=10?90:pow*10) end for printf(1,"\nTotal colourful numbers: %,d\n", sum(count)) ?elapsed(time()-t0)
- Output:
The 66 colourful numbers less than 100 are: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 The largest possible colourful number is: 98,746,253 1 digit colourful number count: 10 - 100.000% 2 digit colourful number count: 56 - 62.222% 3 digit colourful number count: 328 - 36.444% 4 digit colourful number count: 1,540 - 17.111% 5 digit colourful number count: 5,514 - 6.127% 6 digit colourful number count: 13,956 - 1.551% 7 digit colourful number count: 21,596 - 0.240% 8 digit colourful number count: 14,256 - 0.016% Total colourful numbers: 57,256 "1.9s"
Picat
colorful_number(N) =>
N < 10 ;
(X = N.to_string,
X.len <= 8,
not membchk('0',X),
not membchk('1',X),
distinct(X),
[prod(S.map(to_int)) : S in findall(S,(append(_,S,_,X),S != [])) ].distinct).
distinct(L) =>
L.len == L.remove_dups.len.
All colorful numbers <= 100.
main =>
Colorful = [N : N in 0..100, colorful_number(N)],
Len = Colorful.len,
foreach({C,I} in zip(Colorful,1..Len))
printf("%2d%s",C, cond(I mod 10 == 0, "\n"," "))
end,
nl,
println(len=Len)
- Output:
0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 len = 66
Largest colorful number.
main =>
N = 98765431,
Found = false,
while (Found == false)
if colorful_number(N) then
println(N),
Found := true
end,
N := N - 1
end.
- Output:
98746253
Count of colorful numbers in each magnitude and of total colorful numbers.
main =>
TotalC = 0,
foreach(I in 1..8)
C = 0,
printf("Digits %d: ", I),
foreach(N in lb(I)..ub(I))
if colorful_number(N) then
C := C + 1
end
end,
println(C),
TotalC := TotalC + C
end,
println(total=TotalC),
nl.
% Lower and upper bounds.
% For N=3: lb=123 and ub=987
lb(N) = cond(N < 2, 0, [I.to_string : I in 1..N].join('').to_int).
ub(N) = [I.to_string : I in 9..-1..9-N+1].join('').to_int.
- Output:
Digits 1: 10 Digits 2: 56 Digits 3: 328 Digits 4: 1540 Digits 5: 5514 Digits 6: 13956 Digits 7: 21596 Digits 8: 14256 total = 57256
Python
from math import prod
largest = [0]
def iscolorful(n):
if 0 <= n < 10:
return True
dig = [int(c) for c in str(n)]
if 1 in dig or 0 in dig or len(dig) > len(set(dig)):
return False
products = list(set(dig))
for i in range(len(dig)):
for j in range(i+2, len(dig)+1):
p = prod(dig[i:j])
if p in products:
return False
products.append(p)
largest[0] = max(n, largest[0])
return True
print('Colorful numbers for 1:25, 26:50, 51:75, and 76:100:')
for i in range(1, 101, 25):
for j in range(25):
if iscolorful(i + j):
print(f'{i + j: 5,}', end='')
print()
csum = 0
for i in range(8):
j = 0 if i == 0 else 10**i
k = 10**(i+1) - 1
n = sum(iscolorful(x) for x in range(j, k+1))
csum += n
print(f'The count of colorful numbers between {j} and {k} is {n}.')
print(f'The largest possible colorful number is {largest[0]}.')
print(f'The total number of colorful numbers is {csum}.')
- Output:
Colorful numbers for 1:25, 26:50, 51:75, and 76:100: 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 The count of colorful numbers between 0 and 9 is 10. The count of colorful numbers between 10 and 99 is 56. The count of colorful numbers between 100 and 999 is 328. The count of colorful numbers between 1000 and 9999 is 1540. The count of colorful numbers between 10000 and 99999 is 5514. The count of colorful numbers between 100000 and 999999 is 13956. The count of colorful numbers between 1000000 and 9999999 is 21596. The count of colorful numbers between 10000000 and 99999999 is 14256. The largest possible colorful number is 98746253. The total number of colorful numbers is 57256.
Raku
sub is-colorful (Int $n) {
return True if 0 <= $n <= 9;
return False if $n.contains(0) || $n.contains(1) || $n < 0;
my @digits = $n.comb;
my %sums = @digits.Bag;
return False if %sums.values.max > 1;
for 2..@digits -> $group {
@digits.rotor($group => 1 - $group).map: { %sums{ [×] $_ }++ }
return False if %sums.values.max > 1;
}
True
}
put "Colorful numbers less than 100:\n" ~ (^100).race.grep( &is-colorful).batch(10)».fmt("%2d").join: "\n";
my ($start, $total) = 23456789, 10;
print "\nLargest magnitude colorful number: ";
.put and last if .Int.&is-colorful for $start.flip … $start;
put "\nCount of colorful numbers for each order of magnitude:\n" ~
"1 digit colorful number count: $total - 100%";
for 2..8 {
put "$_ digit colorful number count: ",
my $c = +(flat $start.comb.combinations($_).map: {.permutations».join».Int}).race.grep( &is-colorful ),
" - {($c / (exp($_,10) - exp($_-1,10) ) * 100).round(.001)}%";
$total += $c;
}
say "\nTotal colorful numbers: $total";
- Output:
Colorful numbers less than 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest magnitude colorful number: 98746253 Count of colorful numbers for each order of magnitude: 1 digit colorful number count: 10 - 100% 2 digit colorful number count: 56 - 62.222% 3 digit colorful number count: 328 - 36.444% 4 digit colorful number count: 1540 - 17.111% 5 digit colorful number count: 5514 - 6.127% 6 digit colorful number count: 13956 - 1.551% 7 digit colorful number count: 21596 - 0.24% 8 digit colorful number count: 14256 - 0.016% Total colorful numbers: 57256
Wren
import "./math" for Int, Nums
import "./set" for Set
import "./seq" for Lst
import "./fmt" for Fmt
var isColorful = Fn.new { |n|
if (n < 0) return false
if (n < 10) return true
var digits = Int.digits(n)
if (digits.contains(0) || digits.contains(1)) return false
var set = Set.new(digits)
var dc = digits.count
if (set.count < dc) return false
for (k in 2..dc) {
for (i in 0..dc-k) {
var prod = 1
for (j in i..i+k-1) prod = prod * digits[j]
if (set.contains(prod)) return false
set.add(prod)
}
}
return true
}
var count = List.filled(9, 0)
var used = List.filled(11, false)
var largest = 0
var countColorful // recursive
countColorful = Fn.new { |taken, n|
if (taken == 0) {
for (digit in 0..9) {
var dx = digit + 1
used[dx] = true
countColorful.call((digit < 2) ? 9 : 1, String.fromByte(digit + 48))
used[dx] = false
}
} else {
var nn = Num.fromString(n)
if (isColorful.call(nn)) {
var ln = n.count
count[ln] = count[ln] + 1
if (nn > largest) largest = nn
}
if (taken < 9) {
for (digit in 2..9) {
var dx = digit + 1
if (!used[dx]) {
used[dx] = true
countColorful.call(taken + 1, n + String.fromByte(digit + 48))
used[dx] = false
}
}
}
}
}
var cn = (0..99).where { |i| isColorful.call(i) }.toList
System.print("The %(cn.count) colorful numbers less than 100 are:")
for (chunk in Lst.chunks(cn, 10)) Fmt.print("$2d", chunk)
countColorful.call(0, "")
System.print("\nThe largest possible colorful number is:")
Fmt.print("$,d\n", largest)
System.print("Count of colorful numbers for each order of magnitude:")
var pow = 10
for (dc in 1...count.count) {
Fmt.print(" $d digit colorful number count: $,6d - $7.3f\%", dc, count[dc], 100 * count[dc] / pow)
pow = (pow == 10) ? 90 : pow * 10
}
Fmt.print("\nTotal colorful numbers: $,d", Nums.sum(count))
- Output:
The 66 colorful numbers less than 100 are: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 The largest possible colorful number is: 98,746,253 Count of colorful numbers for each order of magnitude: 1 digit colorful number count: 10 - 100.000% 2 digit colorful number count: 56 - 62.222% 3 digit colorful number count: 328 - 36.444% 4 digit colorful number count: 1,540 - 17.111% 5 digit colorful number count: 5,514 - 6.127% 6 digit colorful number count: 13,956 - 1.551% 7 digit colorful number count: 21,596 - 0.240% 8 digit colorful number count: 14,256 - 0.016% Total colorful numbers: 57,256
XPL0
func IPow(A, B); \A^B
int A, B, T, I;
[T:= 1;
for I:= 1 to B do T:= T*A;
return T;
];
func Colorful(N); \Return 'true' if N is a colorful number
int N, Digits, R, I, J, Prod;
def Size = 9*8*7*6*5*4*3*2 + 1;
char Used(Size), Num(10);
[if N < 10 then return true; \single digit number is colorful
FillMem(Used, false, 10); \digits must be unique
Digits:= 0;
repeat N:= N/10; \slice digits off N
R:= rem(0);
if N=1 or R=0 or R=1 then return false;
if Used(R) then return false;
Used(R):= true; \digits must be unique
Num(Digits):= R;
Digits:= Digits+1;
until N = 0;
FillMem(Used+10, false, Size-10); \products must be unique
for I:= 0 to Digits-2 do
[Prod:= Num(I);
for J:= I+1 to Digits-1 do
[Prod:= Prod * Num(J);
if Used(Prod) then return false;
Used(Prod):= true;
];
];
return true;
];
int Count, N, Power, Total;
[Text(0, "Colorful numbers less than 100:
");
Count:= 0;
for N:= 0 to 99 do
if Colorful(N) then
[IntOut(0, N);
Count:= Count+1;
if rem(Count/10) then ChOut(0, 9\tab\) else CrLf(0);
];
Text(0, "
Largest magnitude colorful number: ");
N:= 98_765_432;
loop [if Colorful(N) then quit;
N:= N-1;
];
IntOut(0, N);
Text(0, "
Count of colorful numbers for each order of magnitude:
");
Total:= 0;
for Power:= 1 to 8 do
[Count:= if Power=1 then 1 else 0;
for N:= IPow(10, Power-1) to IPow(10, Power)-1 do
if Colorful(N) then Count:= Count+1;
IntOut(0, Power);
Text(0, " digit colorful number count: ");
IntOut(0, Count);
CrLf(0);
Total:= Total + Count;
];
Text(0, "
Total colorful numbers: ");
IntOut(0, Total);
CrLf(0);
]
- Output:
Colorful numbers less than 100: 0 1 2 3 4 5 6 7 8 9 23 24 25 26 27 28 29 32 34 35 36 37 38 39 42 43 45 46 47 48 49 52 53 54 56 57 58 59 62 63 64 65 67 68 69 72 73 74 75 76 78 79 82 83 84 85 86 87 89 92 93 94 95 96 97 98 Largest magnitude colorful number: 98746253 Count of colorful numbers for each order of magnitude: 1 digit colorful number count: 10 2 digit colorful number count: 56 3 digit colorful number count: 328 4 digit colorful number count: 1540 5 digit colorful number count: 5514 6 digit colorful number count: 13956 7 digit colorful number count: 21596 8 digit colorful number count: 14256 Total colorful numbers: 57256