Убывающая последовательность строк в массиве

@Ankoo · Регистрация: 20.03.2015

Студворк — интернет-сервис помощи студентам

Дана матрица M*N. Упорядочить её строки так, чтобы их минимальные элементы образовывали убываюшую последовательность. Я в каждой строке нахожу минимальный элемент и заношу их в новый одномерный массив, дальше я методом пузырька сортирую элементы в новом массиве по убыванию, можно ли как-то получить индексы убывающих элементов, что бы соответственно им выводить элементы основного массива??? Подкиньте, кто-нибудь идейку, как дальше быть, уже голову сломала

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 <ctime> 
 
using namespace std;
 
int main()
{
    int min, imin, min2, imin2,tmp,  i,j; int temp;
    srand(time(NULL)); 
    int n = 6; 
    int m = 6;
    int b[n],c[n], a[n][m],a2[n];
        for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            a[i][j] = rand() % 30; 
            cout << a[i][j] << "\t "; 
        }
        cout << endl; 
    }
   
    //b[i][j]=a[i][j];
    for ( i = 0; i < n; i++){
    min = a[0][0];
        for( j=0;j<m;j++)
{           for ( j = 0; j < m; j++){
            if (min > a[i][j]){
        
            min = a[i][j];
            imin=i;
            
            b[i]=min;
            c[i]=imin;
            }}
          
                          
            
                                        
        cout<<"\nMinim chislo = "<< min<< endl<<imin<<endl;
     
    }}
    
for(int i = 0; i < n - 1; i++)
                {
            for(int j = i + 1; j < n; j++)
                {
            if (b[i] < b[j])
        {
            temp = b[i];
            b[i] = b[j];
            b[j] = temp;
            
        }
    }
}//i=imin2;
     
     
        for (int i = 0; i < n; i++)
    {
    
           cout<<b[i]<<"\t";
                   } 
                   
                   
 // cout << endl;
  //  cout<<imin2;  
        
    
       
    return 0;
}

@Ultrafight · 08.04.2015, 20:48

Сообщение от Ankoo

Упорядочить её строки так, чтобы их минимальные элементы образовывали убываюшую последовательность.

то есть, если дана матрица
3 2 1
0 4 5
7 6 2

то должны получить
7 6 2
3 2 1
0 4 5
?

@Ankoo · 08.04.2015, 20:56 **[ТС]**

Сообщение от Ultrafight

то есть, если дана матрица
3 2 1
0 4 5
7 6 2

то должны получить
7 6 2
3 2 1
0 4 5
?

да, только я не могу понять как так сделать

@Ultrafight · 08.04.2015, 22:37

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
#include <iostream>
#include <time.h>
#include<stdlib.h>
 
using namespace std;
 
int * ret_mas_transpos(int * m_m_e, int k) // возвращает массив перестановок (m_m_e - входной массив значений минимальных элементов для каждой строки, k - число строк в исходной матрице)
{
    int * tr_m;     // массив перестановок
    int max_cur_el; // максимальный текущий элемент
    int max_pos;    // позиция максимального текущего элемента
    int c;          // счетчик
 
    tr_m = new int[k]; // выделяем память под массив перестановок
 
    c = 0; // обнуляем счетчик
 
    while(c!=k) // пока счетчик не дойдет до значения число строк в матрице
    {
        max_cur_el = -1000;            // максимальное значение текущего элемента
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]>max_cur_el)    // если значение i-го элемента больше max_cur_el
            {
                max_cur_el = m_m_e[i]; // в max_cur_el записываем значение i-го элемента
                max_pos = i;           // в переменную max_pos запоминаем позицию i элемента
            }
        }
 
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]==max_cur_el)   // если i-ый элемент массива равен max_cur_el
            {
                tr_m[c]=i;             // в c-ый элемент массива tr_m заносим i
                c++;                   // увеличиваем счетчик
                m_m_e[i] = -2000;      // устанавливаем значение i-го элемента массива минимальных значений матрицы -2000
            }
        }
    }
 
    return tr_m; // возращаем массив перестановок
}
 
int main()
{
    int ** matrix;      // входная матрица
    int * mas_min_el;   // массив минимальх элементов матрицы (для каждой строки)
    int * mas_transpos; // массив перестановок
    int ** new_matrix;  // "упорядоченная" матрица
    int n = 6;          // число строк в матрице
    int m = 6;          // число столбцов в матрице
 
    // выделение памяти
    matrix = new int*[n];
    for(int i=0; i<n; i++)
    {
        matrix[i] = new int[m];
    }
 
    new_matrix = new int*[n];
    for(int i=0; i<n; i++)
    {
        new_matrix[i] = new int[m];
    }
 
    mas_min_el = new int[n];
 
    srand(time(NULL));
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            matrix[i][j] = rand() % 30; // заполнение матрицы matrix рандомными значениями
        }
    }
 
    // вывод матрицы на экран
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    // заполнение массива минимальх элементов матрицы mas_min_el
    for(int i=0; i<n; i++)
    {
        mas_min_el[i] = matrix[i][0];
        for(int j=0; j<m; j++)
        {
            if(mas_min_el[i]>matrix[i][j])
            {
                mas_min_el[i] = matrix[i][j];
            }
        }
    }
 
    mas_transpos = ret_mas_transpos(mas_min_el,n); // получение массива перестановок из массива минимальных элементов
 
    // заполнение "упорядоченной" матрицы
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            new_matrix[i][j] = matrix[mas_transpos[i]][j];
        }
    }
 
    // вывод "упорядоченной матрицы на экран"
    cout<<"\n";
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<new_matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    // очищение памяти
    for(int i=0; i<n; i++)
    {
        delete [] matrix[i];
    }
    delete [] matrix;
    for(int i=0; i<n; i++)
    {
        delete [] new_matrix[i];
    }
    delete [] new_matrix;
    delete mas_transpos;
    delete mas_min_el;
 
    return 0;
}

Ankoo, прости, что так долго... хотел что-то более извращенное придумать...
прога вроде норм работает. протесть

@Ankoo · 09.04.2015, 15:38 **[ТС]**

Сообщение от Ultrafight

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
#include <iostream>
#include <time.h>
#include<stdlib.h>
 
using namespace std;
 
int * ret_mas_transpos(int * m_m_e, int k) // возвращает массив перестановок (m_m_e - входной массив значений минимальных элементов для каждой строки, k - число строк в исходной матрице)
{
    int * tr_m;     // массив перестановок
    int max_cur_el; // максимальный текущий элемент
    int max_pos;    // позиция максимального текущего элемента
    int c;          // счетчик
 
    tr_m = new int[k]; // выделяем память под массив перестановок
 
    c = 0; // обнуляем счетчик
 
    while(c!=k) // пока счетчик не дойдет до значения число строк в матрице
    {
        max_cur_el = -1000;            // максимальное значение текущего элемента
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]>max_cur_el)    // если значение i-го элемента больше max_cur_el
            {
                max_cur_el = m_m_e[i]; // в max_cur_el записываем значение i-го элемента
                max_pos = i;           // в переменную max_pos запоминаем позицию i элемента
            }
        }
 
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]==max_cur_el)   // если i-ый элемент массива равен max_cur_el
            {
                tr_m[c]=i;             // в c-ый элемент массива tr_m заносим i
                c++;                   // увеличиваем счетчик
                m_m_e[i] = -2000;      // устанавливаем значение i-го элемента массива минимальных значений матрицы -2000
            }
        }
    }
 
    return tr_m; // возращаем массив перестановок
}
 
int main()
{
    int ** matrix;      // входная матрица
    int * mas_min_el;   // массив минимальх элементов матрицы (для каждой строки)
    int * mas_transpos; // массив перестановок
    int ** new_matrix;  // "упорядоченная" матрица
    int n = 6;          // число строк в матрице
    int m = 6;          // число столбцов в матрице
 
    // выделение памяти
    matrix = new int*[n];
    for(int i=0; i<n; i++)
    {
        matrix[i] = new int[m];
    }
 
    new_matrix = new int*[n];
    for(int i=0; i<n; i++)
    {
        new_matrix[i] = new int[m];
    }
 
    mas_min_el = new int[n];
 
    srand(time(NULL));
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            matrix[i][j] = rand() % 30; // заполнение матрицы matrix рандомными значениями
        }
    }
 
    // вывод матрицы на экран
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    // заполнение массива минимальх элементов матрицы mas_min_el
    for(int i=0; i<n; i++)
    {
        mas_min_el[i] = matrix[i][0];
        for(int j=0; j<m; j++)
        {
            if(mas_min_el[i]>matrix[i][j])
            {
                mas_min_el[i] = matrix[i][j];
            }
        }
    }
 
    mas_transpos = ret_mas_transpos(mas_min_el,n); // получение массива перестановок из массива минимальных элементов
 
    // заполнение "упорядоченной" матрицы
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            new_matrix[i][j] = matrix[mas_transpos[i]][j];
        }
    }
 
    // вывод "упорядоченной матрицы на экран"
    cout<<"\n";
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<new_matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    // очищение памяти
    for(int i=0; i<n; i++)
    {
        delete [] matrix[i];
    }
    delete [] matrix;
    for(int i=0; i<n; i++)
    {
        delete [] new_matrix[i];
    }
    delete [] new_matrix;
    delete mas_transpos;
    delete mas_min_el;
 
    return 0;
}

Ankoo, прости, что так долго... хотел что-то более извращенное придумать...
прога вроде норм работает. протесть

Ничего себе, спасибо огромущее)) для меня это уже что-то извращенное.. А что означают этот символ *, я вроде читала адресация какая-то, но так и не поняла суть.

Добавлено через 13 минут
И еще, для чего в конце очищение памяти?

@Ultrafight · 09.04.2015, 18:55

Сообщение от Ankoo

Ничего себе, спасибо огромущее)) для меня это уже что-то извращенное.. А что означают этот символ *, я вроде читала адресация какая-то, но так и не поняла суть.
Добавлено через 13 минут
И еще, для чего в конце очищение памяти?

Ankoo, это указатели) одна из сильнейших вещей в с++. Если говорить по простому, то указатель хранит адрес.
int ** matrix; - аналог двумерного массива.

Если еще не проходила указатели, то просто замени на обычные массивы... я уж к указателям сильно привязался)

вот когда я вызываю эту функцию int * ret_mas_transpos(int * m_m_e, int k), то передаю указатель (адрес ячейки памяти и целое число). Если бы использовал int m_m_e[n], то в функцию передавал бы весь массив.

динамическое выделение памяти для новичков, конечно, непривычно и иногда "опасно)))", но со временем овладеешь этим ^_^ Я на 1-ом курсе в них вообще сначала не въезжал, но потом научился, хотя до сих пор иногда не правильно delete вызываю)

Добавлено через 2 минуты

C++
1
https://vk.com/fdsfdsfdsfdsfds

мой адрес в вк) если какие вопросы, можешь туда писать, чтобы не засорять тему)

Добавлено через 2 часа 25 минут

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
int * ret_mas_transpos(int * m_m_e, int k) // возвращает массив перестановок (m_m_e - входной массив значений минимальных элементов для каждой строки, k - число строк в исходной матрице)
{
    int * tr_m;     // массив перестановок
    int max_cur_el; // максимальный текущий элемент
    int max_pos;    // позиция максимального текущего элемента
    int c;          // счетчик
    int * mas_use_el; // массив "использованных" элементов
 
    tr_m = new int[k]; // выделяем память под массив перестановок
    mas_use_el = new int[k]; // выделяем память под массив "использованных" элементов
 
    // обнуление масива "использованных" элементов
    for(int i=0; i<k; i++)
    {
        mas_use_el[i]=0;
    }
 
    c = 0; // обнуляем счетчик
 
    while(c!=k) // пока счетчик не дойдет до значения число строк в матрице
    {
        // поиск первого "неиспользованного" элемента массива m_m_e
        for(int i=0; i<k; i++)
        {
            if(mas_use_el[i] == 0)
            {
                max_pos = i;
                max_cur_el = m_m_e[i];
                break;
            }
        }
 
        // поиск максимального значения массива m_m_e
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]>max_cur_el && mas_use_el[i]==0)    // если значение i-го элемента больше max_cur_el и этот элемент является "неиспользованным"
            {
                max_cur_el = m_m_e[i]; // в max_cur_el записываем значение i-го элемента
                max_pos = i;           // в переменную max_pos запоминаем позицию i элемента
            }
        }
 
        // заполнение массива перестановок
        for(int i=0; i<k; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(m_m_e[i]==max_cur_el)   // если i-ый элемент массива равен max_cur_el
            {
                tr_m[c]=i;             // в c-ый элемент массива tr_m заносим i
                mas_use_el[i] = 1;     // устанавливаем значение 1 массива "использованных" элементов
                c++;                   // увеличиваем счетчик
            }
        }
    }
 
    delete mas_use_el;
 
    return tr_m; // возращаем массив перестановок
}

@Ankoo · 10.04.2015, 18:00 **[ТС]**

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
#include <iostream>
#include <time.h>
#include<stdlib.h>
 
using namespace std;
 
int * ret_mas_transpos(int * m_m_e, int k) // âîçâðàùàåò ìàññèâ ïåðåñòàíîâîê (m_m_e - âõîäíîé ìàññèâ çíà÷åíèé ìèíèìàëüíûõ ýëåìåíòîâ äëÿ êàæäîé ñòðîêè, k - ÷èñëî ñòðîê â èñõîäíîé ìàòðèöå)
{
    int tr_m[k];     // ìàññèâ ïåðåñòàíîâîê
    int max_cur_el; // ìàêñèìàëüíûé òåêóùèé ýëåìåíò
    int max_pos;    // ïîçèöèÿ ìàêñèìàëüíîãî òåêóùåãî ýëåìåíòà
    int c;          // ñ÷åò÷èê
    int mas_use_el[k]; // ìàññèâ "èñïîëüçîâàííûõ" ýëåìåíòîâ
 
   // tr_m = new int[k]; // âûäåëÿåì ïàìÿòü ïîä ìàññèâ ïåðåñòàíîâîê
    //mas_use_el = new int[k]; // âûäåëÿåì ïàìÿòü ïîä ìàññèâ "èñïîëüçîâàííûõ" ýëåìåíòîâ
 
    // îáíóëåíèå ìàñèâà "èñïîëüçîâàííûõ" ýëåìåíòîâ
    for(int i=0; i<k; i++)
    {
        mas_use_el[i]=0;
    }
 
    c = 0; // îáíóëÿåì ñ÷åò÷èê
 
    while(c!=k) // ïîêà ñ÷åò÷èê íå äîéäåò äî çíà÷åíèÿ ÷èñëî ñòðîê â ìàòðèöå
    {
        // ïîèñê ïåðâîãî "íåèñïîëüçîâàííîãî" ýëåìåíòà ìàññèâà m_m_e
        for(int i=0; i<k; i++)
        {
            if(mas_use_el[i] == 0)
            {
                max_pos = i;
                max_cur_el = m_m_e[i];
                break;
            }
        }
 
        // ïîèñê ìàêñèìàëüíîãî çíà÷åíèÿ ìàññèâà m_m_e
        for(int i=0; i<k; i++)         // ïðîáåãàåìñÿ i ïî âñåì ýëåìåíòàì ìàññèâà ìèíèìàëüíûõ çíà÷åíèé ìàòðèöû
        {
            if(m_m_e[i]>max_cur_el && mas_use_el[i]==0)    // åñëè çíà÷åíèå i-ãî ýëåìåíòà áîëüøå max_cur_el è ýòîò ýëåìåíò ÿâëÿåòñÿ "íåèñïîëüçîâàííûì"
            {
                max_cur_el = m_m_e[i]; // â max_cur_el çàïèñûâàåì çíà÷åíèå i-ãî ýëåìåíòà
                max_pos = i;           // â ïåðåìåííóþ max_pos çàïîìèíàåì ïîçèöèþ i ýëåìåíòà
            }
        }
 
        // çàïîëíåíèå ìàññèâà ïåðåñòàíîâîê
        for(int i=0; i<k; i++)         // ïðîáåãàåìñÿ i ïî âñåì ýëåìåíòàì ìàññèâà ìèíèìàëüíûõ çíà÷åíèé ìàòðèöû
        {
            if(m_m_e[i]==max_cur_el)   // åñëè i-ûé ýëåìåíò ìàññèâà ðàâåí max_cur_el
            {
                tr_m[c]=i;             // â c-ûé ýëåìåíò ìàññèâà tr_m çàíîñèì i
                mas_use_el[i] = 1;     // óñòàíàâëèâàåì çíà÷åíèå 1 ìàññèâà "èñïîëüçîâàííûõ" ýëåìåíòîâ
                c++;                   // óâåëè÷èâàåì ñ÷åò÷èê
            }
        }
    }
 
    delete mas_use_el;
 
    return tr_m; // âîçðàùàåì ìàññèâ ïåðåñòàíîâîê
}
 
int main()
{
          // âõîäíàÿ ìàòðèöà
      
    
     
    int n = 6;          // ÷èñëî ñòðîê â ìàòðèöå
    int m = 6;          // ÷èñëî ñòîëáöîâ â ìàòðèöå
    int matrix[n][m];
    int new_matrix[n][m];// "óïîðÿäî÷åííàÿ" ìàòðèöà
    int mas_min_el[n]; // ìàññèâ ìèíèìàëüõ ýëåìåíòîâ ìàòðèöû (äëÿ êàæäîé ñòðîêè)
    int mas_transpos[n]; // ìàññèâ ïåðåñòàíîâîê
 
    srand(time(NULL));
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            matrix[i][j] = rand() % 30; // çàïîëíåíèå ìàòðèöû matrix ðàíäîìíûìè çíà÷åíèÿìè
        }
    }
 
    // âûâîä ìàòðèöû íà ýêðàí
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<matrix[i][j]<<"\t ";
        }
        cout<<"\n";
    }
 
    // çàïîëíåíèå ìàññèâà ìèíèìàëüõ ýëåìåíòîâ ìàòðèöû mas_min_el
    for(int i=0; i<n; i++)
    {
        mas_min_el[i] = matrix[i][0];
        for(int j=0; j<m; j++)
        {
            if(mas_min_el[i]>matrix[i][j])
            {
                mas_min_el[i] = matrix[i][j];
            }
        }
    }
 
    mas_transpos = ret_mas_transpos(mas_min_el,n); // ïîëó÷åíèå ìàññèâà ïåðåñòàíîâîê èç ìàññèâà ìèíèìàëüíûõ ýëåìåíòîâ
 
    // çàïîëíåíèå "óïîðÿäî÷åííîé" ìàòðèöû
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            new_matrix[i][j] = matrix[mas_transpos[i]][j];
        }
    }
 
    // âûâîä "óïîðÿäî÷åííîé ìàòðèöû íà ýêðàí"
    cout<<"\n";
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<new_matrix[i][j]<<"\t ";
        }
        cout<<"\n";
    }
 
    return 0;
}

@Ultrafight · 10.04.2015, 19:20

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
int main()
{
    int n = 6;          // число строк в матрице
    int m = 6;          // число столбцов в матрице
 
    int matrix[n][m];      // входная матрица
    int mas_min_el[n];   // массив минимальх элементов матрицы (для каждой строки)
    int mas_use_el[n];
    int mas_transpos[n]; // массив перестановок
    int new_matrix[n][m];  // "упорядоченная" матрица
 
    int c;
    int max_pos;
    int max_cur_el;
 
    srand(time(NULL));
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            matrix[i][j] = rand() % 30; // заполнение матрицы matrix рандомными значениями
        }
    }
 
    // вывод матрицы на экран
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    // заполнение массива минимальх элементов матрицы mas_min_el
    for(int i=0; i<n; i++)
    {
        mas_min_el[i] = matrix[i][0];
        for(int j=0; j<m; j++)
        {
            if(mas_min_el[i]>matrix[i][j])
            {
                mas_min_el[i] = matrix[i][j];
            }
        }
    }
 
    ///
    // обнуление масива "использованных" элементов
    for(int i=0; i<n; i++)
    {
        mas_use_el[i]=0;
    }
 
    c = 0; // обнуляем счетчик
 
    while(c!=n) // пока счетчик не дойдет до значения число строк в матрице
    {
        // поиск первого "неиспользованного" элемента массива m_m_e
        for(int i=0; i<n; i++)
        {
            if(mas_use_el[i] == 0)
            {
                max_pos = i;
                max_cur_el = mas_min_el[i];
                break;
            }
        }
 
        // поиск максимального значения массива m_m_e
        for(int i=0; i<n; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(mas_min_el[i]>max_cur_el && mas_use_el[i]==0)    // если значение i-го элемента больше max_cur_el и этот элемент является "неиспользованным"
            {
                max_cur_el = mas_min_el[i]; // в max_cur_el записываем значение i-го элемента
                max_pos = i;           // в переменную max_pos запоминаем позицию i элемента
            }
        }
 
        // заполнение массива перестановок
        for(int i=0; i<n; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(mas_min_el[i]==max_cur_el)   // если i-ый элемент массива равен max_cur_el
            {
                mas_transpos[c]=i;             // в c-ый элемент массива tr_m заносим i
                mas_use_el[i] = 1;     // устанавливаем значение 1 массива "использованных" элементов
                c++;                   // увеличиваем счетчик
            }
        }
    }
 
    ///
 
    // заполнение "упорядоченной" матрицы
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            new_matrix[i][j] = matrix[mas_transpos[i]][j];
        }
    }
 
    // вывод "упорядоченной матрицы на экран"
    cout<<"\n";
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<new_matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
 
    return 0;
}

Добавлено через 53 минуты

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
#include <iostream>
#include <time.h>
#include<stdlib.h>
 
using namespace std;
 
#define n 6
#define m 6
 
void print_element(int h)
{
    cout<<h;
}
 
void print_matrix(int matrix[n][m])
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<"\n";
    }
}
 
int main()
{
    int matrix[n][m];      // входная матрица
    int mas_min_el[n];   // массив минимальх элементов матрицы (для каждой строки)
    int mas_use_el[n];
    int mas_transpos[n]; // массив перестановок
    int new_matrix[n][m];  // "упорядоченная" матрица
 
    int c;
    int max_pos;
    int max_cur_el;
 
    srand(time(NULL));
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            matrix[i][j] = rand() % 30; // заполнение матрицы matrix рандомными значениями
        }
    }
 
    // вывод матрицы на экран
    print_matrix(matrix);
 
    // заполнение массива минимальх элементов матрицы mas_min_el
    for(int i=0; i<n; i++)
    {
        mas_min_el[i] = matrix[i][0];
        for(int j=0; j<m; j++)
        {
            if(mas_min_el[i]>matrix[i][j])
            {
                mas_min_el[i] = matrix[i][j];
            }
        }
    }
 
    ///
    // обнуление масива "использованных" элементов
    for(int i=0; i<n; i++)
    {
        mas_use_el[i]=0;
    }
 
    c = 0; // обнуляем счетчик
 
    while(c!=n) // пока счетчик не дойдет до значения число строк в матрице
    {
        // поиск первого "неиспользованного" элемента массива m_m_e
        for(int i=0; i<n; i++)
        {
            if(mas_use_el[i] == 0)
            {
                max_pos = i;
                max_cur_el = mas_min_el[i];
                break;
            }
        }
 
        // поиск максимального значения массива m_m_e
        for(int i=0; i<n; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(mas_min_el[i]>max_cur_el && mas_use_el[i]==0)    // если значение i-го элемента больше max_cur_el и этот элемент является "неиспользованным"
            {
                max_cur_el = mas_min_el[i]; // в max_cur_el записываем значение i-го элемента
                max_pos = i;           // в переменную max_pos запоминаем позицию i элемента
            }
        }
 
        // заполнение массива перестановок
        for(int i=0; i<n; i++)         // пробегаемся i по всем элементам массива минимальных значений матрицы
        {
            if(mas_min_el[i]==max_cur_el)   // если i-ый элемент массива равен max_cur_el
            {
                mas_transpos[c]=i;             // в c-ый элемент массива tr_m заносим i
                mas_use_el[i] = 1;     // устанавливаем значение 1 массива "использованных" элементов
                c++;                   // увеличиваем счетчик
            }
        }
    }
 
    ///
 
    // заполнение "упорядоченной" матрицы
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            new_matrix[i][j] = matrix[mas_transpos[i]][j];
        }
    }
 
    cout<<"\n";
 
    // вывод "упорядоченной матрицы на экран"
    print_matrix(new_matrix);
 
    return 0;
}

@Ultrafight · 12.04.2015, 19:23

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
#include <iostream>
#include <time.h>
#include <stdlib.h>
 
using namespace std;
 
int main()
{
    int min, jmin, min2, imin2,tmp, i,j; int temp;
    srand(time(NULL));
    int n = 6;
    int m = 6;
    int b[6][1],c[n], a[n][m],a2[n];
    int a_new[n][m+1];
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            a[i][j] = rand() % 30;
            cout << a[i][j] << "\t ";
        }
        cout << endl;
    }
    min = a[0][0];
    for ( i = 0; i < n; i++)
    {
        for( j=0; j<m; j++)
        {
            if (min > a[i][j])
            {
                min = a[i][j];
                jmin=j;
            }
        }
    }
    cout<<"\nMinim chislo = "<< min<< endl<<jmin<<endl;
 
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m+1; j++)
        {
            if(j<jmin)
            {
                a_new[i][j] = a[i][j];
            }
            else if(j==jmin)
            {
                a_new[i][j] = a[i][j];
            }
            else
            {
                a_new[i][j] = a[i][j-1];
            }
        }
    }
 
    cout<<"\n";
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m+1; j++)
        {
            cout<<a_new[i][j]<<"\t";
        }
        cout<<"\n";
    }
    cout<<"\n";
 
    return 0;
}

Новые блоги и статьи Все статьи Все блоги /
Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Programma_Boinc 28.12.2025 Советы по крайней бережливости. Внимание, это ОЧЕНЬ длинный пост. Налог на собак: https:/ / ********/ gallery/ V06K53e Финансовый отчет в Excel: https:/ / ********/ gallery/ bKBkQFf Пост отсюда. . .	Кто-нибудь знает, где можно бесплатно получить настольный компьютер или ноутбук? США. Programma_Boinc 26.12.2025 Нашел на реддите интересную статью под названием Anyone know where to get a free Desktop or Laptop? Ниже её машинный перевод. После долгих разбирательств я наконец-то вернула себе. . .	Thinkpad X220 Tablet — это лучший бюджетный ноутбук для учёбы, точка. Programma_Boinc 23.12.2025 Рецензия / Мнение/ Перевод Нашел на реддите интересную статью под названием The Thinkpad X220 Tablet is the best budget school laptop period . Ниже её машинный перевод. Thinkpad X220 Tablet —. . .	PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Как объединить две одинаковые БД Access с разными данными VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.
Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .

Убывающая последовательность строк в массиве

Решение

Решение