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

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

05.01.2011, 01:26. Показов 2224. Ответов 15
Метки нет (Все метки)
Студворк — интернет-сервис помощи студентам
Есть код, суть его в возведении числа в степень (ооочень большую степень - 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
cpp_developer
Эксперт
20123 / 5690 / 1417
Регистрация: 09.04.2010
Сообщений: 22,546
Блог
 05.01.2011, 01:26
Ответы с готовыми решениями:

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

Заменить 2 подряд идущие буквы на 1 символ
Заменить 2 подряд идущие буквы на 1 символ У меня вышло как то так но не получается доработать. #include &lt;iostream&gt; #include...

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

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

Добавлено через 27 секунд
Всегда при работе с огромными числами все сводится к закономерностям.
0
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 07:15
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  [ТС]
Вот такие дела А можно сделать, чтобы пользователь сам выбирал число, которое надо проверить на кол-во пар?

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::alloc ator<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::ch ar_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::alloc ator<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::ch ar_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::alloc ator<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::ch ar_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::alloc ator<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::ch ar_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::alloc ator<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::ch ar_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
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 12:45
Цитата Сообщение от 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  [ТС]
Ну, ваши дела легко поправимы, нужно только заменить негодный компилятор на путевый.
На какой, например? Нужно, чтобы все работало именно в VC++6
0
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 13:22
Цитата Сообщение от apachan Посмотреть сообщение
На какой, например?
Ну, у меня студия 2008, нормально работает.

Цитата Сообщение от apachan Посмотреть сообщение
Нужно, чтобы все работало именно в VC++6
Мда... Задача странная, но сложная. Ну что ж, успехов вам в этом нелегком деле.
1
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 13:31  [ТС]
Задача странная, но сложная.
Покапавшись на форуме, нашел такую задачу, можете объяснить метод, как Вы анализировали число-результат (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
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 13:46
Цитата Сообщение от 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  [ТС]
То есть на С++ 6 это нельзя реализовать?
0
В астрале
Эксперт С++
 Аватар для ForEveR
8049 / 4806 / 655
Регистрация: 24.06.2010
Сообщений: 10,562
05.01.2011, 14:24
apachan, Если и можно то не этим алгоритмом. Тут STL используется по максимуму
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 14:36  [ТС]
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
Эксперт С++
 Аватар для Mr.X
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
05.01.2011, 14:36
Цитата Сообщение от apachan Посмотреть сообщение
То есть на С++ 6 это нельзя реализовать?
Можно, почему, если всерьез задаться такой целью и приложить достаточные усилия. А зачем вам это?
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
05.01.2011, 14:38  [ТС]
А зачем вам это?
Как уже писал в другой теме - незачем Задание такое, длинная арифметика, анализ результата на повторяющиеся цифры.
0
В астрале
Эксперт С++
 Аватар для ForEveR
8049 / 4806 / 655
Регистрация: 24.06.2010
Сообщений: 10,562
05.01.2011, 14:39
apachan, Да в виде массива целых чисел
0
13 / 13 / 4
Регистрация: 07.12.2010
Сообщений: 127
07.01.2011, 00:57  [ТС]
Да в виде массива целых чисел
Странно, ничего не понимаю, тогда почему не выводит результат, если пройтись по массиву и если (n[i]=n[i+1]) - счетчик увеличивается на 1...


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

Добавлено через 7 часов 8 минут
ап, вроде стандартная задача, есть похожая, где надо в длинном числе найти 2 подряд идущие 9, но решения или хотя бы намеков на него нигде не нашел
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
raxper
Эксперт
30234 / 6612 / 1498
Регистрация: 28.12.2010
Сообщений: 21,154
Блог
 07.01.2011, 00:57
Помогаю со студенческими работами здесь

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

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

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

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

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


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

Или воспользуйтесь поиском по форуму:
16
Ответ Создать тему
Новые блоги и статьи
Жизнь в неопределённости
kumehtar 23.03.2026
Жизнь — это постоянное существование в неопределённости. Например, даже если у тебя есть список дел, невозможно дойти до точки, где всё окончательно завершено и больше ничего не осталось. В принципе,. . .
Модель здравоСохранения: работники работают быстрее после её введения.
anaschu 23.03.2026
geJalZw1fLo Корпорация до введения программа здравоохранения имела много невыполненных работниками заданий, после введения программы количество заданий выросло. Но на выплатах по больничным это. . .
1С: Контроль уникальности заводского номера
Maks 23.03.2026
Алгоритм контроля уникальности заводского (или серийного) номера на примере документа выдачи шин для спецтехники с табличной частью. Данные берутся из регистра сведений, по которому настроено. . .
Хочу заставить корпорации вкладываться в здоровье сотрудников: делаю мат модель здравосохранения
anaschu 22.03.2026
e7EYtONaj8Y Z4Tv2zpXVVo https:/ / github. com/ shumilovas/ med2. git
1С: Программный отбор элементов справочника по группе
Maks 22.03.2026
Установка программного отбора элементов справочника "Номенклатура" из модуля формы документа. В качестве фильтра для отбора справочника служит группа номенклатуры. Отбор по наименованию группы. . .
Как я обхитрил таблицу Word
Alexander-7 21.03.2026
Когда мигает курсор у внешнего края таблицы, и нам надо перейти на новую строку, а при нажатии Enter создается новый ряд таблицы с ячейками, то мы вместо нервных нажатий Энтеров мы пишем любые буквы. . .
Krabik - рыболовный бот для WoW 3.3.5a
AmbA 21.03.2026
без регистрации и смс. Это не торговля, приложение не содержит рекламы. Выполняет свою непосредственную задачу - автоматизацию рыбалки в WoW - и ничего более. Однако если админы будут против -. . .
1С: Программный отбор элементов справочника по значению перечисления
Maks 21.03.2026
Установка программного отбора элементов справочника "Сотрудники" из модуля формы документа. В качестве фильтра для отбора служит значение перечислений. / / Событие "НачалоВыбора" реквизита на форме. . .
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Условия использования - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2026, CyberForum.ru