Разворот слов

using System.Text;

public class Solution {
    public static string ReverseWords(string s) {
        // Переворачивает порядок слов в строке, сохраняя позиции пробелов
        List<string> parts = new List<string>();
        StringBuilder current = new StringBuilder();

        // В конце цикла parts будет содержать подряд идущие пробельные и непробельные блоки
        foreach (char ch in s) {
            // Если тип текущего блока изменился
            if (current.Length > 0 && (ch == ' ') != (current[0] == ' ')) {
                parts.Add(current.ToString());
                current.Clear();
            }
            current.Append(ch);
        }

        // Добавляем последний блок, если он остался
        if (current.Length > 0) {
            parts.Add(current.ToString());
        }

        Stack<string> words = new Stack<string>();
        foreach (string p in parts) {
            if (p[0] != ' ') {
                words.Push(p);
            }
        }

        StringBuilder result = new StringBuilder();
        foreach (string p in parts) {
            if (p[0] == ' ') {
                result.Append(p);
            } else {
                result.Append(words.Pop());
            }
        }
        return result.ToString();
    }
}

#include <string>
#include <vector>

using namespace std;

string reverseWords(string& s) {
    // Переворачивает порядок слов в строке, сохраняя позиции пробелов
    vector<string> parts;
    string current = "";

    // В конце цикла parts будет содержать подряд идущие пробельные и непробельные блоки
    for (char ch : s) {
        // Если тип текущего блока изменился
        if (!current.empty() && (ch == ' ') != (current[0] == ' ')) {
            parts.push_back(current);
            current = "";
        }
        current += ch;
    }

    // Добавляем последний блок, если он остался
    if (!current.empty()) {
        parts.push_back(current);
    }

    vector<string> words;
    for (string& p : parts) {
        if (p[0] != ' ') {
            words.push_back(p);
        }
    }

    string result = "";
    for (string& p : parts) {
        if (p[0] == ' ') {
            result += p;
        } else {
            result += words.back();
            words.pop_back();
        }
    }
    return result;
}

package main

func reverseWords(s string) string {
    // Переворачивает порядок слов в строке, сохраняя позиции пробелов
    parts := []string{}
    current := ""

    // В конце цикла parts будет содержать подряд идущие пробельные и непробельные блоки
    for _, ch := range s {
        // Если тип текущего блока изменился
        if len(current) > 0 && (string(ch) == " ") != (string(current[0]) == " ") {
            parts = append(parts, current)
            current = ""
        }
        current += string(ch)
    }

    // Добавляем последний блок, если он остался
    if len(current) > 0 {
        parts = append(parts, current)
    }

    words := []string{}
    for _, p := range parts {
        if p[0] != ' ' {
            words = append(words, p)
        }
    }

    result := ""
    for _, p := range parts {
        if p[0] == ' ' {
            result += p
        } else {
            result += words[len(words)-1]
            words = words[:len(words)-1]
        }
    }
    return result
}

import java.util.*;

public class Solution {
    public static String reverseWords(String s) {
        // Переворачивает порядок слов в строке, сохраняя позиции пробелов
        List<String> parts = new ArrayList<>();
        StringBuilder current = new StringBuilder();

        // В конце цикла parts будет содержать подряд идущие пробельные и непробельные блоки
        for (char ch : s.toCharArray()) {
            // Если тип текущего блока изменился
            if (current.length() > 0 && (ch == ' ') != (current.charAt(0) == ' ')) {
                parts.add(current.toString());
                current.setLength(0);
            }
            current.append(ch);
        }

        // Добавляем последний блок, если он остался
        if (current.length() > 0) {
            parts.add(current.toString());
        }

        Deque<String> words = new ArrayDeque<>();
        for (String p : parts) {
            if (p.charAt(0) != ' ') {
                words.addLast(p);
            }
        }

        StringBuilder result = new StringBuilder();
        for (String p : parts) {
            if (p.charAt(0) == ' ') {
                result.append(p);
            } else {
                result.append(words.pollLast());
            }
        }
        return result.toString();
    }
}

from typing import *

# Переворачивает порядок слов в строке, сохраняя позиции пробелов
def reverse_words(s: str) -> str:
    parts = []
    current = ''

    # В цонце цикла parts будет содержать подряд идущие пробельные и не пробельные символы
    for ch in s:
        # Если тип текущего блока изменился
        if current and (ch == ' ') != (current[0] == ' '):
            parts.append(current)
            current = ''
        current += ch

    # Добавляем последний блок, если он остался
    if current:
        parts.append(current)

    # Сохраняем только слова (не пробелы), чтобы потом их вставить в обратном порядке
    words = [p for p in parts if p[0] != ' ']

    # Собираем финальный результат: пробелы оставляем, слова берём с конца
    return ''.join(p if p[0] == ' ' else words.pop() for p in parts)

/**
 * @param {string} s
 * @returns {string}
 */
export function reverseWords(s) {
    // Переворачивает порядок слов в строке, сохраняя позиции пробелов
    const parts = []
    let current = ''

    // В конце цикла parts будет содержать подряд идущие пробельные и непробельные блоки
    for (const ch of s) {
        // Если тип текущего блока изменился
        if (current && (ch === ' ') !== (current[0] === ' ')) {
            parts.push(current)
            current = ''
        }
        current += ch
    }

    // Добавляем последний блок, если он остался
    if (current) {
        parts.push(current)
    }

    const words = parts.filter(p => p[0] !== ' ')
    return parts.map(p => p[0] === ' ' ? p : words.pop()).join('')
}