跟踪数组内多个值的计数器

Question

这看起来有点复杂，所以我会尽我最大的努力说清楚 possible.The 我正在寻找的特定功能会动态创建一个 花费的钱 |赢钱 赌博游戏图表。

我有各种各样的彩票可供用户下注。用户可以购买 6 件商品，每件商品有 6 个奖品：

这些可以放入对象或数组中。

var prices = [5,10,28,50,56,280].

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

我正在尝试创建一个图表来计算你必须在每场比赛的每个特定项目上花费多少钱才能保证你赚钱 - 对于 300 场比赛。

下面是图表应该如何开始的示例：

投资 = 最大可能赢利 + 总花费（为负数）

第二行假设第一场比赛已经发生并输了。等等。

我们的想法是从最小的项目开始，一旦它不再让你积极，即使你赢了，就放弃。这就是为什么在第 9 行我们切换到 rock。（我们的投资是0，如果再玩树枝，最多能赢40，所以就算赢了，实际上总共输了5。）

另外值得一提的是，如果你赢了一件物品；您赢得了该特定游戏的所有项目。这样您就获得了所有奖品。

我已经研究了几天了，其中一些相关问题是我的初步尝试（但老实说我不知道）：

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

基本上这个提议依赖于一个函数来获取下一个项目

    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;
        }
    }(),

从零开始的价格，然后将值递增 1，直到找到项目组合。然后返回 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 接受一个数组，其中包含价格和组合给定价格要达到的总和。如果成功，则返回一个包含项目的数组，否则返回一个空数组。

第三部分是只要投资不负数就可以使用物品。如果发生这种情况，将获取新的项目集。

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

这是我的解决方案

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>

跟踪数组内多个值的计数器

A counter keeping track of multiple values inside an array

javascript

arrays

counter

combinations