Форум программистов, компьютерный форум CyberForum.ru

Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец - C++

Восстановить пароль Регистрация
 
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 19:18     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #1
написать две проги...Желательно в Microsoft Visual Studio. Исходный массив
инициализировать случайным образом, предусмотрев возможность введения с клавиатуры размерности обрабатываемого массива. Исходный массив и полученный результат вывести на экран. Это я сделала, помогите, плиз, остальное...
Основные этапы работы с массивом оформить в виде функций. В случае последовательного просмотра элементов массива обращение к элементам осуществлять с помощью указателей.

1.Дан одномерный целочисленный массив. Отсортировать элементы массива следующим образом: отрицательные – в начало массива, положительные – в конец массива, нули – в середине (порядок следования элементов не изменять).

2.В массиве целых чисел среди чисел, стоящих на нечетных позициях, найти нечетные отрицательные элементы и записать их в новый массив, удалив из исходного массива. Оставшийся массив отсортировать по убыванию разности количества единиц и нулей в двоичном представлении числа.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
18.02.2011, 19:18     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец
Посмотрите здесь:

Все положительные элементы массива поставить в начало, а отрицательные - в конец C++
C++ Необходимо, пройдя по массиву один раз, все его положительные элементы поставить в начало а отрицательные в конец
Все отрицательные цифры поместить в начало массива, а положительные в конец C++
C++ Перестановить положительные элементы в начало массива, отрицательные — в конец
В одномерном массиве все отрицательные элементы переместить в начало массива, а остальные – в конец с сохранением порядка следования C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
S1av0k
8 / 8 / 0
Регистрация: 25.01.2011
Сообщений: 21
18.02.2011, 20:07     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #2
Покажите, что уже сделано
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 20:14  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #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
#include<iostream>
 
using namespace std;
 
void RandomArray(int*, int);
void DisplayArray(int*, int);
 
int main()
{
    const int N  = 10;
    int A[N] = {0};
    int n;
    while(true)
    {
        cout << " Enter n <= " << N << "  :";
        cin >> n;
        if ( n > 0 && n <= N)
            break;
        system("cls");
    }
    system("cls");
    RandomArray(A,n);
    cout << "Array A" << endl;
    DisplayArray(A,n);
    cout << endl;
    system("pause");
}
 
void RandomArray(int* p, int n)
{
    for(int* q = p; q < p + n; q++)
        *q = rand() % 10;
}
 
void DisplayArray(int* p, int n)
{
    for(int* q = p; q < p + n; q++)
        cout << *q << ' ';
}
ping_rulezzz
26 / 26 / 4
Регистрация: 18.02.2011
Сообщений: 51
18.02.2011, 20:53     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #4
Сообщение было отмечено автором темы, экспертом или модератором как ответ
Не совсем понятно что имелось в виду.
Оставшийся массив отсортировать по убыванию разности количества единиц и нулей в двоичном представлении числа.
поэтому придётся доделать самому 2ое задание - там не сложно.
Принципе 2ое задание почти сделано, добавить сортировку можно используя часть кода отсюда - http://forum.ishodniki.ru/index.php?topic=10442.0
По 1ому заданию - более изящного способа сортировки не смог придумать на скорую руку, м.б. кто-нибудь сделает красивее.

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
void foo(int *mas, const size_t size) {
    int *t = new int[size];
    int pos_count = 0;
    int neg_count = 0;
    int zero_count = 0;
    
    for (size_t i = 0; i < size; ++i) {
        if (mas[i] > 0) {
            ++pos_count;
        } else if (mas[i] < 0) {
            ++neg_count;
        } else {
            ++zero_count;
        }
    }
 
    int temp1 = pos_count;
    int temp2 = neg_count;
    int temp3 = zero_count;
 
    for (size_t i = 0; i < size; ++i) {
        if (mas[i] > 0) {
            t[pos_count - (temp1--)] = mas[i];
        } else if (mas[i] < 0) {
            t[pos_count + zero_count + neg_count - (temp2--)] = mas[i];
        } else {
            t[pos_count + zero_count -(temp3--)] = mas[i];
        }
    }
 
    for (size_t i = 0; i < size; ++i) {
        mas[i] = t[i];
    }
    delete []t;
}
 
void foo2(int *mas, size_t size) {
    int *new_mas = new int[size];
    int cur_pos = 0;
    int abs_pos = 0;
 
    for (size_t i = 0; i < size; ++i) {
        
        if((abs_pos % 2 == 1) && (mas[i] < 0)) {
            new_mas[cur_pos++] = mas[i];
            
            for (size_t y = i; y < size - 1; ++y){
                mas[y] = mas[y+1];
            }
            --i;
            --size;
            mas[size] = 0;
 
        }
        ++abs_pos;
    }
 
    for(size_t i = 0; i < size; ++i) {
        cout << mas[i] << endl;
    }
    
    for(size_t i = 0; i < cur_pos - 1; ++i) {
        cout << new_mas[i] << endl;
    }
 
}
ЗЫ циклы вывода в foo2 остались для отладки
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 21:02  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #5
спасибо огромное за код))) а вы не могли бы добавить комментарии, а то не везде поняла, что происходит.....
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
18.02.2011, 21:17     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #6
Сообщение было отмечено автором темы, экспертом или модератором как ответ
1
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<iostream>
#include<algorithm>
#include<ctime>
#include<cstdlib>
 
int main(){
    int n, tmp;
    std::cin>>n;
    int *con=new int[n];
    srand(time(0));
    std::generate(con, con+n, [&](){
                  tmp=rand()%40-20;
                  std::cout<<tmp<<"  ";
                  return tmp;
                  });
    std::cout<<"\n";
    std::sort(con, con+n, [](int a, int b){
        if(a<0&&b>=0||a==0&&b>0) return true;
        else return false;
    });
    std::for_each(con, con+n, [](int x){std::cout<<x<<"  ";});
    delete[]con;
}
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 21:27  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #7
igorrr37 а можете написать как-нибудь попроще...без этого:
C++
1
2
3
4
5
6
7
std::cin>>n;
new int[n];    
srand(time(0));   
std::generate(con, con+n, [&]()    
std::sort(con, con+n, [](int a, int b);    
std::for_each(con, con+n, [](int x){std::cout<<x<<"  ";})     
delete[]con;
ping_rulezzz
26 / 26 / 4
Регистрация: 18.02.2011
Сообщений: 51
18.02.2011, 21:27     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #8
Сообщение было отмечено автором темы, экспертом или модератором как ответ
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
void foo(int *mas, const size_t size) {
    int *t = new int[size]; // новый временный массив
    int pos_count = 0;      // кол-во положительных чисел
    int neg_count = 0;      // отрицательных
    int zero_count = 0;     // нулевых
    
    // считаем кол-во чисел >0, =0, <0 в массиве
    for (size_t i = 0; i < size; ++i) {
        if (mas[i] > 0) {
            ++pos_count;
        } else if (mas[i] < 0) {
            ++neg_count;
        } else {
            ++zero_count;
        }
    }
 
    int temp1 = pos_count; // так сказать обратный счётчик кол-ва положительныйх числел
    int temp2 = neg_count; // тоже дял отрицательных
    int temp3 = zero_count; // для нулей
 
    for (size_t i = 0; i < size; ++i) {
        if (mas[i] < 0) {
            //если наше число < 0 то оно записывается в новый массив под индексом neg_count - (temp2--), что при 1ой итерации = 0
            // и сразуже идёт дикремент temp2, и тд
            t[neg_count - (temp2--)] = mas[i]; 
        } else if (mas[i] > 0) {
            t[pos_count + zero_count + neg_count - (temp1--)] = mas[i];
        } else {
            t[pos_count + zero_count -(temp3--)] = mas[i];
        }
    }
 
    for (size_t i = 0; i < size; ++i) {
        mas[i] = t[i]; 
    }
    delete []t;
}
 
void foo2(int *mas, size_t size) {
    int *new_mas = new int[size]; //массив для нечётных отрицательных
    int cur_pos = 0; //текущая позиция в новом массиве
    int abs_pos = 0; // абсолютная позиция в исходном массиве
 
    for (size_t i = 0; i < size; ++i) {
        // если наше число на нечётной позиции и < 0 
        if((abs_pos % 2 == 1) && (mas[i] < 0)) {
            new_mas[cur_pos++] = mas[i]; // добавляем этот элемент в новый массив
            
            for (size_t y = i; y < size - 1; ++y){ // "удаляем" этот элемент из исходного массива путём сдвига
                mas[y] = mas[y+1];
            }
            --i;
            --size;
            mas[size] = 0;
 
        }
        ++abs_pos; // переменная нужна, чтобы следить за нечтностью позиции в исходном массиве, т.к. мы постоянно сдвиаем элементы
    }
 
    for(size_t i = 0; i < size; ++i) {
        cout << mas[i] << endl;
    }
    
    for(size_t i = 0; i < cur_pos - 1; ++i) {
        cout << new_mas[i] << endl;
    }
 
}
ЗЫ чуть-чуть изменил код по 1ому заданию - перепутал местами положительные и отрицательные элементы при сортировки.
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 21:33  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #9
ping_rulezzz, СПАСИБО огромное, вы мне очень помогли)))
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
18.02.2011, 21:38     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #10
innuska, проще написать гораздо сложнее
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
18.02.2011, 21:42  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #11
понимаю, но мне нужно, чтоб я смогла все ето дело объяснить и понять. И использовать в коде мне нужно только то, что я знаю... А из этого я разве что первую строчку понимаю...
C++
1
2
3
4
5
6
7
std::cin>>n;
new int[n]; 
srand(time(0)); 
std::generate(con, con+n, [&]() 
std::sort(con, con+n, [](int a, int b); 
std::for_each(con, con+n, [](int x){std::cout<<x<<" ";}) 
delete[]con;
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
19.02.2011, 00:15     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #12
Сообщение было отмечено автором темы, экспертом или модератором как ответ
сортировка вставками
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<iostream>
#define N 11
 
void sort(int con[N]){
    int tmp, *a, *b;
    for(a=con+1; a<con+N; a++){
        tmp=*a;
        for(b=a-1; b>=con&&(*b>=0&&tmp<0||*b>0&&tmp==0); --b){
            *(b+1)=*b;
        }
        *(b+1)=tmp;
    }
}
 
int main(){
    int con[N]={0, 5, -2, 1, -3, 0, 0, -45, -3, -3, 7};
    sort(con);
    for(int* a=con; a<con+N; a++){
        std::cout<<*a<<"  ";
    }
}
Добавлено через 1 час 24 минуты
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
#include<iostream>
#include<bitset>
#define N 11
 
int dif(int n){
    int one=0, zero=0;
    std::bitset<32> bit(n);
    for(int i=0; i<32; i++){
        if(bit[i]==1) ++one;
        else ++zero;
    }
    //std::cout<<one-zero;
    return one-zero;
}
 
void sort(int con[], int n){
    int tmp, *a=0, *b=0;
    for(a=con+1; a<con+n; a++){
        tmp=*a;
        for(b=a-1; b>=con&&(dif(*b)<dif(tmp)); --b){
            *(b+1)=*b;
        }
        *(b+1)=tmp;
    }
}
 
void print(int mas[], int n){
    for(int *p=mas; p<mas+n; p++){
        std::cout<<*p<<"  ";
    }
}
 
int main(){
    int con[N]={-1, 5, -2, 1, -3, 0, 0, -45, -3, -3, 7}, neg[N], rest[N];
    int *pcon=con, *pneg=neg, *prest=rest;
    for(; pcon<con+N; ++pcon){
        if(((pcon-con)%2)&&((*pcon)%2)&&(*pcon)<0){
            *pneg++=*pcon;
        }
        else *prest++=*pcon;
    }
    std::cout<<"Neg\n";  //нечетные отрицательные элементы
    print(neg, pneg-neg);
    std::cout<<"\nRest\n";//Оставшийся массив
    print(rest, prest-rest);
    sort(rest, prest-rest);
    std::cout<<"\nSorted rest\n";//Оставшийся массив отсортирован
    print(rest, prest-rest);
}
ping_rulezzz
26 / 26 / 4
Регистрация: 18.02.2011
Сообщений: 51
19.02.2011, 00:37     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #13
igorrr37, красиво.

Не понял только одну вещь - для чего проверка ((*pcon)%2). Не могли бы пояснить?
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 7
19.02.2011, 02:48     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #14
Спасибо. Проверка элемента на нечётность:
>на нечетных позициях, найти нечетные отрицательные элементы
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
26.02.2011, 00:01     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец
Еще ссылки по теме:

Отрицательные элементы массива переместить в конец C++
C++ Положительные элементы массива перенести в начало
C++ Положительные элементы массива перенести в начало

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

Или воспользуйтесь поиском по форуму:
innuska
0 / 0 / 0
Регистрация: 25.10.2010
Сообщений: 17
26.02.2011, 00:01  [ТС]     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец #15
Вот мой код, конечно более громоздкий. Не все функции работают правильно. Исправьте ошибки.
Ф-ция CreateArray создает нужный мне массив, но в конце дописывает нули, их не должно быть.
Ф-ция SortingArray должна сортировать исходный массиив без тех элементов, что были удалены, а сортирует исходный полностью.
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
/* В массиве целых чисел среди чисел, стоящих на нечетных позициях, найти нечетные 
отрицательные элементы и записать их в новый массив, удалив из исходного массива.
Оставшийся массив отсортировать по убыванию разности количества единиц и нулей в 
двоичном представлении числа. */ 
 
#include<iostream>
#include<cstdlib>
#include<cmath>
 
using namespace std;
 
void EnterArray(int*, int);             // Ф-ция ввода массива (работает)
void DisplayArray(int*, int);           // Ф-ция вывода массива на экран (работает)
void CreateArray(int*, int*, int);      // Ф-ция создания массива, в который копируются нечетные отрицательные элементы, стоящие на нечетных позициях
void DeleteElements(int*, int);         // Ф-ция удаляет из исходного массива элементы, скопированные в новый массив (работает)
void SortingArray(int*, int);           // Ф-ция сортирует исходный измененный массив по убыванию разности кол-ва 1 и 0
int Diff_Between_Untils_And_Zeros(int); // Ф-ция вычитает кол-во нулей из кол-ва единиц (работает)
int NumberOfUntiles(int);               // Ф-ция считает кол-во единиц в двоичной записи числа (работает)
int NumberOfZeros(int);                 // Ф-ция считает кол-во нулей в двоичной записи числа (работает)
void Swap(int &, int &);                // Ф-ция меняет местами два элемента (работает) 
 
int main()
{
    setlocale(LC_ALL, "rus");
    const int N = 100;
    int A[N] = {0}, n, B[N] = {0};
    while(true)
    {
        cout << " Введите количество элементов массива <= " << N << ": ";
        cin >> n;
        if ( n > 0 && n <= N)
            break;
        system("cls");
    }
    cout << "Введите элементы массива: " << endl;
    EnterArray(A, n);
    system ("cls");
    cout << "Исходный массив: ";
    DisplayArray(A, n);
    cout << endl;
    CreateArray(A, B, n);
    cout << "Массив, состоящий из нечетных отрицательных элементов: ";
    DisplayArray(B, n);
    cout << endl;
    DeleteElements(A, n);
    cout << endl;
    SortingArray(A, n);
    cout << "Отсортированный измененный исходный массив: ";
    DisplayArray(A, n);
    cout << endl;
    system ("pause");
    return 0;
}
 
void EnterArray(int* p, int n)
{
    for (int* q = p, i = 0; q < p + n; q++, i++)
    {
        cout << "A[" << i << "] = ";
        cin >> *q;
    }
}
 
void DisplayArray(int* p, int n)
{
    for (int* q = p, i = 1; q < p + n; q++, i++)
        cout << *q << " ";
}
 
void CreateArray(int* pa, int* pb, int n)
{
    for(int i = 0, j = 0; i < n; i++)
    {
        if (i % 2 == 1 && pa[i] < 0 && (abs(pa[i])) % 2 == 1)
        {
            pb[j] = pa[i];
            j++;
        }
    }
}
 
void DeleteElements(int* pa, int n)
{
    int del = 0, m;
    cout << "Измененный исходный массив: ";
    for(int i = 0, j = 0; i < n; i++)
    {
        if (i % 2 == 1 && pa[i] < 0 && (abs(pa[i])) % 2 == 1)
            continue;
        else
            cout << pa[i] << ' ';
    }
}
 
void SortingArray(int* pa, int n)
{
    for (int i = 0; i < n; i++)
        for(int j = n - 1; j > i;  j--)
            if(Diff_Between_Untils_And_Zeros(pa[j]) > Diff_Between_Untils_And_Zeros(pa[j - 1]))
                Swap(pa[j], pa[j - 1]);
}
 
int Diff_Between_Untils_And_Zeros(int n)
{
    int diff;
    diff = NumberOfUntiles(n) - NumberOfZeros(n);   
    return diff;
}
 
int NumberOfUntiles(int n)
{
    int k = 0;
    while (n)
    {
        if (n % 2)
            k++;
        n /= 2;
    }
    return k;
}
 
int NumberOfZeros(int n)
{
    int k = 0;
    while (n)
    {
        if (!(n % 2))
            k++;
        n /= 2;
    }
    return k;
}
 
void Swap(int & a, int & b)
{
    int t = a;
    a = b;
    b = t;
}
Yandex
Объявления
26.02.2011, 00:01     Отсортировать элементы массива: отрицательные – в начало массива, положительные – в конец
Ответ Создать тему
Опции темы

Текущее время: 07:14. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru