data-structure-typed 2.5.0 → 2.5.2

package/dist/leetcode/deque.mjs

@@ -1,683 +0,0 @@
-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
-};