Comment je résous cela de la manière la plus efficace? Devrions-nous travailler avec .Reduce () et ces méthodes ou devrions-nous utiliser le classique pour en boucle pour itérer sur les clés d'Allstore et le calculer avec la recette?
var soup = { //recipe
potato: 3,
onion: 1,
corn: 5
};
var edoka = {
cheese: 8,
corn: 3,
meat: 6,
onion: 4,
pea: 1,
oregano: 7,
potato: 5,
tomato: 6
};
var were = {
cheese: 6,
corn: 2,
meat: 9,
onion: 5,
pea: 2,
oregano: 6,
potato: 3,
tomato: 3
};
var brutto = {
cheese: 6,
corn: 2,
meat: 9,
onion: 5,
pea: 2,
oregano: 8,
potato: 3,
tomato: 4
};
var allStores = { // this is an example of a "storeCollection"
Brutto: brutto,
Edoka: edoka,
Were: were,
};
function cheapestStoreForRecipe(recipe, storeCollection){
// make it return the key for the store in storeCollection
// that has the cheapest total cost for recipe. Feel free
// to use costOfRecipe inside this function!
}
4 Réponses :
Ceci est le moyen le plus efficace de résoudre votre problème: Certains affirment que pour est plus efficace que foreach . D'autres disent que ce n'est plus vrai, dans les environnements Morrdn. Je préfère la mise en oeuvre foreach pour la lisibilité.
Voici une solution qui vous aidera à explorer comment utiliser exemple P> Premier, array.reduce code>. Ce n'est peut-être pas le plus efficace, mais d'ici, vous pouvez concevoir votre propre solution. Pour que cela soit plus efficace, vous devriez continuer à travailler avec le concept pour obtenir les résultats dont vous avez besoin en termes de temps de traitement ou de complexité. ConsultsStoreForrecpe code> Accepte deux Arguments: recette code> et STOADECOLLECTION CODE>. La méthode renvoie une liste de magasins avec des factures pour la recette qui inclut le coût de chaque élément et le coût total. P> StorECollection code> Iterate à travers chaque magasin de la collection. Deuxièmement, pour chaque magasin, les éléments de recette sont itérés. Lorsqu'il y a un élément de recettes correspondant à un élément d'inventaire de magasin, la Quantité code>, unité code> et Total des valeurs code> pour l'élément sont calculées; Ensuite, le coût total de chaque recette est calculé. P> {
"Brutto": {
"invoice": {
"potato": {
"quantity": 3,
"unit": 3,
"total": 9
},
"onion": {
"quantity": 1,
"unit": 5,
"total": 5
},
"corn": {
"quantity": 5,
"unit": 2,
"total": 10
}
},
"total": 24
},
"Edoka": {
"invoice": {
"potato": {
"quantity": 3,
"unit": 5,
"total": 15
},
"onion": {
"quantity": 1,
"unit": 4,
"total": 4
},
"corn": {
"quantity": 5,
"unit": 3,
"total": 15
}
},
"total": 34
},
"Were": {
"invoice": {
"potato": {
"quantity": 3,
"unit": 3,
"total": 9
},
"onion": {
"quantity": 1,
"unit": 5,
"total": 5
},
"corn": {
"quantity": 5,
"unit": 2,
"total": 10
}
},
"total": 24
}
}
J'irais pour cela personnellement, c'est l'OMI le plus lisible (bien que cela soit subjectif évidemment). Je m'attendrais à ce que la performance aussi bonne que n'importe quel et a une bonne chance d'utiliser la FaceLy New Object.Entries API.
Pour calculer le coût d'une recette, vous devez résumer les valeurs d'un tableau constitué de l'intersection En ce qui concerne l'efficacité de différentes manières de résumer les éléments d'un tableau, J'ai fait une petite démo ci-dessous comparant P> p> pour code> est le plus efficace des tableaux de longue durée. p>
const add = (a, b) => a + b;
const functionsObj = {
usingFor: async(array) => {
return new Promise(res => {
let result = 0;
for (let i = 0; i < array.length; i++) {
result += array[i];
}
res(result);
});
},
usingForeach: async(array) => {
return new Promise(res => {
let result = 0;
array.forEach(number => {
result += number;
})
res(result);
});
},
usingReduce: async(array) => {
return new Promise(res => {
const result = array.reduce(add);
res(result);
});
},
usingForOf: async(array) => {
return new Promise(res => {
let result = 0;
for (let i of array) {
result += i;
}
res(result);
});
}
};
const Arr10M = [];
for (let j = 0; j < 10000000; j++) {
Arr10M.push(
1 + parseInt(40 * Math.random(), 10)
);
}
const Arr10K = Arr10M.slice(0, 10000);
async function runTests(method, arr, attempts = 300) {
let results = [];
for (let attempt of arr.slice(0, attempts)) {
performance.mark('start');
await functionsObj[method](arr);
performance.mark('end');
results.push(performance.measure(method, 'start', 'end').duration);
performance.clearMeasures();
performance.clearMarks();
}
return new Promise(res => {
let min = 1 * Number(Math.min(...results)).toFixed(6),
max = 1 * Number(Math.max(...results)).toFixed(6);
window.setTimeout(() => {
res([min, max]);
}, 1000 - 1 * max);
});
}
(async() => {
let results = {},
methods = ['usingFor', 'usingForOf', 'usingReduce', 'usingForeach'];
for (let method of methods) {
let [
min_10K_elements,
max_10K_elements
] = await runTests(method, Arr10K), [
min_10M_elements,
max_10M_elements
] = await runTests(method, Arr10M, 3),
result = {
min_10K_elements,
max_10K_elements,
min_10M_elements,
max_10M_elements
};
results[method] = result;
console.log({
method,
...result
});
}
console.table(results);
return;
})();
Je pense que c'est votre devoir et vous venez de nous donner le code qui lui appartient. Où est votre propre code et que vous essayez de le résoudre?