Knapsack variant in JavaScript - javascript
I have tried to implement this knapsack problem solution algorithm in JavaScript, but the solutions s_opt I get has a total weight greater than the L_max.
What am I doing wrong?
I suspect it could be something related to Closures in recursion.
/*
GENERAL:
Assume we have a knapsack and we want to bring as much stuff as possible.
Of each thing we have several variants to choose from. Each of these variants have
different value and takes different amount of space.
DEFINITIONS:
L_max = integer, size of the knapsack for the entire problem having N items
l = matrix, having the elements l[i-1][j-1] representing the space taken
by variant j of item i (-1 since indexing the matrices has index starting on zero, i.e. item i is stored at position i-1)
p = matrix, having the elements p[i-1][j-1] representing the value given by
by variant j of item i
n = total number of items (used in a sub-problem)
N = total number of items (used in the full problem, N >= n)
s_opt = vector having the optimal combination of variant selections s_i, i.e. s_opt = arg max p_sum
*/
function knapsack(L_max,l,p) {
// constructing (initializing) - they are private members
var self = this; // in order for private functions to be able read variables
this.N = l.length;
var DCached = []; // this is only used by a private function so it doesnt need to made public using this.*
this.s_opt = [];
this.p_mean = null;
this.L_max = L_max;
// define public optimization function for the entire problem
// when this is completed the user can read
// s_opt to get the solution and
// p_mean to know the quality of the solution
this.optimize = function() {
self.p_mean = D(self.N,self.L_max) / Math.max(1,self.N);
}
// define private sub-problem optimization function
var D = function(n,r) {
if (r<0)
return -Infinity;
if (n==0)
return 0;
if(DCached[n-1] != null) {
if(DCached[n-1][r-1] != null) {
return DCached[n-1][r-1];
}
}
var p_max = -Infinity;
var p_sum;
var J = l[n-1].length;
for(var j = 0; j < J; j++) {
p_sum = p[n-1][j] + D( n-1 , r - l[n-1][j] );
if(p_sum>p_max) {
p_max = p_sum;
self.s_opt[n-1] = j;
}
}
DCached[n-1] = [];
DCached[n-1][r-1] = p_max;
return p_max;
}
}
The client using this knapsack solver does the following:
var knapsackSolution = new knapsack(5,l,p);
knapsackSolution.optimize();
// now the client can access knapsackSolution.s_opt containing the solution.
I found a solution. When solving a sub-problem D(n,r) the code in the question returned the optimized value, but it didn't really manage the array s_opt in a proper way. In the modified solution, pasted below, I fixed this. Instead of only returning the optimized value of the knapsack also an array of chosen variants (e.g. the arg of the max) are returned. The cache is also modified to manage these two parts of the solution (both max value and arg max value).
The code below also contains an additional feature addition. The user can now also pass a value maxComputingComplexity controlling the computational size of the problem in some kind of heuristic manner.
/*
GENERAL:
Assume we have a knapsack and we want to bring as much stuff as possible.
Of each thing we have several variants to choose from. Each of these variants have
different value and takes different amount of space.
The quantity of each variant is one.
DEFINITIONS:
L_max = integer, size of the knapsack, e.g. max number of letters, for the entire problem having N items
l = matrix, having the elements l[i-1][j-1] representing the space taken
by variant j of item i (-1 since indexing the matrices has index starting on zero, i.e. item i is stored at position i-1)
p = matrix, having the elements p[i-1][j-1] representing the value given by
by variant j of item i
maxComputingComplexity = value limiting the product L_max*self.N*M_max in order to make the optimization
complete in limited amount of time. It has a serious implication, since it may cut the list of alternatives
so that only the first alternatives are used in the computation, meaning that the input should be well
ordered
n = total number of items (used in a sub-problem)
N = total number of items (used in the full problem, N >= n)
M_i = number of variants of item i
s_i = which variant is chosen to pack of item i
s = vector of elements s_i representing a possible solution
r = maximum total space in the knapsack, i.e. sum(l[i][s_i]) <= r
p_sum = sum of the values of the selected variants, i.e. sum(p[i][s_i]
s_opt = vector having the optimal combination of variant selections s_i, i.e. s_opt = arg max p_sum
In order to solve this, let us see p_sum as a function
D(n,r) = p_sum (just seeing it as a function of the sub-problem n combined with the maximum total space r)
RESULT:
*/
function knapsack(L_max,l,p,maxComputingComplexity) {
// constructing (initializing) - they are private members
var self = this; // in order for private functions to be able read variables
this.N = l.length;
var DCached = []; // this is only used by a private function so it doesnt need to made public using this.*
//this.s_opt = [];
//this.p_mean = null;
this.L_max = L_max;
this.maxComputingComplexity = maxComputingComplexity;
//console.log("knapsack: Creating knapsack. N=" + N + ". L_max=" + L_max + ".");
// object to store the solution (both big problem and sub-problems)
function result(p_max,s_opt) {
this.p_max = p_max; //max value
this.s_opt = s_opt; //arg max value
}
// define public optimization function for the entire problem
// when this is completed the user can read
// s_opt to get the solution and
// p_mean to know the quality of the solution
// computing complexity O(L_max*self.N*M_max),
// think O=L_max*N*M_max => M_max=O/L_max/N => 3=x/140/20 => x=3*140*20 => x=8400
this.optimize = function() {
var M_max = Math.max(maxComputingComplexity / (L_max*self.N),2); //totally useless if not at least two
console.log("optimize: Setting M_max =" + M_max);
return D(self.N,self.L_max,M_max);
//self.p_mean = mainResult.D / Math.max(1,self.N);
// console.log...
}
// Define private sub-problem optimization function.
// The function reads to "global" variables, p and l
// and as arguments it takes
// n delimiting the which sub-set of items to be able to include (from p and l)
// r setting the max space that this sub-set of items may take
// Based on these arguments the function optimizes D
// and returns
// D the max value that can be obtained by combining the things
// s_opt the selection (array of length n) of things optimizing D
var D = function(n,r,M_max) {
// Start by checking whether the value is already cached...
if(DCached[n-1] != null) {
if(DCached[n-1][r-1] != null) {
//console.log("knapsack.D: n=" + n + " r=" + r + " returning from cache.");
return DCached[n-1][r-1];
}
}
var D_result = new result(-Infinity, []); // here we will manage the result
//D_result.s_opt[n-1] = 0; // just put something there to start with
if (r<0) {
//D_result.p_max = -Infinity;
return D_result;
}
if (n==0) {
D_result.p_max = 0;
return D_result;
}
var p_sum;
//self.s_opt[n] = 0; not needed
var J = Math.min(l[n-1].length,M_max);
var D_minusOneResult; //storing the result when optimizing all previous items given a max length
for(var j = 0; j < J; j++) {
D_minusOneResult = D( n-1 , r - l[n-1][j] , M_max)
p_sum = p[n-1][j] + D_minusOneResult.p_max;
if(p_sum > D_result.p_max) {
D_result.p_max = p_sum;
D_result.s_opt = D_minusOneResult.s_opt;
D_result.s_opt[n-1] = j;
}
}
DCached[n-1] = [];
DCached[n-1][r-1] = D_result;
//console.log("knapsack.D: n=" + n + " r=" + r + " p_max= "+ p_max);
return D_result;
}
}
Related
General reduceInitial function crossfilter
I'm building a dc.js / d3.js dashboard in which I often have to make crossfilter groups containing a quantity for each key and a percentage of the total value for each key. That is why I want to make generic reduceAdd, reduceRemove and reduceInitial functions. I managed doing the first 2, but I don't understand reduceInitial behaviour : function reduceAdd(dim,grouping,col) { var keys = getKeys(dim); // get the keys name in an array of string return function(p,v) { p.total += parseInt(v[col]); // get the running total for (var i = 0; i < keys.length; i++) { if(v[grouping] == keys[i]) {p[keys[i]] += +v[col];} p[keys[i]+"perc"] = p[keys[i]]/p.total; // calculate a percentage for ech key } return p; } } function reduceRemove(dim,grouping,col) { var keys = getKeys(dim); return function(p,v) { p.total -= parseInt(v[col]); for (var i = 0; i < keys.length; i++) { if(v[grouping] == keys[i]) {p[keys[i]] -= +v[col];} p[keys[i]+"perc"] = p[keys[i]]/p.total; } return p; } } This is the working non generic function reduceInitFC() { return {total:0, LILOU:0, MARIUS:0,ORIANE:0,LILOUperc:0,MARIUSperc:0,ORIANEperc:0}; } This is what I tried : function reduceInit(dim) { var keys = getKeys(dim); var initArray= {}; initArray["total"] = 0; for (var i = 0; i < keys.length; i++) { initArray[keys[i]] = 0; initArray[keys[i]+"perc"] = 0; } console.log(initArray); // (1) console.log({total:0, LILOU:0, MARIUS:0,ORIANE:0,LILOUperc:0,MARIUSperc:0,ORIANEperc:0}); return function() { return initArray; } } The result is : (1) The output gives 0 for all the keys every two iterations and some non zero values for the other iterations When I use this function the resulting values in the group are constant respect with the keys what is not the case in reality and not the case when I hand write the zero values. If anyone can help, it would be super kind and useful. Best, Theo
I think your reduceInit looks fine, but I don't think this is possible through the reduce. The reduce calculates totals incrementally -- and don't make sense until the group runs through all the rows in the dimension. So the percentages for each key can't be calculated until reduce is finished. (Likewise, while the reduce can be used to calculate averages across a single key's values, they can't be used for averages across all keys because that would be dependent on the reduced total.) (UPDATED, also see this answer's comments) But since you already have the reduced total and the total for the key / category, you can calculate the percentage in your chart's valueAccessor. function valueAccessor(d){ return d.value[keyName] / d.value.total }
Codility Peak JavaScript Implementation
I am working on the Codility Peak problem: Divide an array into the maximum number of same-sized blocks, each of which should contain an index P such that A[P - 1] < A[P] > A[P + 1]. My own solution is provided below, but it only scores 45%. So my question is: How can I still improve my solution? The code snippet seems to be long, since I added some extra comments to make myself clearer: function solution(A) { var storage = [], counter = 0; // 1. So first I used a loop to find all the peaks // and stored them all into an array called storage for(var i = 1; i < A.length - 1; i++) { if (A[i] > A[i-1] && A[i] > A[i+1]) { storage.push(i); } } // 2. Go and write the function canBeSeparatedInto // 3. Use the for loop to check the counter for(var j = 1; j < A.length; j++) { if (canBeSeparatedInto(j, A, storage)) { counter = j; } } return counter; } /* this function tells if it is possible to divide the given array into given parts * we will be passing our function with parameters: * #param parts[number]: number of parts that we intend to divide the array into * #param array[array]: the original array * #param peaks[array]: an storage array that store all the index of the peaks * #return [boolean]: true if the given array can be divided into given parts */ function canBeSeparatedInto(parts, array, peaks) { var i = 1, result = false; var blockSize = array.length / parts; peaks.forEach(function(elem) { // test to see if there is an element in the array belongs to the ith part if ((elem+1)/blockSize <= i && (elem+1)/blockSize> i-1) { i++; } }); // set the result to true if there are indeed peaks for every parts if (i > parts) { result = true; } return result; } The main problem with my code is that it does not pass the performance test. Could you give me some hint on that?
I would suggest this algorithm: Sort the peeks by the distance they have with their predecessor. To do that, it might be more intuitive to identify "valleys", i.e. maximised ranges without peeks, and sort those by their size in descending order Identify the divisors of the array length, as the solution must be one of those. For example, it is a waste of time to test for solutions when the array length is prime: in that case the answer can only be 1 (or zero if it has no peeks). Try each of the divisors in ascending order (representing the size of array chunks), and see if for each valley such a split would bring one of the chunks completely inside that valley, i.e. it would not contain a peek: in that case reject that size as a solution, and try the next size. Implementation with interactive input of the array: "use strict"; // Helper function to collect the integer divisors of a given n function divisors(n) { var factors = [], factors2 = [], sq = Math.sqrt(n); for (var i = 1; i <= sq; i++) { if (n % i === 0) { factors.push(n / i); // Save time by storing complementary factor as well factors2.push(i); } } // Eliminate possible duplicate when n is a square if (factors[factors.length-1] === factors2[factors2.length-1]) factors.pop(); // Return them sorted in descending order, so smallest is at end return factors.concat(factors2.reverse()); } function solution(A) { var valleys = [], start = 0, size, sizes, i; // Collect the maximum ranges that have no peeks for (i = 1; i < A.length - 1; i++) { if (A[i] > A[i-1] && A[i] > A[i+1]) { valleys.push({ start, end: i, size: i - start, }); start = i + 1; } } // Add final valley valleys.push({ start, end: A.length, size: A.length - start }); if (valleys.length === 1) return 0; // no peeks = no solution // Sort the valleys by descending size // to improve the rest of the algorithm's performance valleys.sort( (a, b) => b.size - a.size ); // Collect factors of n, as all chunks must have same, integer size sizes = divisors(A.length) // For each valley, require that a solution must not // generate a chunk that falls completely inside it do { size = sizes.pop(); // attempted solution (starting with small size) for (i = 0; i < valleys.length && // chunk must not fit entirely inside this valley Math.ceil(valleys[i].start / size) * size + size > valleys[i].end; i++) { } } while (i < valleys.length); // keep going until all valleys pass the test // Return the number of chunks return A.length / size; } // Helper function: chops up a given array into an // array of sub arrays, which all have given size, // except maybe last one, which could be smaller. function chunk(arr, size) { var chunks = []; for (var i = 0; i < arr.length; i += size) { chunks.push(arr.slice(i, i + size)); } return chunks; } // I/O management inp.oninput = function () { // Get input as an array of positive integers (ignore non-digits) if (!this.value) return; var arr = this.value.match(/\d+/g).map(v => +v); var parts = solution(arr); // Output the array, chopped up into its parts: outCount.textContent = parts; outChunks.textContent = chunk(arr, arr.length / parts).join('\n'); } Array (positive integers, any separator): <input id="inp" style="width:100%"> Chunks: <span id="outCount"></span> <pre id="outChunks"></pre>
When checking whether array can be splitted into K parts, you will in worst case (array of [1,2,1,2,1,...]) do N/2 checks (since you are looking at every peak). This can be done in K steps, by using clever datastructures: Represent peaks as an binary array (0 - no peak, 1 - peak). Calculate prefix sums over that. If you want to check if block contains a peak, just compare prefix sums at the start and end of the block. And also you have small other problem there. You should not check number of block which does not divide the size of the array.
Pick m integers randomly from an array of size n in JS
Problem (from Cracking the Coding Interview): Write a method to randomly generate a set of m integers from an array of size n. Each element must have equal probability of being chosen. I'm implementing my answer in JS. For the recursive function, the code sometimes returns undefined as one of the elements in the array. My JS Code var pickMRecursively = function(A, m, i) { if (i === undefined) return pickMRecursively(A, m, A.length); if (i+1 === m) return A.slice(0, m); if (i + m > m) { var subset = pickMRecursively(A, m, i-1); var k = rand(0, i); if (k < m) subset[k] = A[i]; return subset; } return null; }; Given Java Solution int[] pickMRecursively(int[] original, int m,int i) { if (i +1==m){// Basecase /* return first m elements of original */ } elseif(i+m>m){ int[] subset = pickMRecursively(original, m, i - 1); int k = random value between 0 and i, inclusive if(k<m){ subset[k] = original[i]j } return subset; } return null; }
I hate these questions because sometime they're often deliberately vague - I'd ask "What type of data is in the array?". But if this is actually a question about randomly re-ordering an array, then in JavaScript, given that arr is an array of numbers, of which some/all might not be integers... function generateM(arr) { var hold = []; var m = []; var n = arr.length; var grab; // clone arr >> hold while(n--) { hold[n] = arr[n]; } n = hold.length; // select randomly from hold while(n--) { grab = hold.splice(Math.floor(Math.random()*n),1)[0]; // ensure integers m.push(Math.round(grab)); } return m; } The array arr is cloned here to cover scoping issues and to produce a fresh collection, not reorder an existing one. ADDIT: Alternatively, if this is just asking for a set of m.length random integers generated from an array of n.length, then it doesn't matter what the content of the array actually is and the range of possible (randomly generated) values will be (could be?) 0 - n.length, so... function generateM(arr, M) { var aLen = arr.length; var m = []; do { m.push(Math.round(Math.random() * aLen)); } while(M--); return m; } ...but that seems like a stupid, pointless challenge. The data in the 'array of size n' is quite important here it seems to me.
Efficiently find every combination of assigning smaller bins to larger bins
Let's say I have 7 small bins, each bin has the following number of marbles in it: var smallBins = [1, 5, 10, 20, 30, 4, 10]; I assign these small bins to 2 large bins, each with the following maximum capacity: var largeBins = [40, 50]; I want to find EVERY combination of how the small bins can be distributed across the big bins without exceeding capacity (eg put small bins #4,#5 in large bin #2, the rest in #1). Constraints: Each small bin must be assigned to a large bin. A large bin can be left empty This problem is easy to solve in O(n^m) O(2^n) time (see below): just try every combination and if capacity is not exceeded, save the solution. I'd like something faster, that can handle a variable number of bins. What obscure graph theory algorithm can I use to reduce the search space? //Brute force var smallBins = [1, 5, 10, 20, 30, 4, 10]; var largeBins = [40, 50]; function getLegitCombos(smallBins, largeBins) { var legitCombos = []; var assignmentArr = new Uint32Array(smallBins.length); var i = smallBins.length-1; while (true) { var isValid = validate(assignmentArr, smallBins, largeBins); if (isValid) legitCombos.push(new Uint32Array(assignmentArr)); var allDone = increment(assignmentArr, largeBins.length,i); if (allDone === true) break; } return legitCombos; } function increment(assignmentArr, max, i) { while (i >= 0) { if (++assignmentArr[i] >= max) { assignmentArr[i] = 0; i--; } else { return i; } } return true; } function validate(assignmentArr, smallBins, largeBins) { var totals = new Uint32Array(largeBins.length); for (var i = 0; i < smallBins.length; i++) { var assignedBin = assignmentArr[i]; totals[assignedBin] += smallBins[i]; if (totals[assignedBin] > largeBins[assignedBin]) { return false; } } return true; } getLegitCombos(smallBins, largeBins);
Here's my cumbersome recursive attempt to avoid duplicates and exit early from too large sums. The function assumes duplicate elements as well as bin sizes are presented grouped and counted in the input. Rather than place each element in each bin, each element is placed in only one of duplicate bins; and each element with duplicates is partitioned distinctly. For example, in my results, the combination, [[[1,10,20]],[[4,5,10,30]]] appears once; while in the SAS example in Leo's answer, twice: once as IN[1]={1,3,4} IN[2]={2,5,6,7} and again as IN[1]={1,4,7} IN[2]={2,3,5,6}. Can't vouch for efficiency or smooth-running, however, as it is hardly tested. Perhaps stacking the calls rather than recursing could weigh lighter on the browser. JavaScript code: function f (as,bs){ // i is the current element index, c its count; // l is the lower-bound index of partitioned element function _f(i,c,l,sums,res){ for (var j=l; j<sums.length; j++){ // find next available duplicate bin to place the element in var k=0; while (sums[j][k] + as[i][0] > bs[j][0]){ k++; } // a place for the element was found if (sums[j][k] !== undefined){ var temp = JSON.stringify(sums), _sums = JSON.parse(temp); _sums[j][k] += as[i][0]; temp = JSON.stringify(res); var _res = JSON.parse(temp); _res[j][k].push(as[i][0]); // all elements were placed if (i == as.length - 1 && c == 1){ result.push(_res); return; // duplicate elements were partitioned, continue to next element } else if (c == 1){ _f(i + 1,as[i + 1][1],0,_sums,_res); // otherwise, continue partitioning the same element with duplicates } else { _f(i,c - 1,j,_sums,_res); } } } } // initiate variables for the recursion var sums = [], res = [] result = []; for (var i=0; i<bs.length; i++){ sums[i] = []; res[i] = []; for (var j=0; j<bs[i][1]; j++){ sums[i][j] = 0; res[i][j] = []; } } _f(0,as[0][1],0,sums,res); return result; } Output: console.log(JSON.stringify(f([[1,1],[4,1],[5,1],[10,2],[20,1],[30,1]], [[40,1],[50,1]]))); /* [[[[1,4,5,10,10]],[[20,30]]],[[[1,4,5,10,20]],[[10,30]]],[[[1,4,5,20]],[[10,10,30]]] ,[[[1,4,5,30]],[[10,10,20]]],[[[1,4,10,20]],[[5,10,30]]],[[[1,4,30]],[[5,10,10,20]]] ,[[[1,5,10,20]],[[4,10,30]]],[[[1,5,30]],[[4,10,10,20]]],[[[1,10,20]],[[4,5,10,30]]] ,[[[1,30]],[[4,5,10,10,20]]],[[[4,5,10,20]],[[1,10,30]]],[[[4,5,30]],[[1,10,10,20]]] ,[[[4,10,20]],[[1,5,10,30]]],[[[4,30]],[[1,5,10,10,20]]],[[[5,10,20]],[[1,4,10,30]]] ,[[[5,30]],[[1,4,10,10,20]]],[[[10,10,20]],[[1,4,5,30]]],[[[10,20]],[[1,4,5,10,30]]] ,[[[10,30]],[[1,4,5,10,20]]],[[[30]],[[1,4,5,10,10,20]]]] */ console.log(JSON.stringify(f([[1,1],[4,1],[5,1],[10,2],[20,1],[30,1]], [[20,2],[50,1]]))); /* [[[[1,4,5,10],[10]],[[20,30]]],[[[1,4,5,10],[20]],[[10,30]]],[[[1,4,5],[20]],[[10,10,30]]] ,[[[1,4,10],[20]],[[5,10,30]]],[[[1,5,10],[20]],[[4,10,30]]],[[[1,10],[20]],[[4,5,10,30]]] ,[[[4,5,10],[20]],[[1,10,30]]],[[[4,10],[20]],[[1,5,10,30]]],[[[5,10],[20]],[[1,4,10,30]]] ,[[[10,10],[20]],[[1,4,5,30]]],[[[10],[20]],[[1,4,5,10,30]]]] */ Here's a second, simpler version that only attempts to terminate the thread when an element cannot be placed: function f (as,bs){ var stack = [], sums = [], res = [] result = []; for (var i=0; i<bs.length; i++){ res[i] = []; sums[i] = 0; } stack.push([0,sums,res]); while (stack[0] !== undefined){ var params = stack.pop(), i = params[0], sums = params[1], res = params[2]; for (var j=0; j<sums.length; j++){ if (sums[j] + as[i] <= bs[j]){ var _sums = sums.slice(); _sums[j] += as[i]; var temp = JSON.stringify(res); var _res = JSON.parse(temp); _res[j].push(i); if (i == as.length - 1){ result.push(_res); } else { stack.push([i + 1,_sums,_res]); } } } } return result; } Output: var r = f([1,5,10,20,30,4,10,3,4,5,1,1,2],[40,50,30]); console.log(r.length) console.log(JSON.stringify(f([1,4,5,10,10,20,30], [40,50]))); 162137 [[[30],[1,4,5,10,10,20]],[[10,30],[1,4,5,10,20]],[[10,20],[1,4,5,10,30]] ,[[10,30],[1,4,5,10,20]],[[10,20],[1,4,5,10,30]],[[10,10,20],[1,4,5,30]] ,[[5,30],[1,4,10,10,20]],[[5,10,20],[1,4,10,30]],[[5,10,20],[1,4,10,30]] ,[[4,30],[1,5,10,10,20]],[[4,10,20],[1,5,10,30]],[[4,10,20],[1,5,10,30]] ,[[4,5,30],[1,10,10,20]],[[4,5,10,20],[1,10,30]],[[4,5,10,20],[1,10,30]] ,[[1,30],[4,5,10,10,20]],[[1,10,20],[4,5,10,30]],[[1,10,20],[4,5,10,30]] ,[[1,5,30],[4,10,10,20]],[[1,5,10,20],[4,10,30]],[[1,5,10,20],[4,10,30]] ,[[1,4,30],[5,10,10,20]],[[1,4,10,20],[5,10,30]],[[1,4,10,20],[5,10,30]] ,[[1,4,5,30],[10,10,20]],[[1,4,5,20],[10,10,30]],[[1,4,5,10,20],[10,30]] ,[[1,4,5,10,20],[10,30]],[[1,4,5,10,10],[20,30]]]
This problem is seen often enough that most Constraint Logic Programming systems include a predicate to model it explicitly. In OPTMODEL and CLP, we call it pack: proc optmodel; set SMALL init 1 .. 7, LARGE init 1 .. 2; num size {SMALL} init [1 5 10 20 30 4 10]; num capacity{LARGE} init [40 50]; var WhichBin {i in SMALL} integer >= 1 <= card(LARGE); var SpaceUsed{i in LARGE} integer >= 0 <= capacity[i]; con pack( WhichBin, size, SpaceUsed ); solve with clp / findall; num soli; set IN{li in LARGE} = {si in SMALL: WhichBin[si].sol[soli] = li}; do soli = 1 .. _nsol_; put IN[*]=; end; quit; This code produces all the solutions in 0.06 seconds on my laptop: IN[1]={1,2,3,4,6} IN[2]={5,7} IN[1]={1,2,3,4} IN[2]={5,6,7} IN[1]={1,2,3,6,7} IN[2]={4,5} IN[1]={1,2,5,6} IN[2]={3,4,7} IN[1]={1,2,5} IN[2]={3,4,6,7} IN[1]={1,2,4,6,7} IN[2]={3,5} IN[1]={1,2,4,7} IN[2]={3,5,6} IN[1]={1,2,4,6} IN[2]={3,5,7} IN[1]={1,3,4,6} IN[2]={2,5,7} IN[1]={1,3,4} IN[2]={2,5,6,7} IN[1]={1,5,6} IN[2]={2,3,4,7} IN[1]={1,5} IN[2]={2,3,4,6,7} IN[1]={1,4,6,7} IN[2]={2,3,5} IN[1]={1,4,7} IN[2]={2,3,5,6} IN[1]={2,3,4,6} IN[2]={1,5,7} IN[1]={2,3,4} IN[2]={1,5,6,7} IN[1]={2,5,6} IN[2]={1,3,4,7} IN[1]={2,5} IN[2]={1,3,4,6,7} IN[1]={2,4,6,7} IN[2]={1,3,5} IN[1]={2,4,7} IN[2]={1,3,5,6} IN[1]={3,5} IN[2]={1,2,4,6,7} IN[1]={3,4,7} IN[2]={1,2,5,6} IN[1]={3,4,6} IN[2]={1,2,5,7} IN[1]={3,4} IN[2]={1,2,5,6,7} IN[1]={5,7} IN[2]={1,2,3,4,6} IN[1]={5,6} IN[2]={1,2,3,4,7} IN[1]={5} IN[2]={1,2,3,4,6,7} IN[1]={4,6,7} IN[2]={1,2,3,5} IN[1]={4,7} IN[2]={1,2,3,5,6} Just change the first 3 lines to solve for other instances. However, as others have pointed out, this problem is NP-Hard. So it can switch from very fast to very slow suddenly. You could also solve the version where not every small item needs to be assigned to a large bin by creating a dummy large bin with enough capacity to fit the entire collection of small items. As you can see from the "Details" section in the manual, the algorithms that solve practical problems quickly are not simple, and their implementation details make a big difference. I am unaware of any CLP libraries written in Javascript. Your best bet may be to wrap CLP in a web service and invoke that service from your Javascript code.
math random number without repeating a previous number
Can't seem to find an answer to this, say I have this: setInterval(function() { m = Math.floor(Math.random()*7); $('.foo:nth-of-type('+m+')').fadeIn(300); }, 300); How do I make it so that random number doesn't repeat itself. For example if the random number is 2, I don't want 2 to come out again.
There are a number of ways you could achieve this. Solution A: If the range of numbers isn't large (let's say less than 10), you could just keep track of the numbers you've already generated. Then if you generate a duplicate, discard it and generate another number. Solution B: Pre-generate the random numbers, store them into an array and then go through the array. You could accomplish this by taking the numbers 1,2,...,n and then shuffle them. shuffle = function(o) { for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x); return o; }; var randorder = shuffle([0,1,2,3,4,5,6]); var index = 0; setInterval(function() { $('.foo:nth-of-type('+(randorder[index++])+')').fadeIn(300); }, 300); Solution C: Keep track of the numbers available in an array. Randomly pick a number. Remove number from said array. var randnums = [0,1,2,3,4,5,6]; setInterval(function() { var m = Math.floor(Math.random()*randnums.length); $('.foo:nth-of-type('+(randnums[m])+')').fadeIn(300); randnums = randnums.splice(m,1); }, 300);
You seem to want a non-repeating random number from 0 to 6, so similar to tskuzzy's answer: var getRand = (function() { var nums = [0,1,2,3,4,5,6]; var current = []; function rand(n) { return (Math.random() * n)|0; } return function() { if (!current.length) current = nums.slice(); return current.splice(rand(current.length), 1); } }()); It will return the numbers 0 to 6 in random order. When each has been drawn once, it will start again.
could you try that, setInterval(function() { m = Math.floor(Math.random()*7); $('.foo:nth-of-type(' + m + ')').fadeIn(300); }, 300);
I like Neal's answer although this is begging for some recursion. Here it is in java, you'll still get the general idea. Note that you'll hit an infinite loop if you pull out more numbers than MAX, I could have fixed that but left it as is for clarity. edit: saw neal added a while loop so that works great. public class RandCheck { private List<Integer> numbers; private Random rand; private int MAX = 100; public RandCheck(){ numbers = new ArrayList<Integer>(); rand = new Random(); } public int getRandomNum(){ return getRandomNumRecursive(getRand()); } private int getRandomNumRecursive(int num){ if(numbers.contains(num)){ return getRandomNumRecursive(getRand()); } else { return num; } } private int getRand(){ return rand.nextInt(MAX); } public static void main(String[] args){ RandCheck randCheck = new RandCheck(); for(int i = 0; i < 100; i++){ System.out.println(randCheck.getRandomNum()); } } }
Generally my approach is to make an array containing all of the possible values and to: Pick a random number <= the size of the array Remove the chosen element from the array Repeat steps 1-2 until the array is empty The resulting set of numbers will contain all of your indices without repetition. Even better, maybe something like this: var numArray = [0,1,2,3,4,5,6]; numArray.shuffle(); Then just go through the items because shuffle will have randomized them and pop them off one at a time.
Here's a simple fix, if a little rudimentary: if(nextNum == lastNum){ if (nextNum == 0){nextNum = 7;} else {nextNum = nextNum-1;} } If the next number is the same as the last simply minus 1 unless the number is 0 (zero) and set it to any other number within your set (I chose 7, the highest index). I used this method within the cycle function because the only stipulation on selecting a number was that is musn't be the same as the last one. Not the most elegant or technically gifted solution, but it works :)
Use sets. They were introduced to the specification in ES6. A set is a data structure that represents a collection of unique values, so it cannot include any duplicate values. I needed 6 random, non-repeatable numbers ranging from 1-49. I started with creating a longer set with around 30 digits (if the values repeat the set will have less elements), converted the set to array and then sliced it's first 6 elements. Easy peasy. Set.length is by default undefined and it's useless that's why it's easier to convert it to an array if you need specific length. let randomSet = new Set(); for (let index = 0; index < 30; index++) { randomSet.add(Math.floor(Math.random() * 49) + 1) }; let randomSetToArray = Array.from(randomSet).slice(0,6); console.log(randomSet); console.log(randomSetToArray);
An easy way to generate a list of different numbers, no matter the size or number: function randomNumber(max) { return Math.floor(Math.random() * max + 1); } const list = [] while(list.length < 10 ){ let nbr = randomNumber(500) if(!list.find(el => el === nbr)) list.push(nbr) } console.log("list",list)
I would like to add-- var RecordKeeper = {}; SRandom = function () { currTimeStamp = new Date().getTime(); if (RecordKeeper.hasOwnProperty(currTimeStamp)) { RecordKeeper[currTimeStamp] = RecordKeeper[currTimeStamp] + 1; return currTimeStamp.toString() + RecordKeeper[currTimeStamp]; } else { RecordKeeper[currTimeStamp] = 1; return currTimeStamp.toString() + RecordKeeper[currTimeStamp]; } } This uses timestamp (every millisecond) to always generate a unique number.
you can do this. Have a public array of keys that you have used and check against them with this function: function in_array(needle, haystack) { for(var key in haystack) { if(needle === haystack[key]) { return true; } } return false; } (function from: javascript function inArray) So what you can do is: var done = []; setInterval(function() { var m = null; while(m == null || in_array(m, done)){ m = Math.floor(Math.random()*7); } done.push(m); $('.foo:nth-of-type('+m+')').fadeIn(300); }, 300); This code will get stuck after getting all seven numbers so you need to make sure it exists after it fins them all.