Wechselgeld 5 besten Kombinationen
-
@codinglea Hast du schon mal was von "Array" gehört? Das kann doch niemand ernsthaft lesen und überprüfen. Und was, wenn du jetzt keinen 20-Schein mehr hast? Oder wenn ein neuer 30er-Schein eingeführt wird?
-
@wob
Ja, habe ich wieso?Ich habe davon nun mal noch nicht allzu viel Ahnung, sonst hätte ich mich wohl auch nicht hier im Forum gemeldet, oder?
-
@codinglea sagte in Wechselgeld 5 besten Kombinationen:
@wob
Ja, habe ich wieso?Wenn du Variablen hast, die a_wert, b_wert, ..., l_wert, m_wert heißen, meinst du nicht, dass du dann logisch gesehen ein Array von Wert hast?
Also:
int werte[] = {50000, 20000, 10000, ..., 5, 2, 1};
-
@wob
Ja, trotzdem weiß ich nicht, wie ich das lösen kann.Die Werte habe ich ja schon im Array definiert am Anfang für das erste Ergebnis.
-
@codinglea ja das ist halt ein grund, warum man bei sowas rekursiv arbeitet. aber es funktioniert grundsätzlich schonmal, wenn du die schleife in zeile 130 rausnimmst:
#include <stdio.h> #include <stdlib.h> int main() { int betrag; float gbetrag; printf("Geben Sie einen Betrag zwischen 0.01 & 100000.00 ein: "); // Abfrage Geldbetrag scanf("%f", &gbetrag); betrag = gbetrag*100.0001; // Geldbetrag anpassen an das Array (Geldwert) int o, n, m, l, k, j, i, h, g, f, e, d, c, b, a; int o_wert= 50000, n_wert = 20000, m_wert = 10000, l_wert = 5000, k_wert = 2000, j_wert = 1000, i_wert = 500, h_wert = 200, g_wert = 100, f_wert = 50, e_wert = 20, d_wert = 10, c_wert = 5, b_wert = 2, a_wert = 1; int max_o, max_n, max_m, max_l, max_k, max_j, max_i, max_h, max_g, max_f, max_e, max_d, max_c, max_b, max_a; int ergo, ergn, ergm, ergl, ergk, ergj, ergi, ergh, ergg, ergf, erge, ergd, ergc, ergb, erga; max_o = betrag / o_wert; max_n = betrag / n_wert; max_m = betrag / m_wert; max_l = betrag / l_wert; max_k = betrag / k_wert; max_j = betrag / j_wert; max_i = betrag / i_wert; max_h = betrag / h_wert; max_g = betrag / g_wert; max_f = betrag / f_wert; max_e = betrag / e_wert; max_d = betrag / d_wert; max_c = betrag / c_wert; max_b = betrag / b_wert; max_a = betrag / a_wert; for(o = 0; o <= max_o; o++) { for(n = 0; n <= max_n; n++) { if(o*o_wert + n*n_wert > betrag) { break; } for(m = 0; m <= max_m; m++) { if(o*o_wert + n*n_wert + m*m_wert > betrag) { break; } for(l = 0; l <= max_l; l++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert > betrag) { break; } for(k = 0; m <= max_k; k++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert > betrag) { break; } for(j = 0; j <= max_j; j++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert > betrag) { break; } for(i = 0; i <= max_i; i++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert > betrag) { break; } for(h = 0; h <= max_h; h++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert > betrag) { break; } for(g = 0; g <= max_g; g++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert > betrag) { break; } for(f = 0; f <= max_f; f++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert > betrag) { break; } for(e = 0; e <= max_e; e++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert > betrag) { break; } for(d = 0; d <= max_d; d++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert + d*d_wert > betrag) { break; } for(c = 0; c <= max_c; c++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert + d*d_wert + c*c_wert > betrag) { break; } for(b = 0; b <= max_b; b++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert + d*d_wert + c*c_wert + b*b_wert > betrag) { break; } for(a = 0; a <= max_a; a++) { if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert + d*d_wert + c*c_wert + b*b_wert + a*a_wert > betrag) { break; } if(o*o_wert + n*n_wert + m*m_wert + l*l_wert + k*k_wert + j*j_wert + i*i_wert + h*h_wert + g*g_wert + f*f_wert + e*e_wert + d*d_wert + c*c_wert + b*b_wert + a*a_wert == betrag) { ergo = o*o_wert; ergn = n*n_wert; ergm = m*m_wert; ergl = l*l_wert; ergk = k*k_wert; ergj = j*j_wert; ergi = i*i_wert; ergh = h*h_wert; ergg = g*g_wert; ergf = f*f_wert; erge = e*e_wert; ergd = d*d_wert; ergc = c*c_wert; ergb = b*b_wert; erga = a*a_wert; //for(i=0; i<5; i++) //{ printf("%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n%i \n", ergo, ergn, ergm, ergl, ergk, ergj, ergi, ergh, ergg, ergf, erge, ergd, ergc, ergb, erga); getchar(); //hält das programm an, bis return gedrückt wird. //} } } } } } } } } } } } } } } } } return 0; }allerdings werden momentan die schlechtesten ergebnisse angezeigt.
-
@Wade1234
Rekursiv bekomme ich aber leider nicht hin...Wie bekomme ich es den zu den besten Ergebnissen gewechselt?
-
@codinglea bei uns war das so, dass es nur "bestanden" und "nicht bestanden" gab und die lösung an sich war eigentlich egal, solange das ergebnis stimmte.
kurz und knapp gesagt: indem du in der inneren schleife mit dem größten geldwert anfängst und die breaks rausnimmst. er zählt dann erst die 500er, dann die 500er und die 200er usw.
und dann musst du irgendwie noch sicherstellen, dass 5 ergebnisse angezeigt werden.
-
@Wade1234
Ohh nein.. also einmal komplett umkrempeln...
vielen Dank!
-
@codinglea vielleicht musst du es gar nicht komplett umkrempeln.
-
@Wade1234
Öhh.. wieso?
-
@codinglea naja du hast dir doch oben schon die werte angelegt. die musst du doch nur austauschen.
-
@Wade1234
Stimmt.. ist schon spät
hab's getauscht... klappt trotzdem nicht bei 5 als Betrag...
Ich lass es für heute und bastel morgen weiter dran rum.
-
@codinglea es müsste eigentlich klappen, aber weil der rechner ungefähr 1 mrd kombinationen mit 500er scheinen ausprobiert, obwohl von vornherein klar ist, dass das gar nicht passen kann, dauert das ganze halt ewig.
-
@Wade1234
Bei mir hat er da ausgespuckt:
8x 0
5
5x 0
-
@codinglea bei mir rechnet er sich einfach nur tot.
-
@Wade1234 sagte in Wechselgeld 5 besten Kombinationen:
@TGGC mein code war trotzdem schneller, als deiner. wenn ich das richtig in erinnerung habe
Nein.
-
@wob sagte in Wechselgeld 5 besten Kombinationen:
@codinglea Hast du schon mal was von "Array" gehört? Das kann doch niemand ernsthaft lesen und überprüfen. Und was, wenn du jetzt keinen 20-Schein mehr hast? Oder wenn ein neuer 30er-Schein eingeführt wird?
Das hat wade ihm eingeredet. Ist eine Kopie der schrecklichen "Lösung", die er ihm verlinkt hat.
-
@TGGC sagte in Wechselgeld 5 besten Kombinationen:
@wob sagte in Wechselgeld 5 besten Kombinationen:
@codinglea Hast du schon mal was von "Array" gehört? Das kann doch niemand ernsthaft lesen und überprüfen. Und was, wenn du jetzt keinen 20-Schein mehr hast? Oder wenn ein neuer 30er-Schein eingeführt wird?
Das hat wade ihm eingeredet. Ist eine Kopie der schrecklichen "Lösung", die er ihm verlinkt hat.
tja die art und weise, in der jemand nach 2 monaten programmieren kann, unterscheidet sich eben etwas von der, in der jemand nach 5 jahren programmieren kann, aber das raffen manche ja nicht.
ps: ihr
-
@Wade1234 sagte in Wechselgeld 5 besten Kombinationen:
tja die art und weise, in der jemand nach 2 monaten programmieren kann, unterscheidet sich eben etwas von der, in der jemand nach 5 jahren programmieren kann, aber das raffen manche ja nicht.
Verarscht du dich grad selbst oder wie wird da ein Schuh draus?
-
@hustbaer sagte in Wechselgeld 5 besten Kombinationen:
@Wade1234 sagte in Wechselgeld 5 besten Kombinationen:
tja die art und weise, in der jemand nach 2 monaten programmieren kann, unterscheidet sich eben etwas von der, in der jemand nach 5 jahren programmieren kann, aber das raffen manche ja nicht.
Verarscht du dich grad selbst oder wie wird da ein Schuh draus?
naja
- rekursion ist ein thema für fortgeschrittene
- die erfahrung, dass da 15 schleifen verschachtelt werden, dürfte nicht unwichtig sein
- erst "schlecht" programmieren und sich dann "verbessern" ist deutlich motivierender, als alles von vornherein "perfekt" machen zu müssen
- aus den 15 verschachtelten schleifen lässt sich die rekursionsvorschrift ganz toll ablesen
