חברים מישהו היה בראיון לאחרונה ב IMPERVA למשרת פיתוח ב C ?? יכול לספר מה שואלים ??

מי שהיה יכול לעדכן על השאלות שנשאלו ב-C? תודה!

יש למישהו מושג מה שואלים לאחרונה למשרה של C?? תודה רבה!! ובנוסף, מה שאלו ב HR? (תכונות טובות רעות? תוכלו להרחיב?) תודה

אני מתראיין למשרת פיתוח Java , client server מה שואלים? על מה כדאי לעבור? תודה מראש

היי לכולם, יש לי ראיון בקרוב מאוד בחברת imperva. אשמח מאוד אם מישהו ישתף אותי בשאלות ששאלו אותו הן בHR והן בנושאים מקצועיים יותר. תודה מראש לעונים

תודה רבה !

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace ConsoleApplication7 { class Program { static int a = 0; static void Main(string[] args) { Thread thread1 = new Thread(for_func); Thread thread2 = new Thread(for_func); thread1.Start(); thread2.Start(); Console.WriteLine(a.ToString()); Console.ReadLine(); } static void for_func() { for (int i = 0; i < 10; i++) { a++; } } } } זה נותן תוצאות בין 0 ל20. כנראה שהתשובה כאן לא ממש נכונה... אידיוט, אתה מציג את a בלי לחכות לסיום הלולאות. אתה בכלל לא מחכה ששני ה Threads יסימו את פעולתם. אני מציע לך לחזור על החומר של תכנות ב C#, או לחפש מקצוע אחר. תנסה לכתוב את הקוד כך שרק לאחר ששני ה Threads סימו את פעולתם הצגת הערך של a תתבצע (למשל ע"י Code Blocking, שימוש ב Delegates, שימוש ב Events, שימוש ב Parallel או ב Tasks של C# 4.0)

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

שאלת המשך: איך לתקן קוד כדי תמיד לקבל 20? בהנחה שמשתנה הלולאה הוא לוקלי אז הגנה על קריאה/כתיבה למשתנה הסטטי בעזרת mutex יספיק. אופציה נוספת היא להגדיר אותו כ-volatile ו/או להשתמש בפעולות test and increment אטומיות.

לדעתי הדרך נכונה אך המספר הסופי שגוי שכן אם T1 אכן כבר הגיע ל 10 אז כבר בעצם הגענו לתשובה. בעצם הסידרה היא T1 עולה ב9 ואז T2 עולה ב1 כלומר T2 ממשיך בשלו 10 פעמים ו T1 כול פעם עולה מהנקודה בה T2 נעצר עד 10 { 9+1,8+1,7+1,6+1,5+1,4+1...} = 55 וכול זה בהנחה שהמשתנה בלולאה הוא לא volatile

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

לא נתון בשום מקום ש i הוא סטטי, אלא רק ש a סטטי. ולכן כל Thread ירוץ על בתוך הלולאה 10 פעמים. המקרה האידאלי הוא שאין שום התנגשות בין ה Threads ואז ערכו של a יהיה 20. במקרה הגרוע ביותר: 1) Thread1 קורא את הערך של a, כלומר 0 2) Thread2 קורא את הערך של a כלומר 0 3) Thread2 מתחיל לרוץ על הלולאה ורק עליה 9 פעמים, כלומר ערכו של a הוא עכשיו 9 4) Thread1 מבצע a = a + 1 אבל משתמש בערך שנקרא בסעיף 1, ולכן ערכו של a הוא 1 5) Thread2 קורא את הערך החדש של a כלומר 6) Thread1 ממשיך לרוץ על הלולאה ולבצע a++ עוד 9 פעמים (ובכך מסיים את פעולתו) 7) Thread2 מבצע a = a + 1 ומסיים את הריצה האחרונה בתוחך הלולאה ומכניס את הערך 2 לתוך a כלומר בתשובה לשאלה היא שערכו של a ינוע בין 2 ל-20 במקרה ש i כן סטטי, אז המקרה הגרוע ביותר הוא כש: 1) Thread1 קרא את ערכו של a, כלומר 0 2) Thread2 רץ 10 פעמים על הלולאה וקידם את את i לערך 10 3) Thread1 מבצע a = a + 1 תוך שימוש בערך a שנקרא בהתחלה. 4) Thread1 מגיע לשלב של בדיקת תנאי המשך קיום הלולאה (במקרה הזה ערכו של i יהיה 11 ולכן Thread1 יצא מהלולאה) לכן ערכו של a יהיה במקרה זה 1 אבל, במקרה זה, הערך המקסימאלי של a אינו 20, אמחיש זאת ע"י הדוגמא הבאה: 1) Thread1 רץ פעם אחת על הלולאה ובסופה מגיעה לשלב ש i צריך להיות מקודם באחד. לכן ערכו של a עכשיו הוא 1 וערכו של i (שבפתרון הזה הוא גם סטטי) עדיין 0. ערכו של i נקרא לקראת קידומו 2) Thread2 מתחיל לרוץ על הלולאה. הוא רץ עליה 10 פעמים ולכן מקדם את a ב-10. Thread2 מגיע לשלב בו הוא צריך לבצע i++ ומקדם את הערך של i ל-10 (אך עדיין לא מבצע את בדיקת התנאי) 3) Thread1 מסיים את שהתחיל, כלומר מבצע i++ ורושם את הערך 1 לתוך i ערכו של a עכשיו הוא 11 וערכו של i הוא 1 4) עכשיו שוב Thread1 רץ פעם אחת על הלולאה, מקדם את a באחד וקורא את הערך של i (כלומר 1) 5) Thread2 בודק את התנאי של הלולאה... הוא מתקיים מכיוון שערכו של i עכשיו הוא 1 6) Thread2 רץ על הלולאה 9 פעמים וכו וכו... יש פה סדרה חשבונית: 11+10+9+8+7+6+5+4+3+2 שבעצם מורכבת מ: 10 + 1 9 + 1 8 + 1 (כאשר ה-1 זה הקידום שמבוצע ע"י Thread1 והמספר השני הוא מה ש Thread2 קידם באותו מחזור). ובסופו של דבר מתסקלת התוצאה המקסימאלית של a= 65 אבל כאמור, לא נאמר בשום מקום ש i הוא סטטי, ולכן במקרה זה ההתייחסות היא לפתרון הראשון שנתתי, כלומר a נע בין 2 ל 20.

היי לא נכון , מיכאל אתה סתם מתחזה ממש לא יפה, אין שום ראש צוות בשם מיכאל בחברה!!!!!

נכון מאוד, אם i הוא סטטי. אם i הוא לא סטטי, התשובה שונה (אבל עדיין, הערך המינימלי קטן מ- 5).

הבנתי את התשובה שלך, והיא לא נכונה. אם באמת חשוב לך להשתכנע ולהבין למה: 1. תכתוב תוכנה פשוטה שעושה את זה. 2. תוסיף הדפסות של ערכי המשתנים בכל שלב. תריץ אותה מספיק פעמים, ותנסה להבין מה קרה במקרים שבהם a קטן מ- 5.

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

מהנדס תוכנה, אם כך האם אתה מוכן להאיר את עינינו באשר לתשובה הנכונה?

מדוע לא בין 10 ל 20 ? נניח שהלולאה המדוברת היא מסוג כזה: for (int i=0; i<10; i++) { a++; } מתי תבוצע הלולאה מספר מינימלי של פעמים? כאשר כל חוט יבצע את עדכון מונה הלולאה לאחר שהחוט השני _סיים_ לעדכן את המונה. למשל, בתחילת הריצה: חוט1 מבצע ++i i מקודם לערך 1 וערכו _נכתב_ חוט2 מבצע i++ i מקודם לערך 2 וערכו _נכתב_ וכך הלאה... בצורה כזו כל חוט יבצע את גוף הלולאה 5 פעמים. עכשיו, בנוגע לקידום של a: אם החוטים יגשו אל a בצורה הפוכה למה שתואר קודם, כלומר כל חוט יקדם את a לפני שערכו נכתב כתוצאה מהקידום של החוט השני, נקבל שבכל איטרציה של הלולאה a יקודם רק ב-1 אף על פי ששני חוטים מקדמים אותו, כלומר ערכו הסופי 5.

לדעתי הטווח של a הוא בין 5 ל 20

מישהו יודע את התשובה הנכונה (בוודאות)?

חברה מעולה.

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