זה התרגיל:

כתבו תוכנית שנתון לה מערך מספרים שלמים בין 0 ל-9 בגודל מסוים (15), ועליה להדפיס היסטוגרמה שלו, כלומר כמה פעמים מופיע כל מספר. לדוגמה, אם נתון המערך הבא:

int array[15] = {1, 3, 5, 7, 9, 1, 3, 5, 8, 9, 1, 3, 5, 8, 9};

היא תדפיס:

0 appears 0 times
1 appears 3 times
2 appears 0 times
3 appears 3 times
4 appears 0 times
5 appears 3 times
6 appears 0 times
7 appears 1 times
8 appears 2 times
9 appears 3 times

ובעיקרון זה מה שאני עשיתי בדרך שלי, אבל אני לא מצליח לפתור את התקלה, עזרה מתבקשת:

קוד:

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

// here starts the functions
int much(int each, int x)
{
    int each+=x;
 return   each;
}
int main()
{
int arr[15]=(5, 8, 8, 6, 9, 4, 9, 2, 8, 3, 7, 3, 6, 2, 0);   // arrays goes from 0 to 14
int i, x, temp;

for(i=0; i<15; ++i){
         x=0;
         temp=0;
     do {
      if (arr[i] = x){
                 temp++
                 }
         x++;
         }
         while (x<10);
         printf("%d returns %d times\n", arr[each], temp);
         }
getch();
return 0;
}

חוץ מזה, שאלה קטנה, התחלתי ללמוד את C אך אני רואה שC++ לא שונה יותר מדי וכיוון שאני די בהתחלה, האם כדאי לעבור? המטרה שלי היא לדעת האם הכיוון שלי בחיים יהיה לכיוון מדעי המחשב או לא, ולדעתי פרקטיקה תגיד.
עכשיו בנושא השפה, הבנתי שC היא יותר שפה נמוכה משפות דומות לה כגון פייתון, ג'אווה וCPP, ולכן היא עדיפה כי היא נותנת למתחיל ראייה טובה יותר של המכלול, כן?

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

Bad Spellers Unite!

הקוד שלך ממש לא הגיוני. (וחוץ מזה, נראה לי שהוא לא מתקמפל. מאיפה מגיע each בקריאה ל-printf?)

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

ציטוט:

במקור נכתב על ידי SkyRaider חוץ מזה, שאלה קטנה, התחלתי ללמוד את C אך אני רואה שC++ לא שונה יותר מדי וכיוון שאני די בהתחלה, האם כדאי לעבור? המטרה שלי היא לדעת האם הכיוון שלי בחיים יהיה לכיוון מדעי המחשב או לא, ולדעתי פרקטיקה תגיד. עכשיו בנושא השפה, הבנתי שC היא יותר שפה נמוכה משפות דומות לה כגון פייתון, ג'אווה וCPP, ולכן היא עדיפה כי היא נותנת למתחיל ראייה טובה יותר של המכלול, כן?

זו לא שאלה קטנה, אלא שאלה מאוד גדולה. בקיצור:

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

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

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

קודם כל, יש לי פונקציה בשם much ובתוכה יש משתנה each ששווה ל1+ התוספת של x.
הפונקציה מחזירה את הערך של each.
\\עוד מעט יובהר לשם מה הפונקציה.

הגדרתי מערך בגודל של 15 אלמנטים.
3 משתנים.

יצרתי לולאה for, למשתנה i אתחול כל עוד הוא קטן מ15, ואחרון חביב שיגדל ב1 כל סבב.

מיד לאחר מכן, אני מאפס את x ו- temp, בקרוב אסביר מדוע.

ואז יצרתי לולאה נוספת של do..while
ובעצם מה שקורה כאן די פשוט להבנה,
בלולאה החדש יש תנאי, אם המערך בנקודה i שווה לערך של x (שמאותחל ל0) אז מוסיפים למשתנה temp אחד.
לאחר התנאי מחוץ לסוגריים המסולסלים, אני הוספתי 1 לx ואז זה חוזר על עצמו עד שx קטן מ10.
לאחר לולאת do..while יש פקודה להדפיס.
קודם כל זה מדפיס את המערך בנקודה של (יכול להיות שטעיתי בפונקציה עם each אבל הכוונה שלי הייתה שזה ידפיס את המספר x (שמתחיל ב0) ואז יגדל (כמו שרשום בפונקציה בהתחלה each+=x) כנראה שכאן טעיתי..).
בכל מקרה, לאחר שזה מדפיס את מה שזה אמור היה להדפיס, זה רושם את הtemp שזה סך הפעמים שהספרה הופיעה.

לאחר שזה מסתיים, הלולאה של הfor מתחילה פעם נוספת ככה 15 פעמים, וx וtemp מתאפסים לסיבוב נוסף.

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

לגבי השאלה ה"קטנה".

שמע, אני יודע שתואר במדעי המחשב הוא תואר תיאורטי, וחופן בתוכו כמות של מתמטיקה קרובה מאוד לזה שבתואר במתמטיקה עצמה. אך ללא כל ניסיון בתוצר עצמו, ובלי ללכלך את הידיים, בתכנות, איך אדע אם זה יהיה הכיוון שלי? הרי אין לי דרך אחרת להתנסות בכך חוץ מזה. אולי אני במים לא מוכרים אבל אני לא חושב שיש מישהו שיתחיל ללמוד חדו"א, ליניארית וכו' בשביל לדעת אם הכיוון הזה בחיים יתאים לו או לא. (אף על פי שאתה צודק ויש יותר מתמטיקה מתכנות נטו).

ומה הכוונה לא ברור מה מייצג זה שC יותר נמוכה משכניה? אם כך אז מי תתן מבט מקיף וטוב על הנושא הנ"ל בהקשר למדעי המחשב?

תודה

Bad Spellers Unite!

זה ש"תתרגם" לי כל מילה ב-C למילה בעברית לא יעזור. אני יכול לקרוא קוד C. זה לא הופך את הקוד להגיוני...

בוא נוותר על הלולאה החיצונית, ונראה מה קורה עבור i=k כלשהו:

קוד:

x = 0;
temp = 0;
do {
	if (arr[i] = x) {
		temp++
	}
	x++;
} while (x < 10);
printf("%d returns %d times\n", arr[each], temp);

קודם כל, חסר לך שם נקודה-פסיק אחרי temp++‎, ואין לך משתנה בשם each...
עכשיו אני אתרגם לך את מה שעושה הקוד הזה לעברית, שמתבצע עבור ערך ספציפי של i:

• עבור כל מספר מ-0 עד 9 מבצעים את הפעולות הבאות:
  • אם הנקודה במערך שבודקים שווה למספר הנוכחי (0-9) שבודקים:
    • תגדיל את temp ב-1
• מדפיס את temp

או בקיצור: אתה בודק האם במקום הנוכחי במערך (arr[i]‎) יש מספר בין 0 ל-9. אם כן temp שווה 1. אם לא temp נשאר אפס.

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


עכשיו קרא בבקשה את מה שכתבתי לך למעלה.


חוץ מזה, אני לא רואה סיבה לייצר פונקציה שכל מה שהיא עושה זה לחבר שני מספרים...

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

ציטוט:

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

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

c++ לא שונה יותר מדי מC.. זו בדיחה טובה לערב זה..
c זו שפה קלילה, C++ זו שפה מגעליה ומאוד לא קלה ללימוד, אני לא הייתי ממליץ לאנשים מתחלים בעולם התכנות להתחיל מCPP.

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

ציטוט:

כתבו תוכנית שנתון לה מערך מספרים שלמים בין 0 ל-9

ז"א שהרעיון הטרוואלי אמור להיות מיד לבנות מערך עזר בגודל 10.(מאותחל ב-0).
לעבור על המערך שקבלת, ולעשות משהו פשוט בסגנון

קוד:

//int arr_size=15 or what ever you want..
//arr_ezer is an int array of '0' of size 10.
for(int i=0;i<arr_size;i++)
	arr_azer[arr[i]]++;

וכל מה שנשאר, זה כמובן להדפיס את התוצאה..

ותסלח לי שהקוד כתוב בCPP, אם יש משהו שהוא יותר מזמין בCPP מC, אלה הם סיפריות הקלט\פלט..

קוד:

int arr[15]={1, 3, 5, 7, 9, 1, 3, 5, 8, 9, 1, 3, 5, 8, 9};
	int arr_size=15;
	int arr_ezer[10]={0};

	for(int i=0;i<arr_size;i++)
		arr_ezer[arr[i]]++;

	for(int i=0;i<10;i++)
		cout<<i<<" appears "<<arr_ezer[i]<<" times \n";

לא הייתי קורא לזה פתרון "טריוויאלי" בעיקר למי שרק מתחיל ללמוד תיכנות שלא במסגרת אקדמית.
רק מי שלמד על סוגי מיונים ועל יעילות של אלגוריתמים כאלה יכול באמת להבין למה המיון הזה שעשית, Bucket Sort, אכן בהרבה יותר יעיל (סדר גודל של [tex]n[/tex]) מהפתרון שהבחור חשב עליו (סדר גודל של [tex]n^2[/tex]).

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

ציטוט:

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

רק שבשום שלב לא מתרחש מיון.

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

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

נכון, לא מתרחש מיון במובן הקלאסי של המילה (כי אתה לא משנה את המערך המקורי וכו'), אבל מתבצע פה "סוג של" מיון (כפי שציינתי, Bucket Sort).

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

כמו שאמר המוח המפוזר מעלי, זה לא מיון.

אם אתה רוצה להתחכם ולהגיד שאפילו ש"לא מתרחש מיון במובן הקלאסי של המילה", זה "סוג של" מיון, אז בוא נלך קדימה. בוא גם נגיד ש-quicksort זה "סוג של bucket sort" (עם שני סלים), ושימוש בעצמך לצורך המיון הפנימי של הסלים. נכון שברור שזו אמירה מיותרת?

• במקרה שלנו, "ממיינים" לתוך הסלים, אבל לא מבצעים מיון פנימי על הסלים. ב-bucket sort ("קלאסי"...), אחרי שממיינים את המידע לסלים, ממיינים את מה שבתוך הסלים.
• במקרה שלנו, לא אכפת לנו מהתוצאה (לא רק שלא משנים את המערך המקורי, אלא גם לא יוצרים מערך חדש עם התוצאות) של ה"מיון" - חלק מהמידע אובד. נשארת לנו רק ההיסטוגרמה. במיון סלים (כמו בכל מיון), כל המידע המקורי נשמר (מלבד הסדר).
  אם לדוגמה, לא היו לנו מספרים, אלא pair-ים או tuple-ים של מספר-ועוד-באפר-עצום, מיון היה משאיר לנו את הבאפרים המקושרים לכל tuple. אנחנו רק יודעים כמה באפרים היו שמתאימים לכל מספר, אבל התוכן נעלם.

וחוץ מזה:

• ביעני-bucketsort שיש לנו פה (שכבר ברור שאיננו מיון משתי הנקודות לעיל), מספר הסלים שווה למספר הערכים השונים האפשריים לכל אלמנט במערך המקורי. זו גרסה מנוונת למדי של bucketsort (כמו quicksort...), ומסתבר שיש לה שם משלה: http://he.wikipedia.org/wiki/%D7%9E...9%D7%99% D7%94

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

אפשר לקבל גם הסבר מה זה כל המיונים האלה שמדוברים פה?
bucket sort?
quicksort?

תודה!

Bad Spellers Unite!

• Bucket sort
• Quicksort
• כל שאר המיונים שדיברו עליהם פה

ציטוט:

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

סוף סוף תשובה שמבטאת בצורה מלומדת את מה שעשיתי, או לפחות מה שעשיתי בפוטנציה.

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

אז איפה טעיתי בדרך, מה צריך לשנות בקוד שלי כדי שזה יעבוד?

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

Bad Spellers Unite!

קוד:

void Histogram (int arr[], int size){ 
int count[10]={0},i; 

for (i=0;i<size;i++) 
     count[arr[i]]++; 
for (i=0;i<10;i++) 
     printf ("%d apears %d times\n", i,count[i]); 

}

ציטוט:

במקור נכתב על ידי Army_Boy קוד: void Histogram (int arr[], int size){ int count[10]={0},i; for (i=0;i<size;i++) count[arr[i]]++; for (i=0;i<10;i++) printf ("%d apears %d times\n", i,count[i]); }

כמה שאלות להבין טוב יותר:

למה פונקציה ריקה? היא לא מחזירה ערך?

איפה int main)(?

איבדתי אותך בint count תוכל להסביר מה עשית שם?

אשמח להסבר, תודה!

אגב שיפצתי את הקוד שלי, והנה הוא עכשיו:

קוד:

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

// here starts the functions

int main()
{
int arr[15] = {5, 8, 8, 6, 9, 4, 9, 2, 8, 3, 7, 3, 6, 2, 0};   // arrays go from 0 to 14
int i, x, temp;

for(i=0; i<15; i++){
         x=0;
         temp=0;
     do {
      if (arr[i] == x){
                 temp++;
                 }
         x++;
         }
         while (x<10);
         printf("%d appears %d times\n", arr[i], temp);
         }
getch();
return 0;
}

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

בכל מקרה תודה לעוזרים, פקחתם את עיני,

תודה.

Bad Spellers Unite!

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

בINT COUNT
אני בעצם מגדיר מערך חדש, של 10 מקומות, שכל תא במערך מייצג מספר מ0 עד 9 .. כמו שנתון בתרגיל .. אני מאפס את כולו בעזרת ה {int count[10 = {0} ואז לפי הערך שיש לי במערך המקורי נגיד 8 אז אני הולך לתא ה-8 במערך הCOUNT ומקדם אותו ב1 אז עכשיו הערך בפנים הוא לא 0 אלא 1 .. וכך הלאה... בסוף אני עושה לולאה שמדפיסה את הכל וזהו

קוד:

int main(){
int array[15] = {1, 3, 5, 7, 9, 1, 3, 5, 8, 9, 1, 3, 5, 8, 9};

Histogram (array,15);
return 0;
}

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

הצלחת לעזור לי מאוד תודה!

עכשיו כמה שאלות,

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

הפונקציה שלhistogram די מיותרת לא?

כלומר ככה או ככה היית צריך להכניס 15 ספרות, אז בשביל מה הפונקציה?


תודה רבה!

תוכל לעזור בשאלותי האחרות מתחילת הדיון?

Bad Spellers Unite!

ציטוט:

במקור נכתב על ידי SkyRaider הבנתי אותך, הטריק היה ליצור מערך נוסף וככה אפשר לשלוט בגדילה של איזה ערך שרוצים! הצלחת לעזור לי מאוד תודה! עכשיו כמה שאלות, הפונקציה שלך היא void, ואתה אומר שהיא לא מחזירה ערך, ואתה אומר שאתה רוצה להדפיס את המספרים, כיצד אדע מתי להשתמש בvoid או לא? איך אדע מה נחשב ערך? יכולת לדוגמא ליצור פונקציה שמחזירה את המספר הכי קטן במערך, במקרה שלנו אנחנו לא רוצים להחזיר ערך אלא אנחנו רוצים להדפיס משהו. הפונקציה שלhistogram די מיותרת לא? נכון, יכולתי לכתוב את אותו הדבר בMAIN עצמו, אבל זה יותר מסודר.. ומשאיר מקום בMAIN כלומר ככה או ככה היית צריך להכניס 15 ספרות, אז בשביל מה הפונקציה? תודה רבה! תוכל לעזור בשאלותי האחרות מתחילת הדיון?

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

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

למה הקוד שלך זה שטויות?(ויכול מאוד שיש באגים נוספים, אבל הם כרגע פחות מעניינים).
כי הלולאה הראשית שלך עושה 15 סיבובים, והפנימית 10, אבל המטרה בפתרון שלך זה לעבור על המערך המקורי 10 פעמים, ובכל פעם שאתה עובר על המערך לבדוק כמה איברים במערך המקורי שלך שווים ל0
בפעם השניה כמה מהם שווים ל1,.. וכן הלאה עד 9.

מה בברור רואים שהלולאה הראשית שלך, היא בכלל צריכה להיות בגודל 10, וזו הפנימית בגודל 15.