配列内の複数の値を追跡するカウンター

Question

これは複雑なので、できるだけ明確になるように最善を尽くしています。私が動的に探している特定の機能は、を費やしています。お金はギャンブルのゲームのためのチャートを獲得しました。

私は、ユーザーが賭けることができる種類の宝くじを持っています。これらは、オブジェクトや配列に入れることができ

：各6つの賞品を持っているユーザーが買うことができる6つの項目があります。

var prices = [5,10,28,50,56,280]。うち300のゲームのために -

var possibleWins = [40,80,250,400,500,2500]

は、私はあなたがお金を得る保証するために、ゲームごとにそれぞれ特定の項目に費やす必要がありますどのくらいのお金を計算、グラフを作成しようとしています。だからここ

チャートが始めるべきかの例である：

投資=最大可能賞金+

2行が想定されている（負である）費やされた合計最初の試合はすでに起こって失われています。等々。

アイデアは、最小のアイテムから始めて、勝利してもポジティブになることができなくなったら、あきらめることです。このため、行9ではのロックに切り替わります。 （私たちの投資は0であり、再び小枝を演奏すると最大40勝です。実際には5勝を失ってしまいます）

また、 1アイテムに勝つ;あなたはその特定のゲームのすべてのアイテムに勝ちます。だからあなたはすべての賞を組み合わせる。

私は今、数日間これに取り組んできましたし、これらの関連の質問のいくつかは、私の最初の試みを持っている（私は正直分からない）：

How to find the lowest possible combination of keys within an array

Counter that generates the lowest sum from a combination of indexes above the previous value

Add an arrays keys to themselves until exceeding a limit?

編集：ゲームごとに少なくとも1つのアイテムを購入する必要があり、ゲームをスキップすることはできません。

Answer 1

基本的にこの提案はゼロと価格で始まり、アイテムの組み合わせが見つかるまで1によって値をインクリメント次の項目

getItems = function() { 
     var price = 0, 
      array = lottery.map(function (a) { return a.price; }); 

     return function() { 
      var items; 
      do { 
       items = combine(array, price); 
       price++; 
      } while (!items.length) 
      return items; 
     } 
    }(), 

を取得する機能に依存しています。その後、配列itemsが返されます。この関数はジェネレータとして機能します。

他の重要な機能は、アイテムを所定の価格で組み合わせ、アイテムを使用して配列を取得しようとすることです。

function combine(array, sum) { 

    function c(left, right, sum) { 
     if (!sum) { 
      result = right; 
      return true; 
     } 
     return left.some(function (a, i, aa) { 
      return a <= sum && c(aa.slice(i + (a > sum - a)), right.concat(a), sum - a); 
     }); 
    } 

    var result = []; 
    c(array.sort(function (a, b) { return b - a; }), [], sum); 
    return result; 
} 

combine価格と与えられた価格をcombinatingに到達したかった合計の配列をとります。成功した場合は、項目を含む配列が返され、それ以外の場合は空の配列が返されます。

3番目の部分は、投資がマイナスでない限りアイテムを使用することです。その場合、新しいアイテムセットが取得されます。

function combine(array, sum) { 
 

 
    function c(left, right, sum) { 
 
     if (!sum) { 
 
      result = right; 
 
      return true; 
 
     } 
 
     return left.some(function (a, i, aa) { 
 
      return a <= sum && c(aa.slice(i + (a > sum - a)), right.concat(a), sum - a); 
 
     }); 
 
    } 
 

 
    var result = []; 
 
    c(array.sort(function (a, b) { return b - a; }), [], sum); 
 
    return result; 
 
} 
 

 
var lottery = [{ name: 'twig', price: 5, win: 40 }, { name: 'rock', price: 10, win: 80 }, { name: 'shell', price: 28, win: 250 }, { name: 'chip', price: 50, win: 400 }, { name: 'gold', price: 56, win: 500 }, { name: 'diamond', price: 280, win: 2500 }], 
 
    lotteryByPrice = lottery.reduce(function (r, a) { r[a.price] = a; return r; }, Object.create(null)), 
 
    getItems = function() { 
 
     var price = 0, 
 
      array = lottery.map(function (a) { return a.price; }); 
 

 
     return function() { 
 
      var temp; 
 
      do { 
 
       temp = combine(array, price); 
 
       price++; 
 
      } while (!temp.length) 
 
      return temp; 
 
     } 
 
    }(), 
 
    createTableRow = function (element) { 
 
     var table = document.createElement('table'), 
 
      tr = document.createElement('tr'); 
 

 
     ['Game', 'Items', 'Types', 'Spend Per Game', 'Total Spend', 'Max. Possible Winnigs', 'Investment'].forEach(function (a) { 
 
      var th = document.createElement('th'); 
 
      th.appendChild(document.createTextNode(a)); 
 
      tr.appendChild(th); 
 
     }); 
 
     table.appendChild(tr); 
 
     element.appendChild(table); 
 

 
     return function (row) { 
 
      var tr = document.createElement('tr'); 
 
      ['game', 'items', 'types', 'spend', 'total', 'potential', 'investment'].forEach(function (k) { 
 
       var td = document.createElement('td'); 
 
       td.appendChild(document.createTextNode(row[k])); 
 
       tr.appendChild(td); 
 
      }); 
 
      if (row.topBorder) { 
 
       tr.style.borderTop = '2px solid #666'; 
 
      } 
 
      table.appendChild(tr); 
 
     }; 
 
    }(document.body), 
 
    row = { game: null, items: null, types: null, spend: null, total: 0, potential: null, investment: null }, 
 
    i, 
 
    items = getItems(), 
 
    add = function (a, b) { return a + b; }, 
 
    winP = function (a) { return lotteryByPrice[a].win; }, 
 
    nameP = function (a) { return lotteryByPrice[a].name; }; 
 

 
for (i = 1; i <= 70; i++) { 
 
    row.topBorder = false; 
 
    while (row.total - items.reduce(add) + items.map(winP).reduce(add) < 0) { 
 
     items = getItems(); 
 
     row.topBorder = true; 
 
    } 
 
    row.game = i; 
 
    row.items = items.length; 
 
    row.types = items.map(nameP).join(' + '); 
 
    row.spend = -items.reduce(add); 
 
    row.total += row.spend; 
 
    row.potential = items.map(winP).reduce(add); 
 
    row.investment = row.potential + row.total; 
 
    createTableRow(row); 
 
}

table { border-collapse: collapse; font-family: Sans-Serif; } 
 
th { border: 1px solid #ccc; padding: 0 10px; } 
 
td { text-align: center; border: 1px solid #ccc; }

Answer 2

あなたは、プロパティ名がpossibleWinsの値を設定しているオブジェクトを作成することができます。各ラウンドに限度を投資する可能性のあるすべての組み合わせを設定します。配列には、その特定のラウンドの制限より小さい数の可能な組み合わせがすべて含まれていません。つまり、可能な限りすべての組み合わせで数値が分散されるわけではありません。例えば、40のラウンドでは、[10, 10, 10, 10, 0, 0, 0, 0]が配列として含まれています。配列は[10, 0, 10, 10, 0, 10, 0, 10]、または合計で40より小さいインデックスの他の組み合わせに並べ替えることもできます。

返されるオブジェクトの特定のラウンドに対応する配列に、そのラウンドのlimitより小さい可能性のある組み合わせの追加をプッシュします。

この実装は、肯定的な結果につながる各ラウンドの選択ルートを特定しようとしません。配列のセット全体は、各配列内の一致する各インデックス、ランダムなインデックスの組み合わせ、またはすべての可能なインデックスの組み合わせについて繰り返すことができます。

このアプローチは、可能な選択ができる基本テンプレートです。現在のラウンドより小さいプロパティ名の値を持つオブジェクトのプロパティの配列内の配列内の配列内の値を、配列の配列に追加することができます。期待される結果につながる選択肢の組み合わせを見つける。ここで

const [prices, possibleWins] = [ 
 
    [5, 10, 28, 50, 56, 280], 
 
    [40, 80, 250, 400, 500, 2500] 
 
]; 
 

 
const counteropts = (prices, possibleWins) => { 
 
    let rounds = {}; 
 
    for (let price of prices) { 
 
    let [chance, limit] = [[], possibleWins[prices.indexOf(price)]]; 
 
    for (let buyin = price - price; buyin <= limit; buyin += price) { 
 
     chance[chance.length] = buyin; 
 
    } 
 
    if (chance[chance.length - 1] !== limit) { 
 
     chance = [...chance, limit] 
 
    } 
 
    for (let odd of Array.of(chance)) { 
 
     let options = Array(); 
 
     for (let choice of odd) { 
 
     options[options.length] = [...odd.map(
 
      v => v !== choice && v + choice <= limit ? v + choice : 0 
 
     )]; 
 
     if (options.length === prices.length -1) { 
 
      for (let option of options[0]) { 
 
      let keys = options[0].map((_, index) => index + 1) 
 
         .filter(key => key * option <= limit); 
 
      let opt = Array(keys.length).fill(option); 
 
      options = [...options 
 
       , opt.length < options[0].length 
 
       ? [...opt, ...Array(options[0].length - opt.length).fill(0)] 
 
       : opt 
 
       ]; 
 
      } 
 
      rounds[limit] = [...options]; 
 
     } 
 
     } 
 
    } 
 
    } 
 
    return rounds 
 
    
 
} 
 

 
let opts = counteropts(prices, possibleWins); 
 
console.log(opts);

Answer 3

私の解決策は存在回答のいずれかの質問を解決するのですか？carbo0nshel1 @

let items = [{ 
 
    name: 'twig', 
 
    price: 5, 
 
    win: 40 
 
}, { 
 
    name: 'rock', 
 
    price: 10, 
 
    win: 80 
 
}, { 
 
    name: 'shell', 
 
    price: 28, 
 
    win: 250 
 
}, { 
 
    name: 'chip', 
 
    price: 50, 
 
    win: 400 
 
}, { 
 
    name: 'gold', 
 
    price: 56, 
 
    win: 500 
 
}, { 
 
    name: 'diamond', 
 
    price: 280, 
 
    win: 2500 
 
}]; 
 

 
let moves = []; 
 

 
Move.prototype.numberItems = function() { 
 
    let count = 0; 
 
    for (let n = 0; n < 6; n++) { 
 
    count += this.counts[n]; 
 
    } 
 
    return count; 
 
} 
 

 
Move.prototype.nameItems = function() { 
 
    let name = ''; 
 
    for (let n = 0; n < 6; n++) { 
 
    for (let x = 0; x < this.counts[n]; x++) { 
 
     if (name != '') { 
 
     name += ' - '; 
 
     } 
 
     name += items[n].name; 
 
    } 
 
    } 
 
    return name; 
 
} 
 

 

 
Move.prototype.getWin = function() { 
 
    let win = 0; 
 
    for (let n = 0; n < 6; n++) { 
 
    win += this.counts[n] * items[n].win; 
 
    } 
 
    return win; 
 
} 
 

 

 
function Move(cost, counts) { 
 
    this.cost = cost; 
 
    this.counts = counts.slice(); 
 
} 
 

 
function run() { 
 
    createMoves(100); 
 
    moves.sort(function(a, b) { 
 
    return (a.cost - b.cost); 
 
    }); 
 
    print(); 
 
} 
 

 
function createMoves(maxCost) { 
 
    let counts = []; 
 
    for (let n = 0; n < 6; n++) { 
 
    counts.push(0); 
 
    } 
 
    counts[0] ++; 
 
    while (true) { 
 
    let cost = whatCost(counts); 
 
    if (cost < maxCost) { 
 
     moves.push(new Move(cost, counts)); 
 
     counts[0] ++; 
 
     continue; 
 
    } 
 
    if (!escalate(counts)) { 
 
     break; 
 
    } 
 
    } 
 
} 
 

 
function whatCost(counts) { 
 
    let cost = 0; 
 
    for (let n = 0; n < 6; n++) { 
 
    cost += counts[n] * items[n].price; 
 
    } 
 
    return cost; 
 
} 
 

 
function escalate(counts) { 
 
    for (let n = 0; n < 5; n++) { 
 
    if (counts[n] != 0) { 
 
     counts[n] = 0; 
 
     counts[n + 1] ++; 
 
     return true; 
 
    } 
 
    } 
 
    return false; 
 
} 
 

 
function print() { 
 
    let domResult = document.getElementById('results'); 
 
    let game = 1; 
 
    let moveInx = 0; 
 
    let spent = 0; 
 
    for (let moveInx = 0; moveInx < moves.length; moveInx++) { 
 
    let myMove = moves[moveInx]; 
 
    let items = myMove.numberItems(); 
 
    let win = myMove.getWin(); 
 
    let cost = myMove.cost; 
 

 
    for (let repeat = 1;; repeat++) { 
 

 
     let investment = win - spent - cost; 
 

 
     if (investment < 0) { 
 
     break; 
 
     } 
 
     spent += cost; 
 

 
     let row = document.createElement('tr'); 
 
     if (repeat == 1) { 
 
     row.className = 'first'; 
 
     } 
 
     let cell = document.createElement('td'); 
 
     cell.innerHTML = game; 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = items; 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = myMove.nameItems(); 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = cost; 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = spent; 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = win; 
 
     row.appendChild(cell); 
 

 
     cell = document.createElement('td'); 
 
     cell.innerHTML = win - spent; 
 
     row.appendChild(cell); 
 

 
     domResult.appendChild(row); 
 

 
     game++; 
 
     if (game > 300) { 
 
     return; 
 
     } 
 
    } 
 
    } 
 
}

table { 
 
    border-collapse: collapse; 
 
} 
 
tr * { 
 
    border: solid 1px black; 
 
} 
 
.first { 
 
    border-top: solid 4px blue; 
 
}

<button onclick="run()">Run</button> 
 
<table> 
 
    <thead> 
 
    <tr> 
 
     <th>Game</th> 
 
     <th>Items</th> 
 
     <th>Types</th> 
 
     <th>Spent</th> 
 
     <th>Total Spent</th> 
 
     <th>Max win</th> 
 
     <th>Profit</th> 
 
    </tr> 
 
    </thead> 
 
    <tbody id="results"> 
 
    </tbody> 
 
</table>