Rsa97

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

.                   +-м(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), получается полигон. Дальше алгоритм сложения полигонов.

Выбирается палитра и ей в какое-либо соответствие (например линейное) ставится диапазон температур.

while (second != 0) {
    reminder = first % second;
    first = second;
    second = reminder;
}
nod = first;

На C++

#include <iostream>
#include <vector>
#include <set>
#include <time>

std::set<std::string> subSeqs;
struct _element {
    char digit;
    int  count;
};
std::vector<_element> elemSeq;

void recurse(std::vector<_element>::iterator elemRest, std::string subSeqHead) {
  bool fin = (elemRest+1 == elemSeq.end());
    for (int i = 0; i <= elemRest->count; i++, subSeqHead += elemRest->digit)
        if (fin)
            subSeqs.insert(subSeqHead);
        else
            recurse(elemRest+1, subSeqHead);
}

void main(void)
{
  int i;
  _element element;
  std::string initialSeq = "1234567890123";

    std::cout << "Initial sequence: " << initialSeq << "\n";

    clock_t start = clock();

    element.digit = initialSeq[0];
    element.count = 1;
    for (i = 1; i < initialSeq.length(); i++) {
        if (element.digit == initialSeq[i])
            element.count++;
        else {
            elemSeq.push_back(element);
            element.digit = initialSeq[i];
            element.count = 1;
        }
    }
    elemSeq.push_back(element);

    recurse(elemSeq.begin(), "");

    clock_t finish = clock();

    i = 0;
    std::cout << "Elements: (";
    for (std::vector<_element>::iterator t = elemSeq.begin();
                                                t != elemSeq.end(); t++) {
        if (i++ != 0)
            std::cout << ", ";
        std::cout << "{'" << t->digit << "', " << t->count << "}";
    }
    std::cout << ")\n";
    std::cout << subSeqs.size()-1 << " unique subsequences\n";
    std::cout << "Calculation time " << finish-start << " clicks, ";
    std::cout << ((float)(finish-start))/CLOCKS_PER_SEC << " sec\n";
/*     for (std::set<std::string>::iterator t = subSeqs.begin();
                                                t != subSeqs.end(); t++) {
        std::cout << *t << "\n";
    } */
}

Результаты:

Initial sequence: 8246
Elements: ({'8', 1}, {'2', 1}, {'4', 1}, {'6', 1})
15 unique subsequences
Calculation time 0 clicks, 0 sec
================================================================
Initial sequence: 88885
Elements: ({'8', 4}, {'5', 1})
9 unique subsequences
Calculation time 0 clicks, 0 sec
================================================================
Initial sequence: 12345678901234567890
Elements: ({'1', 1}, {'2', 1}, {'3', 1}, {'4', 1}, {'5', 1}, {'6', 1}, {'7', 1},
 {'8', 1}, {'9', 1}, {'0', 1}, {'1', 1}, {'2', 1}, {'3', 1}, {'4', 1}, {'5', 1},
 {'6', 1}, {'7', 1}, {'8', 1}, {'9', 1}, {'0', 1})
1043455 unique subsequences
Calculation time 4383 clicks, 4.383 sec
================================================================
Initial sequence: 11223344556677889900
Elements: ({'1', 2}, {'2', 2}, {'3', 2}, {'4', 2}, {'5', 2}, {'6', 2}, {'7', 2},
 {'8', 2}, {'9', 2}, {'0', 2})
59048 unique subsequences
Calculation time 187 clicks, 0.187 sec

Несколько сократить количество вариантов при переборе можно сгруппировав подряд идущие одинаковые цифры. Скажем для (1 1 1 2 1 1) получим исходный набор ((1, 3), (2, 1), (1, 2)). После этого рекурсивно его перебираем.

функция рекурсия(набор, результат) {
    если набор пуст {
        если результат уникален { 
            добавить результат в список уникальных
        }
    }
    ((цифра, количество), следующий_набор) = набор;
    для i от 0 до количество {
        рекурсия(следующий_набор, результат+(цифра i раз));
    }
}
рекурсия(исходный_набор, '');

Первый шаг рекурсии даст варианты '', '1', '11' или '111'. Второй шаг к каждому из них допишет '' или '2'. Третий шаг к каждому из 8 получившихся вариантов допишет '', '1' или '11'. То есть вместо 2⁶ = 64 вариантов для поиска уникальности получим 4*2*3 = 24.
Чем больше будет в исходной последовательности групп подряд идущих одинаковых цифр тем больше будет выигрыш. Если таких групп нет, то упрёмся в полный перебор.