Comptez le nombre de lettres dans une petite matrice qui apparaissent dans une grande matrice

Quelque chose comme ça pourrait fonctionner. Je le décomposerais en une fonction de comptage qui prend deux arguments: la lettre que vous recherchez et un pointeur vers la grande matrice.

Je créerais ensuite une matrice de résultat avec les mêmes dimensions que la petite matrice et appellerais le nombre fonction pour chaque cellule de la matrice de résultat, en passant dans la grande matrice, et en affectant le résultat de chaque appel de comptage à chaque cellule successive de la matrice de résultat.

Enfin, pour rendre la fonction main () claire, créer une fonction finale qui imprimera une matrice de résultats. Quelque chose comme ceci:

Modifié : j'ai modifié le code en fonction des mises à jour de la question du PO. Ce code crée la sortie suivante:

#include <stdio.h>
#include <stdint.h>
#include <limits.h>

const size_t ROWS = 3;
const size_t COLUMNS = 20;
const size_t SMALL_ROWS = 3;
const size_t SMALL_COLUMNS = 4;
const size_t SIZE = 4;

char LargeMatrix[ROWS][COLUMNS] =
    {{'P', 'A', 'D', 'A', 'Q', 'E', 'Q', 'B', 'G', 'H', 'R', 'O', 'P', 'H', 'C',
      'W', 'S', 'P', 'B', 'Q'},
     {'M', 'B', 'R', 'P', 'R', 'N', 'V', 'S', 'C', 'H', 'M', 'U', 'J', 'P', 'W',
      'C', 'V', 'M', 'F', 'D'},
     {'V', 'W', 'R', 'K', 'E', 'V', 'I', 'Y', 'K', 'K', 'Q', 'Y', 'N', 'H', 'N',
      'G', 'V', 'L', 'B', 'Z'},};

char SmallMatrix[SIZE][SIZE] =
    {{'U', 'N', 'T', 'E'}, {'C', 'P', 'G', 'X'}, {'D', 'L', 'A', 'B'}};

void Count(char mat[ROWS][COLUMNS], char c, size_t *count)
{
  size_t counter = 0;  // Initialize the count answer cell
  for (size_t i = 0; i < ROWS; i++) {
    for (size_t j = 0; j < COLUMNS; j++) {
      if (mat[i][j] == c)
        counter++;
    }

  }
  *count = counter;

}

// clear the char array
void zero_char_array(char *array, size_t len)
{
  for (size_t i = 0; i < len; i++)
    array[i] = 0;
}
//
//
void PrintMaxesAndMins(char haystack[ROWS][COLUMNS],
                       char needlestack[SMALL_ROWS][SMALL_COLUMNS],
                       size_t answerStack[SMALL_ROWS][SMALL_COLUMNS],
                       size_t result_rows,
                       size_t result_columns)
{
  char max_char; // char that occurred the most
  char min_char; // char that occurred the least
  size_t max_char_count =
      0;  // best to use unsigned ints when a value should never go negative.
  size_t min_char_count = UINT32_MAX; // Value should not go negative.
  char max_chars[SMALL_COLUMNS * SMALL_ROWS]; // save all possible max chars
  char *next_max_char;
  char min_chars[SMALL_COLUMNS * SMALL_ROWS]; // sall all possible min chars
  char *next_min_char;

  size_t counter = 0;  // Initialize the count answer cell
  for (size_t i = 0; i < result_rows; i++) {
    for (size_t j = 0; j < result_columns; j++) {
      if (answerStack[i][j] > max_char_count) {
        max_char_count = answerStack[i][j];  // we have a new max

        zero_char_array(max_chars, SMALL_COLUMNS * SMALL_ROWS);
        next_max_char =
            max_chars;  // We have a new max, reset result char array

        *next_max_char = needlestack[i][j];// grab character from needle stack
        ++next_max_char;  // increment.  Could do in prior line, but try to be clear.
      } else if (answerStack[i][j] >= max_char_count) {
        // we are adding to an old max
        *next_max_char = needlestack[i][j];// grab character from needle stack
        ++next_max_char;  // increment.  Could do in prior line, but try to be clear.
      }
      if (answerStack[i][j] > 0 &&  answerStack[i][j] < min_char_count) {
        min_char_count = answerStack[i][j];  // we have a new min

        zero_char_array(min_chars, SMALL_COLUMNS * SMALL_ROWS);
        next_min_char =
            min_chars;  // We have a new min, reset result char array

        *next_min_char = needlestack[i][j];// grab character from needle stack
        ++next_min_char;  // increment.  Could do in prior line, but try to be clear.
      } else if (answerStack[i][j] > 0 && answerStack[i][j] <= min_char_count) {
        // we are adding to an old max
        *next_min_char = needlestack[i][j];// grab character from needle stack
        ++next_min_char;  // increment.  Could do in prior line, but try to be clear.
      }
    }
  }

  if (max_char_count > 0) {
    printf("The most repetitive char(s) occurred %lu time(s): ", max_char_count);
    next_max_char = max_chars;

    while (*next_max_char)
      printf(" %c", *next_max_char++);
  }
  printf("\n\n");
  if (min_char_count > 0) {
    printf("The least repetitive char(s) occurred %lu time(s): ", min_char_count);

    next_min_char = min_chars;
    while (*next_min_char) {
      printf(" %c", *next_min_char++);
    }
  }

}

// BuildResultMatrix()
// haystack is a pointer to the large matrix.
// needlestack is a pointer to the small matrix.
// answerStack is the result matrix of size_t
void BuildResultMatrix(char haystack[ROWS][COLUMNS],
                       char needlestack[SMALL_ROWS][SMALL_COLUMNS],
                       size_t answerStack[SMALL_ROWS][SMALL_COLUMNS],
                       size_t result_rows,
                       size_t result_columns)
{

  // Loop through the rows and columns of the small matrix
  for (size_t i = 0; i < result_rows; i++) {
    for (size_t j = 0; j < result_columns; j++) {
      // Pass the current cell of the small matrix to Count()
      // Count() will then loop through the large matrix, counting
      // the number of cells with the current cell value from the small matrix.
      // Count() will place the final count into the correpsonding cell of the
      // answerStack matrix.
      Count(LargeMatrix, needlestack[i][j], &answerStack[i][j]);
    }
  }
}

void PrintLargeCharMatrix(char (*matrix)[COLUMNS], size_t rows)
{
  for (size_t i = 0; i < rows; i++) {
    for (size_t j = 0; j < COLUMNS; j++) {
      printf("%c ", matrix[i][j]);
    }
    printf("\n");
  }
  printf("\n");
}
void PrintSmallCharMatrix(char (*matrix)[SMALL_COLUMNS], size_t rows)
{
  for (size_t i = 0; i < rows; i++) {
    for (size_t j = 0; j < SMALL_COLUMNS; j++) {
      printf("%c ", matrix[i][j]);
    }
    printf("\n");
  }
  printf("\n");
}
void PrintCountMatrix(size_t (*matrix)[SMALL_COLUMNS], size_t rows)
{
  for (size_t i = 0; i < rows; i++) {
    for (size_t j = 0; j < SMALL_COLUMNS; j++) {
      printf("%lu ", matrix[i][j]);
    }
    printf("\n");
  }
  printf("\n");
}
int main()
{
  size_t ResultMatrix[SMALL_ROWS][SMALL_COLUMNS];

  PrintLargeCharMatrix(LargeMatrix, ROWS);
  PrintSmallCharMatrix(SmallMatrix, SMALL_ROWS);

  BuildResultMatrix(LargeMatrix,
                    SmallMatrix,
                    ResultMatrix,
                    SMALL_ROWS,
                    SMALL_COLUMNS);

  PrintCountMatrix(ResultMatrix, SMALL_ROWS);

  PrintMaxesAndMins(LargeMatrix,
                    SmallMatrix,
                    ResultMatrix,
                    SMALL_ROWS,
                    SMALL_COLUMNS);

  return 0;
}

Le code imprime toutes les minutes et tous les caractères max pour le numéro de fréquence le plus élevé et le plus bas. Pour ce faire, il conserve un tableau de max et de minutes. Ce tableau ne doit pas être plus long que le produit des côtés de la matrice de résultat.

Si aucun caractère n'apparaît au moins une fois, les valeurs max et min ne seront pas affichées.

Alors que l'OP m'a suggéré de mettre à jour la fonction Count () pour prendre en charge la recherche des lettres les plus fréquentes, cela devient vraiment compliqué, en particulier lorsque vous avez plus d'une lettre se produisant le même nombre de fois dans la fente maximale de dans le min slot.

J'ai donc écrit une nouvelle fonction qui utilise ResultMatrix. ResultMatrix contient déjà les comptages de fréquence. La petite matrice nous indique quelles lettres sont les plus fréquentes.

Ainsi, PrintMaxesAndMins () utilise les entrées de ResultMatrix et de SmallMatrix (appelées Needlestack dans mon code).

Le code pourrait être optimisé pour trouver le min et le max avant de rassembler réellement les caractères qui correspondent au min et les caractères qui correspondent au min. Plutôt que de faire cela, mon code réinitialise la chaîne de caractères max chaque fois qu'il se rend compte qu'un max plus élevé a été trouvé.

Faites-moi savoir si vous avez des questions. Si cela fonctionne pour vous, veuillez accepter la réponse. Passez un excellent week-end!

Voici le code:

$> a.out
P A D A Q E Q B G H R O P H C W S P B Q 
M B R P R N V S C H M U J P W C V M F D 
V W R K E V I Y K K Q Y N H N G V L B Z 

U N T E 
C P G X 
D L A B 

1 3 0 2 
3 5 2 0 
2 1 2 4 

The most repetitive char(s) occurred 5 time(s):  P

The least repetitive char(s) occurred 1 time(s):  U L
Process finished with exit code 0

Il existe 2 approches à votre problème:

• vous pouvez écrire 4 boucles imbriquées, en comptant pour chaque cellule de la petite matrice le nombre de fois où la lettre correspondante apparaît dans la grande matrice. cela prendra SIZE * SIZE * ROWS * COLS itérations, potentiellement longtemps.
• vous pouvez utiliser un tableau de int et compter le nombre d'occurrences de chaque lettre dans la grande matrice par étapes ROWS * COLS , puis calculer le nombre de matrices de résultat par en copiant le nombre approprié du tableau pour chaque cellule de la petite matrice dans les étapes SIZE * SIZE .

Voici un exemple pour la deuxième approche:

// assuming 8-bit chars
void Count(char mat[ROWS][COLS], char smallMat[SIZE][SIZE], int result[SIZE][SIZE]) {
    int count[256] = { 0 };
    int i, j;

    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++)
            *(count + (*(*(mat + i) + j) & 255) += 1;
    }
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++)
            *(*(result + i) + j) = *(count + (*(*(smallMat + i) + j) & 255));
    }
}

L'exigence en utilisant des POINTERS est étrange. La fonction reçoit des pointeurs vers les tableaux d'arguments, je suppose que vous pouvez masquer le code ci-dessus pour utiliser la syntaxe pinter * (p + i) à la place de la syntaxe du tableau p [i] pour répondre à cette exigence. Voici le résultat laid:

// assuming 8-bit chars
void Count(char mat[ROWS][COLS], char smallMat[SIZE][SIZE], int result[SIZE][SIZE]) {
    int count[256] = { 0 };
    int i, j;

    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COLS; j++)
            count[mat[i][j] & 255]++;
    }
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++)
            result[i][j] = count[smallMat[i][j] & 255];
    }
}

Je veux AJOUTER la fonction VOID * pour montrer à l'utilisateur quel caractère apparaît le PLUS et lequel apparaît 0 fois ** /:

    void Count(const char mat[ROWS][COLS], char c, int *count)
    {
      int i, j;
      int counter = 0; 
      for (i = 0; i < ROWS; i++) {
         for (j = 0; j < COLS; j++) {
              if (mat[i][j] == c)
                counter++;
            }
           *count = counter;
  if(counter>max)
      counter=max;
  else
      counter=min;
  }
  if(count==max)
     printf("Most repetitive: %c %d times", c,counter);
  if(count==min)
     printf("Most repetitive: NO COMMON LETTERS (max = 0)");

}

Cela devrait ressembler à ceci: Le plus répétitif: PAS DE LETTRES COMMUNES (max = 0) Matrice de résultat: 1 3 0 2 3 4 2 0 2 1 2 4 1 0 3 3 Le plus répétitif: P ... 4 fois

Si vous avez encore du mal à choisir l'approche à adopter, un bon point de repère à comparer est simplement la simple approche par force brute. Bien qu'il existe généralement plusieurs façons d'assembler les choses et qu'il y ait généralement des gains d'efficacité, l'approche par force brute est généralement la plus facile à comprendre. Cela consiste simplement à boucler sur chaque caractère de small , puis à boucler sur chaque caractère de votre grand tableau et avoir mis à zéro le résultat simplement incrémenter l'index dans result chaque fois que le caractère de small correspond à big .

L'approche à 4 boucles ne nécessite rien de plus que de garder une trace de l'index actuellement comparé et qui est incrémenté. Dans ce cas, les index pour small et result se correspondent et vous utilisez simplement deux index supplémentaires pour parcourir big , par exemple p>

$ ./bin/bigsmallfreq <dat/bigmtrxltrs.txt
Big Matrix

 P A D A Q E Q B G H R O P H C W S P B Q
 M B R P R N V S C H M U J P W C V M F D
 V W R K E V I Y K K Q Y N H N G V L B Z

Small Matrix

 U N T E
 C P G X
 D L A B

Result Matrix

 1 3 0 2
 3 5 2 0
 2 1 2 4

À ce stade, votre matrice de résultat est remplie.

Le reste est assez simple. La seule vraie tâche qui reste est de lire big à partir de votre fichier d'entrée (ou stdin ). L'approche simple ici, étant donné le format de big est de lire chaque caractère d'entrée comme un caractère et de simplement tester isalpha (c) (ou isupper (c) si vous le souhaitez). Stockez simplement les caractères alpha, en ignorant le reste, mais en gardant une trace des '\ n' et EOF rencontrés pour mettre à jour / réinitialiser les compteurs nécessaires. Votre lecture pourrait être:

#include <stdio.h>
#include <ctype.h>

#define ROW  3
#define COL  20
#define SIZE 4

#define CHARSET 62

/* fill result count from chars in arr matching small */
void count (char big[ROW][COL], int row, int col, char (*small)[SIZE],
            int rowsm, int (*result)[SIZE])
{
    for (int i = 0; i < rowsm; i++)             /* for each row in small */
        for (int j = 0; j < SIZE; j++)          /* for each col in small */
            for (int k = 0; k < row; k++)       /* for each row in big */
                for (int l = 0; l < col; l++)   /* for each col in big */
                    if (small[i][j] == big[k][l])   /* does small == arr? */
                        result[i][j]++;         /* increment result */
}

/* simple zero VLA */
void zerovla (int rowsm, int (*result)[SIZE])
{
    for (int i = 0; i < rowsm; i++)
        for (int j = 0; j < SIZE; j++)
            result[i][j] = 0;
}

/* print char array */
void prncharray (int row, int col, char (*arr)[col])
{
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            putchar (' ');
            putchar (arr[i][j]);
        }
        putchar ('\n');
    }
}

/* print int array */
void prniarray (int row, int col, int (*arr)[col])
{
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++)
            printf (" %d", arr[i][j]);
        putchar ('\n');
    }
}

int main (int argc, char **argv) {

    char arr[ROW][COL] = {{0}},                     /* big matrix */
        small[][SIZE]  = {{ 'U', 'N', 'T', 'E' },   /* small matrix */
                          { 'C', 'P', 'G', 'X' },
                          { 'D', 'L', 'A', 'B' }};
    int c = 0,          /* to read chars from file into big mtrx */
        rdx = 0,        /* row index */
        cdx = 0,        /* col index */
        colmax = 0,     /* max col found per-row */
        rowsm = sizeof small / sizeof *small,   /* rows in small */
        result[rowsm][SIZE];    /* result matrix */
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("file open failed");
        return 1;
    }

    zerovla (rowsm, result);    /* zero elements in result */

    while (c != EOF) {  /* while not end of file */
        /* while index < row and char not '\n' or EOF */
        while (rdx < ROW && (c = fgetc (fp)) != '\n' && c != EOF)
            if (isalpha (c))            /* if it's a letter */
                arr[rdx][cdx++] = c;    /* store it in big */
        if (!cdx && (c == '\n' || c == EOF))    /* if end of line/file */
            break;                              /* break */
        if (!colmax)            /* if colmax not set */
            colmax = cdx;       /* set with no. cols from 1st row */
        if (cdx != colmax) {    /* validate remaining rows have same cols */
            fputs ("error: row with unuequal columns.\n", stderr);
            return 1;
        }
        rdx++;      /* increment row index  */
        cdx = 0;    /* reset col index zero */
    }
    if (fp != stdin) fclose (fp);   /* close file if not stdin */

    count (arr, rdx, colmax, small, rowsm, result); /* count/fill result */

    puts ("Big Matrix\n");              /* output all matricies */
    prncharray (rdx, colmax, arr);
    puts ("\nSmall Matrix\n");
    prncharray (rowsm, SIZE, small);    
    puts ("\nResult Matrix\n");
    prniarray (rowsm, SIZE, result);

    return 0;
}

En résumé, vous pourriez faire quelque chose de similaire à:

int main (int argc, char **argv) {

    char arr[ROW][COL] = {{0}},                     /* big matrix */
        small[][SIZE]  = {{ 'U', 'N', 'T', 'E' },   /* small matrix */
                          { 'C', 'P', 'G', 'X' },
                          { 'D', 'L', 'A', 'B' }};
    int c = 0,          /* to read chars from file into big mtrx */
        rdx = 0,        /* row index */
        cdx = 0,        /* col index */
        colmax = 0,     /* max col found per-row */
        rowsm = sizeof small / sizeof *small,   /* rows in small */
        result[rowsm][SIZE];    /* result matrix */
    /* use filename provided as 1st argument (stdin by default) */
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        perror ("file open failed");
        return 1;
    }

    zerovla (rowsm, result);    /* zero elements in result */

    while (c != EOF) {  /* while not end of file */
        /* while index < row and char not '\n' or EOF */
        while (rdx < ROW && (c = fgetc (fp)) != '\n' && c != EOF)
            if (isalpha (c))            /* if it's a letter */
                arr[rdx][cdx++] = c;    /* store it in big */
        if (!cdx && (c == '\n' || c == EOF))    /* if end of line/file */
            break;                              /* break */
        if (!colmax)            /* if colmax not set */
            colmax = cdx;       /* set with no. cols from 1st row */
        if (cdx != colmax) {    /* validate remaining rows have same cols */
            fputs ("error: row with unuequal columns.\n", stderr);
            return 1;
        }
        rdx++;      /* increment row index  */
        cdx = 0;    /* reset col index zero */
    }
    ...

Exemple d'utilisation / Output

/* fill result count from chars in arr matching small */
void count (char big[ROW][COL], int row, int col, char (*small)[SIZE],
            int rowsm, int (*result)[SIZE])
{
    for (int i = 0; i < rowsm; i++)             /* for each row in small */
        for (int j = 0; j < SIZE; j++)          /* for each col in small */
            for (int k = 0; k < row; k++)       /* for each row in big */
                for (int l = 0; l < col; l++)   /* for each col in big */
                    if (small[i][j] == big[k][l])   /* does small == arr? */
                        result[i][j]++;         /* increment result */
}

Regardez les choses et faites-moi savoir si vous avez d'autres questions.