fentg.com

Може ли да определите условието на задачата, чието примерно решение е на снимките по-долу?

#include <stdio.h>
#include <malloc.h>

void main() {
   int** matrix;
   int size;
   int idx;
   int max;
   int min;
   int row;
   int col;
   int number;
   
   printf("Enter matrix size: ");
   scanf("%d", &size);
   
   // Dynamic memory allocation
        /*
              Малко пояснение за указателите: Това са променливи, който сочат адрес в адресното пространство, на който се намира стойност от съответен тип. Обикновено са с големина 4 байта (зависи от големината на адресното пространство). Указателите се използват за динамично заделяне на памет, за адресна аритметика, за връщане на повече от 1 резултат от функция... Динамичната памет се заделя в Heap-а, за разлика от статичната, която се заделя в стека.
              Пример: int* a;
                          int b=2;

              В момента сме казали само, че имаме променлива а, която е указател и сочи към адрес, от където трябва да започне да чете int стойност. Тъй като не сме задали никаква стойност на "а", то тази променлива в момента сочи null и ако решим да присвоим стойност директно на нея това ще доведе до забиване на приложението.
              а = &b;
              Тук а взима адреса на b и следователно стойността зад указателя, която може да се достъпи с *а е 2;
              *а = 3;
              Записваме стойност 3 на адреса , който "а" сочи. Тъй като адреса, който сочи "а" е всъщност адресът на "b", след този ред и "b" ще има стойност 3.
              Пример за заделяне на памет динамично:
              int *a;

              a = (int *) malloc(sizeof(int));
              След като сме дефинирали "a", трябва да дадем на указателят някакъв адрес. В случая ще си заделим памет специално за него. За използването на malloc в повечето случаи, ще ви е нужна библиотеката <malloc.h>. Тя се грижи за организацията на паметта на heap-а. Кастваме заделената памет , като така казваме , че това е указател , който сочи стойност от тип int и запазваме памет за 1 елемент , който е с големина int. От тук нататък, вече имаме напълно инициализиран указател, на който може да се посочват стойности, които да записва на адреса към който сочи.
             Пример за заделяне на памет за масив динамично:
             int *a;
             int n;

             printf("Enter number n: ");
             scanf("%d", &n);

             a = (int *) malloc(sizeof(int)*n);
             Нещата са абсолютно идентични с това да се задели памет за 1 елемент , с разликата че тук просто умножавате големината на int с броя на елементите , които искате да имате в масива. Когато се обхожда масива трябва да се внимава да не излизате от границите на заделената памет, защото това ще доведе до срив в програмата. Тук следва малко адресна аритметика. Ако за "n" сме въвели примерно числото 4, то тогава ще сме заделили 16 последователни байта памет в heap-а , които можем да обходим, чрез указателят "a". *(а) взима стойността на първия елемент, *(а+1) на втория, *(а+2) на третия и *(а+3) на четвъртия. Не ни пречи да ползваме и индекси - a[0], a[1], a[2], a[3]. И двата начина имат абсолютно един и същи ефект.
            Пример за заделяне динамично на двумерен масив:
             int **a;
             int n;
             int idx;

             printf("Enter number n: ");
             scanf("%d", &n);

             a = (int **) malloc(sizeof(int*)*n);
             for(idx=0; idx<n; idx++)
                    a[idx] = (int *) malloc(sizeof(int)*n);

             Тук нещата стават по-интересни. Тук имаме указател, който сочи към указател , който сочи към памет , която съдържа int стойност. Нашият двумерен масив ще има n редове и n колони. Да приемем , че n = 4.Първо заделяме редовете, което става с редът "a = (int **) malloc(sizeof(int*)*n);". Този ред заделя в heap-a 16 последователни байта памет, в които се съдържат 4 указателя, които сочат към полета съдържащи int. Идва следващата стъпка - тъй като нито един от тези указатели в момента не сочи към нищо ние трябва за всеки един от тях да заделим памет. Това става с помощта на цикъла , в който заделяме памет за всеки един указател. За всеки един указател се заделят по 16 последователни байта , които ще съдържат в себе си по 4 Int стойности. Общо се заделят 64 байта за 4-те (int *) указателя, който обаче е много вероятно да не са последователни. В крайна сметка имаме заделени 80 байта в heap.
              а -> | *(a) | *(a+1) | *(a+2) | *(a+3) |
                     4 byte   4 byte    4 byte     4 byte
              a[0] == *(a) -> | a[0][0] | a[0][1] | a[0][2] | a[0][3] |
                                       4 byte     4 byte   4 byte      4 byte
              a[1] == *(a+1)-> | a[1][0] | a[1][1] | a[1][2] | a[1][3] |
                                         4 byte     4 byte    4 byte    4 byte
              a[2] == *(a+2)-> | a[2][0] | a[2][1] | a[2][2] | a[2][3] |
                                         4 byte     4 byte    4 byte     4 byte
              a[3] == *(a+3)-> | a[3][0] | a[3][1] | a[3][2] | a[3][3] |
                                         4 byte     4 byte     4 byte    4 byte

              След като сте приключили работа с динамично заделената памет е ваша отговорността да си я освободите. Това става с функцията free(). В случай като последния пример първо освобождавате указателите към Int и след това освобождавате указателя към указателите.
              Надявам се малко да съм пояснил нещата за динамичното заделяне на памет.
       */
   matrix = (int **) malloc(sizeof(int*)*size);
   for(idx=0; idx<size; idx++)
      matrix[idx] = (int *) malloc(sizeof(int)*size);
   
   // Init matrix;
   for(row=0; row<size; row++)
      for(col=0; col<size; col++)
         matrix[row][col] = 0;
   
   
   number = size*size;
   max = size;
   min = 0;
   
   if(size%2 == 1) {
      // Start from top left [0][0] to bottom
      row = 0;
      col = 0;
      
      while( min < max ) {
         
         while( row < max ) {
            matrix[row++][col] = number--;
         }
         row--;
         col++;
         while( col < max ) {
            matrix[row][col++] = number--;
         }
         col--;
         row--;
         while( row >= min ) {
            matrix[row--][col] = number--;
         }
         row++;
         col--;
         while( col > min ) {
            matrix[row][col--] = number--;
         }
         col++;
         row++;
         
         min++;
         max--;
      }   
   } else {
      // Start from bottom right [size-1][size-1] to top
      row = size-1;
      col = size-1;
      
      while( min < max ) {
         
         while( row >= min ) {
            matrix[row--][col] = number--;
         }
         row++;
         col--;
         while( col >= min ) {
            matrix[row][col--] = number--;
         }
         col++;
         row++;
         while( row < max ) {
            matrix[row++][col] = number--;
         }
         row--;
         col++;
         while( col < max-1 ) {
            matrix[row][col++] = number--;
         }
         col--;
         row--;
         
         min++;
         max--;
      }   
   }
   
   
   for(row=0; row<size; row++) {
      printf("\n");
      for(col=0; col<size; col++)
         printf("%d\t", matrix[row][col]);
   }
   
   // Free memory
   for(idx=0; idx<size; idx++)
      free(matrix[idx]);
   free(matrix);
      
   return;
}

direction=(direction+1)%4;

if(direction%4)direction++;
else direction=1;

main()
{unsigned N=100;
    unsigned a[N][N];
    ...................

unsigned a[50][50];

%d\t

%4d