Rsa97

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

#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

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

2 3
0 0
1 1
1 2

int sum = 0;
int maxSum = 0;
for (int i = 0; i < len; i++) {
    sum += val[i];
    if (sum > maxSum)
        maxSum = sum;
    if (sum < 0)
        sum = 0;
}

// Инициализируем C, надо заменить на ввод исходных данных
$C = array(1, 1, 1, 0, 0, 1, 1, 1, 0, 1);
$N = count($C);

// Добавляем в начало и конец нули
array_unshift($C, 0);
$C[] = 0;

// Создаём массив P, заполняем 0 и N+1 элементы нулями
$P[0] = 0;
$P[$N+1] = 0;

// Заполняем чётные ячейки
for ($i = 1; $i <= $N; $i += 2)
    $P[$i+1] = $P[$i-1] ^ $C[$i];

// Заполняем нечётные ячейки
if (($N&1) == 0) {
    // Вариант с чётным количеством ячеек
    for ($i = $N; $i >= 1; $i -= 2)
        $P[$i-1] = $P[$i+1] ^ $C[$i];
} else {
    // Вариант с нечётным количеством ячеек
    $P[1] = 0;
    for ($i = 1; $i <= $N; $i -= 2)
        $P[$i-1] = $P[$i+1] ^ $C[$i];
}

// Выводим результат
for ($i = 1; $i <= $N; $i++)
    print $P[$i];

для i от 1 до N с шагом 2
    P[i+1] = P[i-1] xor C[i];

для i от N до 1 с шагом -2
    P[i-1] = P[i+1] xor C[i];

P[1] = 0; // или 1
для i от 2 до N с шагом 2
    P[i+1] = P[i-1] xor C[i];

SELECT count(*) AS x FROM records 
    WHERE (begin BETWEEN '{$newRecordBegin}' AND '{$newRecordEnd}') OR
          ('{$newRecordBegin}' BETWEEN begin AND end)

d = V[1]-V[0];
for (i = 1; i < N-1, i++) {
    d1 = V[i+1]-V[i];
    if (d < 0 && d1 > 0) {
        // Локальный минимум V[i]
    } else if (d > 0 && d1 < 0) {
        // Локальный максимум V[i]
    }
    d = d1;
}

noise = 2; // Уровень шума, поставить нужное значение
t1 = 0; // Точка перехода к нулю
upDown = 0; // Направление движения до нуля, > 0 - вверх, < 0 - вниз, 0 - начало графика
d = V[1]-V[0];
if (abs(d) < noise)
    d = 0;
for (i = 1; i < N-1, i++) {
    d1 = V[i+1]-V[i];
    if (abs(d1) < noise)
        d1 = 0;
    if (d < 0 && d1 > 0) {
        // Локальный минимум V[i]
    } else if (d > 0 && d1 > 0) {
        // Локальный максимум V[i]
    } else if (d != 0 && d1 == 0) {
        t1 = i;
        upDown = d;
    } else if (d == 0 && d1 > 0 && upDown < 0) {
        // Локальный минимум V[(t1+i)/2] или (V[t1]+V[i])/2
    } else if (d == 0 && d1 < 0 && upDown > 0) {
        // Локальный максимум V[(t1+i)/2] или (V[t1]+V[i])/2
    }
    d = d1;
}