שאלות מחברת רדווין ב-c++

[eminemm]

היי, הייתי שבוע שעבר בראיון בחברץ רדווין היו מספר שאלות ב-c++: אודה למי שיפתור את השאלה הזו:
1. בנה מנהל זיכרון מבוסס רשימה משורשרת של אלמנטים:כל אלמנט מכיל זיכרון של 100 בתים
ו-header בו סימון כמה מאוכלסים מב-100
ומצביע לאמנט הבא. מנהל יתמוך ב-allocate ו-free

[אבי]

אתה יכול לפרט שאלות נוספות מהראיון?

[eminemm]

1. הייתה שאלה שצריך לציין מהם 3 המאיפיינים של oop ולתת דוגמא
2. הייתה שאלה שבה מופיע טקסט ובו היה צריך לציין לפחות 10 בעיות בטקסט ,כלומר בקטע קוד מבחינת OOP ,תקינות קידוד
3. הייתה שאלה שבה נתון
פונקציה
למשל:
int convertnum2string(int number,char* str){
switch(number){
case 0:
strcpy(str,"zero"));
break;
.
.
.case 9:
strcpy(str,"nine");
break;
}
ואז ביקשו לכתוב פו' יעילה יותר המחשבת אותה פונקציונליות

זה מה שאני זוכר

[דילברט]

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

[דילברט]

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

[דילברט]

קוד: בחר הכל

#include <stdio.h>


typedef unsigned char byte;

typedef struct _node_
{
   int size;
    _node_ *next;
   byte mem[100];
}node;

class MemMngr
{
private:
   node *list;
public:
   MemMngr()
   {
      list = 0;
      for (int i=0; i<3; i++)
      {
         node *elem = (node*)malloc(sizeof(node));
         elem->size = 0;
         elem->next = list;
         list = elem;
      }
   }
   ~MemMngr()
   {
      while (list)
      {
         node *head = list->next;
         free(list);
         list = head;
      }
   }
   void* mem_alloc(int sz)
   {
      void *ptr = 0;
      if (list && (sz>0) && (sz<=100))
      {
         node *elem = list;
         list = list->next;
         elem->size = sz;
         for (int i=0; i<100; i++)
            elem->mem[i] = '1';
         ptr = elem->mem;
      }
      return ptr;
   }
   void mem_free(void *ptr)
   {
      if (ptr)
      {
         node *elem = (node*)((byte*)ptr-sizeof(int)-sizeof(node*));
         elem->size = 0;
         elem->next = list;
         for (int i=0; i<100; i++)
            elem->mem[i] = '0';
         list = elem;
      }
   }
};

int main(int argc, char **argv)
{
   MemMngr MM;
   void *my_ptr1 = MM.mem_alloc(100);
   void *my_ptr2 = MM.mem_alloc(100);
   void *my_ptr3 = MM.mem_alloc(100);
   void *my_ptr4 = MM.mem_alloc(100);
   MM.mem_free(my_ptr1);
   MM.mem_free(my_ptr2);
   MM.mem_free(my_ptr3);


   return 0;
}

[אורח]

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

למישהו יש תשובה לזה? או כיוון..?

אני אישית לא למדתי design patterns אז ככה שאני לא כ"כ יודע מה זה אומר

תודה מראש..

[_ohho_]

דוגמה והסבר למכונת מצבים:

http://www.mh2000.co.il/articles/update ... attern.pdf

[רון]

[quote="eminemm"]1. הייתה שאלה שצריך לציין מהם 3 המאיפיינים של oop ולתת דוגמא
2. הייתה שאלה שבה מופיע טקסט ובו היה צריך לציין לפחות 10 בעיות בטקסט ,כלומר בקטע קוד מבחינת OOP ,תקינות קידוד
3. הייתה שאלה שבה נתון
פונקציה
למשל:
int convertnum2string(int number,char* str){
switch(number){
case 0:
strcpy(str,"zero"));
break;
.
.
.case 9:
strcpy(str,"nine");
break;
}
ואז ביקשו לכתוב פו' יעילה יותר המחשבת אותה פונקציונליות

זה מה שאני זוכר[/quote]

מהם שלושת המאפיינים של OOP? אני יודע מה זה אבל דווקא שלושה מאפיינים? ומה הבעיה עם היעילות של הפוקנציה? רוצים שנבטל את הסוויצ'?

[ביזיון]

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

[תומר28]

[quote="דילברט"]נא לתאר NAT - מה המטרה, כיצד זה עובד / מה האלגוריתם, מה המבנה נתונים שמשתמשים בו.
לאחר מכן לכתוב קוד קצר ב C שמדגים זאת.[/quote]

למישהו יש דוגמא של מימוש NAT

[רעננית]

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

תודה מראש.

[admin]

שאלות בנושאי תוכנה ראדווין , שייכים לקבוצת RAD ‏2/03/2010

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

פתרון

הדרך הראשונה:

יוצרים רשימה משורשרת חדשה סדר גודל N! –
מתחילים מהראש של הרשימה הנתונה ומכניסים את הכתובת של אותה רשומה לרשימה החדשה, מתקדמים לרשימה הבאה ועושים את אותו דבר.
לפני שעוברים לרשומה הבאה רצים על כל הרשומה החדשה לראות אם ה-NEXT
של הרשומה הנוכחית כבר מופיע ברשימה החדשה. אם לא, עוברים הלאה ואם כן אז עוצרים ויודעים שהיא מעגלית. אם מגיעים ל-NULL מתישהו אז יודעים שהיא לא מעגלית.

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

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

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

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

פתרון נוסף :

מאוד דומה אבל קצר יותר.
סוכמים את האיברי המערך.
סכמום צריך לצאת :
1 +2 +3 + ... + N
ונקרא לסכום זה Sum.

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

המספר החסר, נקרא לו
K
הוא בדיוק:
K = Sum - newSum


סיבוך של השאלה הקודמת
אותו דבר רק שמוציאים שני איברים

פתרון
כשרצים על המערך, גם מסכמים וגם מכפילים בנפרד את האיברים. בסוף מחשבים את הסכום והמכפלה שהיתה אמורה להיות, ואז יש פשוט 2 משוואות עם שני נעלמים:
a+b=s
a*b=p


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

לשאלה זו מספר דרכי פתרון.
פתרון אחד מביניהם:
לעבור על המחרוזת הראשונה מביניהם.
בכל מקום בו מופיעה הספרה אפס, נוסיף עוד אפס אחד.
נניח המחרוזת הייתה: 100010010
כעת היא תהיה: 100001000100
כלומר, לא יהיה 0 שעומד לבדו.
כעת את המחרוזת החדשה נבנה מהמחרוזת הישנה, ונוסיף בסופה 101 (ע"מ לוודא בידוד של האפס היחיד הראשון במחרוזת, שיסמן על ההפרדה בין המחרוזות).
כעת נחבר לסוף המחרוזת את המחרוזת השנייה.
אם המחרוזת השנייה הייתה: 10111, והראשונה הייתה: 100010010 והשתנתה להיות 100001000100,
המחרוזת המאוחדת תהיה:
10000100010010110111.


בהצלחה !