data-structure-typed 2.2.7 → 2.3.0

package/dist/leetcode/trie.mjs

@@ -0,0 +1,413 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
+  constructor(options) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  _toElementFn;
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *values() {
+    for (const item of this) yield item;
+  }
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (!predicate(item, index++, this)) return false;
+      } else {
+        const fn = predicate;
+        if (!fn.call(thisArg, item, index++, this)) return false;
+      }
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return true;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return true;
+      }
+    }
+    return false;
+  }
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        callbackfn(item, index++, this);
+      } else {
+        const fn = callbackfn;
+        fn.call(thisArg, item, index++, this);
+      }
+    }
+  }
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return item;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return item;
+      }
+    }
+    return;
+  }
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  reduce(callbackfn, initialValue) {
+    let index = 0;
+    const iter = this[Symbol.iterator]();
+    let acc;
+    if (arguments.length >= 2) {
+      acc = initialValue;
+    } else {
+      const first = iter.next();
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      acc = first.value;
+      index = 1;
+    }
+    for (const value of iter) {
+      acc = callbackfn(acc, value, index++, this);
+    }
+    return acc;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var TrieNode = class {
+  static {
+    __name(this, "TrieNode");
+  }
+  constructor(key) {
+    this._key = key;
+    this._isEnd = false;
+    this._children =  new Map();
+  }
+  _key;
+  get key() {
+    return this._key;
+  }
+  set key(value) {
+    this._key = value;
+  }
+  _children;
+  get children() {
+    return this._children;
+  }
+  set children(value) {
+    this._children = value;
+  }
+  _isEnd;
+  get isEnd() {
+    return this._isEnd;
+  }
+  set isEnd(value) {
+    this._isEnd = value;
+  }
+};
+var Trie = class extends IterableElementBase {
+  static {
+    __name(this, "Trie");
+  }
+  constructor(words = [], options) {
+    super(options);
+    if (options) {
+      const { caseSensitive } = options;
+      if (caseSensitive !== void 0) this._caseSensitive = caseSensitive;
+    }
+    if (words) {
+      this.addMany(words);
+    }
+  }
+  _size = 0;
+  get size() {
+    return this._size;
+  }
+  _caseSensitive = true;
+  get caseSensitive() {
+    return this._caseSensitive;
+  }
+  _root = new TrieNode("");
+  get root() {
+    return this._root;
+  }
+  get _total() {
+    return this._size;
+  }
+  add(word) {
+    word = this._caseProcess(word);
+    let cur = this.root;
+    let isNewWord = false;
+    for (const c of word) {
+      let nodeC = cur.children.get(c);
+      if (!nodeC) {
+        nodeC = new TrieNode(c);
+        cur.children.set(c, nodeC);
+      }
+      cur = nodeC;
+    }
+    if (!cur.isEnd) {
+      isNewWord = true;
+      cur.isEnd = true;
+      this._size++;
+    }
+    return isNewWord;
+  }
+  addMany(words) {
+    const ans = [];
+    for (const word of words) {
+      if (this.toElementFn) {
+        ans.push(this.add(this.toElementFn(word)));
+      } else {
+        ans.push(this.add(word));
+      }
+    }
+    return ans;
+  }
+  has(word) {
+    word = this._caseProcess(word);
+    let cur = this.root;
+    for (const c of word) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return cur.isEnd;
+  }
+  isEmpty() {
+    return this._size === 0;
+  }
+  clear() {
+    this._size = 0;
+    this._root = new TrieNode("");
+  }
+  delete(word) {
+    word = this._caseProcess(word);
+    let isDeleted = false;
+    const dfs =  __name((cur, i) => {
+      const char = word[i];
+      const child = cur.children.get(char);
+      if (child) {
+        if (i === word.length - 1) {
+          if (child.isEnd) {
+            if (child.children.size > 0) {
+              child.isEnd = false;
+            } else {
+              cur.children.delete(char);
+            }
+            isDeleted = true;
+            return true;
+          }
+          return false;
+        }
+        const res = dfs(child, i + 1);
+        if (res && !cur.isEnd && child.children.size === 0) {
+          cur.children.delete(char);
+          return true;
+        }
+        return false;
+      }
+      return false;
+    }, "dfs");
+    dfs(this.root, 0);
+    if (isDeleted) {
+      this._size--;
+    }
+    return isDeleted;
+  }
+  getHeight() {
+    const startNode = this.root;
+    let maxDepth = 0;
+    if (startNode) {
+      const bfs =  __name((node, level) => {
+        if (level > maxDepth) {
+          maxDepth = level;
+        }
+        const { children } = node;
+        if (children) {
+          for (const child of children.entries()) {
+            bfs(child[1], level + 1);
+          }
+        }
+      }, "bfs");
+      bfs(startNode, 0);
+    }
+    return maxDepth;
+  }
+  hasPurePrefix(input) {
+    input = this._caseProcess(input);
+    let cur = this.root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return !cur.isEnd;
+  }
+  hasPrefix(input) {
+    input = this._caseProcess(input);
+    let cur = this.root;
+    for (const c of input) {
+      const nodeC = cur.children.get(c);
+      if (!nodeC) return false;
+      cur = nodeC;
+    }
+    return true;
+  }
+  hasCommonPrefix(input) {
+    input = this._caseProcess(input);
+    let commonPre = "";
+    const dfs =  __name((cur) => {
+      commonPre += cur.key;
+      if (commonPre === input) return;
+      if (cur.isEnd) return;
+      if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
+      else return;
+    }, "dfs");
+    dfs(this.root);
+    return commonPre === input;
+  }
+  getLongestCommonPrefix() {
+    let commonPre = "";
+    const dfs =  __name((cur) => {
+      commonPre += cur.key;
+      if (cur.isEnd) return;
+      if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
+      else return;
+    }, "dfs");
+    dfs(this.root);
+    return commonPre;
+  }
+  getWords(prefix = "", max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false) {
+    prefix = this._caseProcess(prefix);
+    const words = [];
+    let found = 0;
+    function dfs(node, word) {
+      for (const char of node.children.keys()) {
+        const charNode = node.children.get(char);
+        if (charNode !== void 0) {
+          dfs(charNode, word.concat(char));
+        }
+      }
+      if (node.isEnd) {
+        if (found > max - 1) return;
+        words.push(word);
+        found++;
+      }
+    }
+    __name(dfs, "dfs");
+    let startNode = this.root;
+    if (prefix) {
+      for (const c of prefix) {
+        const nodeC = startNode.children.get(c);
+        if (nodeC) {
+          startNode = nodeC;
+        } else {
+          return [];
+        }
+      }
+    }
+    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
+    return words;
+  }
+  clone() {
+    const next = this._createInstance();
+    for (const x of this) next.add(x);
+    return next;
+  }
+  filter(predicate, thisArg) {
+    const results = this._createInstance();
+    let index = 0;
+    for (const word of this) {
+      if (predicate.call(thisArg, word, index, this)) {
+        results.add(word);
+      }
+      index++;
+    }
+    return results;
+  }
+  map(callback, options, thisArg) {
+    const newTrie = this._createLike([], options);
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      if (typeof v !== "string") {
+        throw new TypeError(`Trie.map callback must return string; got ${typeof v}`);
+      }
+      newTrie.add(v);
+    }
+    return newTrie;
+  }
+  mapSame(callback, thisArg) {
+    const next = this._createInstance();
+    let i = 0;
+    for (const key of this) {
+      const mapped = thisArg === void 0 ? callback(key, i++, this) : callback.call(thisArg, key, i++, this);
+      next.add(mapped);
+    }
+    return next;
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    const next = new Ctor([], {
+      toElementFn: this.toElementFn,
+      caseSensitive: this.caseSensitive,
+      ...options ?? {}
+    });
+    return next;
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  _spawnLike(options) {
+    return this._createLike([], options);
+  }
+  *_getIterator() {
+    function* _dfs(node, path) {
+      if (node.isEnd) {
+        yield path;
+      }
+      for (const [char, childNode] of node.children) {
+        yield* _dfs(childNode, path + char);
+      }
+    }
+    __name(_dfs, "_dfs");
+    yield* _dfs(this.root, "");
+  }
+  _caseProcess(str) {
+    if (!this._caseSensitive) {
+      str = str.toLowerCase();
+    }
+    return str;
+  }
+};
+export {
+  Trie,
+  TrieNode
+};