חיפוש

עזרה

הרשמה

התחברות

עדכונים

תיכנות
UnderWarrior Forums : תיכנות

נושא: עזרה בכתיבת פונקציה עבור מטריצות ב-C

כותב

הודעה

<< נושא קודם | נושא הבא >>

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 28 December 2006 בשעה 11:59

| IP רשוּם

שלום לכולם,

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

לדוגמא:

אם מטריצה A: שהיא 6x6

4 1 1 3 2 1

8 5 2 3 2 1

3 2 1 3 2 1

3 2 1 2 1 8

3 2 1 9 4 3

ומטריצה B: שהיא 3x3

3 2 1

הפלט אמור להיות: צטריצה B מופיעה 2 פעמים בתוך מטריצה A

אני מניחה שצריך להשתמש ב-4 לולאות מקוננות אך אינני מצליחה

אשמח אם מישהו יוכל לעזור לי

תודה, אנאבל

חזרה לתחילת העמוד

321
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 28 December 2006 בשעה 15:57

| IP רשוּם

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

חזרה לתחילת העמוד

mor
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 28 December 2006 בשעה 17:10

| IP רשוּם

קוד:

boolean Func_mx_in_mx(int m,int n)
{
int i,j,k,l;
boolean degel=false;
int [][] a=new int [n][n];//bigger
int [][] b=new int [m][m];//smaller
for(i=0; i<m;i++)//A's line
{
 for(j=0;j<m;j++)//A's coulmn
  for(k=0; i<m;i++)//B's line
   for(l=0;j<m;j++)//B's coulmn
   {
     if(a[k][l ]==b[j])
        degel=true;
     else
     {
       return false;//failed
     }
        
   }
  
}
}//

func

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 31 December 2006 בשעה 09:50

| IP רשוּם

המון המון תודה מור...

למיטב הבנתי הפונקציה אינה מבצעת בדיקה של כמה פעמים מטריצה B מופיעה במטריצה A

תוכל\י לעזור בזה?

שנית למה הכוונה בשורה הזו:

int [][] a=new

שוב תודה על העזרה

אנאבל.

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 31 December 2006 בשעה 19:56

| IP רשוּם

הקוד הוא ב-JAVA. הפונקציה אמורה לקבל את המטריצות כקלט ולא לאתחל 2 מטריצות סתם כך. כמו כן הפונקציה לא סופרת את מס' המופעים של המטריצה הקטנה בתוך הגדולה ולכן הקוד של mor לא עושה את הנדרש, SORRY MOR, WE LOVE YOU

תיקון של הקוד (הפעם ב-C):

קוד:

int Func_mx_in_mx(int **a, int n, int **b, int m)  
{
   //a is a nxn matrix and b is a mxm matrix, a is bigger than b.
   int i,j,k,l; 
   int count=0;
   for(i=0; i<n-m+1;i++)//A's line
   {
        for(j=0;j<n-m+1;j++)//A's coulmn
        {
  degel = true;
  for(k=0; k<m || !degel;k++)//B's line.
    {
       for(l=0;l<m || !degel;l++)//B's coulmn
          {
        if(a[i+k][j+l]!=b[k][l])
             degel=false;
          }
    }
    if (degel)
       count++;
 }
  }
  
  return count;
}
 

בהצלחה !

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 31 December 2006 בשעה 20:07

| IP רשוּם

שכחתי

bool degel;

בהגדרת המשתנים

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 08:17

| IP רשוּם

מעולה, המון תודה.

בשורת הגדרת הפונקציה (שורה ראשונה):

(int Func_mx_in_mx(int **a, int n, int **b, int m

מה הכוונה ב: a** ו- b** - לא זכור לי שלמדתי את זה.

שוב תודה,

אנאבל.

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 10:12

| IP רשוּם

* ב-C מתייחס ל-POINTER - תקראי חומר בנושא POINTERS כדי להבין יותר,

על כל מקרה כשכותבים ** לפני שם משתנה מסוג int למשל, הכוונה היא שהמשתנה הוא מצביע (POINTER) למערך דו-ממדי מסוג int.

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 10:22

| IP רשוּם

תודה צחי,

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

שוב תודה,

אנאבל.

חזרה לתחילת העמוד

דני מגן
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 11:15

| IP רשוּם

צחי\אנאבל,

אשמח לדעת אם יש לכם דרך לעשות זאת ללא מצביעים.

נראה קצת מסובך

דני.

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 12:55

| IP רשוּם

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

אולי זה יהיה יותר ברור מהדוגמה הבאה,

שורת ה-PROTOTYPE של פונקציה יכולה גם להיראות כך:

קוד:

const N = 4;
const M = 2;
int Func(int a[N][N], int b[M][M])
{
   .
   .
   .
}
זה בדיוק כמו:
int Func(int **a, int **b)
{
   .
   .
   .
}

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

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 01 January 2007 בשעה 13:23

| IP רשוּם

צחי,

אתה פשוט אחלה,

תודה תודה,

אנאבל.

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 02 January 2007 בשעה 10:00

| IP רשוּם

שוב שלום,

הכנסתי את הפונקציה לתוך תוכנית והרצתי אותה אך התוצאה הינה תמיד 0

שיניתי את true ו false ל-0 ו-1 כדי לפשט את הפונקציה יותר.

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

אשמח אם תוכל לעזור שוב לזהות את הבעיה

אנאבל.

#include <stdio.h>
#define N 6
#define M 3
int a[N][N]={{1,2,3,1,1,4},
      {1,2,3,2,5,8},
      {1,2,3,1,2,3},
      {8,1,2,1,2,3},
      {3,4,9,1,2,3},
      {9,8,7,6,5,4}};

int b[M][M]={{1,2,3},
{1,2,3},
{1,2,3}};

int func_mx_in_mx(int a[N][N], int b[M][M]);
void main ()
{

int i,j,count;

func_mx_in_mx(a,b);
printf ("\nMatrix B is presented %d times in Matrix A\n",count);
}

int func_mx_in_mx(int a[N][N], int b[M][M])
{
int i,j,k,l;
int count=0;
int flag;

for(i=0; i<=N-M;i++)          /* A's line */
{
      for(j=0;j<=N-M;j++)      /*A's coulmn */
       {
flag=0;
for(k=0; k<M || !flag;k++)     /* B's line */
{
   for(l=0;l<M || !flag;l++)    /* B's coulmn */
    {
     if(a[i+k][j+l]!=b[k])
      flag=1;
    }
}
if (flag)
count++;
       }
}
return count;
}

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 02 January 2007 בשעה 17:52

| IP רשוּם

קצת התבלבת בהגדרה של המצב של flag: אם falg==1 , לפי הקוד שלך, אז התת-מטריצה בתוך A אינה זהה למטריצה B (לפחות איבר אחד שונה). לעומת זאת, אם flag==0 אז לא נמצא הבדל (עד כה) בין תת-המטריצה של A למטריצה B - אם עברנו על כל אברי תת המטריצה והשוונו אז flag יישאר 0 ולכן התנאי להדיל את הסכום צריך להיות אם flag==0. קוד מתוקן (תיקון קטן):

קוד:

 
#include <stdio.h>
#define N 6
#define M 3
int a[N][N]={{1,2,3,1,1,4},
      {1,2,3,2,5,8},
      {1,2,3,1,2,3},
      {8,1,2,1,2,3},
      {3,4,9,1,2,3},
      {9,8,7,6,5,4}};
int b[M][M]={{1,2,3},
      {1,2,3},
      {1,2,3}};
int func_mx_in_mx(int a[N][N], int b[M][M]);
void main ()
{
int i,j,count;
func_mx_in_mx(a,b);
printf ("\nMatrix B is presented %d times in Matrix A\n",count);
}
int func_mx_in_mx(int a[N][N], int b[M][M])
{
 int i,j,k,l;
 int count=0;
 int flag;
 for(i=0; i<=N-M;i++)          /* A's line */
  {
      for(j=0;j<=N-M;j++)      /*A's coulmn */
       {
 flag=0;
 for(k=0; k<M || flag==1;k++)     /* B's line */
  {
   for(l=0;l<M || flag==1;l++)    /* B's coulmn */
    {
     if(a[i+k][j+l]!=b[k][l])
      flag=1;
    }
  }
 if (flag==0)
 count++;
       }
  }
 return count;
}

חזרה לתחילת העמוד

צחי
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 02 January 2007 בשעה 17:53

| IP רשוּם

להדיל = להגדיל

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 02 January 2007 בשעה 22:57

| IP רשוּם

היי צחי,

אכן שיניתי את FLAG בגלל שהוא נכנס ללולאה אינסופית.

ניסיתי להריץ את התוכנית המעודכנת ששלחת והוא שוב נכנס ללולאה אינסופית.

יש לך רעיון למה?

אנאבל.

חזרה לתחילת העמוד

צחי@
משתמש חבר

הצטרף / הצטרפה: 02 January 2007
מדינה: Israel
משתמש: מנותק/ת
הודעות: 209

נשלח בתאריך: 02 January 2007 בשעה 23:55

| IP רשוּם

צודקת, יש אצלי באג, לצערי אין לי בד"כ זמן לקמפל ולהריץ, יש טעות בתנאי ב-2 הלולאות הפנימיות. הקוד המתוקן מתוקן....

קוד:

#include <stdio.h>
#define N 6
#define M 3
int a[N][N]={{1,2,3,1,1,4},
      {1,2,3,2,5,8},
      {1,2,3,1,2,3},
      {8,1,2,1,2,3},
      {3,4,9,1,2,3},
      {9,8,7,6,5,4}};

int b[M][M]={{1,2,3},
      {1,2,3},
      {1,2,3}};

int func_mx_in_mx(int a[N][N], int b[M][M]);

int main ()
{
        int count;

        count = func_mx_in_mx(a,b);
        printf ("\nMatrix B is presented %d times in Matrix A\n",count);
        return 0;
}

int func_mx_in_mx(int a[N][N], int b[M][M])
{
        int i,j,k,l;
        int count=0;
        int flag;

        for(i=0; i<=N-M;i++)          /* A's line */
        {
                for(j=0;j<=N-M;j++)      /*A's coulmn */
                {
                          flag=0;
                          for(k=0; k<M && flag==0;k++)     /* B's line */
                          {
                                  for(l=0;l<M && flag==0;l++)    /* B's coulmn */
                                  {
                                          if(a[i+k][j+l]!=b[k][l])
                                                    flag=1;
                                  }
                          }
                          if (flag==0)
                                  count++;
                }
        }

        return count;
}

הפעם זה עובד - בדקתי !
בלי שום קשר אני ממליץ לך להתחיל ולהתיידד עם ה-DEBUGGER - ככה תוכלי לעלות על בעיות כאלה בעצמך.

__________________
דלתות אדריכלים גגות פוליש

חזרה לתחילת העמוד

אנאבל
אורח

הצטרף / הצטרפה: 01 October 2003
משתמש: אונליין
הודעות: 12647

נשלח בתאריך: 03 January 2007 בשעה 11:05

| IP רשוּם

אכן עובד.

יצאת גדול - תודה רבה

חזרה לתחילת העמוד

אם ברצונך להגיב לנושא זה עליך קודם להתחבר
אם אינך רשום/ה כבר עליך להרשם

גרסת הדפסה

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