עזרה ב C

[LooKinG FoR My NaMe]

עזרה ב C

היי,
יש לי פונקציה שבה אני מקבלת את המטריצה ואת הקורדינאטות שלה, אני צריכה לעבור על 8 השכנים שלה,
יש 3 אפשרויות לכל תא X Y Z, ואני צריכה לסכום את ההופעות של X Y.

עכשיו, אני יכולה לעשות את הבדיקה של "אם אפשר להגיע לתא העליון/תחתון/שמאלי..." ואז לקונן עוד תנאים- אם זה X תעלה את הקאונטר של איקס, אם זה Y...
קוד כזה יוצא ארוך ומבולגן, אז השתמשתי ב switch case. אבל שוב פעם אני צריכה לרשום אותו כל פעם מחדש.

if (row != 0 )
{
int currState= matrix[row-1][col];
switch ( currState ) {
case 1:
countX++;
break;
case 2:
countY++;
break;
default:
break;
}
}

if (row != SIZE)
{
int currState= matrix[row+1][col];
switch ( currState ) {
case 1:
countX++;
break;
case 2:
countY++;
break;
default:
break;
}

}





חשבתי גם על ליצור מערך ולקרוא לפונקציה שתעשה את העלייה של הקאונטר לפי מה שנמצא בשכן, ואז זה יהיה יותר מסודר, אבל זה ליצור מערך ולשחרר.

יש לכם אולי פתרונות חוסכי שכפול קוד?

תודה

 

[nocgod]

לא בדיוק הבנתי את השאלה

יש לך מטריצה עם מופעים של ערכים X Y Z
את צריכה לעבור על השכנים שלה ולסכום רק מופעים של ערכים X Y? (כמובן תוך כדי הקפדה שאת לא יוצאת מגבולות המטריצה)

 

[LooKinG FoR My NaMe]

תיקון טעות-

אני צריכה לעבור על השכנים של התא במטריצה. אני מקבלת את המטריצה ואת התא.

 

[nocgod]

וצריכה לעשות מה?

לסכום מופעים של X Y מתוך 3 מופעים אפשריים של Z Y X?

 

[LooKinG FoR My NaMe]

כן

יש לי 2 קאונטרים, אחד ל X ואחד ל Y, אני אח"כ צריכה לעשות חישובים ולהחזיר תוצאה בהתאם לתנאים כלשהם.

 

[nocgod]

אוקי...

אם את יודעת שמה שאת צריכה לעשות זה לבדוק אל אחד מהשכנים ולסכום אם המופע מתאים לX או Y
אני חושב שזה סוג של straight forward לא?

בכל מקרה:
תכתבי פונקציה שמקבלת 2 קואורדינטות ובודקת אם הן על הלוח/מטריצה שלך. נקרא לה validateRange(int xCoord, int yCoord) היא רק תדע להחזיר לך true אם הנקודות על הלוח ו false אחרת.
עכשיו, יש טריק חמוד שלמדתי פעם: את יכולה ללעשות הסטה (מהמילה להסיט) של הקואורדינטות שלך באמצעות 2 לולאות for. מאחר ואת צריכה רק את השכנים והם נמצאים בקאורדינטות אשר מרחקן הוא 1 לכל היותר על כל ציר
תוכלי לעשות לולאת for החל מ 1- עוד 1 בתוכה עוד אחת כזאת ולהשתמש במספרים האלה כדי להסיט את הקואורדינטה שלך בצורה מבוקרת, ישנו רק מקרה קצה אחד והוא כאשר ההסטים שווים ל 0 ואז את פשוט מוותרת על האיטרציה

אגב אני לא בטוח מה הבחור שם כתב, אני לא רוצה להעביר ביקורת על קוד של אנשים אחרים, אבל אפשר לכתוב את זה יותר פשוט.

 

[MLCollege]

בבקשה

דוגמא מצורפת.


#include <stdio.h>
#define SIZE 5

void countNeighbours(char A[SIZE][SIZE], int row,int col, int* num_x, int* num_y, int* num_z)
{
int left, right, top, bottom, i, j;
left = (col==0?0:col-1);
right = (col==SIZE-1?SIZE-1:col+1);
top = (row==0?0:row-1);
bottom = (row==SIZE-1?SIZE-1:row+1);
(*num_x) = (*num_y) =(*num_z) = 0;

for(i=top; i<=bottom; i++)
for(j=left; j<=right; j++)
{
if(i==row && j==col)
continue;
if(A[j]=='X')
(*num_x)++;
else if(A[j]=='Y')
(*num_y)++;
else if(A[j]=='Z')
(*num_z)++;
}
}

int main()
{
char A[SIZE][SIZE] =
{{'X', 'Y', 'Z', 'X', 'Y'},
{'Y', 'Z', 'X', 'Y', 'Z'},
{'Z', 'Z', 'X', 'X', 'Y'},
{'Y', 'Z', 'Z', 'X', 'Y'},
{'Z', 'Y', 'Y', 'Z', 'X'}};
int nx, ny, nz;
countNeighbours(A, 0, 0, &nx, &ny, &nz);
printf("\nnumber of X neighbours = %d\nnumber of Y neighbours = %d\nnumber of Z neighbours = %d\n", nx, ny, nz);
}


בברכה,
מתן,
[URL='http://www.mlcollege.co.il']www.mlcollege.co.il[/URL]

 

[KingUnique]

תגובה

אני מבין את הרצון הלגיטימי שלך לפרסם את השירותים שלך אבל אתה חייב להבין שפתרון מלא ללא הסברים לא ייתרום כלום ל-OP. ואם אתה כבר נותן פתרון תדאג שהוא יהיה נכון ואיכותי
כי אחרת אתה גורם יותר נזק מתועלת כי הבנאדם יסגל לעצמו הרגלי תכנות גרועים.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef char val_t;
const val_t vals[] = {'X', 'Y', 'Z'};
const unsigned VALS_NO = sizeof(vals)/sizeof(vals[0]);
const unsigned ROW_DIM = 5;
const unsigned COL_DIM = 5;

void printMatrix (val_t m[][COL_DIM]);
void generateTestMatrix (val_t m[][COL_DIM]);
void countNeighbors (const val_t m[][COL_DIM],
unsigned xCoord, unsigned yCoord,
unsigned* countX, unsigned* countY);

int main()
{
const unsigned TESTS_NO = 4;
val_t m[ROW_DIM][COL_DIM];
unsigned countX = 0;
unsigned countY = 0;

srand( time(0) );

for (unsigned i = 0; i < TESTS_NO; ++i) {
unsigned xCoord = rand()%COL_DIM;
unsigned yCoord = rand()%ROW_DIM;
generateTestMatrix (m);
printMatrix(m);
countNeighbors (m, xCoord, yCoord, &countX, &countY);
fprintf(stdout, "matrix(%u, %u) X = %u, Y = %u\n------------------\n", yCoord, xCoord, countX, countY);
countX = countY = 0;
}
return 0;
}

void generateTestMatrix (val_t m[][COL_DIM])
{
for (unsigned i = 0; i < ROW_DIM; ++i)
for (unsigned j = 0; j < COL_DIM; ++j)
m[j] = vals[rand()%VALS_NO];
}

void printMatrix (val_t m[][COL_DIM])
{
for (unsigned i = 0; i < ROW_DIM; ++i) {
for (unsigned j = 0; j < COL_DIM; ++j) {
fprintf (stdout, "%c, ", m[j]);
}
fprintf(stdout, "\n");
}
fprintf(stdout, "\n");
}

void countNeighbors (const val_t m[][COL_DIM],
unsigned xCoord, unsigned yCoord,
unsigned* countX, unsigned* countY)
{
static const int neighborOffset[][2] = {{0,1}, {1,1}, {1,0}, {1,-1},
{0,-1}, {-1,-1}, {-1,0}, {-1,1}};

for (unsigned i = 0; i < 8; ++i) {
const unsigned relXCoord = xCoord+neighborOffset[1];
const unsigned relYCoord = yCoord+neighborOffset[0];
if (relXCoord < COL_DIM && relXCoord >= 0 &&
relYCoord < ROW_DIM && relYCoord >= 0 ) {
switch (m[relYCoord][relXCoord]) {
case 'X':
(*countX)++;
break;
case 'Y':
(*countY)++;
break;
}
}
}
}


הפונקציות printMatrix ן generateMatrix הן רק פונקציות עזר לצורך בדיקה. ה"טריק" הוא להשתמש במערך הסטים (offsets) כמו ש-nocgod כבר ציין אבל במקום להשתמש ב-2 לולאות, ניתן להסתפק בלולאה אחת אם מספקים את ההיסטים בשני הצירים.
ניתן להימנע מבדיקת הגבולות אם נרפד את המטריצה בערכים שונים מערכים שאנחנו מחפשים (X Y)

התוכנית שלי רחוקה מלהיות מושלמת, אם יש לך עוד שאלות בבקשה.

 

[LooKinG FoR My NaMe]

תודה רבה לכם

ה"טריק" הזה בדיוק מה שחיפשתי