DScheglov

class FixedSizeBuffer<T> {
  #buffer: T[];
  #maxSize: number;
  #index: number = 0;
  #count: number = 0;

  static of<T>(size: number) {
    return new FixedSizeBuffer<T>(size);
  }

DScheglov

Середнє останніх N

Сервер отримує послідовність запитів. Кожен запит — це дійсне число, результат обчислення. Після кожного запиту потрібно повертати середнє значення останніх не більше ніж N чисел.

Вхідні дані

Перший рядок містить одне ціле число N (1 ≤ N ≤ 10⁵) — максимальна кількість останніх значень, які враховуються при обчисленні середнього.

Другий рядок містить одне ціле число Q (1 ≤ Q ≤ 10⁵) — кількість запитів.

DScheglov

type ShouldRetryFn = (err: unknown, res: Response | undefined) => boolean

export class RetryFetchError extends TypeError {
  name = "RetryFetchError"
  constructor(maxAttempts: number, cause?: unknown) {
    super(`Failed to fetch after ${maxAttempts} attempts.`, { cause });
    if (!Object.prototype.hasOwnProperty.call(this, "cause")) {
      Object.defineProperty(this, "cause", { value: cause })
    }
  }

DScheglov

/**
 * TaxiOrder:
 * - **Draft** (default) the order is created with empty data
 * - Placed - the order is placed and System is searching for Driver
 * - Accepted - the Driver accepted the Order, but the the trip is not yet started
 * - InProgress - the trip is started but not finished
 * - Completed - the trip is ended
 * - Cancelled - the Order has been cancelled by Driver or by Customer
 */

DScheglov

type AnyResolvers = {
  [prop in PropertyKey]: (params: any) => any
}

type Resolved<R extends AnyResolvers> = {
  [prop in keyof R]: Awaited<ReturnType<R[prop]>>
}

type UnionToIntersection<U> = (U extends any ? (a: U) => any : never) extends ((b: infer A) => any) ? A : never;

DScheglov

const startsWith = (letter: string) =>
  (word: string) =>
    word[0] === letter;

const isAny = () =>
  true;

const lastLetterOf = (word: string): string =>
  word[word.length - 1];

DScheglov

const isThenable = value => typeof value?.then === "function";

const wrapHandler = (handler, resolve, reject) => resultOrError => {
  try {
    const handledResult = handler(resultOrError);

    if (isThenable(handledResult)) {
      handledResult.then(resolve, reject);
    } else {
      resolve(handledResult);

DScheglov

public abstract class CodingService {
  abstract Developer createDeveloper();
  public void writeCode() {
    Developer dev = createDeveloper();
    String code = dev.writeCode();
    System.out.println(code);
  }
}

DScheglov

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';
import { flatMap } from 'rxjs/operators';
import { fromFunctionCall } from '../common/utils';

@Injectable()
export class LoginInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const req = context.switchToHttp().getRequest();

DScheglov

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable, Observer } from 'rxjs';
import { flatMap } from 'rxjs/operators';

const nextAndComplete = <T>(observer: Observer<T>, value?: T): void => {
  observer.next(result);
  observer.complete();
};

@Injectable()