Форум программистов [Powered by Invision Power Board]

Код


#include <iostream>
#include <cstdlib>
#include <ctime>
using std::cout;
using std::cin;
using std::endl;

int main()
{
    srand(time(0));
    const int m=3;
    const int n=3;
    int Array[m][n]={0};
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            Array[i][j]=rand();
        }
    }
    cout<<"Array"<<endl;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<Array[i][j]<<" ";
        }
        cout<<endl;
    }
    int A;//число окторе вводит пользователь
    int counterA=0;//счетчик
    cout<<"Enter digit: ";
    cin>>A;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(Array[i][j]>A||-Array[i][j]>A)
                counterA++;
        }
    }
    cout<<"Kol-vo chisel "<<counterA<<endl;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(Array[i][j]%2==0)//здесь обнуляется четный элемент, но не тот который стоит на четном месте
            Array[i][j]=0;
        }
    }
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<Array[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<"Enter number of element x and y";
    int x, y;
    int tmp;
    cin>>x>>y;
    tmp=Array[m-1][n-1];
    Array[m-1][n-1]=Array[x][y];
    Array[x][y]=tmp;
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            cout<<Array[i][j]<<" ";
        }
        cout<<endl;
    }
return 0;
}

Код


#include <algorithm>
#include <functional>
#include <iostream>
#include <time.h>


//----------------------------------------------------------------------------------------------
// 0. Заполнить массив m на n случайными числами
//----------------------------------------------------------------------------------------------
template <typename T, size_t M, size_t N>
void fill_array(T (&arr)[M][N])
{
    std::generate(&arr[0][0], &arr[0][0] + M*N, &rand);
}

//----------------------------------------------------------------------------------------------
// 1. Подсчитать кол-во элементов превосходящих по модулю заданное число А
//----------------------------------------------------------------------------------------------
struct greater_mod : public std::unary_function<int, bool>
{
    greater_mod(argument_type limit) : limit_(limit) {}
    result_type operator()(const argument_type& val) const
    { return std::abs(val) > limit_; }
    argument_type limit_;
};

template <typename T, size_t M, size_t N>
size_t greater_then(const T (&arr)[M][N], const T A)
{
    return std::count_if(&arr[0][0], &arr[0][0] + M*N, greater_mod(A));
}


//----------------------------------------------------------------------------------------------
// 2. Заполнить все элементы массива стоящие на четных местах на 0
//----------------------------------------------------------------------------------------------
template <
    typename InputIterator,
    typename OutputIterator,
    typename UnaryProc,
    typename UnaryPredicate>
OutputIterator transform_if(
    InputIterator begin, InputIterator end,
    OutputIterator out, UnaryProc op, UnaryPredicate pred)
{
    while (begin != end)
    {
        if (pred(*begin))
            *out = op(*begin);

        ++begin;
        ++out;
    }
    return (out);
}

struct is_even : public std::unary_function<int, bool>
{
    is_even() : counter_(0) {};
    result_type operator()(const argument_type&)
    { return !(counter_++ & 1); }
    argument_type counter_;
};

struct replacer : public std::unary_function<int, int>
{
    replacer(argument_type value) : value_(value) {}
    result_type operator()(const argument_type&) const
    { return value_; }
    argument_type value_;

};

template <typename T, size_t M, size_t N>
void replace_even(T (&arr)[M][N], const T newVal)
{
    transform_if(&arr[0][0], &arr[0][0] + M*N, &arr[0][0], replacer(newVal), is_even());
}

int main()
{
    srand(static_cast<unsigned int>(time(NULL)));

    // подготовить массив
    const size_t M = ...;
    const size_t N = ...;

    int arr[M][N];

    // 0. Заполнение массива
    fill_array(arr);

    // 1. Поиск в массиве
    int A;
    std::cin >> A;
    size_t greaterA = greater_then(arr, A);
    std::cout << greaterA << std::endl;

    // 2. Замена в массиве
    replace_even(arr, 0);    
    return (0);
}

Код


int* min = std::min_element(&arr[0][0], &arr[0][0] + M*N);
std::swap(*min, arr[M-1][N-1]);

Код


return std::count_if(
        &arr[0][0], &arr[0][0] + M*N,
        lm::bind<T>(&std::abs, lm::_1) > A);

Код


// Использование стандартного алгоритма
{
    int cnt = 0;
    std::transform(
        &arr[0][0], &arr[0][0] + M*N, &arr[0][0],
        lm::if_then_else_return(lm::var(cnt)++ & 1, lm::_1, 0));
}

// Использование user-defined алгоритма
{
    int cnt = 0;
    transform_if(
        &arr[0][0], &arr[0][0] + M*N, &arr[0][0],
        lm::constant(0), !(lm::var(cnt)++ & 1));
}

Код


template <typename T, size_t M, size_t N>
void swap_min_and_last(T (&arr)[M][N])
{
    T* min = std::min_element(&arr[0][0], &arr[0][0] + M*N); // получить итератор, который соответствует позиции минимального элемента в массиве
    std::swap(*min, arr[M-1][N-1]); // обменять содержимое итератора и последний элемент массива
}