Описать функцию Compare

[papercut]

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

Описать функцию Compare(A,B,n), возвразающую 1, если можно преобразовать квадратную матрицу А размером n x n
в матрицу B, отражениями относительно главной и побочной диагонали, и 0 в обратном случае.

Кто чем может подскажите, во вторник уже сдавать, а вообще не в зуб ногой... Код приветствуется. Заранее спасибо.

[Sazary]

отражениями относительно главной и побочной диагонали

Отражениями чего? Половин матрицы?
Вот есть матрица А:

1 2 3
4 5 6
7 8 9

Отражением относительно главной диагонали будет такая?

1 4 7
2 5 8
3 6 9

[papercut]

Насколько я понимаю именно половин:

1 2 3
4 5 6 
7 8 9

1 4 7
2 5 8
3 6 9

9 8 7
6 5 4
3 2 1

[Sazary]

Тогда можно создать еще 2 дополнительные функции. Первая будет отражать матрицу относительно главной диагонали, а вторая - относительно побочной.
И в функции compare нужно перебрать разные комбинации вызовов этих функций, постоянно сравнивая полученную матрицу с матрицей B. Если вдруг совпало, то возвращаем 1.

Ну а комбинаций будет, навскидку, не очень много.

[papercut]

Хотя я в своем изучении С++ пока до функции не дополз все равно спасибо, буду разбираться, если кто-нибудь что-то хочет добавить или помочь буду рад

[papercut]

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <conio.h>
#include <iostream.h>
//---------------------------------------------------------------------------
#pragma argsused
 
// функция отражающая матрицу относительно главной диагонали
void glavOtrazh(int **A, int n)
{
 int tmp;
 for(int i=0; i<n; i++)
  for(int j=i; j<n; j++)
   {
        tmp = A[i][j];
        A[i][j] = A[j][i];
        A[j][i] = tmp;
   }
}
 
 
main () {
int n=2;
 
//создаем и заполняем матрицу В, которая не будет изменятся
int** B = new int*[n];
 
for(int i = 0; i < n; ++i)
  B[i] = new int[n];
 
  for(int i = 0; i < n; ++i)
  for(int j = 0; j < n; ++j){
        cout << "B[" << i + 1 << "][" << j + 1 << "]= ";
         cin >> B[i][j];
        }
 
  for(int i = 0; i < n; ++i){
 
for(int j = 0; j < n; ++j)
  cout << B[i][j] <<" ";
 
        cout << endl;
  }
 
// создаем и заполняем матрицу А
int** A = new int*[n];
 
for(int i = 0; i < n; ++i)
  A[i] = new int[n];
 
  for(int i = 0; i < n; ++i)
  for(int j = 0; j < n; ++j){
        cout << "A[" << i + 1 << "][" << j + 1 << "]= ";
         cin >> A[i][j];
        }
 
  for(int i = 0; i < n; ++i){
 
for(int j = 0; j < n; ++j)
  cout << A[i][j] <<" ";
 
        cout << endl;
  }
 
//отражаем матрицу А относительно главной диагонали
glavOtrazh(A,n);

Подскажите, как теперь описать требуемую функцию Compare, котарая сравнит полученную матрицу А с В ?

Пожалуйста, мне через 3 часа уже сдавать....

[Sazary]

Не знаю, все ли здесь комбинации учитываются, но раз вы сами не хотите думать, то я уж тем более за вас это делать не буду.

#include <conio.h>
#include <iostream>
#include <fstream>
using namespace std;

// функция отражения относительно главной диагонали
void glavOtrazh(int **matr, int n)
{
 int tmp;
 for(int i=0; i<n; i++)
  for(int j=i; j<n; j++)
   {
    tmp = matr[i][j];
    matr[i][j] = matr[j][i];
    matr[j][i] = tmp;
   }
}

// относительно побочной
void pobochOtrazh(int **matr, int N)
{
 int tmp;
 for(int i=0; i<N; i++)
  for(int j=0; j<N-i; j++)
   {
    tmp = matr[i][j];
    matr[i][j] = matr[N-j-1][N-i-1];
    matr[N-j-1][N-i-1] = tmp;
   }
}

// копирование матрицы
void copyMatr(int **A, int **source, int n)
{
 for(int i=0; i<n; i++)
  for(int j=0; j<n; j++)
   A[i][j] = source[i][j];
}
//-----------------

// сравнивает две матрицы
bool CompareIt(int **A, int **B, int n)
{
int i,j;
for(i=0; i<n; i++)
 for(j=0; j<n; j++)
  if(A[i][j]!=B[i][j]) return false;
return true;
}

// очищает память под матрицу
void freeTmp(int **tmp, int n)
{
 for(int i=0; i<n; i++)
  delete[] tmp[i];
 delete[] tmp;
}

// выводит матрицу
void printMatr(int **A, int n)
{
for(int i=0; i<n; i++)
 {
  for(int j=0; j<n; j++)
   {
    cout.width(4);
    cout<<A[i][j];
   }
   cout<<endl;
 }
cout<<"-----\n";
}

// та самая функция
int compareMatr(int **A, int **B, int n)
{
int i,j;
int **tmp = new int*[n];
for(i=0; i<n; i++)
 {
  tmp[i] = new int[n];
  for(j=0; j<n; j++)
   tmp[i][j] = A[i][j];
 }
// сохранили исходную матрицу

//-----------
// смотрим разные комбинации и сверяем
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }

copyMatr(A,tmp,n);

pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
freeTmp(tmp,n);
return 0;
}

// функция для теста (заполняет матрицы)
void test(int **A, int **B, int n)
{
 int k=1,l=9;
 for(int i=0; i<n; i++)
  for(int j=0; j<n; j++)
   {
    A[i][j] = k++;
    B[i][j] = l--;
   }
}

int main ()
{
 int n=3,i,j;
 int **A,**B;
 A = new int*[n];
 for(i=0;i<n;i++)
  {
   A[i] = new int[n];
 /*  for(j=0; j<n; j++)
    {
     cout<<"A["<<i<<"]["<<j<<"]: ";
     cin>>A[i][j];
    }*/
  //  cout<<endl;
  }
  cout<<endl;
//pobochOtrazh(A,n);
//cout<<"\nMatrix B:\n";
B = new int*[n];
for(i=0; i<n; i++)
 {
  B[i] = new int[n];
/*  for(j=0; j<n; j++)
   {
    cout<<"B["<<i<<"]["<<j<<"]: ";
    cin>>B[i][j];
   }*/
 }
//--------------------
test(A,B,n);
cout<<"-----------------\n\n";
cout<<"Matrix A:\n";
for(i=0; i<n; i++)
 {
  for(j=0; j<n; j++)
  {
   cout.width(4);
   cout<<A[i][j];
  }
  cout<<endl;
 }
cout<<"\n\nMatrix B:\n";
for(i=0; i<n; i++)
 {
  for(j=0; j<n; j++)
  {
   cout.width(4);
   cout<<B[i][j];
  }
  cout<<endl;
 }
//---------------
cout<<"\n";
if(compareMatr(A,B,n)==1) cout<<"YES\n";
else cout<<"NO\n";


for(i=0; i<n; i++)
 {
  delete[] A[i];
  delete[] B[i];
 }
delete[] A;
delete[] B;
getch();
return 0;
}

[papercut]

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

Не знаю, все ли здесь комбинации учитываются, но раз вы сами не хотите думать, то я уж тем более за вас это делать не буду.

#include <conio.h>
#include <iostream>
#include <fstream>
using namespace std;

// функция отражения относительно главной диагонали
void glavOtrazh(int **matr, int n)
{
 int tmp;
 for(int i=0; i<n; i++)
  for(int j=i; j<n; j++)
   {
    tmp = matr[i][j];
    matr[i][j] = matr[j][i];
    matr[j][i] = tmp;
   }
}

// относительно побочной
void pobochOtrazh(int **matr, int N)
{
 int tmp;
 for(int i=0; i<N; i++)
  for(int j=0; j<N-i; j++)
   {
    tmp = matr[i][j];
    matr[i][j] = matr[N-j-1][N-i-1];
    matr[N-j-1][N-i-1] = tmp;
   }
}

// копирование матрицы
void copyMatr(int **A, int **source, int n)
{
 for(int i=0; i<n; i++)
  for(int j=0; j<n; j++)
   A[i][j] = source[i][j];
}
//-----------------

// сравнивает две матрицы
bool CompareIt(int **A, int **B, int n)
{
int i,j;
for(i=0; i<n; i++)
 for(j=0; j<n; j++)
  if(A[i][j]!=B[i][j]) return false;
return true;
}

// очищает память под матрицу
void freeTmp(int **tmp, int n)
{
 for(int i=0; i<n; i++)
  delete[] tmp[i];
 delete[] tmp;
}

// выводит матрицу
void printMatr(int **A, int n)
{
for(int i=0; i<n; i++)
 {
  for(int j=0; j<n; j++)
   {
    cout.width(4);
    cout<<A[i][j];
   }
   cout<<endl;
 }
cout<<"-----\n";
}

// та самая функция
int compareMatr(int **A, int **B, int n)
{
int i,j;
int **tmp = new int*[n];
for(i=0; i<n; i++)
 {
  tmp[i] = new int[n];
  for(j=0; j<n; j++)
   tmp[i][j] = A[i][j];
 }
// сохранили исходную матрицу

//-----------
// смотрим разные комбинации и сверяем
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }

copyMatr(A,tmp,n);

pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
glavOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
pobochOtrazh(A,n);
if(CompareIt(A,B,n)) { freeTmp(tmp,n); return 1; }
freeTmp(tmp,n);
return 0;
}

// функция для теста (заполняет матрицы)
void test(int **A, int **B, int n)
{
 int k=1,l=9;
 for(int i=0; i<n; i++)
  for(int j=0; j<n; j++)
   {
    A[i][j] = k++;
    B[i][j] = l--;
   }
}

int main ()
{
 int n=3,i,j;
 int **A,**B;
 A = new int*[n];
 for(i=0;i<n;i++)
  {
   A[i] = new int[n];
 /*  for(j=0; j<n; j++)
    {
     cout<<"A["<<i<<"]["<<j<<"]: ";
     cin>>A[i][j];
    }*/
  //  cout<<endl;
  }
  cout<<endl;
//pobochOtrazh(A,n);
//cout<<"\nMatrix B:\n";
B = new int*[n];
for(i=0; i<n; i++)
 {
  B[i] = new int[n];
/*  for(j=0; j<n; j++)
   {
    cout<<"B["<<i<<"]["<<j<<"]: ";
    cin>>B[i][j];
   }*/
 }
//--------------------
test(A,B,n);
cout<<"-----------------\n\n";
cout<<"Matrix A:\n";
for(i=0; i<n; i++)
 {
  for(j=0; j<n; j++)
  {
   cout.width(4);
   cout<<A[i][j];
  }
  cout<<endl;
 }
cout<<"\n\nMatrix B:\n";
for(i=0; i<n; i++)
 {
  for(j=0; j<n; j++)
  {
   cout.width(4);
   cout<<B[i][j];
  }
  cout<<endl;
 }
//---------------
cout<<"\n";
if(compareMatr(A,B,n)==1) cout<<"YES\n";
else cout<<"NO\n";


for(i=0; i<n; i++)
 {
  delete[] A[i];
  delete[] B[i];
 }
delete[] A;
delete[] B;
getch();
return 0;
}

Вы меня извините ради бога, я просто не успел отписаться прежде чем пошел задачки защищать, я уже написал эту с помощью того что вы мне посоветовали + сам подумал)), все правильно получилось!

ОГРОМНОЕ СПАСИБО за помощь!!!))