Завдання таке дивне було.
Кажуть, уявіть собі 32-бітне число зі знаком. І нам треба його відзеркалити, тобто, 132 стає 231, а -1234 стає -4321. При цьому, кажуть, якшо отримане число більше 32-біт, то повернути 0.
А я ж веб-макакій, то й зробив по-своєму.

function reverse(x: number): number {
  const abs = Math.abs(x);
  const sign = Math.sign(x);
  const rev = Number(abs.toString().split('').reverse().join(''));
  return rev > Math.pow(2, 31) - 1 ? 0 : sign * rev;
};

Про розв'язок напишу тепер. Я вам відразу скажу, шо курс по алгоритмам і структурам даних, який я проходив пів року тому - не минув дарма, бо я відразу зрозумів, шо нам треба два курсора, один завжди був би поперед іншого.

Ідея в тім, шо у нас є геш таблиця, котрі тримає інфу про індекси символів. Також у нас є два оці курсори. Перший на 0 індексі, другий на 1.
І далі ми перевіряємо - якшо символ під правим курсором вже є в таблиці, і його індекс більший за лівий курсор - це означає, шо ми натрапили на дублікат символу, і все, шо є між попереднім значенням правого курсора і лівим курсором - унікальний рядок, в котрому символи не повторюються.
Коли ми натрапляємо на такий дубль, то нам тре зберегти довжину того унікального підрядка. Ну а потім ми збільшуємо правий курсор на 1, а лівий встановлюємо в (попередній індекс символу, котрий зустріли + 1) і перевіряємо то все заново. І ще треба не забувати заносити в геш таблицю індекси тих символів, котрі зустрічаємо.

Нехай у нас є такий рядок

123145

Спершу лівий курсор на 1, а правий на 2.
Ми дивимося в таблицю, і бачимо, шо 2 в нас ще там нема, тому рухаємось вперід, заносячи індекс двійки в таблицю.

Далі у нас лівий курсор так само на 1, а правий вже на 3. Ми не бачимо 3 в таблиці, тому рухаємось далі, і заносимо інфу про цей символ в таблицю.

Тепер у нас лівий курсор на 1, а правий на 1. Ми дивимось в таблицю, і бачимо, шо ми вже зустрічали 1 під індексом 0, і наш лівий курсор як раз на нього вказує. Це означає, шо нам тепер тре відняти індекс правого курсора (3) від індексу лівого курсора (0), і нас виходе 3 - це довжина підрядка, в якому символи не повторюються.

Тепер ми рухаємо лівий курсор на (останній індекс дубльованого символу + 1, тобто 0 + 1 = 1)=, а правий курсор просто інкрементуємо.

Тепер лівий курсор на 2, а правий на 4. 4 ще не було в таблиці, тому заносимо його, і рухаємось далі.

Тепер лівий курсор так само на 2, а правий на 5. 5 так само новеньке для нас.

Тепер правий курсор дійшов кінця рядка, і ми беремо його індекс (5) і віднімаємо від нього індекс лівого курсора (1) і виходе 4. Але це не дуже правильно, бо насправді довжина підрядка - 5, а не 4. І оце проблєма індексів, яку я постійно маю. Воно працює добре для того, що йде всередині рядка, але коли ми доходимо до кінця, то одинички не вистачає, тому цей випадок я окремо обробляю, в кінці.

function lengthOfLongestSubstring(s: string): number {
  let left = 0,
    right = 1;
  const table = new Map<string, number>();
  table.set(s[left], left);
  
  let max = 0;
  while (right < s.length) {
    const check = s[right];
    if (table.has(s[right]) && table.get(s[right]) >= left) {
      max = Math.max(max, right - left);
      left = table.get(s[right]) + 1;
    }
    table.set(s[right], right);
    right++;
  }

  max = Math.max(max, s.length - left);

  return max;
}

По діленню двох чисел без використання множення, ділення і ділення по модулю - все виявилось складніше, ніж я думав.
У мене відразу зв'явився простий алгоритм - в циклі віднімаємо від діленого дільник, і рахуємо кількість таких віднімань. Але якшо у нас буде 2147483647, що ділиться на 1, то це ж буде 2147483647 операцій в циклі.     І воно не пропускає по часу.

Я довго кулупався з рішеннями, котрі самі користувачі пропонували, і через те, шо один і той самий алгоритм кожна людина може написати по-своєму, мені було складнувато допетрати, шо той код робе, але зрештою я зрозумів ідею ділення кутом, і написав код по-своєму.

function divide (dividend, divisor) {  
  const max = Math.pow(2, 31) - 1;
  const min = -Math.pow(2, 31);
  
  const dividendAbs = Math.abs(dividend);
  const divisorAbs = Math.abs(divisor);
  const dividendStr = dividendAbs.toString();
  const divisorStr = divisorAbs.toString();
  let result = [];
  let rest = 0;
     const divisorLength = divisorStr.length;
  
  for (let i = 0; i <= dividendStr.length-1; i+=divisorLength) {
      rest = Number(rest + dividendStr.slice(i, i+divisorLength));
    let multiplier = 0;

    if (rest >= divisorAbs) {
        while (rest >= divisorAbs) {
          multiplier++;
        rest -= divisorAbs;
      }
    }
    
    result.push(multiplier)
  }
  let signedResult = Number(result.join(''));
  if (dividend < 0) signedResult = -signedResult;
  if (divisor < 0) signedResult = -signedResult;
  return signedResult > max ? max : signedResult < min ? min : signedResult;
}

Ще є варіант з бітовим зсувом, але це я ще не написав, як напишу, то напишу.

Чорт. Мене спіймали минулого разу. Ось така задача.
Від числа n (10<=n<10000) віднімають суму його цифр. Якщо результат став від 1 до 100, беремо відповідь з масива і повертаємо, якщо ні - результат - наше нове n, повторюємо процедуру.

Особливе попередження: треба подумати перед кодуванням.

Просто минулого разу я її на пайтоні писав і мені було влом думати.
А на C вже доводиться.

Там немає нічого складного, просто порядково розбираєте команди.

def get_value(arg, registers):
    try:
        return int(arg)
    except ValueError:
        return registers[arg]

def simple_assembler(program):
    registers = {}
    ip = 0
    while 0<=ip<len(program):
        parts = program[ip].split()
        if parts[0]=="inc":
            registers[parts[1]] += 1
        elif parts[0]=="dec":
            registers[parts[1]] -= 1
        elif parts[0]=="mov":
            registers[parts[1]] = get_value(parts[2], registers)
        elif parts[0]=="jnz":
            if get_value(parts[1], registers)!=0:
                ip += get_value(parts[2], registers)
                continue
        else:
            raise ValueError("Wrong instruction: " + program[ip])
        ip += 1
    return registers

Проглянув інші рішення - є ж талановиті люди...

Довго промучився, пробуючи рекурсію як за каноном у Scala, проте на «складних програмах» воно сипалося. І ніяк не придумав, де втулити хвостову рекурсію з теґом @tailrec.

object SimpleAssembler {
  def interpret(program: List[String]): Map[String, Int] = {
    val result = new HashMap[String, Int]

    def loop(list: List[String]): Unit = breakable {
      for (command <- list) {
        val args = command.split(' ')
        args(0) match {
          case "mov" => 
            result.put(args(1), result.get(args(2)).getOrElse(args(2).toInt))
          case "inc" => 
            result.put(args(1), result.get(args(1)).get + 1)
          case "dec" => 
            result.put(args(1), result.get(args(1)).get - 1)
          case "jnz" =>
            val switcher = 
                result.get(args(2)).getOrElse(args(2).toInt)
            if (result.get(args(1)).getOrElse(args(1).toInt) != 0) {
              val startPosition = program.indexOf(command) + switcher
              loop(program.slice(startPosition, program.length))
              break()
            }
        }
      }
    }
    loop(program)
    result.toMap
  }
}

Зрештою закинув до готових цей процедурний стандарт як у koala:

object SimpleAssembler {
  def interpret(program: List[String]): Map[String, Int] = {
    val result = new HashMap[String, Int]
    var iter = 0
    

    while (iter < program.length) {
      breakable {
        val args = program(iter).split(' ')
        args(0) match {
          case "mov" => 
            result.put(args(1), result.get(args(2)).getOrElse(args(2).toInt))
          case "inc" => 
            result.put(args(1), result.get(args(1)).get + 1)
          case "dec" => 
            result.put(args(1), result.get(args(1)).get - 1)
          case "jnz" =>
            val switcher = 
                result.get(args(2)).getOrElse(args(2).toInt)
            if (result.get(args(1)).getOrElse(args(1).toInt) != 0) {
              iter = iter + switcher
              break()
            }
        }
        iter = iter + 1
      }
    }
    result.toMap
  }
}

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

Ок, можна ще так, щоб зовсім без зайвини. І на цьому мої ідеї сьодні вичерпались.

object SimpleAssembler {
  def interpret(program: List[String], 
                currentIndex: Int = 0, 
                result: HashMap[String, Int] = new HashMap[String, Int]
                ): Map[String, Int] = {
    if (currentIndex >= program.length) result.toMap
    else {
      lazy val getNumericValue = (
        hashMap: HashMap[String, Int], 
        value: String
      ) => 
        hashMap.get(value).getOrElse(value.toInt)
      val args = program(currentIndex).split(' ')
      val switcher: Int = args(0) match {
        case "mov" =>
          result.put(args(1), getNumericValue(result, args(2)))
          1
        case "inc" =>
          result.put(args(1), result.get(args(1)).get + 1)
          1
        case "dec" =>
          result.put(args(1), result.get(args(1)).get - 1)
          1
        case "jnz" =>
          if (getNumericValue(result, args(1)) != 0) {
            getNumericValue(result, args(2))
          } else {
            1
          }
      }
      interpret(program, currentIndex + switcher, result)
    }
  }
}