Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.60/5: Рейтинг темы: голосов - 5, средняя оценка - 4.60
Quadrillionaire
13 / 13 / 1
Регистрация: 09.03.2013
Сообщений: 180
1

Сложная задача или есть ли в C++ типы с порядком в 30 цифр?

14.10.2014, 13:47. Просмотров 900. Ответов 10
Метки нет (Все метки)

Собственно говоря вот задача, хз как её решать, если запретили использоваться библиотеки для обработки больших чисел, а стандартные типы(численные) и средства C++ не позволяют это сделать:
Смоделировать операцию деления двух действительных чисел в форме +/- m.n Е K, где суммарная длина мантиссы (m+n) - до 30 значащих цифр, а величина порядка K - до 5 цифр. Результат выдать в форме +/- 0.m1 Е K1.
Может кто помочь решить?
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
14.10.2014, 13:47
Ответы с готовыми решениями:

Есть натуральное двузначное число n. Верно ли, что среди его цифр есть 11 или 99?
Добрый вечер , такая вот задача : есть натуральное двузначное число n. Верно...

Получить число с обращеннным порядком цифр
1. Напишите функцию, получающую целое значение, которая возвращает число с...

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

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

Типы данных: есть ли универсальный тип, который может заменить все типы данных в Си?
Добрый вечер! Был бы очень признателен, если бы Вы помогли бы мне понять...

10
nmcf
6412 / 5673 / 2582
Регистрация: 14.04.2014
Сообщений: 24,016
14.10.2014, 13:53 2
Свой тип придумай. Класс, например, создай для хранения твоего числа.
1
Quadrillionaire
13 / 13 / 1
Регистрация: 09.03.2013
Сообщений: 180
14.10.2014, 13:59  [ТС] 3
Я об этом тоже думал, но как реализовать операцию деления (там ведь еще кроме целой части еще и дробная есть)? И в своем "типе" число реализовывать как строку?
0
nmcf
6412 / 5673 / 2582
Регистрация: 14.04.2014
Сообщений: 24,016
14.10.2014, 14:25 4
Лучше определи его (внутри класса) как массив целых, ну или массив char, только не в символьном, а в прямом числовом смысле. Так удобнее будет арифметические операции выполнять.
Деление можешь определить как функцию в классе или перегрузить операцию деления.
1
Quadrillionaire
13 / 13 / 1
Регистрация: 09.03.2013
Сообщений: 180
14.10.2014, 14:27  [ТС] 5
Ок, ща попробую реализовать..
0
Mr.X
Эксперт С++
3182 / 1709 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
14.10.2014, 20:27 6
Цитата Сообщение от Quadrillionaire Посмотреть сообщение
+/- m.n Е K
А порядок K отрицательным не может быть что ли?
1
Mr.X
Эксперт С++
3182 / 1709 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
16.10.2014, 03:45 7
Лучший ответ Сообщение было отмечено Quadrillionaire как решение

Решение

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
/////////////////////////////////////////////////////////////////////////////////////////
//запретили использоваться библиотеки для обработки больших чисел, а стандартные типы
//(численные) и средства C++ не позволяют это сделать:
//Смоделировать операцию деления двух действительных чисел в форме +/- m.n Е K, где 
//суммарная длина мантиссы (m+n) - до 30 значащих цифр, а величина порядка K - до 5 цифр. 
//Результат выдать в форме +/- 0.m1 Е K1.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <sstream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_big_float
{
    //-----------------------------------------------------------------------------------
    static  const   char    PLUS_SYMB       =   '+';
    static  const   char    MINUS_SYMB      =   '-';
    static  const   char    POINT_SYMB      =   '.';
    static  const   char    ZERO_SYMB       =   '0';
    static  const   char    EXPONENT_SYMB   =   'E';
    static  const   char    SPACE_SYMB      =   ' ';
    static  const   int     DIGITS_10       =   30;
    static  const   int     HEAD_TAIL_SIZE  =   DIGITS_10 / 2;
    //-----------------------------------------------------------------------------------
    typedef long long   T_big_int;
    //-----------------------------------------------------------------------------------
    bool        is_correct_;
    bool        is_NaN_;
    bool        is_inf_;
    bool        is_zero_;
    bool        is_positive_;
    T_str       significand_;
    T_big_int   exponent_;
    T_big_int   head_;
    T_big_int   tail_;
    T_big_int   head_tail_mod_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_big_float( T_str  s   =   "" )
        :
        is_NaN_         ( false     ),
        is_inf_         ( false     ),
        exponent_       (),
        head_tail_mod_  ( 1 )
    {
        for( int  i = 0; i < HEAD_TAIL_SIZE; ++i )
        {
            head_tail_mod_  *=  10;
        }
 
        remove_spaces(s);
 
        is_correct_     =       successfully_read_sign          (s)
                            &&  successfully_read_significand   (s)
                            &&  successfully_read_exponent      (s);
 
        if( is_correct_ )
        {
            trim_front_significand();
 
            is_zero_    =       significand_.size   ()  ==  1
                            &&  significand_.front  ()  ==  ZERO_SYMB;
 
            if( !is_zero_ )
            {
                set_head_and_tail();
            }
        }//if
    }
    //-----------------------------------------------------------------------------------
    bool    is_correct()
    {
        return  is_correct_;
    }
    //-----------------------------------------------------------------------------------
    T_big_float     operator/=  ( T_big_float   const   &   R )
    {
        is_NaN_     =       is_NaN_
                        ||  R.is_NaN_
 
                        ||  (
                                    is_zero_
                                &&  R.is_zero_
                            )
 
                        ||  (
                                    is_inf_
                                &&  R.is_inf_
                            );
 
        if  (
                    !is_NaN_
                &&  !is_inf_
                &&  !is_zero_
            )
        {
            is_positive_    =       is_positive_
                                ==  R.is_positive_;
 
            if( R.is_zero_ )
            {
                is_inf_     =   true;
            }
            else if( R.is_inf_ )
            {
                is_zero_    =   true;
            }
            else
            {
                exponent_   -=  R.exponent_;
                divide_head_and_tail_by( R );
                exponent_   -=  DIGITS_10   -   1;
                set_head_and_tail();
            }
        }//if
 
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    T_str   to_string()                                                             const
    {
        T_str   res_str;
 
        if( is_NaN_ )
        {
            res_str     =   "NaN";
        }
        else
        {
            std::ostringstream  sout;
 
            if( !is_positive_ )
            {
                sout    <<  MINUS_SYMB;
            }
 
            if( is_inf_ )
            {
                sout    <<  "infinity";
            }
            else
            {
                sout    <<  ZERO_SYMB;
 
                if( !is_zero_ )
                {
                    sout    <<  POINT_SYMB
                            <<  significand_.substr
                                    (
                                        0,
                                        significand_.find_last_not_of( ZERO_SYMB ) + 1
                                    );
 
                    auto    temp_exponent   =   exponent_ + DIGITS_10;
 
                    if( temp_exponent )
                    {
                        sout    <<  SPACE_SYMB
                                <<  EXPONENT_SYMB
                                <<  SPACE_SYMB
                                <<  temp_exponent;
                    }
                }//if
            }//else
 
            res_str     =   sout.str();
        }//else
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static  void    remove_spaces( T_str    &   s )
    {
        s.assign
            (
                s.begin(),
                std::remove_if
                    (
                        s.begin     (),
                        s.end       (),
                        isspace
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void    divide_head_and_tail_by( T_big_float   const   &   R )
    {
        significand_.clear();
 
        if  (
                head_and_tail_less_than( R )
            )
        {
            shift_left_head_and_tail();
            --exponent_;
        }
 
        while   (
                        significand_.size()
                    <   DIGITS_10
                )
        {
            char    cur_digit   =   0;
 
            while   (
                        !head_and_tail_less_than( R )
                    )
            {
                ++cur_digit;
                subtract_from_head_and_tail( R );
            }
 
            significand_.push_back      ( cur_digit + ZERO_SYMB );
            shift_left_head_and_tail    ();
        }//while
    }
    //-----------------------------------------------------------------------------------
    bool    head_and_tail_less_than( T_big_float   const   &   R )
    {
        return      std::make_pair( head_,      tail_       )
                <   std::make_pair( R.head_,    R.tail_     );
    }
    //-----------------------------------------------------------------------------------
    void    shift_left_head_and_tail()
    {
        head_   *=  10;
        tail_   *=  10;
        head_   +=  tail_ / head_tail_mod_;
        tail_   %=  head_tail_mod_;
    }
    //-----------------------------------------------------------------------------------
1
Mr.X
Эксперт С++
3182 / 1709 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
16.10.2014, 03:49 8
Лучший ответ Сообщение было отмечено Quadrillionaire как решение

Решение

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
    void    subtract_from_head_and_tail( T_big_float   const   &   R )
    {
        tail_   -=  R.tail_;
        head_   -=  R.head_;
 
        if( tail_ < 0 )
        {
            --head_;
            tail_   +=  head_tail_mod_;
        }
    }
    //-----------------------------------------------------------------------------------
    void    trim_front_significand()
    {
        while   (
                        significand_.size   ()  >   1
                    &&  significand_.front  ()  ==  ZERO_SYMB
                )
        {
            significand_.erase( 0, 1 );
        }
    }
    //-----------------------------------------------------------------------------------
    void    normalize_significand_size()
    {
        while   (
                    significand_.size()     <   DIGITS_10
                )
        {
            significand_.push_back( ZERO_SYMB );
            --exponent_;
        }
 
        while   (
                    significand_.size()     >   DIGITS_10
                )
        {
            significand_.pop_back();
            ++exponent_;
        }
    }
    //-----------------------------------------------------------------------------------
    void    set_head_and_tail()
    {
        normalize_significand_size();
        head_   =   0;
        tail_   =   0;
 
        for( int  i = 0; i < HEAD_TAIL_SIZE; ++i )
        {
            in_push_back
                (
                    head_,
                    significand_[i] - ZERO_SYMB
                );
 
            in_push_back
                (
                    tail_,
                    significand_[ i + HEAD_TAIL_SIZE ] - ZERO_SYMB
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
    void    in_push_back
        (
            T_big_int   &   num,
            T_big_int       digit
        )
    {
        num     *=  10;
        num     +=  digit;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_sign( T_str   &   s )
    {
        bool    bool_res    =   !s.empty();
 
        if( bool_res )
        {
            if  (
                        s.front()   ==  PLUS_SYMB
                    ||  s.front()   ==  MINUS_SYMB
                )
            {
                is_positive_    =   s.front()   ==  PLUS_SYMB;
                s.erase( 0, 1 );
            }
            else
            {
                is_positive_    =   true;
            }
        }//if
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_significand( T_str    &   s )
    {
        while   (
                        !s.empty()
 
                    &&  isdigit
                            (
                                s.front()
                            )
                )
        {
            significand_.push_back
                (
                    s.front()
                );
 
            s.erase( 0, 1 );
        }//while
 
        if  (
                    !s.empty    ()
                &&  s.front     ()  ==  POINT_SYMB
            )
        {
            s.erase( 0, 1 );
 
            while   (
                            !s.empty()
 
                        &&  isdigit
                                (
                                    s.front()
                                )
                    )
            {
                significand_.push_back
                    (
                        s.front()
                    );
 
                s.erase( 0, 1 );
                --exponent_;
            }//while
        }//if
 
        return  !significand_.empty();
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_read_exponent( T_str   &   s )
    {
        bool    bool_res    =   true;
 
        if  (
                s.empty()
            )
        {
            bool_res    =   true;
        }
        else
        {
            bool_res    =       tolower (
                                            s.front()
                                        )
 
                            ==  tolower( EXPONENT_SYMB );
 
            if( bool_res )
            {
                s.erase( 0, 1 );
                bool_res    =   !s.empty();
 
                if( bool_res )
                {
                    std::istringstream  ssin(s);
                    T_big_int     exponent_delta   =   0;
                    bool_res    =       ssin    >>  exponent_delta
                                    &&  !(ssin  >>    T_str() );
 
                    if( bool_res )
                    {
                        exponent_   +=  exponent_delta;
                    }
                }//if
            }//if
        }//else
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_big_float     operator/
    (
        T_big_float     const   &   L,
        T_big_float     const   &   R
    )
{
    T_big_float     res     =   L;
    return  res     /=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
std::ostream    &   operator<<
    (
        std::ostream            &   ostr,
        T_big_float     const   &   big_float
    )
{
    ostr    <<  big_float.to_string();
    return  ostr;
}
/////////////////////////////////////////////////////////////////////////////////////////
std::istream    &   operator>>
    (
        std::istream    &   istr,
        T_big_float     &   big_float
    )
{
    T_str   str_big_float;
    getline( istr,  str_big_float );
    big_float   =   T_big_float( str_big_float );
    return  istr;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        std::cout   <<  "\n\n\n\n"
                    <<  "Введите два числа в формате +/- m.n Е K, где m и n - очень большие натуральные"
                    <<  std::endl
                    <<  "числа, а порядок K - целое число"
                    <<  std::endl
                    <<  "(пробелы, знак плюс, дробную либо целую часть и порядок можно опускать):"
                    <<  std::endl;
 
        T_big_float     x;
        do
        {
            std::cout   <<  '\t'
                        <<  "x\t= ";
            std::cin    >>  x;
        }
        while   (
                    !x.is_correct()
                );
 
        T_big_float     y;
        do
        {
            std::cout   <<  '\t'
                        <<  "y\t= ";
            std::cin    >>  y;
        }
        while   (
                    !y.is_correct()
                );
 
        std::cout   <<  "\n\t"
                    <<  "x / y\t= "
                    <<  x / y
                    <<  std::endl;
    }//for
}
2
Quadrillionaire
13 / 13 / 1
Регистрация: 09.03.2013
Сообщений: 180
16.10.2014, 09:25  [ТС] 9
О спасиб большое) Я как раз баг не мог найти в коде вчера, сделал все таки через обработку чисел как массива строк, а деление "столбиком" реализовал)
0
zss
Модератор
Эксперт С++
7412 / 6802 / 4302
Регистрация: 18.12.2011
Сообщений: 17,969
Завершенные тесты: 1
16.10.2014, 09:56 10
Mr.X, чем заменить significand_.pop_back(); ?
В VS 2008 такого нет.
C++
1
significand_.erase(significand_.size()-1,1);
Правильно?
Еще пришлось везде .front() заменить на [0]
1
Mr.X
Эксперт С++
3182 / 1709 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
16.10.2014, 10:52 11
Цитата Сообщение от zss Посмотреть сообщение
Правильно?
!!!
1
16.10.2014, 10:52
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
16.10.2014, 10:52

Напишите функцию, получающую целое значение, которая возвращает число с обращенным порядком цифр
1. Напишите функцию, получающую целое значение, которая возвращает число с...

Составить функцию, которая формирует новое число с обратным порядком цифр по отношению к исходному числу
1. Составить функцию с оператором return. 2. Преобразовать функцию к...

Дано натуральное трехзначное число n. Верно ли, что среди его цифр есть 0 или 9?
Доброго времени суток как реализовать на c++?Дано натуральное трехзначное число...


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

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

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