Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.86/7: Рейтинг темы: голосов - 7, средняя оценка - 4.86
0 / 0 / 0
Регистрация: 24.12.2014
Сообщений: 12
1

Построить таблицу истинности для формул

06.12.2015, 17:23. Просмотров 1464. Ответов 2
Метки нет (Все метки)

Пользователь вводит одну из формул вида (A*((!)B*C))*D или A*((!)B*(C*D)) или (A*(!)B)*(C*D) , где * - любая из логических операций. Построить и вывести таблицу истинности для введенной формулы
0
Лучшие ответы (1)
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
06.12.2015, 17:23
Ответы с готовыми решениями:

Построить таблицу истинности и определить выполнимость формулы: Значения Х1,Х2,Х3 одинаковы для всех вариантов
X1 X2 X3 0 0 0 0 0 1 Вот моё задание 7) Х1*Х2*Х3 + Х1*Х2*Х3 + Х1*Х2*Х3...

Построить таблицу истинности
Здравствуйте! В принципе задача фигня, единственное с чем у меня загвоздка, это в том что в...

Построить таблицу истинности по формуле
нужно построить таблицу истинности по формуле подскажите как это реализовать вот у меня есть уже...

Нужно построить таблицу истинности по заданном логическому выражению.
Нужно построить таблицу истинности по заданном логическому выражению. Но суть не в этом, а в том,...

2
Эксперт С++
3204 / 1731 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
07.12.2015, 15:27 2
Лучший ответ Сообщение было отмечено expectations7 как решение

Решение

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
/*
 Пользователь вводит одну из формул вида (A*((!)B*C))*D или A*((!)B*(C*D)) 
 или (A*(!)B)*(C*D) , где * - любая из логических операций. 
 Построить и вывести таблицу истинности для введенной формулы 
*/
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iostream>
#include <iterator>
#include <stack>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef std::stack      < char  >   T_symb_stack;
///////////////////////////////////////////////////////////////////////////////
const   char    NOT_SYMB            =   '!';
const   char    SP_NOT_SYMB         =   '-';
const   char    AND_SYMB            =   '&';
const   char    OR_SYMB             =   '|';
 
const   char    XOR_SYMB            =   '^';
const   char    IMPL_SYMB           =   '>';
const   char    EQ_SYMB             =   '=';
 
const   char    LEFT_BRACKET_SYMB   =   '(';
const   char    RIGHT_BRACKET_SYMB  =   ')';
///////////////////////////////////////////////////////////////////////////////
const   T_str   BINT_OP_STR             =   "&|^>=";
const   size_t  VARIABLES_COUNT_MAX     =   8;
///////////////////////////////////////////////////////////////////////////////
typedef std::bitset     < VARIABLES_COUNT_MAX   >   T_bitset;
///////////////////////////////////////////////////////////////////////////////
void    print_prompt_and_input_formula  ( T_str     &   formula_str )
{
    std::cout   <<  "Введите логическую формулу вида"
                <<  std::endl
                <<  '\t'    <<  "(A*((!)B*C))*D"
                <<  std::endl
                <<  "или\tA*((!)B*(C*D))"
                <<  std::endl
                <<  "или\t(A*(!)B)*(C*D),"
                <<  std::endl
                <<  "содержащую не более "
                <<  VARIABLES_COUNT_MAX
                <<  " уникальных переменных,"
                <<  std::endl
                <<"где * - любая из следующих логических операций:"
                <<  std::endl
 
                <<  NOT_SYMB        <<  "\t- "  <<  "отрицание"         <<  std::endl
                <<  AND_SYMB        <<  "\t- "  <<  "и"                 <<  std::endl
                <<  OR_SYMB         <<  "\t- "  <<  "или"               <<  std::endl
 
                <<  XOR_SYMB        <<  "\t- "  <<  "исключающее или"   <<  std::endl
                <<  IMPL_SYMB       <<  "\t- "  <<  "импликация"        <<  std::endl
                <<  EQ_SYMB         <<  "\t- "  <<  "эквивалентность"   <<  std::endl
 
                <<  std::endl
                <<  ">> ";
 
    getline( std::cin,  formula_str );
 
    formula_str.erase
        (
            std::remove_if
                (
                    formula_str.begin   (),
                    formula_str.end     (),
                    std::isspace
                ),
 
            formula_str.end             ()
        );
}
///////////////////////////////////////////////////////////////////////////////
void    for_formula_set_letter_str
    (
        T_str   const   &   formula_str,
        T_str           &   letter_str
    )
{
    std::copy_if
        (
            formula_str.begin   (),
            formula_str.end     (),
            std::back_inserter  ( letter_str ),
            std::isalpha
        );
 
    std::for_each
        (
            letter_str.begin    (),
            letter_str.end      (),
 
            []                  ( auto  &   letter )
            {
                letter  =   std::toupper( letter );
            }
        );
 
    std::sort
        (
            letter_str.begin    (),
            letter_str.end      ()
        );
 
    letter_str.erase
        (
            std::unique
                (
                    letter_str.begin    (),
                    letter_str.end      ()
                ),
 
            letter_str.end              ()
        );
}
///////////////////////////////////////////////////////////////////////////////
T_str   line()
{
    return  T_str( 80, '-' );
}
///////////////////////////////////////////////////////////////////////////////
void    print_table_header_for_formula_and_letter_str
    (
        T_str   const   &   formula_str,
        T_str   const   &   letter_str
    )
{
    std::cout   <<  std::endl
                <<  line()
                <<  "Таблица истинности для формулы"
 
                <<  std::endl
                <<  formula_str
                <<  std::endl
 
                <<  line();
 
    std::copy
        (
            letter_str.begin                (),
            letter_str.end                  (),
            std::ostream_iterator<char>     ( std::cout,    "\t" )
        );
 
    std::cout   <<  OR_SYMB
                <<  '\t'        
                <<  "Рез."
                <<  std::endl
                <<  line();
}
///////////////////////////////////////////////////////////////////////////////
bool    is_bin_op_symb( char    const   symb )
{
    return  BINT_OP_STR.find( symb )    !=  T_str::npos;
}
///////////////////////////////////////////////////////////////////////////////
bool    get_bool_res_of_bin_op
    (
        bool    L,
        bool    R,
        char    bin_op_symb
    )
{
    switch( bin_op_symb )
    {
    case    AND_SYMB:
        return  L   &&   R;
 
    case    OR_SYMB:
        return  L   ||   R;
 
    case    XOR_SYMB:
        return  L   !=   R;
 
    case    IMPL_SYMB:
        return  !L  ||   R;
 
    case    EQ_SYMB:
        return  L   ==   R;
 
    default:
        return  true;
    }
}
///////////////////////////////////////////////////////////////////////////////
void    push_in_stack_bool_val_or_opposite_val
    (
        T_symb_stack    &   symb_stack,
        bool                bool_val    
    )
{
    if  (
                !symb_stack.empty   ()
            &&  symb_stack.top      ()  ==  SP_NOT_SYMB
        )
    {
        symb_stack.pop      ();
 
        symb_stack.push     ( 
                                '0' + !bool_val
                            );
    }
    else
    {
        symb_stack.push     ( 
                                '0' + bool_val
                            );
    }//else
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_calculate_operation_with_not_symb_in_top
    ( T_symb_stack  &   symb_stack )
{
    symb_stack.pop();
 
    bool    bool_res    =       !symb_stack.empty()
                            &&  symb_stack.top()    ==  LEFT_BRACKET_SYMB;
 
    if( bool_res )
    {
        symb_stack.pop();
 
        if  (
                    !symb_stack.empty   ()
                &&  symb_stack.top      ()  ==  SP_NOT_SYMB
            )
        {
            symb_stack.pop();
        }
        else
        {
            symb_stack.push( SP_NOT_SYMB );
        }
    }//if
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_calculate_operation_with_digit_in_top
    ( T_symb_stack  &   symb_stack )
{
    bool    right_dig_bool_val  =   symb_stack.top() - '0'     ==  1;
 
    symb_stack.pop();
    bool    bool_res    =   !symb_stack.empty();
 
    if( bool_res )
    {
        if  (
                is_bin_op_symb
                    (
                        symb_stack.top()        
                    )
            )
        {
            char    bin_op_symb     =   symb_stack.top();
            symb_stack.pop();
 
            bool_res    =       !symb_stack.empty()
 
                            &&  std::isdigit
                                    (
                                        symb_stack.top()      
                                    );
 
            if( bool_res )
            {
                bool    left_dig_bool_val   =   symb_stack.top() - '0'  ==  1;
                symb_stack.pop();
 
                bool_res    =       !symb_stack.empty   ()
                                &&  symb_stack.top      ()  ==  LEFT_BRACKET_SYMB;
 
                if( bool_res )
                {
                    symb_stack.pop();
 
                    push_in_stack_bool_val_or_opposite_val
                        (
                            symb_stack,
 
                            get_bool_res_of_bin_op
                                (
                                    left_dig_bool_val,
                                    right_dig_bool_val,
                                    bin_op_symb
                                )
                        );
                }//if
            }//if
        }//if   is_bin_op_symb
        else if     (
                        symb_stack.top()    ==  LEFT_BRACKET_SYMB
                    )
        {
            symb_stack.pop();
 
            push_in_stack_bool_val_or_opposite_val
                (
                    symb_stack,
                    right_dig_bool_val
                );
        }
        else
        {
            bool_res    =   false;
        }//else
    }//if bool_res
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
0
Эксперт С++
3204 / 1731 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
07.12.2015, 15:29 3
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
bool    successfully_calculate_operation    ( T_symb_stack  &   symb_stack )
{
    bool    bool_res    =   !symb_stack.empty();
 
    if( bool_res )
    {
        if  (
                symb_stack.top()    ==  NOT_SYMB
            )
        {
            bool_res    
                =   successfully_calculate_operation_with_not_symb_in_top( symb_stack );
        }
        else if     (
                        std::isdigit
                            (
                                symb_stack.top()       
                            )
                    )
        {
            bool_res    
                =   successfully_calculate_operation_with_digit_in_top( symb_stack );
        }
        else
        {
            bool_res    =   false;   
        }
    }//if( bool_res )
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool    bool_value_of_letter
    (
        char                    letter,
        T_str       const   &   letter_str,
        T_bitset    const   &   num_bitset
    )
{
    return      num_bitset
                    [
                            letter_str.size     () 
                        -   letter_str.find     ( letter )
                        -   1
                    ]
 
            ==  1;
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_set_res
    (
        T_str       const   &   formula_str,
        T_str       const   &   letter_str,
        T_bitset    const   &   num_bitset,
        bool                &   res
    )
{
    bool    bool_res    =   true;
 
    T_symb_stack    symb_stack;
 
    for( auto   symb: formula_str )
    {
        if( symb == RIGHT_BRACKET_SYMB )
        {
            bool_res    =   successfully_calculate_operation( symb_stack );
 
            if( !bool_res )
            {
                break;
            }
        }
        else if     (
                        std::isalpha( symb )
                    )
        {
            push_in_stack_bool_val_or_opposite_val
                (
                    symb_stack,
 
                    bool_value_of_letter
                        (
                            std::toupper( symb ),
                            letter_str,
                            num_bitset
                        )
                );
        }
        else
        {
            symb_stack.push( symb );
        }
    }//for
 
    if( bool_res )
    {
        bool_res    =       !symb_stack.empty()
 
                        &&  std::isdigit
                                (
                                    symb_stack.top()        
                                );
 
        if( bool_res )
        {
            res     =   symb_stack.top() - '0'  ==  1;
        }//if
 
        symb_stack.pop();
        bool_res    =   symb_stack.empty();
    }//if
 
    return  bool_res;  
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_print_table_line_for_formula_and_num_and_letter_str
    (
        T_str   const   &   formula_str,
        size_t              num,
        T_str   const   &   letter_str 
    )
{
    T_bitset    num_bitset( num );
    T_str       num_bitset_str  =   num_bitset.to_string();
 
    num_bitset_str.erase
        (
            0,
 
                num_bitset_str  .size()
            -   letter_str      .size()
        );
 
    bool        res             =   false;
 
    bool        bool_res        =   successfully_set_res
                                        (
                                            formula_str,
                                            letter_str,
                                            num_bitset,
                                            res
                                        );
 
    if( bool_res )
    {
        std::copy
            (
                num_bitset_str.begin            (),
                num_bitset_str.end              (),
                std::ostream_iterator< char >   ( std::cout,    "\t" )
            );
 
        std::cout   <<  OR_SYMB
                    <<  '\t'        
                    <<  res
                    <<  std::endl;
    }//if
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_print_truth_table_for_formula_and_letter_str
    (
        T_str   const   &   formula_str,
        T_str   const   &   letter_str
    )
{
    size_t  num_upper_bound     =   static_cast< size_t >
                                        (
                                            std::pow    (
                                                            2,
                                                            letter_str.size()  
                                                        )                                            
                                        );
 
    print_table_header_for_formula_and_letter_str
        (
            formula_str,
            letter_str
        );
 
    T_str   formula_str_in_brackets;
    formula_str_in_brackets.push_back( LEFT_BRACKET_SYMB    );
    formula_str_in_brackets     +=  formula_str; 
    formula_str_in_brackets.push_back( RIGHT_BRACKET_SYMB   );
 
    for (
            size_t
            num   =   0;
            num   <   num_upper_bound;
            ++num
        )
    {
        if  (
                !successfully_print_table_line_for_formula_and_num_and_letter_str
                    (
                        formula_str_in_brackets,
                        num,
                        letter_str
                    )
            )
        {
            return  false;
        }//if
    }//for
 
    std::cout   <<  line();
    return  true;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        T_str   formula_str;
        T_str   letter_str;
 
        std::cout   <<  std::endl
                    <<  std::endl;
 
        print_prompt_and_input_formula  ( formula_str );
 
        for_formula_set_letter_str
            (
                formula_str,
                letter_str
            );
 
        if  (
                letter_str.empty()
            )
        {
            std::cout   <<  "В формуле отсутствуют переменные."
                        <<  std::endl;
        }
        else if     (
                        letter_str.size()   >   VARIABLES_COUNT_MAX
                    )
        {
            std::cout   <<  "В формуле больше "
                        <<  VARIABLES_COUNT_MAX
                        <<  " уникальных переменных."
                        <<  std::endl;
        }
        else if     (
                        !successfully_print_truth_table_for_formula_and_letter_str
                            (
                                formula_str,
                                letter_str
                            )
                    )
        {
            std::cout   <<  "В формуле синтаксическая ошибка."
                        <<  std::endl;
        }//else
    }//for
}
0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
07.12.2015, 15:29

Заказываю контрольные, курсовые, дипломные и любые другие студенческие работы здесь.

Эквивалентность формул. По таблице истинности
Помогите написать программу доказывающую эквивалентность формул по таблице истинности

Написать программу, которая выводит таблицу истинности для логической функции
Написать программу, которая выводит таблицу истинности для логической функции (A B &amp; C) A, где &amp;,...

Определить существенные и фиктивные переменные. Вывести на экран таблицу истинности для существенных переменных
Для функции трёх переменных определить существенные и фиктивные переменные. Вывести на экран...

Напечатать таблицу истинности для логической функции (A⇔B ⇔C) ∨ A
Напечатать таблицу истинности для логической функции (A⇔B ⇔C) ∨ A .


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

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

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