Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
227
Task/Sum-to-100/JavaScript/sum-to-100-1.js
Normal file
227
Task/Sum-to-100/JavaScript/sum-to-100-1.js
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
(function () {
|
||||
'use strict';
|
||||
|
||||
// GENERIC FUNCTIONS ----------------------------------------------------
|
||||
|
||||
// permutationsWithRepetition :: Int -> [a] -> [[a]]
|
||||
var permutationsWithRepetition = function (n, as) {
|
||||
return as.length > 0 ?
|
||||
foldl1(curry(cartesianProduct)(as), replicate(n, as)) : [];
|
||||
};
|
||||
|
||||
// cartesianProduct :: [a] -> [b] -> [[a, b]]
|
||||
var cartesianProduct = function (xs, ys) {
|
||||
return [].concat.apply([], xs.map(function (x) {
|
||||
return [].concat.apply([], ys.map(function (y) {
|
||||
return [
|
||||
[x].concat(y)
|
||||
];
|
||||
}));
|
||||
}));
|
||||
};
|
||||
|
||||
// curry :: ((a, b) -> c) -> a -> b -> c
|
||||
var curry = function (f) {
|
||||
return function (a) {
|
||||
return function (b) {
|
||||
return f(a, b);
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
// flip :: (a -> b -> c) -> b -> a -> c
|
||||
var flip = function (f) {
|
||||
return function (a, b) {
|
||||
return f.apply(null, [b, a]);
|
||||
};
|
||||
};
|
||||
|
||||
// foldl1 :: (a -> a -> a) -> [a] -> a
|
||||
var foldl1 = function (f, xs) {
|
||||
return xs.length > 0 ? xs.slice(1)
|
||||
.reduce(f, xs[0]) : [];
|
||||
};
|
||||
|
||||
// replicate :: Int -> a -> [a]
|
||||
var replicate = function (n, a) {
|
||||
var v = [a],
|
||||
o = [];
|
||||
if (n < 1) return o;
|
||||
while (n > 1) {
|
||||
if (n & 1) o = o.concat(v);
|
||||
n >>= 1;
|
||||
v = v.concat(v);
|
||||
}
|
||||
return o.concat(v);
|
||||
};
|
||||
|
||||
// group :: Eq a => [a] -> [[a]]
|
||||
var group = function (xs) {
|
||||
return groupBy(function (a, b) {
|
||||
return a === b;
|
||||
}, xs);
|
||||
};
|
||||
|
||||
// groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
|
||||
var groupBy = function (f, xs) {
|
||||
var dct = xs.slice(1)
|
||||
.reduce(function (a, x) {
|
||||
var h = a.active.length > 0 ? a.active[0] : undefined,
|
||||
blnGroup = h !== undefined && f(h, x);
|
||||
|
||||
return {
|
||||
active: blnGroup ? a.active.concat(x) : [x],
|
||||
sofar: blnGroup ? a.sofar : a.sofar.concat([a.active])
|
||||
};
|
||||
}, {
|
||||
active: xs.length > 0 ? [xs[0]] : [],
|
||||
sofar: []
|
||||
});
|
||||
return dct.sofar.concat(dct.active.length > 0 ? [dct.active] : []);
|
||||
};
|
||||
|
||||
// compare :: a -> a -> Ordering
|
||||
var compare = function (a, b) {
|
||||
return a < b ? -1 : a > b ? 1 : 0;
|
||||
};
|
||||
|
||||
// on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
|
||||
var on = function (f, g) {
|
||||
return function (a, b) {
|
||||
return f(g(a), g(b));
|
||||
};
|
||||
};
|
||||
|
||||
// nub :: [a] -> [a]
|
||||
var nub = function (xs) {
|
||||
return nubBy(function (a, b) {
|
||||
return a === b;
|
||||
}, xs);
|
||||
};
|
||||
|
||||
// nubBy :: (a -> a -> Bool) -> [a] -> [a]
|
||||
var nubBy = function (p, xs) {
|
||||
var x = xs.length ? xs[0] : undefined;
|
||||
|
||||
return x !== undefined ? [x].concat(nubBy(p, xs.slice(1)
|
||||
.filter(function (y) {
|
||||
return !p(x, y);
|
||||
}))) : [];
|
||||
};
|
||||
|
||||
// find :: (a -> Bool) -> [a] -> Maybe a
|
||||
var find = function (f, xs) {
|
||||
for (var i = 0, lng = xs.length; i < lng; i++) {
|
||||
if (f(xs[i], i)) return xs[i];
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
// Int -> [a] -> [a]
|
||||
var take = function (n, xs) {
|
||||
return xs.slice(0, n);
|
||||
};
|
||||
|
||||
// unlines :: [String] -> String
|
||||
var unlines = function (xs) {
|
||||
return xs.join('\n');
|
||||
};
|
||||
|
||||
// show :: a -> String
|
||||
var show = function (x) {
|
||||
return JSON.stringify(x);
|
||||
}; //, null, 2);
|
||||
|
||||
// head :: [a] -> a
|
||||
var head = function (xs) {
|
||||
return xs.length ? xs[0] : undefined;
|
||||
};
|
||||
|
||||
// tail :: [a] -> [a]
|
||||
var tail = function (xs) {
|
||||
return xs.length ? xs.slice(1) : undefined;
|
||||
};
|
||||
|
||||
// length :: [a] -> Int
|
||||
var length = function (xs) {
|
||||
return xs.length;
|
||||
};
|
||||
|
||||
// SIGNED DIGIT SEQUENCES (mapped to sums and to strings)
|
||||
|
||||
// data Sign :: [ 0 | 1 | -1 ] = ( Unsigned | Plus | Minus )
|
||||
// asSum :: [Sign] -> Int
|
||||
var asSum = function (xs) {
|
||||
var dct = xs.reduceRight(function (a, sign, i) {
|
||||
var d = i + 1; // zero-based index to [1-9] positions
|
||||
if (sign !== 0) {
|
||||
// Sum increased, digits cleared
|
||||
return {
|
||||
digits: [],
|
||||
n: a.n + sign * parseInt([d].concat(a.digits)
|
||||
.join(''), 10)
|
||||
};
|
||||
} else return { // Digits extended, sum unchanged
|
||||
digits: [d].concat(a.digits),
|
||||
n: a.n
|
||||
};
|
||||
}, {
|
||||
digits: [],
|
||||
n: 0
|
||||
});
|
||||
return dct.n + (
|
||||
dct.digits.length > 0 ? parseInt(dct.digits.join(''), 10) : 0
|
||||
);
|
||||
};
|
||||
|
||||
// data Sign :: [ 0 | 1 | -1 ] = ( Unsigned | Plus | Minus )
|
||||
// asString :: [Sign] -> String
|
||||
var asString = function (xs) {
|
||||
var ns = xs.reduce(function (a, sign, i) {
|
||||
var d = (i + 1)
|
||||
.toString();
|
||||
return sign === 0 ? a + d : a + (sign > 0 ? ' +' : ' -') + d;
|
||||
}, '');
|
||||
|
||||
return ns[0] === '+' ? tail(ns) : ns;
|
||||
};
|
||||
|
||||
// SUM T0 100 ------------------------------------------------------------
|
||||
|
||||
// universe :: [[Sign]]
|
||||
var universe = permutationsWithRepetition(9, [0, 1, -1])
|
||||
.filter(function (x) {
|
||||
return x[0] !== 1;
|
||||
});
|
||||
|
||||
// allNonNegativeSums :: [Int]
|
||||
var allNonNegativeSums = universe.map(asSum)
|
||||
.filter(function (x) {
|
||||
return x >= 0;
|
||||
})
|
||||
.sort();
|
||||
|
||||
// uniqueNonNegativeSums :: [Int]
|
||||
var uniqueNonNegativeSums = nub(allNonNegativeSums);
|
||||
|
||||
return ["Sums to 100:\n", unlines(universe.filter(function (x) {
|
||||
return asSum(x) === 100;
|
||||
})
|
||||
.map(asString)),
|
||||
|
||||
"\n\n10 commonest sums (sum, followed by number of routes to it):\n",
|
||||
show(take(10, group(allNonNegativeSums)
|
||||
.sort(on(flip(compare), length))
|
||||
.map(function (xs) {
|
||||
return [xs[0], xs.length];
|
||||
}))),
|
||||
|
||||
"\n\nFirst positive integer not expressible as a sum of this kind:\n",
|
||||
show(find(function (x, i) {
|
||||
return x !== i;
|
||||
}, uniqueNonNegativeSums.sort(compare)) - 1), // zero-based index
|
||||
|
||||
"\n10 largest sums:\n",
|
||||
show(take(10, uniqueNonNegativeSums.sort(flip(compare))))
|
||||
].join('\n') + '\n';
|
||||
})();
|
||||
184
Task/Sum-to-100/JavaScript/sum-to-100-2.js
Normal file
184
Task/Sum-to-100/JavaScript/sum-to-100-2.js
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
(() => {
|
||||
'use strict';
|
||||
|
||||
// GENERIC FUNCTIONS ----------------------------------------------------
|
||||
|
||||
// permutationsWithRepetition :: Int -> [a] -> [[a]]
|
||||
const permutationsWithRepetition = (n, as) =>
|
||||
as.length > 0 ? (
|
||||
foldl1(curry(cartesianProduct)(as), replicate(n, as))
|
||||
) : [];
|
||||
|
||||
// cartesianProduct :: [a] -> [b] -> [[a, b]]
|
||||
const cartesianProduct = (xs, ys) =>
|
||||
[].concat.apply([], xs.map(x =>
|
||||
[].concat.apply([], ys.map(y => [[x].concat(y)]))));
|
||||
|
||||
// curry :: ((a, b) -> c) -> a -> b -> c
|
||||
const curry = f => a => b => f(a, b);
|
||||
|
||||
// flip :: (a -> b -> c) -> b -> a -> c
|
||||
const flip = f => (a, b) => f.apply(null, [b, a]);
|
||||
|
||||
// foldl1 :: (a -> a -> a) -> [a] -> a
|
||||
const foldl1 = (f, xs) =>
|
||||
xs.length > 0 ? xs.slice(1)
|
||||
.reduce(f, xs[0]) : [];
|
||||
|
||||
// replicate :: Int -> a -> [a]
|
||||
const replicate = (n, a) => {
|
||||
let v = [a],
|
||||
o = [];
|
||||
if (n < 1) return o;
|
||||
while (n > 1) {
|
||||
if (n & 1) o = o.concat(v);
|
||||
n >>= 1;
|
||||
v = v.concat(v);
|
||||
}
|
||||
return o.concat(v);
|
||||
};
|
||||
|
||||
// group :: Eq a => [a] -> [[a]]
|
||||
const group = xs => groupBy((a, b) => a === b, xs);
|
||||
|
||||
// groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
|
||||
const groupBy = (f, xs) => {
|
||||
const dct = xs.slice(1)
|
||||
.reduce((a, x) => {
|
||||
const
|
||||
h = a.active.length > 0 ? a.active[0] : undefined,
|
||||
blnGroup = h !== undefined && f(h, x);
|
||||
|
||||
return {
|
||||
active: blnGroup ? a.active.concat(x) : [x],
|
||||
sofar: blnGroup ? a.sofar : a.sofar.concat([a.active])
|
||||
};
|
||||
}, {
|
||||
active: xs.length > 0 ? [xs[0]] : [],
|
||||
sofar: []
|
||||
});
|
||||
return dct.sofar.concat(dct.active.length > 0 ? [dct.active] : []);
|
||||
};
|
||||
|
||||
// compare :: a -> a -> Ordering
|
||||
const compare = (a, b) => a < b ? -1 : (a > b ? 1 : 0);
|
||||
|
||||
// on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
|
||||
const on = (f, g) => (a, b) => f(g(a), g(b));
|
||||
|
||||
// nub :: [a] -> [a]
|
||||
const nub = xs => nubBy((a, b) => a === b, xs);
|
||||
|
||||
// nubBy :: (a -> a -> Bool) -> [a] -> [a]
|
||||
const nubBy = (p, xs) => {
|
||||
const x = xs.length ? xs[0] : undefined;
|
||||
|
||||
return x !== undefined ? [x].concat(
|
||||
nubBy(p, xs.slice(1)
|
||||
.filter(y => !p(x, y)))
|
||||
) : [];
|
||||
};
|
||||
|
||||
// find :: (a -> Bool) -> [a] -> Maybe a
|
||||
const find = (f, xs) => {
|
||||
for (var i = 0, lng = xs.length; i < lng; i++) {
|
||||
if (f(xs[i], i)) return xs[i];
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Int -> [a] -> [a]
|
||||
const take = (n, xs) => xs.slice(0, n);
|
||||
|
||||
// unlines :: [String] -> String
|
||||
const unlines = xs => xs.join('\n');
|
||||
|
||||
// show :: a -> String
|
||||
const show = x => JSON.stringify(x); //, null, 2);
|
||||
|
||||
// head :: [a] -> a
|
||||
const head = xs => xs.length ? xs[0] : undefined;
|
||||
|
||||
// tail :: [a] -> [a]
|
||||
const tail = xs => xs.length ? xs.slice(1) : undefined;
|
||||
|
||||
// length :: [a] -> Int
|
||||
const length = xs => xs.length;
|
||||
|
||||
|
||||
// SIGNED DIGIT SEQUENCES (mapped to sums and to strings)
|
||||
|
||||
// data Sign :: [ 0 | 1 | -1 ] = ( Unsigned | Plus | Minus )
|
||||
// asSum :: [Sign] -> Int
|
||||
const asSum = xs => {
|
||||
const dct = xs.reduceRight((a, sign, i) => {
|
||||
const d = i + 1; // zero-based index to [1-9] positions
|
||||
if (sign !== 0) { // Sum increased, digits cleared
|
||||
return {
|
||||
digits: [],
|
||||
n: a.n + (sign * parseInt([d].concat(a.digits)
|
||||
.join(''), 10))
|
||||
};
|
||||
} else return { // Digits extended, sum unchanged
|
||||
digits: [d].concat(a.digits),
|
||||
n: a.n
|
||||
};
|
||||
}, {
|
||||
digits: [],
|
||||
n: 0
|
||||
});
|
||||
return dct.n + (dct.digits.length > 0 ? (
|
||||
parseInt(dct.digits.join(''), 10)
|
||||
) : 0);
|
||||
};
|
||||
|
||||
// data Sign :: [ 0 | 1 | -1 ] = ( Unsigned | Plus | Minus )
|
||||
// asString :: [Sign] -> String
|
||||
const asString = xs => {
|
||||
const ns = xs.reduce((a, sign, i) => {
|
||||
const d = (i + 1)
|
||||
.toString();
|
||||
return (sign === 0 ? (
|
||||
a + d
|
||||
) : (a + (sign > 0 ? ' +' : ' -') + d));
|
||||
}, '');
|
||||
|
||||
return ns[0] === '+' ? tail(ns) : ns;
|
||||
};
|
||||
|
||||
|
||||
// SUM T0 100 ------------------------------------------------------------
|
||||
|
||||
// universe :: [[Sign]]
|
||||
const universe = permutationsWithRepetition(9, [0, 1, -1])
|
||||
.filter(x => x[0] !== 1);
|
||||
|
||||
// allNonNegativeSums :: [Int]
|
||||
const allNonNegativeSums = universe.map(asSum)
|
||||
.filter(x => x >= 0)
|
||||
.sort();
|
||||
|
||||
// uniqueNonNegativeSums :: [Int]
|
||||
const uniqueNonNegativeSums = nub(allNonNegativeSums);
|
||||
|
||||
|
||||
return [
|
||||
"Sums to 100:\n",
|
||||
unlines(universe.filter(x => asSum(x) === 100)
|
||||
.map(asString)),
|
||||
|
||||
"\n\n10 commonest sums (sum, followed by number of routes to it):\n",
|
||||
show(take(10, group(allNonNegativeSums)
|
||||
.sort(on(flip(compare), length))
|
||||
.map(xs => [xs[0], xs.length]))),
|
||||
|
||||
"\n\nFirst positive integer not expressible as a sum of this kind:\n",
|
||||
show(find(
|
||||
(x, i) => x !== i,
|
||||
uniqueNonNegativeSums.sort(compare)
|
||||
) - 1), // i is the the zero-based Array index.
|
||||
|
||||
"\n10 largest sums:\n",
|
||||
show(take(10, uniqueNonNegativeSums.sort(flip(compare))))
|
||||
].join('\n') + '\n';
|
||||
})();
|
||||
122
Task/Sum-to-100/JavaScript/sum-to-100-3.js
Normal file
122
Task/Sum-to-100/JavaScript/sum-to-100-3.js
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
SumTo100();
|
||||
|
||||
function SumTo100()
|
||||
{
|
||||
var
|
||||
ADD = 0,
|
||||
SUB = 1,
|
||||
JOIN = 2;
|
||||
|
||||
var
|
||||
nexpr = 13122;
|
||||
|
||||
function out(something)
|
||||
{
|
||||
WScript.Echo(something);
|
||||
}
|
||||
|
||||
function evaluate(code)
|
||||
{
|
||||
var
|
||||
value = 0,
|
||||
number = 0,
|
||||
power = 1;
|
||||
|
||||
for ( var k = 9; k >= 1; k-- )
|
||||
{
|
||||
number = power*k + number;
|
||||
switch( code % 3 )
|
||||
{
|
||||
case ADD: value = value + number; number = 0; power = 1; break;
|
||||
case SUB: value = value - number; number = 0; power = 1; break;
|
||||
case JOIN: power = power * 10 ; break;
|
||||
}
|
||||
code = Math.floor(code/3);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function print(code)
|
||||
{
|
||||
var
|
||||
s = "";
|
||||
var
|
||||
a = 19683,
|
||||
b = 6561;
|
||||
|
||||
for ( var k = 1; k <= 9; k++ )
|
||||
{
|
||||
switch( Math.floor( (code % a) / b ) ){
|
||||
case ADD: if ( k > 1 ) s = s + '+'; break;
|
||||
case SUB: s = s + '-'; break;
|
||||
}
|
||||
a = b;
|
||||
b = Math.floor(b/3);
|
||||
s = s + String.fromCharCode(0x30+k);
|
||||
}
|
||||
out(evaluate(code) + " = " + s);
|
||||
}
|
||||
|
||||
function comment(commentString)
|
||||
{
|
||||
out("");
|
||||
out(commentString);
|
||||
out("");
|
||||
}
|
||||
|
||||
comment("Show all solutions that sum to 100");
|
||||
for ( var i = 0; i < nexpr; i++)
|
||||
if ( evaluate(i) == 100 )
|
||||
print(i);
|
||||
|
||||
comment("Show the sum that has the maximum number of solutions");
|
||||
var stat = {};
|
||||
for ( var i = 0; i < nexpr; i++ )
|
||||
{
|
||||
var sum = evaluate(i);
|
||||
if (stat[sum])
|
||||
stat[sum]++;
|
||||
else
|
||||
stat[sum] = 1;
|
||||
}
|
||||
|
||||
var best = 0;
|
||||
var nbest = -1;
|
||||
for ( var i = 0; i < nexpr; i++ )
|
||||
{
|
||||
var sum = evaluate(i);
|
||||
if ( sum > 0 )
|
||||
if ( stat[sum] > nbest )
|
||||
{
|
||||
best = i;
|
||||
nbest = stat[sum];
|
||||
}
|
||||
}
|
||||
out("" + evaluate(best) + " has " + nbest + " solutions");
|
||||
|
||||
comment("Show the lowest positive number that can't be expressed");
|
||||
for ( var i = 0; i <= 123456789; i++ )
|
||||
{
|
||||
for ( var j = 0; j < nexpr; j++)
|
||||
if ( i == evaluate(j) ) break;
|
||||
if ( i != evaluate(j) ) break;
|
||||
}
|
||||
out(i);
|
||||
|
||||
comment("Show the ten highest numbers that can be expressed");
|
||||
var limit = 123456789 + 1;
|
||||
for ( i = 1; i <= 10; i++ )
|
||||
{
|
||||
var best = 0;
|
||||
for ( var j = 0; j < nexpr; j++)
|
||||
{
|
||||
var test = evaluate(j);
|
||||
if ( test < limit && test > best )
|
||||
best = test;
|
||||
}
|
||||
for ( var j = 0; j < nexpr; j++)
|
||||
if ( evaluate(j) == best ) print(j);
|
||||
limit = best;
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue