Wechselgeld 5 besten Kombinationen



  • @Wade1234
    Arbeite so gut wie immer nur in der main und weiß daher nicht, wie ich das machen soll.
    Ich google mal ein bisschen und probier aus, danke. 🙂



  • @Wade1234 sagte in Wechselgeld 5 besten Kombinationen:

    ja es ist nötig, die unterschiede zwischen iterativer (schnell aber aufwändig zu programmieren) und rekursiver (langsam aber relativ einfach zu programmieren) lösungsfindung aufzuzeigen. oder schämst du dich für das schlechte beispiel, das du da abgeliefert hattest?

    Nein, ist es nicht, weil dein Code unabhängig von rekursiv und iterativ Kacke ist. Es gibt in beiden Varianten gute Lösungen und deine ist einfach nur schlecht!



  • @TGGC mein code war trotzdem schneller, als deiner. wenn ich das richtig in erinnerung habe, so um den faktor 16. kacke hin oder her.

    die iterative lösung wäre übrigens auch in diesem fall schon lange programmiert gewesen.🙄 also es soll im praktischen leben ja mal vorkommen, dass man auch tatsächlich mal rechenergebnisse haben möchte und nicht einfach nur eine 1 mit sternchen für den tollsten lösungsweg.



  • Alsooo... leider bekomme ich es nicht hin, das i in werte zu initialisieren oder wie auch immer.



  • @codinglea womit willst du es denn überhaupt initialisieren? bzw. was soll die funktion machen und was soll das i da eigentlich bewirken?



  • @Wade1234
    Die Funktion ist ja dazu da, dass die Möglichkeiten einmal durchgegangen werden und dafür brauche ich ja das i, um die Arraypositionen abzuklappern.



  • @codinglea achso. also in dem beispiel, das ich dir gegeben habe (welches übrigens nur das beste ergebnis liefert) wurde aber am anfang mit dem kleinsten geldwert verglichen, um zu überprüfen, ob der (rest-) geldbetrag überhaupt noch vollständig ausgezahlt werden kann. da kam gar kein i drin vor. also bezogen auf zeile 8 in dem code von dir.



  • @Wade1234 Der Code ist Kacke und hat in einem Thread wo Anfänger fragen wie man sowas macht einfach nix verloren. Ganz egal wie schneller läuft.



  • @Wade1234
    Ohh man... irgendwie bekomme ich die Aufgabe nicht hin. Ich lass die wohl aus... 🙁

    Ich muss die Aufgabe morgen vorzeigen und ich weiß leider nicht, wie ich eine Funktion rekursiv darstelle. Die muss ja mehrere Möglichkeiten ausgeben können. Mit Brute Force bin ich leider gescheitert...



  • @codinglea sagte in Wechselgeld 5 besten Kombinationen:

    @Wade1234
    Mit Brute Force bin ich leider gescheitert...

    was hast du da denn versucht?



  • @Wade1234
    Ich habe versucht, mit Brute Force die Möglichkeiten zu erstellen. Aber leider erfolglos.
    Ich schicke sonst mal den Code dafür rein.



  • @codinglea sagte in Wechselgeld 5 besten Kombinationen:

    @Wade1234
    Ich schicke sonst mal den Code dafür rein.

    das meinte ich ja auch. 🙄



  • Nicht lachen! 😀

    #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);
                                                                        }
                                                                     }
                                                                 }
                                                             }
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         return 0;
    }
    
    


  • @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.