J'ai un hashmap
p>
const hash = {
"00:00": "Hello",
"00:01": "Every one",
"00:04": "Nice to meet you",
"00:10": "Could you introduce yourself?",
"00:23": "Hi, My name is HashMap"
}
console.log(hash["00:00"]);
console.log(hash["00:01"]);
console.log(hash["00:04"]);
console.log(hash["00:05"]); // it returns `undefined`, so it should find previous element. in this case "00:04"
console.log(hash["00:10"]);
console.log(hash["00:17"]); // it also returns `undefined`, it should find "00:10" element.
console.log(hash["00:19"]); // it also should find "00:10" element.
console.log(hash["00:22"]); // it also should find "00:10" element.
console.log(hash["00:23"]); 3 Réponses :
const hash = {
"00:00": "Hello",
"00:01": "Every one",
"00:04": "Nice to meet you",
"00:10": "Could you introduce yourself?",
"00:23": "Hi, My name is HashMap"
}
function x(time, check) {
var prev = -1;
var i;
for (i in time) {
var n = i;
if ((prev != -1) && (check < n))
return prev;
else
prev = n;
}
}
console.log(x(hash, "00:05"));Merci pour la réponse, mais je ne veux pas itérer tous les éléments.
Vous devriez pouvoir obtenir avec un Proxy . Cela vous permet d'intercepter et de redéfinir les opérations sur un objet. Utilisation de votre exemple, cela pourrait ressembler à ceci:
p>
let hash = {
"01:00": "Hello",
"01:01": "Every one",
"01:04": "Nice to meet you",
"01:10": "Could you introduce yourself?",
"01:23": "Hi, My name is HashMap"
}
const handler = {
get: function (obj, prop) {
if (obj[prop] !== undefined) {
return obj[prop];
} else {
// Validate input format before bothering to search
if (/\d{2}:\d{2}/.test(prop) !== true) return undefined;
// Search for nearest previous property
const keys = Object.keys(obj);
return obj[findPrevious(keys, prop, 0, keys.length)];
}
}
}
function findPrevious(keys, prop, start, end) {
// No previous key is available, so bail out
if (start > end) return undefined;
const middle = Math.floor((start + end) / 2);
const current = keys[middle];
const next = keys[middle + 1];
// Previous property is found or is the maximum defined
if (current < prop && (next > prop || next === undefined)) {
return keys[middle];
}
// Otherwise, keep searching
if (keys[middle] > prop) {
return findPrevious(keys, prop, start, middle - 1);
} else {
return findPrevious(keys, prop, middle + 1, end);
}
}
// Implement proxy
hash = new Proxy(hash, handler);
console.log(hash["00:01"]); // undefined
console.log(hash["01:00"]); // Hello
console.log(hash["01:01"]); // Every one
console.log(hash["01:04"]); // Nice to meet you
console.log(hash["01:05"]); // Nice to meet you
console.log(hash["01:10"]); // Could you introduce yourself?
console.log(hash["01:17"]); // Could you introduce yourself?
console.log(hash["01:19"]); // Could you introduce yourself?
console.log(hash["01:22"]); // Could you introduce yourself?
console.log(hash["01:23"]); // Hi, My name is HashMap
console.log(hash["10:00"]); // Hi, My name is HashMapExcellent! Merci beaucoup.
Question. Est proxy nécessaire? parce que je n'ai aucune connaissance à ce sujet.
@Jinongun Ce n'est nécessaire que si vous voulez le faire ressembler à ce que ce soit un objet ayant sa propriété accessible. Dans ce cas, le proxy vous donne simplement un contrôle lorsqu'une propriété est tentée à accéder. Il est similaire à l'appel d'une fonction avec l'objet sous forme d'argument (quelque chose comme FindSadeorPrevious (hachage, "00:00" ) mais avec une interface plus simple.
Je pense que c'est exactement ce dont vous avez besoin, vous pourrez récupérer du hachage, p>
const hash = {
"00:00": "Hello",
"00:01": "Every one",
"00:04": "Nice to meet you",
"00:10": "Could you introduce yourself?",
"00:23": "Hi, My name is HashMap"
}
function gethrmin(key){
ka=key.split(':')
a=ka[0].charAt(0) ,b=ka[0].charAt(1), c=ka[1].charAt(0), d=ka[1].charAt(1) ,prev=""
h= a =='0' && b=='0'?0:(a=='0' && b!='0'?parseInt(b):parseInt(ka[0]))
m= c =='0' && d=='0'?0:(c=='0' && d!='0'?parseInt(d):parseInt(ka[1]))
}
function prevTi(){
return h<9&&h!=0 && m==0?prev="0"+`${h-1}`+":"+"59":( h>9 && m==0?prev=`${h-1}`+":"+"59":(h==0 && m==0?prev="23:59":(h==0 && m<9 &&m!=0?prev="00:"+"0"+`${m-1}`:(h==0 && m>9 &&m!=0?prev="00:"+`${m-1}`:(h<9 && h!=0 || m<9&& m!=0 ?prev="0"+h+":"+"0"+`${m-1}`:(h>9 && h!=0 || m>9 && m!=0 ?prev=h+':'+`${m-1}`:(h>9 && h!=0 || m<9 && m!=0 ?prev=h+':'+"0"+":"+`${m-1}`:(h<9 && h!=0 || m>9 && m!=0 ?prev="0"+h+':'+m:null))))))))
}
function checkdb(key){
if(!hash[key]){
gethrmin(key)
nk=prevTi()
return checkdb(nk)
}
else
return hash[key]
}
function _(key){
if(hash[key]) return hash[key]
return checkdb(key)
}
console.log(_('00:00'))
console.log(_('00:01'))
console.log(_('00:04'))
console.log(_('00:05'))
console.log(_('00:10'))
console.log(_('00:17'))
console.log(_('00:19'))
console.log(_('00:22'))
console.log(_('22:22'))
Uplevote, mais je ne suis pas sûr qu'un hashmap est la bonne structure de données pour ce problème. Je pense que vous pourriez avoir besoin de commander aux clés du temps.
"Je ne veux pas itérer tous les éléments. Parce qu'il n'a aucune signification avec HashMap" ... Selon cette logique, "Element précédent" n'a aucun sens non plus.
@Gerardofurtado Je comprends, je voulais juste connaître n'importe quel "algorithme spécial" pour cela. Parce que je ne connais pas tous les algorithmes de ce monde.
@Gerardofurtado Vous voulez donc dire, il n'y a aucun moyen de résoudre ma question avec la complexité de temps
O (1) ou sousO (n) ?Êtes-vous bien avec l'utilisation de bibliothèques?
@ hev1 peut-être :) Je veux juste garder la complexité du temps
@jinongun par "Élément précédent" Voulez-vous dire que la propriété précédemment accessible ou la propriété alphabétique précédente?
@Ezra cela signifie une propriété alphabétique précédente. Je suis désolé de vous faire confus.
@jinongunk ok, j'ai mis à jour ma solution en conséquence. Je me rends compte que ce n'est pas la performance que vous espérait sortir d'un haschmap, mais je pense que cela répond au moins à votre question.