נתונים שני מערכים A ו- B באותו הגודל N. את N עליך להגדיר עם הוראת #define.

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

אילוצים:

אסור למיין את המערכים.

הגדר את המערכים כך:

int A[N]={1,5,5,2,-3};

int B[N]={5,1,5,-3,2};

הפלט יהיה רק YES אם הם אכן עונים על התנאי, ו-NO אם לא.

(עבור הדוגמא הזו שאיתה עליך לעבוד הפלט יהיה YES.)

יש רעיונות?

BOOL xexist=TRUE;

for (i=0;i<N;i++)
{
BOOL found=FALSE;

for(ia=0;ia<N;ia++)
{
if(B[ia]==A[i])
found=TRUE;
}

if(found==FALSE)
{
xexist=FALSE;
break;
}
}

if(xexist==TRUE)
//write yes
else
//write no

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

לדוגמא,
A = {1,2,3,3,3}
B = {1,2,1,2,3}
zz
התכנית שלך תחזיר אמת, למרות שאין זה כך.
לפותח האשכול, יש לך הרבה אופציות, שתים מהן זה להשתמש במערכי עזר (למיין בתוכם)
או, לנרמל את המערכים (להחליף כפילויות בNULLים) - ואז לעשות את מה שהבחור מעלי כתב.

Any sufficiently advanced bug is indistinguishable from a feature

לא נראה לי להחליף בNULLים זה רעיון טוב...אחרי הכל יכול להיות איברים שהם 0.
לפי דעתי מה שצריך לעשות זה למיין תוך כדי חיפוש את המערך...משהו כזה:

קוד PHP:

 #include <stdio.h>
#define N 7

int search_from_bottom(int arr[], int until, int num);

int main()
{
    int A[N]={1,5,5,2,-3};
    int B[N]={5,1,5,-3,2};

    int tmp, back_offset=N-1;

    for(int i=0; i<N; ++i)
    {
        tmp=search_from_bottom(B,back_offset,A[i]);
        if(tmp==-1)
            break;
        B[tmp] = B[back_offset--];
    }

    if(i<N)
        printf("NO");
    else
        printf("YES");

}

int search_from_bottom(int *arr, int until, int num)
{
    for(int i=0;i<=until;++i)
        if(arr[i]==num)
            return i;
    return -1;
} 


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

(ם_O........רואה מה אתם גורם לי לעשות?! הכל בגלל שמנהל מסויים *אהמ אהמ* הפסיק לכתוב קודים)

וכשחזרתי זכרתי שהייתי חייב לערוך משהו איפשהו, רק לא זכרתי איפה..
בכל מקרה, במקום לשנות כפילויות לNULLים, כמובן אפשר לעבור על מקסימום N+1 ערכים, לשם הפשטות עוקבים, מביניהם מובטחים k1,k2 שבהתאמה אינם שייכים לA,B וגם כמובן שונים זה מזה.
ולהחליף בהתאמה את הכפילויות בk1,k2.

בכל מקרה, מה שכתבת יותר אלגנטי, נחמד ..
אבל מה, הוא ביקש בלי למיין את A וB, ופה חלק יאמרו שהתכנית שלך לא עונה לקריטריונים ... זה אמנם לא מיון שיחזיר מערך מסודר לפי יחס סדר רגיל, אבל אפשר לומר שזה "מיון יחסית לאיברי A"
(למי שלא קרא את התכנית, הוא בודק עבור כל איברי A אם הם נמצאים בB כאשר הוא מחליף בB את האיבר באינדקס i [זה שכרגע נמצאה לו התאמה בA] באיבר ה1 אחרי המקסימום לחיפוש בקריאה הבאה, בשביל לשמור בתחום החיפוש על כל איברי B שעדיין לא הותאמו לאיבר בA)

מבחינתי זה מתקבל

Any sufficiently advanced bug is indistinguishable from a feature

הכל תירוצים, שמטרתם להסתיר - עצלנות!