mthread_course/mnogochlen.cpp at master · smart--petea/mthread_course · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/*
 * Задача простая - найти производную многочлена. Многочлен может быть большой, но только с положительными целыми
 * степенями и целыми коэффициентами. Подумайте, каким образом его лучше представить в памяти? Вывод должен быть без
 * пробелов и в порядке убывания степеней, хотя ввод этому правилу может не удовлетворять. Также на ввод может быть
 * подан многочлен с неприведенными слагаемыми.
 */

#include <iostream>
#include <sstream>
#include <map>
#include <functional>

bool getSign(char& character, std::istream& is, int& sign)
{
    switch(character)
    {
        case '+':
            sign = 1;
            is.get(character);
            break;
        case '-':
            sign = -1;
            is.get(character);
            break;
        default:
            sign = 1;
            break;
    }

    return true;
}

bool getCoefficient(char& character, std::istream& is, int& coefficient)
{
    if(character >= '0' && character <= '9')
    {
        coefficient = 0;
        while(character >= '0' && character <= '9')
        {
            coefficient = coefficient * 10 + (character - '0');
            is.get(character);
        }

        if(character == '*') is.get(character); //?
    } else
    {
        coefficient = 1;
    }

    return true;
}

bool preparePower(char& character, std::istream& is, int& power)
{
    if(character != 'x')
    {
        power = 0;
        return false;
    }

    is.get(character);
    if(character != '^')
    {
        power = 1;
        return false;
    }

    is.get(character);

    return true;
}

std::string derivative(std::string polynomial) {
    char character;
    int pwr;
    int coefficient;
    int sign;
    std::map<int, int, std::greater<int> > polinom;
    std::istringstream plnmInput(polynomial + '\0');
    std::ostringstream result;

    character = plnmInput.get();
    while(character != '\0')
    {
        getSign(character, plnmInput, sign)
        &&
        getCoefficient(character, plnmInput, coefficient)
        &&
        preparePower(character, plnmInput, pwr)
        &&
        getCoefficient(character, plnmInput, pwr);

        coefficient *= sign;

        polinom[pwr] += coefficient;
    }

    std::map<int, int>::iterator it = polinom.begin();
    std::map<int, int>::iterator end = polinom.end();
    bool isFirstLoop = true;
    for(;it != end; it++)
    {
        pwr = it->first - 1;
        coefficient = it->second * it->first;

        if(coefficient == 0) continue;
        if(coefficient > 0 && isFirstLoop == false) result << "+";

        result << coefficient;

        if(pwr > 0) {
            result << "*x";
            if(pwr > 1) result << "^" <<  pwr;
        }

        isFirstLoop = false;
    }

    return result.str();
}


int main()
{
    std::cout << derivative("x+x+x+x+x+x+x+x+x+x") << std::endl;

    return 0;
}