0 / 0 / 0
Регистрация: 05.09.2014
Сообщений: 52
1

Определить, образуют ли элементы массива прогрессию

06.09.2014, 14:15. Показов 2945. Ответов 5
Метки нет (Все метки)

Author24 — интернет-сервис помощи студентам
Помогите решить задачку.Проверить образует ли элементы целочисленного массива N арифметическую1 и геометрическую 2 прогрессию, Если да то вывести разность1 знаменатель 2 прогрессии, если нет- вывести 0
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
06.09.2014, 14:15
Ответы с готовыми решениями:

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

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

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

Определить, образуют ли элементы массива арифметическую прогрессию
Проверить, образуют ли элементы целочисленного массива размера N арифметическую прогрессию. Если...

5
Модератор
Эксперт С++
13585 / 10819 / 6438
Регистрация: 18.12.2011
Сообщений: 28,849
06.09.2014, 16:02 2
Проходите циклом по массиву (от 1 до n-1-го элемента) и проверяете, верно ли, что
1(Арифм). a[i]=a[i-1]+d. d - вычисляете на первом шаге как d=a[1]-a[0]
2(Геом). a[i]=a[i-1]*k. k - вычисляете на первом шаге как k=a[1]/a[0]
0
0 / 0 / 0
Регистрация: 05.09.2014
Сообщений: 52
08.09.2014, 11:18  [ТС] 3
zss, Спасибо
0
Эксперт С++
3225 / 1752 / 436
Регистрация: 03.05.2010
Сообщений: 3,867
08.09.2014, 20:58 4
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
/////////////////////////////////////////////////////////////////////////////////////////
//Проверить образует ли элементы целочисленного массива N арифметическую1 
//и геометрическую 2 прогрессию, Если да то вывести разность1 знаменатель 2 прогрессии, 
//если нет- вывести 0
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iterator>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector < int   >   T_int_vector;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_progression_state
{
    NOT_PROGRESSION_STATE,
    ARITHMETIC_PROGRESSION_STATE,
    GEOMETRIC_PROGRESSION_STATE,
    ARITHMETIC_AND_GEOMETRIC_PROGRESSION_STATE
};
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_get_progression_state_and_parameter
{
    int     elem_counter_;
    bool    is_arithm_progr_;
    bool    is_geom_progr_;
    double  prev_val_;
    double  progression_difference_;
    double  progression_common_ratio_;
    //-----------------------------------------------------------------------------------
    T_get_progression_state_and_parameter()
        :
        elem_counter_       (),
        is_arithm_progr_    ( true ),
        is_geom_progr_      ( true )
    {}
    //-----------------------------------------------------------------------------------
    void    operator()  ( double   val )
    {
        if( elem_counter_ == 1 )
        {
            progression_difference_     =   val - prev_val_;
            progression_common_ratio_   =   val / prev_val_;
        }
        else if( elem_counter_ > 1 )
        {
            is_arithm_progr_    =       is_arithm_progr_
                                    &&  val - prev_val_     ==  progression_difference_;
 
            is_geom_progr_      =       is_geom_progr_
                                    &&  val / prev_val_     ==  progression_common_ratio_;
        }//else
        prev_val_   =   val;
        ++elem_counter_;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
void    check_whether_vector_is_progression_and_set_state_and_progression_parameter
    (
        T_int_vector    const   &   int_vector,
        T_progression_state     &   progression_state,
        double                  &   progression_parameter
    )
{
    auto    progression_state_and_parameter
        =   std::for_each
                (
                    int_vector.begin                        (),
                    int_vector.end                          (),
                    T_get_progression_state_and_parameter   ()
                );
 
    if( progression_state_and_parameter.is_arithm_progr_ )
    {
        if( progression_state_and_parameter.is_geom_progr_ )
        {
            progression_state       =   ARITHMETIC_AND_GEOMETRIC_PROGRESSION_STATE;
        }
        else
        {
            progression_state       =   ARITHMETIC_PROGRESSION_STATE;
            progression_parameter   =   progression_state_and_parameter.progression_difference_;
        }
    }
    else if( progression_state_and_parameter.is_geom_progr_ )
    {
        progression_state       =   GEOMETRIC_PROGRESSION_STATE;
        progression_parameter   =   progression_state_and_parameter.progression_common_ratio_;
 
    }//else
}
/////////////////////////////////////////////////////////////////////////////////////////
void    rand_generate_int_vector_and_sort( T_int_vector   &   int_vector )
{
    const   int     INT_VAL_MIN         =   1;
    const   int     INT_VAL_MAX         =   10;
 
    std::generate
        (
            int_vector.begin    (),
            int_vector.end      (),
 
            [ INT_VAL_MIN, INT_VAL_MAX ]    ()
            {
                return  rand() % ( INT_VAL_MAX - INT_VAL_MIN + 1 ) + INT_VAL_MIN;
            }
        );
 
    std::sort
        (
            int_vector.begin    (),
            int_vector.end      ()
        );
};
/////////////////////////////////////////////////////////////////////////////////////////
void    ptint_int_vector( T_int_vector  const   &   int_vector )
{
    std::copy
        (
            int_vector.begin                (),
            int_vector.end                  (),
            std::ostream_iterator< int >    ( std::cout, "\t" )
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_vector_state_and_progression_parameter
    (
        T_progression_state     progression_state,
        double                  progression_parameter
    )
{
    switch( progression_state )
    {
    case    ARITHMETIC_PROGRESSION_STATE   :
        std::cout   <<  "Вектор является арифметической прогрессией с разностью "
                    <<  progression_parameter
                    <<  std::endl;
        break;
 
    case    GEOMETRIC_PROGRESSION_STATE   :
        std::cout   <<  "Вектор является геометрической прогрессией со знаменателем "
                    <<  progression_parameter
                    <<  std::endl;
        break;
 
    case    ARITHMETIC_AND_GEOMETRIC_PROGRESSION_STATE   :
        std::cout   <<  "Вектор является арифметической прогрессией с разностью 0"
                    <<  std::endl
                    <<  "и одновременно геометрической прогрессией со знаменателем 1."
                    <<  std::endl;
        break;
 
    default :
        std::cout   <<  "Вектор не является прогрессией."
                    <<  std::endl;
    }//swotch
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    const   int             INT_VALUES_TOTAL    =   3;
    T_int_vector            int_vector( INT_VALUES_TOTAL );
    T_progression_state     progression_state;
    double                  progression_parameter;
 
    for(;;)
    {
        do
        {
            progression_state       =   T_progression_state();
            progression_parameter   =   0;
 
            rand_generate_int_vector_and_sort( int_vector );
 
            check_whether_vector_is_progression_and_set_state_and_progression_parameter
                (
                    int_vector,
                    progression_state,
                    progression_parameter
                );
        }
        while   (
                        progression_state == NOT_PROGRESSION_STATE
                    &&  rand() % 10
                );
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl;
 
        ptint_int_vector( int_vector );
        std::cout   <<  std::endl;
 
        print_vector_state_and_progression_parameter
            (
                progression_state,
                progression_parameter
            );
        std::cout   <<  std::endl;
        system("pause");
    }//for
}
0
0 / 0 / 1
Регистрация: 07.09.2014
Сообщений: 7
09.09.2014, 01:13 5
Функции основаны на алгоритмах от https://www.cyberforum.ru/members/216425.html .
Думаю, что дописать программу не составит труда.
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
#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <ctime>
 
void generateArray(int *array, int size)
{
    for (int i = 0; i < size; i++) {
        array[i] = rand() % 20;
    }
}
 
void printArray(int *array, int size)
{
    for (int i = 0; i < size; i++) {
        std::cout << std::setw(4) << array[i];
    }
    std::cout << std::endl;
}
 
bool checkForArif(int *array, int size)
{
    for (int i = 0; i < size; i++) {
        int arif = array[1] - array[0];
        if (array[i] != array[i - 1] + arif) {
            return false;
        }
    }
    return true;
}
 
bool checkForGeom(int *array, int size)
{
    for (int i = 0; i < size; i++) {
        int geom = array[1] / array[0];
        if (array[i] != array[i - 1] * geom) {
            return false;
        }
    }
    return true;
}
 
int main()
{
    int size;
    std::cout << "Enter size" << std::endl;
    std::cin >> size;
    int *array = new int[size];
    generateArray(array, size);
    printArray(array, size);
    if (checkForArif(array, size) == true) {
        std::cout << "Yes" << std::endl;
    } else {
        std::cout << "No" << std::endl;
    }
    if (checkForGeom(array, size) == true) {
        std::cout << "Yes" << std::endl;
    } else {
        std::cout << "No" << std::endl;
    }
 
    delete [] array;
 
    return 0;
}
0
323 / 49 / 28
Регистрация: 07.09.2014
Сообщений: 217
09.09.2014, 12:55 6
В варианте SpringBear есть 1 маленький недосмотр - в циклах функций i начинается с 0, а проверка элементов идет с использованием i-1, то есть идет обращение к array[-1].

Так же для проверки на ариф. прогрессию можно использовать формулу https://www.cyberforum.ru/cgi-bin/latex.cgi?a_i = \frac {a_{i-1} + a_{i+1}}{2}, а для геом. прогресссии https://www.cyberforum.ru/cgi-bin/latex.cgi?a_i = \sqrt{a_{i-1}a_{i+1}}, однако для проверки оптимальнее наверное таскать с собой переменную, чем брать каждый раз корень.
0
09.09.2014, 12:55
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
09.09.2014, 12:55
Помогаю со студенческими работами здесь

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

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

Проверить, образуют ли элементы массива арифметическую прогрессию
Дан целочисленный массив размера n (вводится с клавиатуры), не содержащий одинаковых чисел....

Проверить образуют ли элементы массива геометрическую прогрессию
Вот задание: Дан массив ненулевых целых чисел размера N. Проверить, образуют ли его элементы...


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

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

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