Cum agerem algorithmarum studebam, hoc veni . Non solum ideam praebet quomodo colloquia in amplis collegiis technologiarum geruntur, sed etiam permittit ut intellegas quomodo problemata algorithmica quam efficacissime solvantur.
Hic articulus comitatus est quasi quaedam visio. In ea commentationes praebeo de omnibus solutionibus demonstratis, plus meae versionis solutionis in JavaScript. Nuces algorithmorum singulorum etiam discutiuntur.
admonemus; omnibus legentibus "Habr" - discount 10 rublorum cum scribendo in quavis Skillbox utens "Habr" codice promotivo.
Skillbox commendat: Cursus practicus .
DE PECCATO quaestio
Datur ordo ordinatus et valorem specificum. Quaeritur ergo munus creare quod redit verum vel falsum secundum utrum summa cuiuslibet duorum numerorum in ordine adaequare possit datum valorem.
Aliis verbis, suntne duo integri in ordine, x et y, ut simul additi valorem determinatum aequant?
Exemplum A
Si detur ordinatus [1, 2, 4, 9] et valor est 8, functio reddetur falsa, quia nullus numerus in acie potest addere usque ad 8 .
Exemplum B
Sed si suus ordo est [1, 2, 4, 4] et valor est 8, functio vera debet reddere quia 4 + 4 = 8 .
Solutio in primo
Tempus complexionis: O (N²).
Spatium complexionis: O (1).
Manifestissima significatio est uti par loramenta frondium.
const findSum = (arr, val) => {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length; j++) {
if (i !== j && arr[i] + arr[j] === val) {
return true;
};
};
};
return false;
};Haec solutio non est efficiens, quia coercet omnem summam possibilium duorum elementorum in ordine et etiam in bis singulis par indices comparat. (Exempli gratia, quando i = 1 et j=2 idem actu est quod cum i = 2 et j=1 comparet, sed in hac solutione utrumque bene conamur).
Quod solutionem nostram utatur par nidificatis pro ansulis, quadratica est cum O (N²) temporis complexitate.
Solutio 2: Inquisitio binarii
Tempus complexionis: O (Nlog(N)).
Complexus spatii: O (1).
Cum ordinatae sunt, solutionem quaerere possumus utendi binarii inquisitionis. Haec est efficacissima algorithmus ordinatus vestit. Investigatio binaria ipsum tempus cursus O (log(N)) habet). Tamen adhuc opus est uti pro loop ad singula elementa contra omnes alios valores reprimendam.
Ecce quam solutionem spectare licet. Ad res manifestas, munus separatum utimur ad inquisitionem binariam regendam. Ac etiam munus Index removere, quae versionem ordinatae minus dati indicem reddit.
const findSum = (arr, val) => {
for (let i = 0; i < arr.length; i++){
if (binarySearch(removeIndex(arr, i), val - arr[i])) {
return true;
}
};
return false;
};
const removeIndex = (arr, i) => {
return arr.slice(0, i).concat(arr.slice(i + 1, arr.length));
};
const binarySearch = (arr, val) => {
let start = 0;
let end = arr.length - 1;
let pivot = Math.floor(arr.length / 2);
while (start < end) {
if (val < arr[pivot]) {
end = pivot - 1;
} else if (val > arr[pivot]) {
start = pivot + 1;
};
pivot = Math.floor((start + end) / 2);
if (arr[pivot] === val) {
return true;
}
};
return false;
};Incipit algorithmus ab indice [0]. Is igitur versionem ordinatam creat ad primum indicem excludens et binarii inquisitionis utitur ad videndum, si quis ex reliquis valoribus addi potest ad ordinatam summam producere desideratam. Haec actio semel pro unoquoque elemento in ordine perficitur.
Ipsa ansa pro tempore complexionem O(N) linearem habebit, sed intra pro loop inquisitionem binariam peragimus, quae altiorem temporis complexionem O(Nlog(N) tribuit). Solutio haec melior est quam prior, sed adhuc locus est emendationis.
Solutio III;
Tempus complexionis: O (N).
Spatium complexionis: O (1).
Nunc solvemus problema, memorans ordinata digestus est. Solutio est ad duos numeros: unum in principio et unum in fine. Si effectus a inquisita differat, incipientia et desinentia puncta mutant.
Tandem aut valorem desideratum occurremus et verum reddemus, aut initium et finis appropinquabunt et falsa reddent.
const findSum = (arr, val) => {
let start = 0;
let end = arr.length - 1;
while (start < end) {
let sum = arr[start] + arr[end];
if (sum > val) {
end -= 1;
} else if (sum < val) {
start += 1;
} else {
return true;
};
};
return false;
};
Omne autem pulchrum, optima solutio videtur. Sed quis spondeat ordinata esse ordinata?
Quid ergo?
Primo aspectu, simpliciter potuimus ordinare primum aciem et deinde solutionem adhiberi supra. Sed quomodo hoc tempus afficit exsecutionis?
Optima algorithmus velox est cum tempore complexionis O (Nlog (N)). Si ea in optimali solutione utemur, mutabit effectum suum ab O(N) ad O(Nlog(N)). Potestne invenire solutionem linearem cum ordine inordinato?
Solutio 4
Tempus complexionis: O (N).
Spatium complexionis: O (N).
Ita linearis solutio est: ad hoc faciendum opus est ut novum apparatum efficiat in quo indices compositus quos quaerimus. Commercium-off hic plus memoriae usus est: sola solutio in charta est cum multiplicitate spatii quam O (1).
Si primus valor alicuius ordinis est 1 et quaesitio valoris 8, possumus addere valorem 7 ad ordinata "investigationis" ordinata.
Deinde, dum singula elementa ordinatae processimus, ordinatam "inquisitionem valorum" inspicere possumus et videre si unum ex illis nostro valore aequale sit. Si sic, verum revertere.
const findSum = (arr, val) => {
let searchValues = [val - arr[0]];
for (let i = 1; i < arr.length; i++) {
let searchVal = val - arr[i];
if (searchValues.includes(arr[i])) {
return true;
} else {
searchValues.push(searchVal);
}
};
return false;
};Fundamentum solutionis est pro fascia, quam, ut supra vidimus, temporis complexionem linearem habet O(N).
Secunda pars iterativae functionis nostrae est Array.prototype.include(), methodus JavaScript quae reddet verum vel falsum secundum an ordinata contineat valorem datum.
Ad instar temporis complexionem Array.prototype.includes(), spectare possumus ad polyfill parata a MDN (et scripta in JavaScript) vel methodo in fonte codice machinae JavaScript ut Google V8 (C++).
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
if (!Array.prototype.includes) {
Object.defineProperty(Array.prototype, 'includes', {
value: function(valueToFind, fromIndex) {
if (this == null) {
throw new TypeError('"this" is null or not defined');
}
// 1. Let O be ? ToObject(this value).
var o = Object(this);
// 2. Let len be ? ToLength(? Get(O, "length")).
var len = o.length >>> 0;
// 3. If len is 0, return false.
if (len === 0) {
return false;
}
// 4. Let n be ? ToInteger(fromIndex).
// (If fromIndex is undefined, this step produces the value 0.)
var n = fromIndex | 0;
// 5. If n ≥ 0, then
// a. Let k be n.
// 6. Else n < 0,
// a. Let k be len + n.
// b. If k < 0, let k be 0.
var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
function sameValueZero(x, y) {
return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));
}
// 7. Repeat, while k < len
while (k < len) {
// a. Let elementK be the result of ? Get(O, ! ToString(k)).
// b. If SameValueZero(valueToFind, elementK) is true, return true.
if (sameValueZero(o[k], valueToFind)) {
return true;
}
// c. Increase k by 1.
k++;
}
// 8. Return false
return false;
}
});
}Hic pars iterativa Array.prototype.include() est dum ansa in gradu 7 quod (fere) totam longitudinem dati ordinatae percurrit. Hoc significat eius temporis complexionem etiam linearem esse. Bene, cum semper unus gradus post nostrum principalem ordinem consistat, tempus multiplicitatis est O (N + (N - 1)). Big O notatione utendo, simplicioremus id ad O(N) - quia N est quod maximum momentum habet cum initus magnitudinis augendae.
Quoad complexionem spatialem, ordo additus necessarius est cuius longitudo primam aciem (minus, immo, immo, sed ignorari potest), ex in O(N) complexitate locali inspicitur. Bene, usus memoriae auctus maximam algorithm efficaciam efficit.
Spero te articulum utilem inventurum cum supplemento ad colloquium video tuum. Ostendit problema simplicem pluribus modis solvi posse cum diversis facultatibus adhibitis (tempus, memoria).
Skillbox commendat:
- De online cursum .
- Online cursum .
- Cursus practicus .
Source: www.habr.com