מטריצה - Matrix
int[,] matrix = new int[5, 7];, כלומר חמש שורות ושבע עמודות. הפסיק בתוך הסוגריים המרובעים מסמן מטריצה דו-ממדית.matrix[2, 4] = 90; מכניס ערך לתא בשורה 2 ובעמודה 4, ו-Console.WriteLine(matrix[2, 4]); מציג אותו.GetLength(0) נותן את מספר השורות, GetLength(1) את מספר העמודות, ו-Length את מספר התאים הכולל, שהוא 35 במקרה הזה.i < matrix.GetLength(0)) והפנימית על העמודות (j < matrix.GetLength(1)). בסוף כל שורה יורדים שורה.CreateMultiplicationBoard מחזירה מטריצה חדשה של לוח הכפל 10 על 10, שבה כל תא מקבל את הערך (i + 1) * (j + 1). בכותרת הפונקציה מופיע הטיפוס int[,] כערך המוחזר.matrix.Length. בלוח הכפל התוצאה היא 30.25. כדי שהתוצאה לא תחזור כמחרוזת, משנים את הטיפוס המוחזר של הפונקציה ל-double.פרקי ההרצאה: מטריצה - Matrix
תמלול ההרצאה: מטריצה - Matrix
הטקסט המלא של הדקות הראשונות בהרצאה «מטריצה - Matrix» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
הדבר הבא שאנחנו הולכים לראות נקרא מטריצה באנגלית מטריקס. מטריצה זה בעצם תא זיכרון כמו מערך שמכיל המון תאים בתוכו אבל התאים מסודרים במעין טבלה זאת אומרת שאנחנו לא רק מגדירים מערך חד-ממדי אחד ויחיד אלא אנחנו מגדירים גם מספר שורות וגם מספר עמודות וכך בעצם נוצרת לנו טבלה בזיכרון שבה אנחנו יכולים להגיע לכל תא במיוחד.
כאשר הצרנו מערך חד-ממדי אנחנו רשמנו לדוגמה מערך מטיפוס integer int array שווה new int בגודל 10 אז נפתח לנו סך הכל שורה אחת של עשרה תאים והיינו יכולים להגיע לכל תא בצורה נפרדת מטריצה זה סיפור אחר מטריצה פותחת לנו מעין טבלה עם שורות ועמודות ואנחנו יכולים להגיע לכל טבלה, לכל תא בטבלה, בצורה
ספציפית. איך אנחנו מגדירים מטריצה? אז בואו נניח שהמטריצה שאנחנו רוצים זה מטיפוס אינטג'ר.
בטיפוס אנחנו רושמים בצורה כזאת int. לאחר מכן אנחנו רושמים סוגריים ובתוכם פסיק. בואו נפתח את השם של המשתנה, מטריקס, ונגדיר new int.
אבל כאן אנחנו נותנים את מספר השורות, בואו נניח אנחנו רוצים 5 שורות, ואת מספר העמודות. בואו נניח אנחנו רוצים 7 עמודות, לכל שורה וכעת יצרנו מעין טבלה עם חמש שורות ושבע עמודות.
איך אנחנו מגיעים לתא בטבלה? קודם כל כל תא הוא מטיפוס אינטג'ר בגלל שהגדרנו את המטריצה כאינטג'ר. אם היינו מגדירים את המטריצה כסטרינג בצורה כזאת ובצורה כזאת אז כל תא היה בעצם סטרינג והיינו יכולים להכניס טקסט לכל אחד מהתאים במטריצה.
בגלל שאנחנו באינטג'ר אז אנחנו בעצם יכולים להכניס מספרים שלמים לכל אחד מהתאים. איך אנחנו מגיעים לתא? שם המטריצה, פותחים סוגריים, קודם כל רוצים, אנחנו צריכים לרשום את מספר השורה, כאשר היא תמיד מתחילה מאפס, לאחר מכן פסיק, ואז את מספר העמודה,
שהעמודות מתחילות באפס. לכן זהו התא הראשון במטריצה. בואו נציג אותו, תא 0 על 0, ונראה שהכנסנו בתוכו 100. מהו התא האחרון במטריצה?
כלומר הכי ימני והכי תחתון בטבלה. וכמובן השורה האחרונה שיש לנו היא שורה מספר 4. בגלל שיש לנו 5 שורות הן מתחילות מ-0 עד 4. לאחר מכן העמודה האחרונה והעמודה באינדקס מספר 6.
מפני שיש לנו 7 עמודות הן מתחילות מ-0 עד 6. ופה בואו נכניס לדוגמה את המספר 200 ונדפיס מטריקס במיקום 4 עד 6 ואנחנו הולכים לראות 200. איך כל הסיפור הזה נראה בזיכרון?
ואנחנו רואים שיש לנו מטריצה בגודל חמש שורות ושבע עמודות. ציירתי אותה פה במסמך הדוקימנט הזה, ואנחנו רואים שזה בעצם מה שנפתח לנו בזיכרון.
יש לנו אחת, שתיים, שלוש, ארבע, חמש שורות, ויש לנו אחת, שתיים, שלוש, ארבע, חמש, שש, שבע עמודות. אינדקסים.
לכל תא כמובן יש שני אינדקסים, מספר השורה ומספר העמודה. האינדקס מתחילים 0 עד 4 בשורות, עד 6 בעמודות אם אנחנו עכשיו בתוכנית כותבים לדוגמא matrix במיקום 2 על 4 ומכניסים לתוכו 90 אז בעצם מה שקורה זה שהמערכת הולכת לשורה שהאינדקס שלה הוא 2 זאת השורה הזאת ועמודה שהאינדקס שלה זה 4 זה העמודה הזאת ומכניסה 90 בתוך העמודה הזאת אם
אנחנו לאחר מכן מכניסים console נקודה right מטריקס במיקום 2 על 4 אז המערכת הולכת בדיוק לתא הזה מוציאה את התוכן שלו ומציגה אותו.
אנחנו כמובן יכולים להתייחס לכל אחד מהתאים כאילו שהוא אינטג'ר. אם היינו רושמים int num שווה מטריקס במיקום 2 על 4 אז כמובן המערכת הייתה הולכת מוציאה את ה-90 הזה ומכניסה אותו לתוך המשתנה num שהגדרנו פה.
אז ככה בעצם נראית המטריצה בזיכרון, מעין טבלה שבה יש שורות ועמודות ואנחנו יכולים לגשת לכל אחד מהתאים על ידי האינדקס קודם כל של השורה שבו הוא נמצא החל מאפס ולאחר מכן על ידי האינדקס של העמודה שבו הוא נמצא החל מאפס.
בואו נעשה משהו עם המטריצה הזאת. בואו נלך וניצור לנו מטריצה שתוכל להחזיק את לוח הכפל, נהתחל אותה באיזושהי פונקציה ולאחר מכן נדפיס אותה בפונקציה.
כאן אנחנו הולכים לראות איך אנחנו יכולים לשלוח לפונקציה מטריצה בכדי שהפונקציה תאכל אותה בערכים ולשלוח את המטריצה שוב לפונקציה בכדי שהפונקציה תדפיס את הערכים.
אז בואו נבנה כאן מטריצה, נקרא לה Multiplication Board, לוח הכפל. לוח הכפל הוא בגודל 10 על 10. אז בואו נניח שאנחנו בונים תוכנה לילדים שמאמנת את לוח הכפל ואנחנו רוצים בהמון מקומות להשתמש עם לוח הכפל.
לוח הכפל הוא מידע טבלאי ולכן נכון לשמור אותו בתוך מטריצה אז יש לנו פה את האובייקט של המטריצה בואו נייצר פונקציה שקודם כל מציגה מטריצה static void print matrix מקבלת int בצורה כזאת matrix עכשיו שימו לב שכאשר אנחנו מקבלים את המטריצה יש פה אותו סיפור כמו של אינטג'ר מערך אינטג'רית אנחנו לא
יכולים לרשום פה new כמו בהגדרה שלנו אז איך אנחנו בעצם רצים ומציגים את המטריצה כמידע טבלאי דבר ראשון מה שאנחנו צריכים לראות זה שלמטריצה יש איזושהי פונקציה פנימית שנקראת getLength getLength מקבלת משהו שנקרא dimension dimension זה אותו מספר שמתאר האם אנחנו במספר השורות או האם אנחנו במספר העמודות וזה בעצם המספרים שנמצאים אם אנחנו שנייה אחת נוריד את
זה נחזור לתרגיל הקודם בשביל להבהיר יותר טוב מה זה גט דיימנשן ואנחנו נראה שיש לנו מספר אפשרויות להצגה בואו נציג את matrix.getdimension יותר נכון getlength 0 0 זה המספר שרשמנו פה המספר הראשון במימדים שלה ויהיה 5 בואו נריץ ונראה שקיבלנו 5 בואו נדפיס את
matrix.getlength 1 1 זה המספר השני שהגדרנו אותו, ולכן זה יהיה 7. פיס ונראה 7. עכשיו, למטריצה, בדיוק כמו למערך, יש גם Length.
בואו נראה מה זה ה-Length, ונראה שה-Length זה 35. ה-Length זה מספר התאים הכולל שיש במטריצה. אז יש לנו אפשרות להגיע למספר התאים הכולל שיש במטריצה, למספר השורות על ידי Get Length 0, או למספר העמודות על ידי Get Length 1. בדרך כלל מספר התאים במטריצה לא זה ממש יעזור לנו אם אנחנו רוצים לסרוק את כל המטריצה שורות ועמודות.
בואו נחזור בחזרה לפונקציה שבנינו מקודם, ועכשיו אנחנו רוצים לרוץ בלולאת 4 עד matrix.getLength של 0, פה אנחנו רוצים את מספר השורות.
לאחר מכן אנחנו רוצים עוד לולאה מקוננת, אבל הפעם היא רצה על משתנה לולאת j, אנחנו לא יכולים כבר להשתמש ב-i. אנחנו רוצים עד ל-matrix, נקודה get length 1. זאת אומרת שאנחנו רצים על העמודות.
הלולאה הפנימית בהתאם ללולאה המקוננת מתחילה כל פעם מההתחלה j שווה 0 ורצה עד מספר העמודות. זאת אומרת שאם בלולאה הפנימית אנחנו פשוט מאוד רושמים console right line נניח מרווחים של 4. מטריקס במיקום i פסיק j אנחנו הולכים