Rsa97

А в чём проблема?
Определяем алфавит: (а, и, й, м, н, о, р, ф, ц, ы).
Считаем символы (распределение вероятности).

а | и | й | м | н | о | р | ф | ц | ы
1 | 2 | 1 | 1 | 3 | 2 | 1 | 1 | 1 | 1

Строим накопительную сумму

а | и | й | м | н | о  | р  | ф  | ц  | ы
1 | 3 | 4 | 5 | 8 | 10 | 11 | 12 | 13 | 14

Приводим в отрезок [0,1) делением на общую сумму (14)

а     | и     | й     | м     | н     | о     | р     | ф     | ц     |  ы
0.071 | 0.214 | 0.286 | 0.357 | 0.571 | 0.714 | 0.786 | 0.857 | 0.929 | 1

Кодируем сообщение

старт - [0, 1)
и - [0.071, 0.214)
н - [0.122, 0,153)
ф - [0.1465, 0.1486)
...
й - [0.147980532221506, 0.147980532221545)

Берём середину интервала, получаем кодированное сообщение 0.147980532221526

Можно. https://play.golang.org/p/NSweti4o8R

Сортировка - практически то же бинарное дерево, так что проще за один проход.
Ну или добавить корзинную сортировку, растить несколько деревьев, разделяя их по одной-двум первым буквам слова.
А может лучше и не бинарное дерево. Если алфавит заранее известен и ограничен (скажем, N символов), то в каждом узле дерева делать разделение на N ветвей, беря в качестве индекса порядковый номер символа в алфавите.

Задача сводится к разбиению исходного множества грузов на группы, суммарное время доставки которых не превосходит 2:58, но максимально близко к этой величине.
Точное решение - перебор всех вариантов - на таком количестве грузов неприменим.
Один из методов приближённого решения - жадный алгоритм. Рассортируем грузы по убыванию времени доставки. Заведём (1000/(178/30)) = 169 ячеек и для каждого груза из отсортированного списка будем просматривать ячейки начиная с первой на возможность добавления в неё груза с учётом ограничений.

Угу. Туда же попадут "автор", "автохтон", "автобиография", "автомат"... А уж слова с приставками... По хорошему, надо разделять слова на приставку, корень (корни), суффикс и окончание, для чего желательно знать, как минимум роль слова в предложении (и то может не помочь, попробуйте разобрать "Косил косой косой косой" - да, тот самый заяц на поляне, да ещё и коса кривая.
Но если так хочется - строите дерево, где каждый уровень - следующая буква слова, а в узлах и листьях стоят счётчики количества слов. Для слов "автомобиль", "авто" и "автострада" получаем:

.                   +-м(1)-о(1)-б(1)-и(1)-л(1)-ь(1)
.а(3)-в(3)-т(3)-о(3)+
.                   +-с(1)-т(1)-р(1)-а(1)-д(1)-а(1)

Затем обходим дерево, там где сумма счётчиков в дочерних узлах не равна счётчику в родительском - заканчивается слово, а разность между суммами даёт количество этих слов в тексте.

последовательно читаем выражение, для каждой лексемы по её типу:
число -> создать ноду (ЧИСЛО, значение), положить её на стек;
унарный оператор -> снять со стека ноду (потомок), создать ноду (УНАРНАЯОПЕРАЦИЯ, тип, потомок), положить новую ноду на стек;
бинарный оператор -> снять со стека две ноды (потомок1 и потомок2), создать ноду (БИНАРНАЯОПЕРАЦИЯ, тип, потомок1, потомок2), положить новую ноду на стек;
функция -> снять со стека N нод по числу аргументов функции (потомок1,... потомокN), создать ноду (ФУНКЦИЯ, имя, потомок1,... потомокN), положить новую ноду на стек;

В конце работы по корректному выражению на стеке должна лежать одна нода, она и будет корнем дерева.

Для разбиения на две группы задача сводится к задаче о рюкзаке с весом рюкзака равным половине общего веса камней и ценностью камней равной их весу.

Не должны повторяться перестановки - значит для каждого множества слагаемых {a, b, c} можно найти множество {a', b', c'}, образованное перестановкой элементов исходного множества, такое, что a'<=b'<=c'. Значит каждый следующий вложенный цикл должен начинаться не с 1, а со значения итератора предыдущего цикла.
---
Подумал ещё:
При условии a<=b<=c, a+b+c=n значение a не может быть больше n/3, иначе b либо c будут б̶о̶л̶ь̶ш̶е меньше, чем a.
Значение b не может быть больше, чем (n-a)/2, иначе c будет б̶о̶л̶ь̶ш̶е меньше b.
Значение c будет равно (n-a-b).
Итого, получаем

int n = Integer.parseInt(reader.readLine());
for (int i = 1; i <= n/3; i++) {
    for (int j = i; j <= (n-i)/2; j++) {
        System.out.println("Числа " + i + " + " + j + " + " + (n-i-j));
    }
}

Если знаете английский, почитайте эту статью

К каждой линии добавляются точки (x₁; 0) и (x_n; 0) (проекции крайних точек на ось X), получается полигон. Дальше алгоритм сложения полигонов.