מדובר בקוד של כספומט,
יש מערך ובו 3 תאים, בתא הראשון יש מספר שטרות של 20 בתא השני יש מספר שטרות של 50 ובתא השלישי יש מספר שטרות של 100.
צריך לבנות פרוצדורה שתקבל סכום כלשהו שרוצים "למשוך". הפרוצדורה צריכה "להוציא" כסף-לעדכן את המערך בשטרות שהוצאו (צריך להוציא כמה שפחות שטרות. לדוגמה: אם רוצים להוציא 120 הפרוצדורה תשתמש בשטר אחד של 100 ובשטר אחד של 20 ורק אם אין ברירה וחסר שטרות של 100 הפרוצדורה תשתמש ב2 שטרות של 50 ושטר אחד של 20).
ניסיתי לעשות את זה אבל יש מלא תנאים ומלא מצבים ואני לא יודע מאיפה להתחיל. מישהו יכול לעשות לי את זה?
תודה מראש

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

קוד:

int arr[N][2]={{...},...,{...}};

כאשר arr[k][0] יאכסן כמה שטרות מסוג k יש,
ו arr[k][1] יאכסן מה ערך השטר מסוג k.

עכשיו, גם אין לך בכלל תנאים, וגם יש לך פתרון כללי
תעשה כך:

קוד PHP:

 #include <stdio.h>
#include <math.h>
#define N 3

int arr[N][2] = {{1,20} , {8,50} , {1,100} };

int Set(int Amount){
    int howmany;
    for (int i=N-1; i>=0; i--){
        howmany=arr[i][0];
        arr[i][0] = (howmany - Amount/arr[i][1] + fabs((float)howmany-Amount/arr[i][1]))/2;
        Amount = Amount - (howmany-arr[i][0])*arr[i][1];
        }
    return Amount;
}
             

int main(int argc, char *argv[])
{
        int i;
        for (i=0; i<N; i++)
            printf("%d - %d\n", arr[i][1], arr[i][0]);
        printf("\nAFTER...\n\n");
        int HowMuchLeft = Set(420);
        for (i=0; i<N; i++)
            printf("%d - %d\n", arr[i][1], arr[i][0]);
        printf("\nAmount left that cannot be payed with those kinds of coins: %d", HowMuchLeft);       
}
} 


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

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

קוד PHP:

 int Set(int Amount){
    int howmany,shtar;
    for (int i=N-1; i>=0; i--){
        howmany=arr[i];
        if (i==0)
           shtar = 20;
        else if (i==1)
             shtar = 50;
        else
            shtar = 100;
        arr[i] = (howmany - Amount/shtar + fabs((float)howmany-Amount/shtar))/2;
        Amount = Amount - (howmany-arr[i])*shtar;
        }
    return Amount;
} 


Any sufficiently advanced bug is indistinguishable from a feature

התוכנית שלך לא מתמודדת עם מקרים כמו 60 שקל או 80 שקל או 110....

אולי הקומפיילר שלך לא סלחני כמו שלי (אם יש המרה מטיפוס 1 לשני ואז לאותו אחד, הוא כבר עושה אוטומטית כנראה), אז תוסיף (int) לפני הfabs - אחרת אין שום מקור אפשרי לבעיה...התכנית מתמודדת עם כל מקרה.

Any sufficiently advanced bug is indistinguishable from a feature

תוכל רגע להסביר לי את האלגוריתם במקרה של 60 שקל כאשר יש את כל השטרות?
הוא בודק 100, רואה שהוא לוקח 0 שטרות משם....
הוא בודק 50, ולוקח שטר אחד של חמישים....
ואז הוא נשאר עם 10, שאין לו מה לעשות איתם...

במקום 3 שטרות של 20...

או שפספסתי משהו?

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

בשביל לעשות כמו שאתה רוצה, אז פשוט במידה ויש שארית בסוף התכנית, בודקים אם המס' מתחלק ב20 אבל לא ב50, אם כן - וגם יש מספיק שטרות 20 משנים את התוצאה
כנ"ל לגבי100 ו50 (מספ' אי זוגי של 50ים כמובן) ואז על השארית את מה שכתבתי מקודם על ה20ים [ועבור תכנית כללית, בודקים אם המס' מתחלק בכל שטר ולא בכל שטר אחר שאינו כפולה שלו]

Any sufficiently advanced bug is indistinguishable from a feature

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

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

תודה על התגובה. יש רק בעיה אחת קטנה, אני לא יודע C..

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

קוד:

program blah;
const N=3;

var
arr:Array[1..N, 1..2] of integer;
i:integer;

function Set1(Amount:integer):integer;
var
howmany,i:integer;
begin
for i:=N downto 1 do
begin
	howmany:=arr[i,1];
	arr[i,1]:=(howmany - Amount div arr[i,2] + abs(howmany - Amount div arr[i,2])) div 2;
	Amount := Amount - (howmany-arr[i,1])*arr[i,2];
end;
Set1 := Amount;
end;

begin
arr[1,1]:=1;
arr[2,1]:=2;
arr[3,1]:=1;
arr[1,2]:=20;
arr[2,2]:=50;
arr[3,2]:=100;
writeln(Set1(120));
for i:=1 to N do
writeln(arr[i][1]);
end.
end;

Any sufficiently advanced bug is indistinguishable from a feature