С Новым годом! Форум программистов, компьютерный форум, киберфорум
Наши страницы

C++

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 2744, средняя оценка - 4.89
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
#1

Задачи для тренировки и лучшего понимания - C++

15.07.2010, 05:53. Просмотров 352598. Ответов 1272
Метки нет (Все метки)

Ребят. Кто-нибудь может дать задачу для тренировки? Приблизительно по всему курсу С++. Буду благодарен за сложную задачу, но которую способен сделать новичок-любитель. Затраты сил-времени не важно. Главное, чтобы это было интересно и не слишком рутинно. + Если найдется человек который даст задачу просьба помогать с кодом, который я буду себя скидывать. Не переписывать за меня, но указывать на ошибки и желательно объяснять. Заранее спасибо.

Список задач, решение которых присутствует в данной теме:
41
Лучшие ответы (59)
Сообщение: #857841 Сообщение: #857861 Сообщение: #858352 Сообщение: #859371 Сообщение: #860160 Сообщение: #860255 Сообщение: #860259 Сообщение: #860317 Сообщение: #860368 Сообщение: #860466 Сообщение: #860508 Сообщение: #860720 Сообщение: #861091 Сообщение: #862174 Сообщение: #862617 Сообщение: #867259 Сообщение: #870298 Сообщение: #872053 Сообщение: #876456 Сообщение: #880114 Сообщение: #882889 Сообщение: #884418 Сообщение: #886414 Сообщение: #886989 Сообщение: #887733 Сообщение: #888464 Сообщение: #888487 Сообщение: #888941 Сообщение: #888947 Сообщение: #889040 Сообщение: #889450 Сообщение: #889587 Сообщение: #891772 Сообщение: #891790 Сообщение: #891862 Сообщение: #897758 Сообщение: #897782 Сообщение: #906325 Сообщение: #907991 Сообщение: #943672 Сообщение: #943700 Сообщение: #967735 Сообщение: #1053777 Сообщение: #1054209 Сообщение: #1083853 Сообщение: #1083928 Сообщение: #1131058 Сообщение: #1131359 Сообщение: #1273743 Сообщение: #1275465 Сообщение: #1276743 Сообщение: #1279215 Сообщение: #1282583 Сообщение: #1309088 Сообщение: #1315633 Сообщение: #1366395 Сообщение: #1550164 Сообщение: #1603678 Сообщение: #1604364
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
15.07.2010, 05:53
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Задачи для тренировки и лучшего понимания (C++):

Прошу примеров для понимания INDY - C++ Builder
Уважаемые коллеги и братья по интересу. Прошу примеров использования Indy UDP Server (TIdUDPServer) и Indy UDP Client (TIdUDPClient) для...

Ищу примеры для понимания взаимодействия Callback + event - C++ WinAPI
Господа, подкиньте плиз какой-нибудь пример для понимания взаимодействия Callback+event С самими Callback функциями вроде разобрался, а...

Элементарные программы, для лучшего понимания языка... - C++
Здравствуйте. Вот сегодня решил что пора изучать с++. Есть пару задач. Начал решать и уже на первой запоролся( суть в том чтобы определить...

Нужны задачи для тренировки - C++
Здравствуйте киньте пожалуйста задания по с++ для человека начинающего изучать Turbo с++

Нужны задачи для тренировки - C++
Киньте задачки на классы......а то в самоучителе, по которому я учу Сишку....приведены задачки, касающиеся только математики.....сами...

Нужны простые задачи для тренировки - C++
Добрый день всем:) Наверное подобных тем как я тут сотни,но всё же. Начал изучать С++(так как необходим для универа)в дальнейшем...

1272
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
07.08.2010, 16:36 #616
Цитата Сообщение от Nameless One Посмотреть сообщение
Кстати, существует довольно-таки несложный алгоритм для преобразования выражения в инфиксной нотации в выражение в постфиксной нотации. ИМХО, именно таким образом и нужно запрограммировать калькулятор (ввел выражение в инфиксной нотации -> перевел в постфиксную -> вычислил), т.к. с появлением в нем хотя бы тех же скобок для переопределения приоритетов реализация сильно усложниться.
написал конвертер из инфиксной в постфиксную.
C++
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
#include <iostream>
#include <algorithm>
#include <string>
#include <stack>
 
#define OP_PLUS            '+'
#define OP_MINUS           '-'
#define OP_ASTERIX         '*'
#define OP_SLASH           '/'
#define OP_LEFT_BRACKET    '('
#define OP_RIGHT_BRACKET   ')'
#define OP_QUOTE           '\"'
 
const int code_matrix[5][4] = { 
   { 0, 0, 0, 0 },
   { 1, 2, 2, 1 },
   { 1, 1, 2, 1 },
   { 1, 1, 1, 1 },
   { 4, 2, 2, 3 }
};
 
int code_priority(char ch)
{
   switch(ch)
   {
   case OP_PLUS:
   case OP_MINUS: 
      return 1;
 
   case OP_ASTERIX:
   case OP_SLASH: 
      return 2;
 
   case OP_LEFT_BRACKET:
      return 3;
 
   case OP_RIGHT_BRACKET:
      return 4;
 
   default: 
      return 0;
   }
}
int get_code(int row, int col)
{
   return code_matrix[row][col];
}
 
int main()
{
   std::string expr;
   std::string out;
   std::stack<char> stack;
 
   std::cout << "input expression: ";
   std::cin >> expr;
 
   for(int i = 0, code = 0; i < expr.size(); ++i)
   {
      if(stack.empty())
         code = get_code(code_priority(expr[i]), 0);
      else
         code = get_code(code_priority(expr[i]), code_priority(stack.top()));
 
      switch(code)
      {
      case 0: // GREEN
         out += expr[i];
         break;
 
      case 1: // PUSH
         stack.push(expr[i]);
         break;
 
      case 2: // POP
         out += stack.top();
         stack.pop();
         i--;
         break;
 
      case 3: // DEL
         stack.pop();
         break;
 
      default:
         std::cerr << "error" << std::endl;
 
         system("PAUSE");
         return EXIT_FAILURE;
      }
   }
 
   while(!stack.empty())
   {
      if(stack.top() != OP_RIGHT_BRACKET && stack.top() != OP_LEFT_BRACKET)
         out += stack.top();
      stack.pop();
   }
 
   std::cout << out << std::endl;
 
   system("PAUSE");
   return EXIT_SUCCESS;
}
1
nikkka
07.08.2010, 16:41
  #617

Не по теме:

Цитата Сообщение от fasked Посмотреть сообщение
написал конвертер из инфиксной в постфиксную.
так как я ничего не понял, удаляюсь в дебри википедии...

0
ForEveR
07.08.2010, 16:50  [ТС]
  #618

Не по теме:

fasked, Красиво все через стек закручено. I like it

0
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
07.08.2010, 16:51 #619
Цитата Сообщение от nikkka Посмотреть сообщение
так как я ничего не понял, удаляюсь в дебри википедии...
да тут все предельно просто. в постфиксной нотации в принципе нет проблем с приоритетами операций, так как нет скобок и оператор расположен после операндов, а не между как в привычной нам записи. соответственно считать проще и памяти уходит меньше. гуглить по словам "обратная польская запись"

Добавлено через 1 минуту
Цитата Сообщение от Lavroff Посмотреть сообщение
Красиво все через стек закручено. I like it
от switch-case конструкций надо бы избавиться. и еще там есть как минимум одна бесполезная функция.
0
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
07.08.2010, 17:29  [ТС] #620
Мда... Видимо получилось хуже чем ночью...

Const_strings.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef _Const_string_H_
#define _Const_string_H_
 
#include <string>
 
namespace Operators
{
    const char Plus='+';
    const char Minus='-';
    const char Div='/';
    const char Mult='*';
}
 
#endif

Main.cpp
C++
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
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <stdexcept>
#include "Const_strings.h"
 
using namespace Operators;
 
int main()
{
    std::string Str;
    std::cout<<"Enter string: ";
    std::getline(std::cin, Str);
    std::string Delim;
    Delim+=Plus; Delim+=Minus; Delim+=Div; Delim+=Mult;
    char ch='0';
    std::string::iterator p=Str.begin();
    p=(std::find_first_of(Str.begin(), Str.end(), Delim.begin(), Delim.end()));
    if(p!=Str.end())
        ch=*p;
    std::stringstream ss(Str);
    std::string Temp;
    std::vector<double> Vec;
    int i=0;
    while(ss>>Temp)
    {
        double l=atof(Temp.c_str());
        Vec.push_back(l);
    }
    if(ch=='+')
        std::cout<< Vec[0] + Vec[2] <<'\n';
    else if(ch=='-')
        std::cout<< Vec[0] + Vec[2] <<'\n';
    else if(ch=='*')
        std::cout<< Vec[0] * Vec[2] <<'\n';
    else if(ch=='/')
    {
        try
        {
            if(Vec[2]==0)
                throw(std::runtime_error("Can` t divide by zero!"));
            std::cout<< Vec[0] / Vec[2] <<'\n';
        }
        catch(std::exception&e)
        {
            std::cout<< e.what() <<'\n';
        }
    }
    else
        std::cerr<<"There is no such token\n";
    return 0;
}
0
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
07.08.2010, 17:38 #621
Цитата Сообщение от Lavroff Посмотреть сообщение
Мда... Видимо получилось хуже чем ночью...
у меня не работает, вылет за пределы массива.
Код
Assertion Failed!
Expression: vector subscript out of range
0
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
07.08.2010, 17:40  [ТС] #622
fasked, Через пробелы писать. Например 2 + 5. Одно действие одновременно из +-*/
0
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
07.08.2010, 17:47 #623
Цитата Сообщение от Lavroff Посмотреть сообщение
Через пробелы писать. Например 2 + 5. Одно действие одновременно из +-*/
не слишком ли мудрено? я про такое решение в целом
0
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,547
Завершенные тесты: 3
07.08.2010, 19:30  [ТС] #624
fasked, Не знаю даже... Через пробелы логичнее, дабы разбивать строку по частям, когда встречаются пробелы. Посему строка 2 + 5 превратится в
2
+
5...
+ еще меня atof несколько бесит, ибо получается 2,0,5 в векторе. Приходится смотреть по индексам массива, дабы не было выхода за пределы. Поэтому более двух слагаемых здесь не получится, если не переработать

Добавлено через 1 час 37 минут
За такой код сразу убивают или дают чуть-чуть пожить?

Lolc
C++
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
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <fstream>
 
#define BegErr "In begin of programm must be BEG\n"
#define LpErr "Programm must beginning with {\n"
#define RpErr "Program must ended with }\n"
#define EndErr "In end of programm must be END\n"
#define PunctErr "After expression must be ;\n"
 
int main()
{
    std::string Str;
    std::string Var;
    std::string Ass;
    double Value=0;
    std::vector<std::string> ArrStr;
    std::ifstream ifs("Test.txt");
    size_t i=0;
    if(!(ifs))
    {
        std::cerr<<"Can` t open file or file doesn`t existed\n";
        return 1;
    }
    while(!(ifs.eof()))
    {
    std::getline(ifs, Str);
    ArrStr.push_back(Str);
    }
    for(size_t i=0;i!=ArrStr.size();++i)
    {
        if(i==0)
        {
            if(ArrStr[0]=="BEG") std::cout<<"BEG\n";
            if(ArrStr[0]!="BEG")
            {
                std::cerr<<BegErr;
                return 1;
            }
        }
        if(i==1)
        {
            if(ArrStr[1]=="{") std::cout<<"{\n";
            if(ArrStr[1]!="{")
            {
                std::cerr<<LpErr;
                return 1;
            }
        }
        if(i==ArrStr.size()-2)
        {
            if(ArrStr[ArrStr.size()-2]=="}") std::cout<<"}\n";
            if(ArrStr[ArrStr.size()-2]!="}")
            {
                std::cerr<<RpErr;
                return 1;
            }
        }
        if(i==ArrStr.size()-1)
        {
            if(ArrStr[ArrStr.size()-1]=="END") std::cout<<"END\n";
            if(ArrStr[ArrStr.size()-1]!="END")
            {
                std::cerr<<EndErr;
                return 1;
            }
        }
        if(ArrStr[i]!="BEG"&&ArrStr[i]!="END"&&ArrStr[i]!="{"&&ArrStr[i]!="}")
        {
            if(ArrStr[i][ArrStr[i].size()-1]!=';')
            {
                std::cerr<<PunctErr;
                return 1;
            }
        }
        std::stringstream ss(ArrStr[i]);
        std::string Temp;
        if(ArrStr[i].find('=')!=std::string::npos)
        {
            ss>>Temp;
            Var=Temp;
            ss>>Temp;
            Ass=Temp;
            ss>>Temp;
            Value=atof(Temp.c_str());
            std::cout<< Var << Ass << Value <<';'<<'\n';
        }
    }
    return 0;
}
0
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
07.08.2010, 20:00 #625
Цитата Сообщение от Lavroff Посмотреть сообщение
За такой код сразу убивают или дают чуть-чуть пожить?
это ж сколько if'ов то здесь..
раз уж многие начали калькуляторы писать, может объеденим усилия? может что и не совсем жуткого выйдет.
0
Mr.X
Эксперт С++
3051 / 1696 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
07.08.2010, 20:31 #626
Дополнил свой калькулятор из поста #403 (страница 41) до той же функциональности, что и в книжке у Страуструпа:
C++
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
///////////////////////////////////////////////////////////////////////////////
// Калькулятор делает то же, что и калькулятор в книжке Страуструпа, т.е.
// вычисляет последовательность арифметических выражений, в которых используются
// круглые скобки. Арифметические выражения должны быть записаны в одной строке, 
// и разделены точкой с запятой. Арифметическим выражением также считается 
// инициализация переменной. Имеются встроенные константы pi и e.
// Пример корректной строки ввода:
// r = 1.5; a = 2 * pi * r; b = a * a
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef double                  T_num;
typedef std::map<T_str, T_num>  T_names_values;
///////////////////////////////////////////////////////////////////////////////
class T_calculator
{
    //-------------------------------------------------------------------------    
    enum
    {
        LEFT_PARENTHESIS   = '(',
        RIGHT_PARENTHESIS  = ')',               
        
        PLUS_SIGN   = '+',
        MINUS_SIGN  = '-',        
 
        ASTERISK    = '*',
        SLASH       = '/',
 
        EQUALS_SIGN = '=',
        SEMICOLON   = ';',        
        FINISH_SYMB = '$'
    };
    //-------------------------------------------------------------------------
    T_names_values  names_values;
    //-------------------------------------------------------------------------
public:
    T_calculator();    
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    bool  calc_expr_list            (const T_str&  s_inp, T_str&  s_out);
    bool  print_expr                (const T_str&  s_inp, T_str&  s_out);    
 
    void  remove_spaces             (T_str&  s);
    bool  calc_expr                 (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_semicolon            (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_summand              (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_line_of_summand      (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_factor               (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_line_of_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_add_summand          (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_subtract_summand     (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_minus_factor         (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_expr_in_brackets     (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_name_and_name_init   (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_num                  (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_mult_to_factor       (const T_str&  s_inp, T_str&  s_out, T_num& res);
    bool  calc_div_into_factor      (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_plus                 (const T_str&  s_inp, T_str&  s_out);
    bool  calc_minus                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_left_parenthesis     (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_right_parenthesis    (const T_str&  s_inp, T_str&  s_out);
    void  calc_name                 (const T_str&  s_inp, T_str&  s_out, T_str& name);
    bool  calc_name_init            (const T_str&  s_inp, T_str&  s_out, T_num& res);
 
    bool  calc_asterisk             (const T_str&  s_inp, T_str&  s_out);
    bool  calc_slash                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_equals_sign          (const T_str&  s_inp, T_str&  s_out);
    bool  calc_symb                 (const char c, const T_str&  s_inp, T_str&  s_out);
};
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    calc_equals_sign  (s_inp, s_out);
    return  calc_expr (s_out, s_out, res);
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::calc_name(const T_str&  s_inp, T_str&  s_out, T_str&  name)
{ 
    T_str::const_iterator  str_it = std::find_if(s_inp.begin(), s_inp.end(), 
                                                 std::not1(std::ptr_fun(isalpha)));
    name.assign(s_inp.begin(), str_it);
    s_out.assign(str_it, s_inp.end());
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_name_and_name_init(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_str  name;    
    calc_name(s_inp, s_out, name);    
    bool  bool_res;
    if(s_out[0] == EQUALS_SIGN)
    {
        bool_res = calc_name_init(s_out, s_out, res);
        if(bool_res)
        {                
            names_values[name] = res;
        }            
        return  bool_res; 
    }
    else//После имени нет инициализатора.
    {            
        bool_res = (names_values.count(name) != 0);
        //Если имя уже было инициализировано:
        if(bool_res)
        {
            res = names_values[name];                
        }
        else
        {                
            std::cout << "The variable \"" 
                      << name
                      << "\" is not initialized."
                      << std::endl;                
        }
        return  bool_res; 
    }                
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_equals_sign(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(EQUALS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_semicolon(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SEMICOLON, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::print_expr(const T_str&  s_inp, T_str&  s_out)
{
    T_num  num_res;
    bool   bool_res = calc_expr(s_inp, s_out, num_res);
    if(bool_res)
    {
        std::cout << num_res
                  << std::endl;
    }
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_list(const T_str&  s_inp, T_str&  s_out)
{
    if(!print_expr(s_inp, s_out))
    {
        return false;
    }
    switch(s_out[0])
    {
    case FINISH_SYMB:
        return  true;
    case SEMICOLON:
        calc_semicolon(s_out, s_out);
        if(s_out[0] == FINISH_SYMB)
        {
            return true;
        }
        else
        {
            return  calc_expr_list(s_out, s_out);
        }        
    default:
        return false;
    }
}
///////////////////////////////////////////////////////////////////////////////
T_calculator::T_calculator()
{
    names_values["pi"]  = 3.1415926535897932385;                       
    names_values["e"]   = 2.7182818284590452354;
                      
    std::cout << "-> ";
    T_str  s_inp;
    std::getline(std::cin, s_inp);
    if(s_inp.empty()) exit(0);
    remove_spaces(s_inp);
    T_str  s_out;    
    if(!calc_expr_list(s_inp += FINISH_SYMB, s_out))
    {
        std::cout << "Not correct expr.";
    }
    std::cout << std::endl
              << std::endl
              << std::endl;
}
///////////////////////////////////////////////////////////////////////////////
void  T_calculator::remove_spaces(T_str&  s)
{    
    for(;;)
    {
        T_str::size_type  pos = s.find_first_of(" \t");   
        if(pos == T_str::npos)
        {
            break;
        }
        s = s.erase(pos, 1);
    }    
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_summand         (s_inp, s_out, res)
            && calc_line_of_summand (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    return     calc_factor         (s_inp, s_out, res)
            && calc_line_of_factor (s_out, s_out, res);   
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{   
    switch(s_inp[0])
    {
    case PLUS_SIGN:
        return     calc_add_summand      (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    case MINUS_SIGN:
        return     calc_subtract_summand (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    switch(s_inp[0])
    {
    case MINUS_SIGN:
        return  calc_minus_factor           (s_inp, s_out, res);
    case LEFT_PARENTHESIS:
        return  calc_expr_in_brackets       (s_inp, s_out, res);    
    default:
        if(isalpha(s_inp[0]))
        {
            return  calc_name_and_name_init (s_inp, s_out, res);
        }
        else
        {
            return  calc_num                (s_inp, s_out, res);
        }        
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    bool   bool_res =    calc_minus  (s_inp, s_out)
                      && calc_factor (s_out, s_out, res);
    res *= -1;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    switch(s_inp[0])
    {
    case ASTERISK:
        return     calc_mult_to_factor  (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    case SLASH:
        return     calc_div_into_factor (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_add_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_plus    (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res += res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_subtract_summand(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_summand;
    bool   bool_res =     calc_minus   (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res -= res_summand;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_mult_to_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_asterisk (s_inp, s_out)
                       && calc_factor   (s_out, s_out, res_factor);
    res *= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_div_into_factor(const T_str&  s_inp, T_str&  s_out, T_num& res)
{    
    T_num  res_factor;
    bool   bool_res =     calc_slash  (s_inp, s_out)
                       && calc_factor (s_out, s_out, res_factor);
    res /= res_factor;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_plus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(PLUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_asterisk(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(ASTERISK, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_slash(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(SLASH, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(MINUS_SIGN, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_in_brackets(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    return     calc_left_parenthesis  (s_inp, s_out)
            && calc_expr              (s_out, s_out, res)
            && calc_right_parenthesis (s_out, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_num(const T_str&  s_inp, T_str&  s_out, T_num& res)
{
    std::istringstream  sin(s_inp);    
    bool  bool_res = ((sin >> res) != 0);
    sin >> s_out;
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_left_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(LEFT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_right_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(RIGHT_PARENTHESIS, s_inp, s_out);
}
///////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_symb(const char c, const T_str&  s_inp, T_str&  s_out)
{    
    bool  res = (s_inp[0] == c);
    if(res)
    {        
        s_out = s_inp.substr(1);
    }
    return res;    
}
///////////////////////////////////////////////////////////////////////////////
int main()
{    
    for(;;)
    { 
        T_calculator  calculator;        
    }
    return 0;
}
2
nikkka
Мат в 32 хода
235 / 170 / 8
Регистрация: 10.09.2009
Сообщений: 1,096
08.08.2010, 14:26 #627
Имеется неупорядоченный массив из n различных целых чисел от 0 до n (0,1,…,j-1,j+1,….,n). Необходимо за один цикл определить недостающее число j.

Добавлено через 14 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
using namespace std;
int needed(int arr[], int size)
{
    int max=0;
    int sum0=0;
    for(int i=0;i<size;i++)
    {
        if(max<arr[i]) max=arr[i];
        sum0+=arr[i];
    }
    return (max/2)*(max+1)-sum0;
}
int main()
{
    int a[7]={0,3,5,1,6,2};
    cout<<needed(a,6)<<"\n";
    system("pause");
    return 0;
}
Добавлено через 29 секунд
Неужели тема умирает?!?!?!...

Добавлено через 4 часа 31 минуту
Evg, до меня только что дошло что такое ОПЗ и как переводить инфиксную запись в постинфиксную (я не спутал термины?). Вот, сидел надо кодом с утра. Не могу понять одного - как реализавать алгоритм для n-значных чисел. У меня ведь только для цифер!!!...
C++
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
#include <iostream>
#include <string>
#include <conio.h>
const int size=10;
class stek
{
    private:
        char array[size];
    public:
        stek();
        void additem(char c);
        void substractitem(void);
        std::string stekins(void);
        char upperitem(void);
};
stek::stek()
{
    for(int i=0;i<size;i++)
        array[i]='\0';
}
void stek::additem(char c)
{
    for(int i=size-1;i>=0;i--)
        array[i]=array[i-1];
    array[0]=c;
}
void stek::substractitem(void)
{
    for(int i=0;i<size-1;i++)
        array[i]=array[i+1];
    array[size-1]='\0';
}
std::string stek::stekins(void)
{
    std::string s0;
    for(int i=0;i<size;i++)
        if(array[i]!='\0')
           s0=s0+array[i]+" ";
    return s0;
}
char stek::upperitem(void)
{
    return array[0];
}
std::string itorpn(std::string s)
{
    std::string s0;
    stek st;
    for(int i=0;i<s.length();i++)
    {
        if(isdigit(s[i]))
            s0=s0+s[i]+" ";
        if(s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/')
        {
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
            {
                s0=s0+st.upperitem()+" ";
                st.substractitem();
            }
            st.additem(s[i]);
        }
        if(s[i]=='(')
            st.additem('(');
        if(s[i]==')')
            {
                while(st.upperitem()!='(')
                {
                    s0=s0+st.upperitem()+" ";
                    st.substractitem();
                }
                st.substractitem();
            }
    }
    s0=s0+st.stekins();
    return s0;
}
int main()
{
    std::string ss;
    std::cin>>ss;
    std::cout<<itorpn(ss)<<"\n";
    getch();
    return 0;    
}
0
Evg
Эксперт CАвтор FAQ
18381 / 6429 / 441
Регистрация: 30.03.2009
Сообщений: 17,847
Записей в блоге: 28
08.08.2010, 15:04 #628
Цитата Сообщение от nikkka Посмотреть сообщение
Evg, до меня только что дошло что такое ОПЗ и как переводить инфиксную запись в постинфиксную (я не спутал термины?). Вот, сидел надо кодом с утра. Не могу понять одного - как реализавать алгоритм для n-значных чисел. У меня ведь только для цифер!!!...
Ещё раз просто мои посты в теме про интерпретатор. Там более-менее внятным языком всё объяснено. Весь этот процесс делится на две части. Первая часть - это разбиение строкового выражения на отдельные "слова" (грамматические единицы, token'ы). Вторая часть - анализ этих слов. У тебя всё это сделано, но на очень примитивном уровне и явно одно от другого не разделяется. Всё смешано в одну кучу и работает напрямую со строкой. Такой подход тоже возможен, но в нём очень легко запутаться и очень сложно сопровождать (например, дальнейшее развитие).
1
nikkka
Мат в 32 хода
235 / 170 / 8
Регистрация: 10.09.2009
Сообщений: 1,096
08.08.2010, 15:11 #629
Вот, работает и для n-значных. А нельзя сначала перевести в ОПЗ а потом уже делить на token-ы? Ведья там у меня все token-ы разделены пробелами, а значит и отличать их легче... Так?
C++
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
#include <iostream>
#include <string>
#include <conio.h>
const int size=10;
class stek
{
    private:
        char array[size];
    public:
        stek();
        void additem(char c);
        void substractitem(void);
        std::string stekins(void);
        char upperitem(void);
};
stek::stek()
{
    for(int i=0;i<size;i++)
        array[i]='\0';
}
void stek::additem(char c)
{
    for(int i=size-1;i>=0;i--)
        array[i]=array[i-1];
    array[0]=c;
}
void stek::substractitem(void)
{
    for(int i=0;i<size-1;i++)
        array[i]=array[i+1];
    array[size-1]='\0';
}
std::string stek::stekins(void)
{
    std::string s0;
    for(int i=0;i<size;i++)
        if(array[i]!='\0')
           s0=s0+array[i]+" ";
    return s0;
}
char stek::upperitem(void)
{
    return array[0];
}
std::string itorpn(std::string s)
{
    std::string s0;
    stek st;
    for(int i=0;i<s.length();i++)
    {
        if(isdigit(s[i]) && isdigit(s[i+1]))
            s0=s0+s[i];
        else if(isdigit(s[i]))
                 s0=s0+s[i]+" ";
        if(s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/')
        {
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
            {
                s0=s0+st.upperitem()+" ";
                st.substractitem();
            }
            st.additem(s[i]);
        }
        if(s[i]=='(')
            st.additem('(');
        if(s[i]==')')
            {
                while(st.upperitem()!='(')
                {
                    s0=s0+st.upperitem()+" ";
                    st.substractitem();
                }
                st.substractitem();
            }
    }
    s0=s0+st.stekins();
    return s0;
}
int main()
{
    std::string ss;
    std::cin>>ss;
    std::cout<<itorpn(ss)<<"\n";
    getch();
    return 0;
}
0
fasked
Эксперт С++
4952 / 2532 / 180
Регистрация: 07.10.2009
Сообщений: 4,311
Записей в блоге: 1
08.08.2010, 15:20 #630
Цитата Сообщение от nikkka Посмотреть сообщение
Вот, работает и для n-значных. А нельзя сначала перевести в ОПЗ а потом уже делить на token-ы? Ведья там у меня все token-ы разделены пробелами, а значит и отличать их легче... Так?
я бы попробовал выделить токен как отдельную абстракцию. отдельный объект. пусть он также представляется в виде строки, но это будет вектор строк, то есть вектор токенов. тогда проблема отпадет на самом первом этапе. тогда и части программы будут более независимы и понятны.
1
08.08.2010, 15:20
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
08.08.2010, 15:20
Привет! Вот еще темы с ответами:

Какая база требуется для понимания C++? - C++
Доброго времени суток! Возникло желание научиться работать в Си, но одолели смутные сомнения. Каюсь, ничего сложнее Pascal ABC в школьные...

Нужен пример рекурсивной функции для понимания ее назначения и практической пользы - C++
Не могу понять пользу рекурсии, может ли кто привести код в пример.

Киньте задачки для тренировки - C++
Хочу порешать задачки по C++......нужны либо книжки с задачками - либо ваши примеры.....желательно (если книжки) - чтобы там и решение...

Дайте задания для тренировки - C++
День добрый. Учу C++. Я уверен, что тут есть люди которые с ним отлично знаком и работают. Можете ли вы накидать заданий, возможно из...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
630
Закрытая тема Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.