Развернуть слова в строке

Решение

Задача на разворот слов — простая, но требует внимательности к деталям. Покажем несколько способов реализации.

Решение 1: map + split/join (самый читаемый)

Способ с использованием функциональных методов:

function reverseWords(str: string): string {
  return str
    .split(" ")           // Разбиваем на слова
    .map(word =>          // Разворачиваем каждое слово
      word.split("").reverse().join("")
    )
    .join(" ");           // Собираем обратно
}

console.log(reverseWords("Hello World"));
// "olleH dlroW"

console.log(reverseWords("The quick brown fox"));
// "ehT kciuq nworb xof"

console.log(reverseWords("a b c"));
// "a b c"

console.log(reverseWords("JavaScript"));
// "tpircSavaJ"

Анализ:

• Временная сложность: O(n) — проходим по каждому символу
• Пространственная сложность: O(n) — новые строки
• Читаемость: Отличная — сразу видна логика
• Масштабируемость: Хорошая — легко изменить

Решение 2: Регулярные выражения

Более компактный вариант:

function reverseWordsRegex(str: string): string {
  return str.replace(/\S+/g, word =>
    word.split("").reverse().join("")
  );
}

Анализ:

• \S+ — один или больше непробельных символов
• g — глобальный поиск (все слова)
• Более компактно, но менее явно

Решение 3: Цикл с массивом

Для большей контроля над процессом:

function reverseWordsLoop(str: string): string {
  const words = str.split(" ");
  const result: string[] = [];
  
  for (const word of words) {
    let reversed = "";
    for (let i = word.length - 1; i >= 0; i--) {
      reversed += word[i];
    }
    result.push(reversed);
  }
  
  return result.join(" ");
}

Анализ:

• Явная логика разворота
• Хорошо для понимания процесса
• Немного более многословно

Решение 4: Функциональное решение

Функция для разворота + применение к словам:

const reverseString = (str: string): string =>
  str.split("").reverse().join("");

function reverseWordsFunction(str: string): string {
  return str
    .split(" ")
    .map(reverseString)
    .join(" ");
}

// Или с более сложной логикой
function reverseWordsComposed(str: string): string {
  const reverseEach = (words: string[]) =>
    words.map(reverseString);
  
  const compose = (...fns: Array<(arg: any) => any>) =>
    (x: any) => fns.reduce((acc, fn) => fn(acc), x);
  
  const pipeline = compose(
    (str: string) => str.split(" "),
    reverseEach,
    (words: string[]) => words.join(" ")
  );
  
  return pipeline(str);
}

Бонус 1: Разворот всей строки целиком

Вторая часть бонуса — разворот всей строки:

// Простое решение
function reverseString(str: string): string {
  return str.split("").reverse().join("");
}

// Оптимизированное решение
function reverseStringOptimal(str: string): string {
  let reversed = "";
  for (let i = str.length - 1; i >= 0; i--) {
    reversed += str[i];
  }
  return reversed;
}

// Используя Array.from
function reverseStringArray(str: string): string {
  return Array.from(str).reverse().join("");
}

console.log(reverseString("Hello World"));
// "dlroW olleH"

console.log(reverseString("JavaScript"));
// "tpircSavaJ"

Бонус 2: Разворот слов И разворот всей строки

Комбинируем две операции:

// Сначала разворачиваем слова, потом всю строку
function reverseWordsAndString(str: string): string {
  const reversedWords = reverseWords(str);
  return reverseString(reversedWords);
}

console.log(reverseWordsAndString("Hello World"));
// dlroW olleH → dlroW olleH (слова развернуты)
// затем вся строка: "Hwo dlroW olleH" - нет, не так

// Правильно:
console.log(reverseWordsAndString("Hello World"));
// reverseWords: "olleH dlroW"
// reverseString: "dlroW olleH"

Бонус 3: Разворот порядка слов (ещё один бонус!)

Третий вариант бонуса:

function reverseWordOrder(str: string): string {
  return str.split(" ").reverse().join(" ");
}

console.log(reverseWordOrder("Hello World"));
// "World Hello"

console.log(reverseWordOrder("The quick brown fox"));
// "fox brown quick The"

Сложный случай: Сохранение множественных пробелов

Если нужно сохранить несколько пробелов между словами:

function reverseWordsPreservSpaces(str: string): string {
  return str.replace(/\S+/g, word =>
    word.split("").reverse().join("")
  );
}

console.log(reverseWordsPreservSpaces("Hello  World"));
// "olleH  dlroW" (два пробела сохранены)

Полная тестовая батарея

const testCases = [
  { input: "Hello World", expected: "olleH dlroW" },
  { input: "The quick brown fox", expected: "ehT kciuq nworb xof" },
  { input: "a b c", expected: "a b c" },
  { input: "JavaScript", expected: "tpircSavaJ" },
  { input: "", expected: "" },
  { input: "a", expected: "a" },
  { input: "  a  b  ", expected: "  a  b  " }
];

testCases.forEach(({ input, expected }) => {
  const result = reverseWords(input);
  console.assert(result === expected, 
    `Failed: "${input}" => "${result}" (expected "${expected}")`
  );
});

Сравнение подходов

Рекомендации для собеседования

1. Начните с простого split/map/join — очень читаемо
2. Объясните временную сложность — O(n)
3. Предложите regex вариант — знание регулярных выражений
4. Обсудите edge cases — пустые строки, пробелы
5. Реализуйте бонусы — это покажет полноту решения

Лучший выбор: split/map/join — современный JavaScript, читаемый и эффективный.