javascript - repetidos - Un contador que realiza un seguimiento de múltiples valores dentro de una matriz.
reduce javascript ejemplo (3)
Esto parece algo complejo, así que haré todo lo posible para ser lo más claro posible. La función particular que busco dinámicamente crea un dinero gastado | Gráfico de dinero ganado para un juego de apuestas.
Tengo una especie de lotería en la que el usuario puede apostar. Hay 6 artículos que el usuario puede comprar y cada uno tiene 6 premios:
Estos se pueden poner en objetos o matrices.
var prices = [5,10,28,50,56,280] .
var possibleWins = [40,80,250,400,500,2500]
Estoy tratando de crear una tabla que calcule cuánto dinero tendría que gastar en cada artículo en particular por juego para garantizar que gane dinero, por 300 juegos.
Este es un ejemplo de cómo debería comenzar el gráfico:
inversión = ganancias máximas posibles + gasto total (que es negativo)
La segunda fila está asumiendo que el primer juego ya pasó y se perdió. Y así.
La idea es comenzar con el elemento más pequeño, pero renunciar una vez que ya no puede ser positivo incluso si ganas. Es por esto que en la fila 9 cambiamos a la roca . (nuestra inversión es de 0 y si volvemos a jugar una ramita, lo máximo que podemos ganar es de 40. Así que incluso si hubiéramos ganado, habríamos perdido 5 en total).
También vale la pena señalar que si ganas en 1 artículo; usted gana en todos los artículos para ese juego en particular. Así consigues todos los premios combinados.
He estado trabajando en esto por unos días y algunas de estas preguntas relacionadas tienen mis intentos iniciales (pero honestamente no tengo idea):
Cómo encontrar la combinación de teclas más baja posible dentro de una matriz
Contador que genera la suma más baja de una combinación de índices por encima del valor anterior
¿Agregar una clave de arrays a sí mismos hasta superar un límite?
EDITAR: Se debe comprar al menos 1 artículo (s) por cada juego y los juegos no se pueden omitir
Aquí está mi solución
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>
Básicamente, esta propuesta se basa en una función para obtener los siguientes elementos.
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;
}
}(),
que comienza a precio con cero e incrementa el valor en uno hasta que se encuentra una combinación de artículos. A continuación, se devuelve la matriz de items . La función funciona como generador.
La otra función importante es la combinación de artículos con un precio determinado y el intento de obtener una matriz con los artículos.
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 toma una matriz con precios y una suma deseada para alcanzar combinando los precios dados. Si tiene éxito, se devuelve una matriz con los elementos, de lo contrario, una matriz vacía.
La tercera parte es utilizar los elementos siempre que la inversión no sea negativa. Si eso sucede, se recupera un nuevo conjunto de elementos.
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; }
Puede crear un objeto en el que los nombres de propiedad establezcan los valores de los possibleWins . Establezca todas las combinaciones posibles de invertir el límite en cada ronda. Las matrices no contienen todas las combinaciones posibles de números menores que el límite para esa ronda en particular. Es decir, los números no están dispersos en cada combinación posible. Por ejemplo, en la ronda 40 , [10, 10, 10, 10, 0, 0, 0, 0] se incluye como una matriz; aunque la matriz también podría reorganizarse a [10, 0, 10, 10, 0, 10, 0, 10] , u otra combinación de índices que sumen menos de 40 .
Además de las posibles combinaciones permitidas inferiores al limit para esa ronda, se debe enviar a la matriz correspondiente a una ronda específica en el objeto devuelto.
Esta implementación no intenta localizar las rutas de selección de cada ronda, lo que llevaría a un resultado positivo. El conjunto completo de matrices se puede iterar en relación con cada índice coincidente en cada matriz, combinación de índices aleatorios o cada combinación posible de índices.
El enfoque es una plantilla base desde la cual se pueden hacer posibles selecciones. Otras matrices opcionales que contienen combinaciones de valores menos el nombre de la propiedad del objeto, que es la ronda particular, o valores dentro de las matrices dentro de las matrices en las propiedades del objeto que tiene un valor de nombre de propiedad menor que la ronda actual, se pueden agregar a la matriz de las matrices; para encontrar las combinaciones de selecciones que conducen al resultado esperado.
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);