Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C++ > С++ для начинающих
Войти
Регистрация
Восстановить пароль
Карта форума Темы раздела Блоги Социальные группы Поиск Сообщения за день Заказать работу  
 
Рейтинг 4.91/11: Рейтинг темы: голосов - 11, средняя оценка - 4.91
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
1

Идущие подряд числа

05.01.2011, 01:26. Показов 1893. Ответов 15
Метки нет (Все метки)
Author24 — интернет-сервис помощи студентам
Есть код, суть его в возведении числа в степень (ооочень большую степень - 3^3456), в результате тоже как бы число (массив), нужно выяснить, есть ли в этом массиве 2 (3, 4...) подряд идущие цифры (11, 22, например), если есть вывести кол-во таких "пар" . Я в тупике вообще.

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

#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>
 
typedef std::deque<int>  T_digits;
 
void  normalize(T_digits&  digits)
{
    int  ostatok = 0;
    for(T_digits::reverse_iterator dig_rev_it = digits.rbegin(); 
        dig_rev_it != digits.rend(); ++dig_rev_it)
    {
        *dig_rev_it += ostatok;
        ostatok = *dig_rev_it / 10;
        *dig_rev_it %= 10;
    }
    if(ostatok)
    {
        digits.push_front(ostatok);        
        normalize(digits);
    }    
}
 
T_digits&  operator*=(T_digits&  digits, int  mnozhitel)
{
    std::transform(digits.begin(), digits.end(), digits.begin(), 
                   std::bind2nd(std::multiplies<int>(), mnozhitel));
    normalize(digits);
    return digits;    
}
 
T_digits big_pow(int osnovanie, int stepen)
{
    T_digits  res_digits(1, 1);
    for(int i = 0; i < stepen; ++i)
    {        
        res_digits *= osnovanie;
    }
    return  res_digits;
}
 
int main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        int osn;
        do
        {
            std::cout << std::endl
                      << "Введите целое основание степени  (>= 0): "; 
            std::cin >> osn;
        }while(osn < 0);
        int stepen;
        do
        {
            std::cout << "Введите целый показатель степени (>= 1): ";        
            std::cin >> stepen;        
        }while(stepen < 1);        
        
        std::cout << osn
                  << " ^ "
                  << stepen
                  << " = ";
        T_digits  res_digits = big_pow(osn, stepen);
        std::copy(res_digits.begin(), res_digits.end(),                   
                  std::ostream_iterator<int>(std::cout)); 
        std::cout << std::endl;
    }
    return 0;
}
Добавлено через 2 часа 24 минуты
ап, неужто никто не знает
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
 05.01.2011, 01:26
Ответы с готовыми решениями:

Заменить в строке пробелы идущие подряд
В заданной строке,заменить парное количество пробелов,которые идут подряд на 'П',а не парное на...

Заменить 2 подряд идущие буквы на 1 символ
Заменить 2 подряд идущие буквы на 1 символ У меня вышло как то так но не получается доработать....

Найти в массиве подряд идущие элементы
//--------------------------------------------------------------------------- #include &lt;vcl.h&gt;...

Удалить одинаковые слова предложения, идущие подряд
Объясните как это сделать с помощью библиотеки &lt;string.h&gt; Удалить одинаковые слова предложения,...

15
131 / 108 / 12
Регистрация: 04.12.2010
Сообщений: 313
05.01.2011, 01:31 2
apachan, тут число разве 4то поместить в символьный массив или string... но нет уверенности, что памяти хватит.
возможно, надо искать закономерность.

Добавлено через 27 секунд
Всегда при работе с огромными числами все сводится к закономерностям.
0
Эксперт С++
3224 / 1751 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 07:15 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

//////////////////////////////////////////////////////////////////////////////////////
//нужно выяснить, есть ли в этом массиве 2 (3, 4...) подряд идущие цифры 
//(11, 22, например), если есть вывести кол-во таких "пар"
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <string>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::deque<int>          T_digits;
typedef std::string              T_str;
typedef std::map<T_str, size_t>  T_repeats_counter;
////////////////////////////////////////////////////////////////////////////////////// 
void  normalize(T_digits&  digits)
{
    int  ostatok = 0;
    for(T_digits::reverse_iterator dig_rev_it = digits.rbegin(); 
        dig_rev_it != digits.rend(); ++dig_rev_it)
    {
        *dig_rev_it += ostatok;
        ostatok = *dig_rev_it / 10;
        *dig_rev_it %= 10;
    }
    if(ostatok)
    {
        digits.push_front(ostatok);        
        normalize(digits);
    }    
}
//////////////////////////////////////////////////////////////////////////////////////  
T_digits&  operator*=(T_digits&  digits, int  mnozhitel)
{
    std::transform(digits.begin(), digits.end(), digits.begin(), 
                   std::bind2nd(std::multiplies<int>(), mnozhitel));
    normalize(digits);
    return digits;    
}
//////////////////////////////////////////////////////////////////////////////////////  
T_digits big_pow(int osnovanie, int stepen)
{
    T_digits  res_digits(1, 1);
    for(int i = 0; i < stepen; ++i)
    {        
        res_digits *= osnovanie;
    }
    return  res_digits;
}
//////////////////////////////////////////////////////////////////////////////////////  
bool  count_and_print_symb_repeats(T_str  s)
{
    T_repeats_counter  repeats_counter;
    
    for(T_str::iterator  find_it_L = s.begin();;)
    {
        find_it_L = std::adjacent_find(find_it_L, s.end());    
        if(find_it_L == s.end()) break;              
        T_str::value_type  symb_cur    = *find_it_L;
        T_str::size_type   pos_find_L  = std::distance(s.begin(), find_it_L);
        T_str::size_type   pos_find_R  = s.find_first_not_of(symb_cur, pos_find_L);
        size_t  len_cur 
            = ((pos_find_R == T_str::npos) ? s.size() : pos_find_R) - pos_find_L;
        ++repeats_counter[T_str(len_cur, symb_cur)];
        find_it_L += len_cur;
    }
    
    struct  T_print_rep_data
    {
        void  operator() (T_repeats_counter::value_type  repeats_counter_elem)
        {
            std::cout << repeats_counter_elem.first
                      << '\t'
                      << repeats_counter_elem.second
                      << " шт."
                      << std::endl;
        }
    };
 
    std::for_each(repeats_counter.begin(), repeats_counter.end(), T_print_rep_data());
    return  repeats_counter.size() != 0;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        int osn;
        do
        {
            std::cout << std::endl
                      << "Введите целое основание степени  (>= 0): "; 
            std::cin >> osn;
        }while(osn < 0);
        int stepen;
        do
        {
            std::cout << "Введите целый показатель степени (>= 1): ";        
            std::cin >> stepen;        
        }while(stepen < 1);        
        
        std::cout << osn
                  << " ^ "
                  << stepen
                  << " = ";
        T_digits  res_digits = big_pow(osn, stepen);
        std::copy(res_digits.begin(), res_digits.end(),                   
                  std::ostream_iterator<int>(std::cout)); 
        std::cout << std::endl;
 
        T_str  s;
        std::transform(res_digits.begin(), res_digits.end(), std::back_inserter(s),
                       std::bind2nd(std::plus<char>(), '0'));
        std::cout << "В полученном числе встречаются следующие повторения цифр:"
                  << std::endl;
        if(!count_and_print_symb_repeats(s))
        {
            std::cout << "нет повторений."
                      << std::endl;
        }
    }    
}
1
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 12:07  [ТС] 4
Вот такие дела А можно сделать, чтобы пользователь сам выбирал число, которое надо проверить на кол-во пар?

c:\program files\microsoft visual studio\vc98\include\xtree(120) : warning C4786: 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const ,
unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Kfn,std::less<std::basic_strin
g<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\map(46) : see reference to class template instantiation 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > const ,unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int
> >::_Kfn,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<c har> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(53) : see reference to class template instantiation 'std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > >,std::allocator<unsigned int> >' being compiled
c:\program files\microsoft visual studio\vc98\include\xtree(120) : warning C4786: 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const ,
unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Kfn,std::less<std::basic_strin
g<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::const_iterator' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\map(46) : see reference to class template instantiation 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > const ,unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int
> >::_Kfn,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<c har> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(53) : see reference to class template instantiation 'std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > >,std::allocator<unsigned int> >' being compiled
c:\program files\microsoft visual studio\vc98\include\xtree(120) : warning C4786: 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const ,
unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Kfn,std::less<std::basic_strin
g<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::iterator' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\map(46) : see reference to class template instantiation 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > const ,unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int
> >::_Kfn,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<c har> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(53) : see reference to class template instantiation 'std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > >,std::allocator<unsigned int> >' being compiled
c:\program files\microsoft visual studio\vc98\include\xtree(120) : warning C4786: 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const ,
unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Kfn,std::less<std::basic_strin
g<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Node' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\map(46) : see reference to class template instantiation 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > const ,unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int
> >::_Kfn,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<c har> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(53) : see reference to class template instantiation 'std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > >,std::allocator<unsigned int> >' being compiled
c:\program files\microsoft visual studio\vc98\include\xtree(120) : warning C4786: 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const ,
unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::_Kfn,std::less<std::basic_strin
g<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int> >::const_iterator' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\map(46) : see reference to class template instantiation 'std::_Tree<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std:air<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > const ,unsigned int>,std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,std::allocator<unsigned int
> >::_Kfn,std::less<std::basic_string<char,std::char_traits<char>,std::allocator<c har> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(53) : see reference to class template instantiation 'std::map<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,unsigned int,std::less<std::basic_string<char,std::char_traits<
char>,std::allocator<char> > >,std::allocator<unsigned int> >' being compiled
C:\CPP\Cpp1 (2).cpp(80) : error C2918: 'T_print_rep_data' : illegal use of local type in template instantiation
C:\CPP\Cpp1 (2).cpp(123) : warning C4508: 'main' : function should return a value; 'void' return type assumed
Error executing cl.exe.

Cpp1 (2).exe - 1 error(s), 6 warning(s)

Добавлено через 1 минуту
Типа этого: "введите кол-во повторений (2, 3...), введите цифру(1, 2...)".
0
Эксперт С++
3224 / 1751 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 12:45 5
Цитата Сообщение от apachan Посмотреть сообщение
Вот такие дела А можно сделать, чтобы пользователь сам выбирал число, которое надо проверить на кол-во пар? Типа этого: "введите кол-во повторений (2, 3...), введите цифру(1, 2...)".
Ну, ваши дела легко поправимы, нужно только заменить негодный компилятор на путевый.

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

//////////////////////////////////////////////////////////////////////////////////////
//нужно выяснить, есть ли в этом массиве 2 (3, 4...) подряд идущие цифры 
//(11, 22, например), если есть вывести кол-во таких "пар"
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <string>
//////////////////////////////////////////////////////////////////////////////////////
typedef std::deque<int>          T_digits;
typedef std::string              T_str;
typedef T_str::value_type        T_symb;
typedef std::map<T_str, size_t>  T_repeats_counter;
////////////////////////////////////////////////////////////////////////////////////// 
void  normalize(T_digits&  digits)
{
    int  ostatok = 0;
    for(T_digits::reverse_iterator dig_rev_it = digits.rbegin(); 
        dig_rev_it != digits.rend(); ++dig_rev_it)
    {
        *dig_rev_it += ostatok;
        ostatok = *dig_rev_it / 10;
        *dig_rev_it %= 10;
    }
    if(ostatok)
    {
        digits.push_front(ostatok);        
        normalize(digits);
    }    
}
//////////////////////////////////////////////////////////////////////////////////////  
T_digits&  operator*=(T_digits&  digits, int  mnozhitel)
{
    std::transform(digits.begin(), digits.end(), digits.begin(), 
                   std::bind2nd(std::multiplies<int>(), mnozhitel));
    normalize(digits);
    return digits;    
}
//////////////////////////////////////////////////////////////////////////////////////  
T_digits big_pow(int osnovanie, int stepen)
{
    T_digits  res_digits(1, 1);
    for(int i = 0; i < stepen; ++i)
    {        
        res_digits *= osnovanie;
    }
    return  res_digits;
}
//////////////////////////////////////////////////////////////////////////////////////  
bool  count_and_print_symb_repeats(T_str  s, T_symb  dig_symb)
{
    T_repeats_counter  repeats_counter;
 
    struct  T_eq_dig_symb
    {
        const  T_symb  symb_;
        T_eq_dig_symb(T_symb  symb) : symb_(symb)
        {}
 
        bool  operator() (T_symb  symb_A, T_symb  symb_B)
        {
            return    symb_A == symb_B
                   && symb_A == symb_;
        }
    };
    
    for(T_str::iterator  find_it_L = s.begin();;)
    {
        find_it_L = std::adjacent_find(find_it_L, s.end(), T_eq_dig_symb(dig_symb));    
        if(find_it_L == s.end()) break;              
        T_str::value_type  symb_cur    = *find_it_L;
        T_str::size_type   pos_find_L  = std::distance(s.begin(), find_it_L);
        T_str::size_type   pos_find_R  = s.find_first_not_of(symb_cur, pos_find_L);
        size_t  len_cur 
            = ((pos_find_R == T_str::npos) ? s.size() : pos_find_R) - pos_find_L;
        ++repeats_counter[T_str(len_cur, symb_cur)];
        find_it_L += len_cur;
    }
    
    struct  T_print_rep_data
    {
        void  operator() (T_repeats_counter::value_type  repeats_counter_elem)
        {
            std::cout << repeats_counter_elem.first
                      << '\t'
                      << repeats_counter_elem.second
                      << " шт."
                      << std::endl;
        }
    };
 
    std::for_each(repeats_counter.begin(), repeats_counter.end(), T_print_rep_data());
    return  repeats_counter.size() != 0;
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        int osn;
        do
        {
            std::cout << std::endl
                      << "Введите целое основание степени  (>= 0): "; 
            std::cin >> osn;
        }while(osn < 0);
        int stepen;
        do
        {
            std::cout << "Введите целый показатель степени (>= 1): ";        
            std::cin >> stepen;        
        }while(stepen < 1);        
        
        std::cout << osn
                  << " ^ "
                  << stepen
                  << " = ";
        T_digits  res_digits = big_pow(osn, stepen);
        std::copy(res_digits.begin(), res_digits.end(),                   
                  std::ostream_iterator<int>(std::cout)); 
        std::cout << std::endl;
 
        for(;;)
        {
            std::cout << "Введите цифру для проверки числа ее повторений в полученном числе"
                      << std::endl
                      <<"(для отказа введите не цифру): ";
            T_symb  dig_symb = 0;
            std::cin >> dig_symb;
            if(   dig_symb < '0'
               || '9' < dig_symb)
            {
                break;
            }
 
            T_str  s;
            std::transform(res_digits.begin(), res_digits.end(), std::back_inserter(s),
                           std::bind2nd(std::plus<T_symb>(), '0'));
            std::cout << "В полученном числе встречаются следующие повторения цифры "
                      << dig_symb 
                      << ":"
                      << std::endl;
            if(!count_and_print_symb_repeats(s, dig_symb))
            {
                std::cout << "нет повторений."
                          << std::endl;
            }        
        }
    }    
}
2
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 13:11  [ТС] 6
Ну, ваши дела легко поправимы, нужно только заменить негодный компилятор на путевый.
На какой, например? Нужно, чтобы все работало именно в VC++6
0
Эксперт С++
3224 / 1751 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 13:22 7
Цитата Сообщение от apachan Посмотреть сообщение
На какой, например?
Ну, у меня студия 2008, нормально работает.

Цитата Сообщение от apachan Посмотреть сообщение
Нужно, чтобы все работало именно в VC++6
Мда... Задача странная, но сложная. Ну что ж, успехов вам в этом нелегком деле.
1
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 13:31  [ТС] 8
Задача странная, но сложная.
Покапавшись на форуме, нашел такую задачу, можете объяснить метод, как Вы анализировали число-результат (34248767247882463) на предмет повторяющихся цифр-пар (11, 22...) в своем коде? Вот вывела программа (ниже) в конце число, что дальше?

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

#include <stdio.h>
#include <stdlib.h>
 
/* длинная арифметика 3^100
   равно 515377520732011331036461129765621272702107522001 */
int main(void) /* C89 ANSI */
{
    int n[100] = { 1 };
    /* число храним в достаточно длинном массиве
       первый элемент станет основанием,
       с которого число будет расти
       в сторону старших разрядов */
    
    int base = 10;
    /* полученное число будет в десятичной системе
       можно устанавливать степени десятки
       100, 1000, 10000 и так далее,
       это повысит скорость вычисления,
       результат будет выглядет одинаково;
       нужно учесть размер одного числа в массиве
       если int, то не более 10000 */
    
    int i, j, flag;
    /* i - внешние счётчики
       j - внутренние счётчики первого уровня
       flag - флажок, который при выводе числа
              помогает пропустить начальные нули в числе
              начальные нули - это разряды, до которых
              число не доросло */
    
    for (i = 0; i < 100; i++) {
        
        for (j = 0; j < 100; j++)
            n[j] *= 3;
        /* умножаем всё число на три,
           как будто в столбик на бумаге,
           для каждого разряда */
            
        for (j = 0; j < 100-1; j++)
            if (n[j] >= base) {
                n[j+1] += n[j] / base;
                n[j] %= base;
            }
        /* для всех разрядов, исключая самый старший,
           выполнить проверку на переполнение;
           
           если переполнение в каком-то из разрядов есть,
           то переполнившую часть перенести
           в соседний, более старший, разряд,
           а в самом разряде оставить остаток,
           который не переполняет разряд;
           
           при переносе переполнившей части
           в более старший соседний разряд,
           она прибавляется к тому, что уже там хранится */
        
    }
    /* умножает число на три сто раз,
       проводя проверки на переполнение его разрядов
       и переносы, в случаях переполнения */
    
    flag = 1;
    /* флаг пропуска начальных нулей
       устанавливается в положение "пропустить" */
    
    for (i = 99; i >= 0; i--) {
        
        if (flag == 1)
            if (n[i] == 0)
                continue;
            else
                flag = 0;
        /* если флаг пропуска начальных нулей
           установлен в положение "пропустить",
           то проверить не началось ли число;
           
           если число началось,
           то есть встречен первый ненулевой разряд,
           то переключить флаг в положение "вывести";
           если число не началось,
           сразу перейти к следующему разряду,
           не выводя ничего */
          
        printf("%d", n[i]);
        /* выводит очередной разряд числа,
           начиная слева */
    }
    /* выводит получившееся число слева направо,
       поразрядно, начиная с первого ненулевого разряда */
    
    putchar('\n');
    /* после числа переводит строку */
    
    exit(EXIT_SUCCESS);
    /* возвращает статус успешного завершения
       в операционную среду */
}
0
Эксперт С++
3224 / 1751 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 13:46 9
Цитата Сообщение от apachan Посмотреть сообщение
можете объяснить метод, как Вы анализировали число-результат (34248767247882463) на предмет повторяющихся цифр-пар (11, 22...) в своем коде?
Алгоритм поиска очень простой. С помощью алгоритма std::adjacent_find отыскиваем удвоенные цифры, равные заданной, затем с помощью функции find_first_not_of контейнера std::string отыскиваем первую другую цифру, и так в цикле.
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 14:23  [ТС] 10
То есть на С++ 6 это нельзя реализовать?
0
В астрале
Эксперт С++
8049 / 4806 / 655
Регистрация: 24.06.2010
Сообщений: 10,562
05.01.2011, 14:24 11
apachan, Если и можно то не этим алгоритмом. Тут STL используется по максимуму
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 14:36  [ТС] 12
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

#include <stdio.h>
#include <stdlib.h>
 //2^xxxx
int main(void) 
{
    int n[11213] = { 1 };
    int base = 10;
    int i, j, flag;
  
    for (i = 0; i < 11213; i++) {
        
        for (j = 0; j < 11213; j++)
            n[j] *= 2;
 
        for (j = 0; j < 11213-1; j++)
            if (n[j] >= base) {
                n[j+1] += n[j] / base;
                n[j] %= base;
            }
        
    }
 
    flag = 1;
 
    for (i = 11212; i >= 0; i--) {
        
        if (flag == 1)
            if (n[i] == 0)
                continue;
            else
                flag = 0;
 
          
        printf("%d", n[i]);
       
    }
 
    
    putchar('\n');
 
    
    exit(EXIT_SUCCESS);
 
}
В этом коде число представляется в виде массива?
C++
1

printf("%d", n[i]);
0
Эксперт С++
3224 / 1751 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 14:36 13
Цитата Сообщение от apachan Посмотреть сообщение
То есть на С++ 6 это нельзя реализовать?
Можно, почему, если всерьез задаться такой целью и приложить достаточные усилия. А зачем вам это?
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 14:38  [ТС] 14
А зачем вам это?
Как уже писал в другой теме - незачем Задание такое, длинная арифметика, анализ результата на повторяющиеся цифры.
0
В астрале
Эксперт С++
8049 / 4806 / 655
Регистрация: 24.06.2010
Сообщений: 10,562
05.01.2011, 14:39 15
apachan, Да в виде массива целых чисел
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
07.01.2011, 00:57  [ТС] 16
Да в виде массива целых чисел
Странно, ничего не понимаю, тогда почему не выводит результат, если пройтись по массиву и если (n[i]=n[i+1]) - счетчик увеличивается на 1...


Добавлено через 14 часов 7 минут
ап, может кого осенит внезапно

Добавлено через 7 часов 8 минут
ап, вроде стандартная задача, есть похожая, где надо в длинном числе найти 2 подряд идущие 9, но решения или хотя бы намеков на него нигде не нашел
0
07.01.2011, 00:57
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
 07.01.2011, 00:57
Помогаю со студенческими работами здесь

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

Удалить подряд идущие вхождения слова в предложениях
Дана строка содержащая текст на русском языке. В предложении некоторые слова записаны подряд...

Удалить подряд идущие одинаковые слова из строки
Одна из ошибок, которую часто допускают неопытные наборщики - дважды написанное слово. Найти такие...

Заменить подряд идущие пробелы на один пробел
2) В заданной строке заменить подряд идущие пробелы на один пробел (посредством цикла for).


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

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

КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru