השאלה היא:

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

הקוד שכתבתי:

#include<stdio.h>
#include<conio.h>
#define n 10
	typedef int array[n];
	void kelet (array a)
 {
	int i;
	for (i=0;i<n;i++)
		scanf ("%d", &a[i]);
 }
	int Bdika (array a)
 {
	int i, shone, flag;
  shone=a[0];
  flag=0;
  for (i=1;i<n;i++)
  {
  while (flag!=1)
  {
  if (a[i]!=shone)
  {
   shone=a[i];
  }
   else
   	flag=1;
  }
  }
  return (flag);
 }
	void main ()
 {
	array b;
	int s;
	clrscr();
	kelet (b);
	s=Bdika(b);
	printf ("%d",s);
 }

משום מה זה תמיד מחזיר לי את המספר 1.

מה הבעיה?

תודה לעוזרים.

שים לב לקטע הזה:

while (flag!=1)
{
  if (a[i]!=shone)
  {
    shone=a[i];
  }
  else
    flag=1;
}

אתה מתחיל עם flag==0. ה-if הראשון מתקיים, ולכן מבוצע [shone=a[i. מן הסתם עכשיו גם [shone==a[i - זאת תוצאה ישירה של ההשמה.

מאחר שעדיין flag==0 אתה נשאר בתוך ה-while. הפעם התנאי של ה-if כמובן לא מתקיים (מה שכתבתי אחרי "מן הסתם") ולכן מבוצע flag=1.

זה יתבצע בלי קשר למספר הערכים שיש (אולי חוץ ממקרי קצה). מאחר שאתה לא משנה את flag בשום מקום אחר הפונקציה תמיד תחזיר 1.

לא התעמקתי ממש באלגוריתם שלך, אבל נראה לי שאו שאתה צריך לקדם את i בתוך ה-while (ויכול להיות שעדיף לך להשתמש ב-for, ואולי גם ב-j בנוסף ל-i), או שאתה צריך לשנות את ה-while הזה למשהו אחר (אולי להוסיף בו && ועוד תנאי).

מה שהוא אמר...

מה שאתה צריך לעשות זה שתי לולאות for מקוננות.

החיצונית מקדמת את האינדקס (i למשל) במערך - כלומר בודקת את מספר i במערך.

והשניה שמקדמת נגיד את האינדקס v במערך ממספר i (המספר הנבדק) והאלה עד n (גודל המערך) ומוודא שאין מספרים דומים למספר שיושב באינדקס i.

למה לא לבדוק כל פעם אם המספר הנוכחי שווה למספר הקודם, וכאשר רואים שאחד מהם שונה, להחזיר 0?

יותר יעיל.

למה לא לבדוק כל פעם אם המספר הנוכחי שווה למספר הקודם, וכאשר רואים שאחד מהם שונה, להחזיר 0?

יותר יעיל.

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

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

אה.. אופס חשבתי שצריך להחזיר 1 אם כל המספרים שווים זה לזה, ולא אם כולם שונים.

תודה רבה.

תיקנתי, אבל עושה את אותה בעיה.

#include<stdio.h>
#include<conio.h>
#define n 10
	typedef int array[n];
	void kelet (array a)
 {
	int i;
	for (i=0;i<n;i++)
		scanf ("%d", &a[i]);
 }
	int Bdika (array a)
 {
	int i, flag,j;
  for (i=0;i<n-1;i++)
  {
  	for (j=1;j<n;j++)
   {
   if (a[i]==a[j])
	   flag=1;
   }
  }
  return (flag);
 }
	void main ()
 {
	array b;
	int s;
	clrscr();
	kelet (b);
	s=Bdika(b);
	printf ("%d",s);
 }

ב for בפנימי שבתוך Bdika אתה שם 1 בflag כדי לסמן כאשר יש שוויון. אבל אתה לא בודק מה קורה כשהם שונים ואז צריך לאפס את flag...

הצעה:

תשים מלכתחילה1 בflag, והבדיקה שתעשה בתוך הfor המקונן תהייה האם [a != a[j.. כאשר התנאי מתקיים אתה שם 0 ב flag, ובסוף אתה מחזיר את flag... ככה אתה חוסך בדיקה, ואתה יודע שאם אחד מהתאים שונה מהשני, flag ידע על זה...

עשיתי את זה כבר, זה לא עזר לי:

	int Bdika (array a)
 {
	int i, flag,j;
  flag=1;
  for (i=0;i<n-1;i++)
  {
  	for (j=1;j<n;j++)
   {
   if (a[i]!=a[j])
	   flag=0;
   }
  }
  return (flag);
 }

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

תנסה את הקוד הזה:

#include <stdio.h>
#include <conio.h>

#define n 10

typedef int array[n];

void kelet(array a)
{
    int i;
    for (i=0;i<n;i++)
    scanf ("%d", &a[i]);
}

int Bdika(array a)
{
    int i, j;

    for (i = 0;
          i < n - 1;
          i++)
    {
        for (j = i + 1;
              j < n;
              j++)
        {
            if (a[i] == a[j])
            {
                return 1;
            }
        }
    }

    return 0;
}

void main()
{
    array b;
    int s;
    clrscr();
    kelet (b);
    s=Bdika(b);
    printf ("%d",s);
}

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

ועוד אגב, אין לי כאן קומפיילר לבדוק עליו אם הקוד הזה עובד - תבדוק ותגיד לי.

עבד :]

תודה רבה,

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

הזחות נורמליות אולי לא עשיתי כי נחפזתי, אבל כל השאר? ככה המורה שלי לימדה אותי...

צודק - מיון ניתן לעשות ב- o(nlogn) לעומת הפתרונות שהוצגו כאן שהם n^2.

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

דוגמא:

#include <stdio.h>
#include <conio.h>

// Number of items in IntArray type
#define ITEMS_IN_ARRAY 10

// IntArray type
typedef int TIntArray[ITEMS_IN_ARRAY];

// Populate an IntArray from user input
void GetUserInput(TIntArray iaArray)
{
  int iCurrentItem;
  for (iCurrentItem = 0;
     iCurrentItem < ITEMS_IN_ARRAY;
     iCurrentItem++)
  scanf ("%d", &iaArray[i]);
}

// Search for identical items in an IntArray. true if found, false if not.
bool CheckForIdenticalItems(TIntArray iaArray)
{
  int iMainItem, iComparedItem;

  // Compare each item to all of the items following it
  for (iMainItem = 0;
     iMainItem < ITEMS_IN_ARRAY - 1;
     iMainItem++)
  {
    for (iComparedItem = iMainItem + 1;
       iComparedItem < ITEMS_IN_ARRAY;
       iComparedItem++)
    {
      if (iaArray[iMainItem] == iaArray[iComparedItem])
      {
        // Found two identical items
        return true;
      }
    }
  }

  // Could not find two identical items
  return false;
}

void main()
{
  TIntArray tiArray;
  bool fIdenticalItemsFound;

  // Clear the screen
  clrscr();

  // Get IntArray values from user and check for identical items in the array
  GetUserInput(tiArray);
  fIdenticalItemsFound = CheckForIdenticalItems(tiArray);

  if (fIdenticalItemsFound == true)
  {
    printf("Identical items found.\n");
  }
  else
  {
    printf("No identical items found.\n");
  }
}

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

על נוטציה הונגרית תוכל לקרוא כאן:

http://en.wikipedia.org/wiki/Hungarian_notation

לגבי הערות, אני מניח שאתה מסוגל להבין מה צריך לעשות לבד לא לכתוב הערות מיותרות כמו נגיד:

  // Print out what happened...
  if (fIdenticalItemsFound == true)
  {
    // Identical items found
    printf("Identical items found.\n");
  }
  else
  {
    // No identical items found
    printf("No identical items found.\n");
  }

לדאוג שהקוד שלך "יתעד את עצמו".

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

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

אלא אם אתה מתכנת system (למשל ב-win32) ובאמת משתמש בשפות ארכאיות באופן קבוע אז אולי כדאי לך לכתוב ככה.

אחרת לא.

יום טוב.

אבל למה שמת ; בחתימה שלך?