data-structure-typed 2.2.6 → 2.2.8

package/dist/leetcode/deque.mjs

@@ -0,0 +1,683 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var rangeCheck =  __name((index, min, max, message = "Index out of bounds.") => {
+  if (index < min || index > max) throw new RangeError(message);
+}, "rangeCheck");
+var calcMinUnitsRequired =  __name((totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize), "calcMinUnitsRequired");
+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 LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  _maxLen = -1;
+  get maxLen() {
+    return this._maxLen;
+  }
+  indexOf(searchElement, fromIndex = 0) {
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  findIndex(predicate, thisArg) {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  splice(start, deleteCount = 0, ...items) {
+    const removedList = this._createInstance();
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start);
+      if (removed !== void 0) {
+        removedList.push(removed);
+      }
+    }
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]);
+    }
+    return removedList;
+  }
+  join(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  toReversedArray() {
+    const array = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i));
+    }
+    return array;
+  }
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue ?? 0;
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i), i, this);
+    }
+    return accumulator;
+  }
+  slice(start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i));
+    }
+    return newList;
+  }
+  fill(value, start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+    return this;
+  }
+};
+var Deque = class extends LinearBase {
+  static {
+    __name(this, "Deque");
+  }
+  _equals = Object.is;
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { bucketSize } = options;
+      if (typeof bucketSize === "number") this._bucketSize = bucketSize;
+    }
+    let _size;
+    if ("length" in elements) {
+      _size = typeof elements.length === "function" ? elements.length() : elements.length;
+    } else {
+      _size = typeof elements.size === "function" ? elements.size() : elements.size;
+    }
+    this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
+    for (let i = 0; i < this._bucketCount; ++i) {
+      this._buckets.push(new Array(this._bucketSize));
+    }
+    const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
+    this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+    this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
+    this.pushMany(elements);
+  }
+  _bucketSize = 1 << 12;
+  get bucketSize() {
+    return this._bucketSize;
+  }
+  _bucketFirst = 0;
+  get bucketFirst() {
+    return this._bucketFirst;
+  }
+  _firstInBucket = 0;
+  get firstInBucket() {
+    return this._firstInBucket;
+  }
+  _bucketLast = 0;
+  get bucketLast() {
+    return this._bucketLast;
+  }
+  _lastInBucket = 0;
+  get lastInBucket() {
+    return this._lastInBucket;
+  }
+  _bucketCount = 0;
+  get bucketCount() {
+    return this._bucketCount;
+  }
+  _buckets = [];
+  get buckets() {
+    return this._buckets;
+  }
+  _length = 0;
+  get length() {
+    return this._length;
+  }
+  get first() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketFirst][this._firstInBucket];
+  }
+  get last() {
+    if (this._length === 0) return;
+    return this._buckets[this._bucketLast][this._lastInBucket];
+  }
+  static fromArray(data, options) {
+    return new this(data, options);
+  }
+  push(element) {
+    if (this._length) {
+      if (this._lastInBucket < this._bucketSize - 1) {
+        this._lastInBucket += 1;
+      } else if (this._bucketLast < this._bucketCount - 1) {
+        this._bucketLast += 1;
+        this._lastInBucket = 0;
+      } else {
+        this._bucketLast = 0;
+        this._lastInBucket = 0;
+      }
+      if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();
+    }
+    this._length += 1;
+    this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.shift();
+    return true;
+  }
+  pop() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketLast][this._lastInBucket];
+    if (this._length !== 1) {
+      if (this._lastInBucket > 0) {
+        this._lastInBucket -= 1;
+      } else if (this._bucketLast > 0) {
+        this._bucketLast -= 1;
+        this._lastInBucket = this._bucketSize - 1;
+      } else {
+        this._bucketLast = this._bucketCount - 1;
+        this._lastInBucket = this._bucketSize - 1;
+      }
+    }
+    this._length -= 1;
+    return element;
+  }
+  shift() {
+    if (this._length === 0) return;
+    const element = this._buckets[this._bucketFirst][this._firstInBucket];
+    if (this._length !== 1) {
+      if (this._firstInBucket < this._bucketSize - 1) {
+        this._firstInBucket += 1;
+      } else if (this._bucketFirst < this._bucketCount - 1) {
+        this._bucketFirst += 1;
+        this._firstInBucket = 0;
+      } else {
+        this._bucketFirst = 0;
+        this._firstInBucket = 0;
+      }
+    }
+    this._length -= 1;
+    return element;
+  }
+  unshift(element) {
+    if (this._length) {
+      if (this._firstInBucket > 0) {
+        this._firstInBucket -= 1;
+      } else if (this._bucketFirst > 0) {
+        this._bucketFirst -= 1;
+        this._firstInBucket = this._bucketSize - 1;
+      } else {
+        this._bucketFirst = this._bucketCount - 1;
+        this._firstInBucket = this._bucketSize - 1;
+      }
+      if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();
+    }
+    this._length += 1;
+    this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
+    return true;
+  }
+  pushMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.push(this.toElementFn(el)));
+      } else {
+        ans.push(this.push(el));
+      }
+    }
+    return ans;
+  }
+  unshiftMany(elements = []) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.unshift(this.toElementFn(el)));
+      } else {
+        ans.push(this.unshift(el));
+      }
+    }
+    return ans;
+  }
+  isEmpty() {
+    return this._length === 0;
+  }
+  clear() {
+    this._buckets = [new Array(this._bucketSize)];
+    this._bucketCount = 1;
+    this._bucketFirst = this._bucketLast = this._length = 0;
+    this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+  }
+  at(pos) {
+    if (pos < 0 || pos >= this._length) return void 0;
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    return this._buckets[bucketIndex][indexInBucket];
+  }
+  setAt(pos, element) {
+    rangeCheck(pos, 0, this._length - 1);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+    this._buckets[bucketIndex][indexInBucket] = element;
+    return true;
+  }
+  addAt(pos, element, num = 1) {
+    const length = this._length;
+    rangeCheck(pos, 0, length);
+    if (pos === 0) {
+      while (num--) this.unshift(element);
+    } else if (pos === this._length) {
+      while (num--) this.push(element);
+    } else {
+      const arr = [];
+      for (let i = pos; i < this._length; ++i) {
+        const v = this.at(i);
+        if (v !== void 0) arr.push(v);
+      }
+      this.cut(pos - 1, true);
+      for (let i = 0; i < num; ++i) this.push(element);
+      for (let i = 0; i < arr.length; ++i) this.push(arr[i]);
+    }
+    return true;
+  }
+  cut(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        this.clear();
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketLast = bucketIndex;
+      this._lastInBucket = indexInBucket;
+      this._length = pos + 1;
+      return this;
+    } else {
+      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+      newDeque._setBucketSize(this._bucketSize);
+      for (let i = 0; i <= pos; i++) {
+        const v = this.at(i);
+        if (v !== void 0) newDeque.push(v);
+      }
+      return newDeque;
+    }
+  }
+  splice(start, deleteCount = this._length - start, ...items) {
+    rangeCheck(start, 0, this._length);
+    if (deleteCount < 0) deleteCount = 0;
+    if (start + deleteCount > this._length) deleteCount = this._length - start;
+    const removed = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    removed._setBucketSize(this._bucketSize);
+    for (let i = 0; i < deleteCount; i++) {
+      const v = this.at(start + i);
+      if (v !== void 0) removed.push(v);
+    }
+    const tail = [];
+    for (let i = start + deleteCount; i < this._length; i++) {
+      const v = this.at(i);
+      if (v !== void 0) tail.push(v);
+    }
+    this.cut(start - 1, true);
+    for (const it of items) this.push(it);
+    for (const v of tail) this.push(v);
+    return removed;
+  }
+  cutRest(pos, isCutSelf = false) {
+    if (isCutSelf) {
+      if (pos < 0) {
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketFirst = bucketIndex;
+      this._firstInBucket = indexInBucket;
+      this._length = this._length - pos;
+      return this;
+    } else {
+      const newDeque = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+      newDeque._setBucketSize(this._bucketSize);
+      if (pos < 0) pos = 0;
+      for (let i = pos; i < this._length; i++) {
+        const v = this.at(i);
+        if (v !== void 0) newDeque.push(v);
+      }
+      return newDeque;
+    }
+  }
+  deleteAt(pos) {
+    rangeCheck(pos, 0, this._length - 1);
+    let deleted;
+    if (pos === 0) {
+      return this.shift();
+    } else if (pos === this._length - 1) {
+      deleted = this.last;
+      this.pop();
+      return deleted;
+    } else {
+      const length = this._length - 1;
+      const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+      deleted = this._buckets[targetBucket][targetPointer];
+      for (let i = pos; i < length; i++) {
+        const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
+        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+      }
+      this.pop();
+      return deleted;
+    }
+  }
+  delete(element) {
+    const size = this._length;
+    if (size === 0) return false;
+    let i = 0;
+    let index = 0;
+    while (i < size) {
+      const oldElement = this.at(i);
+      if (!this._equals(oldElement, element)) {
+        this.setAt(index, oldElement);
+        index += 1;
+      }
+      i += 1;
+    }
+    this.cut(index - 1, true);
+    return true;
+  }
+  deleteWhere(predicate) {
+    for (let i = 0; i < this._length; i++) {
+      const v = this.at(i);
+      if (predicate(v, i, this)) {
+        this.deleteAt(i);
+        return true;
+      }
+    }
+    return false;
+  }
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  reverse() {
+    this._buckets.reverse().forEach(function(bucket) {
+      bucket.reverse();
+    });
+    const { _bucketFirst, _bucketLast, _firstInBucket, _lastInBucket } = this;
+    this._bucketFirst = this._bucketCount - _bucketLast - 1;
+    this._bucketLast = this._bucketCount - _bucketFirst - 1;
+    this._firstInBucket = this._bucketSize - _lastInBucket - 1;
+    this._lastInBucket = this._bucketSize - _firstInBucket - 1;
+    return this;
+  }
+  unique() {
+    if (this._length <= 1) {
+      return this;
+    }
+    let index = 1;
+    let prev = this.at(0);
+    for (let i = 1; i < this._length; ++i) {
+      const cur = this.at(i);
+      if (!this._equals(cur, prev)) {
+        prev = cur;
+        this.setAt(index++, cur);
+      }
+    }
+    this.cut(index - 1, true);
+    return this;
+  }
+  shrinkToFit() {
+    if (this._length === 0) return;
+    const newBuckets = [];
+    if (this._bucketFirst === this._bucketLast) return;
+    else if (this._bucketFirst < this._bucketLast) {
+      for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+    } else {
+      for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+      for (let i = 0; i <= this._bucketLast; ++i) {
+        newBuckets.push(this._buckets[i]);
+      }
+    }
+    this._bucketFirst = 0;
+    this._bucketLast = newBuckets.length - 1;
+    this._buckets = newBuckets;
+  }
+  clone() {
+    return this._createLike(this, {
+      bucketSize: this.bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    });
+  }
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setBucketSize(this._bucketSize);
+    let index = 0;
+    for (const el of this) {
+      if (predicate.call(thisArg, el, index, this)) out.push(el);
+      index++;
+    }
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const out = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+    out._setBucketSize(this._bucketSize);
+    let index = 0;
+    for (const v of this) {
+      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
+      out.push(mv);
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const out = this._createLike([], {
+      ...options ?? {},
+      bucketSize: this._bucketSize,
+      maxLen: this._maxLen
+    });
+    let index = 0;
+    for (const el of this) {
+      const mv = thisArg === void 0 ? callback(el, index, this) : callback.call(thisArg, el, index, this);
+      out.push(mv);
+      index++;
+    }
+    return out;
+  }
+  _setBucketSize(size) {
+    this._bucketSize = size;
+  }
+  *_getIterator() {
+    for (let i = 0; i < this._length; ++i) {
+      const v = this.at(i);
+      if (v !== void 0) yield v;
+    }
+  }
+  _reallocate(needBucketNum) {
+    const newBuckets = [];
+    const addBucketNum = needBucketNum || this._bucketCount >> 1 || 1;
+    for (let i = 0; i < addBucketNum; ++i) {
+      newBuckets[i] = new Array(this._bucketSize);
+    }
+    for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+      newBuckets[newBuckets.length] = this._buckets[i];
+    }
+    for (let i = 0; i < this._bucketLast; ++i) {
+      newBuckets[newBuckets.length] = this._buckets[i];
+    }
+    newBuckets[newBuckets.length] = [...this._buckets[this._bucketLast]];
+    this._bucketFirst = addBucketNum;
+    this._bucketLast = newBuckets.length - 1;
+    for (let i = 0; i < addBucketNum; ++i) {
+      newBuckets[newBuckets.length] = new Array(this._bucketSize);
+    }
+    this._buckets = newBuckets;
+    this._bucketCount = newBuckets.length;
+  }
+  _getBucketAndPosition(pos) {
+    let bucketIndex;
+    let indexInBucket;
+    const overallIndex = this._firstInBucket + pos;
+    bucketIndex = this._bucketFirst + Math.floor(overallIndex / this._bucketSize);
+    if (bucketIndex >= this._bucketCount) {
+      bucketIndex -= this._bucketCount;
+    }
+    indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+    if (indexInBucket < 0) {
+      indexInBucket = this._bucketSize - 1;
+    }
+    return { bucketIndex, indexInBucket };
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  *_getReverseIterator() {
+    for (let i = this._length - 1; i > -1; i--) {
+      const v = this.at(i);
+      if (v !== void 0) yield v;
+    }
+  }
+};
+export {
+  Deque
+};