Wechselgeld 5 besten Kombinationen


  • Gesperrt

    Dieser Beitrag wurde gelöscht!


  • Ich finde es viel gemeiner, jemanden zur Ausbildung anzustellen und denjenigen dann sich selbst zu überlassen.



  • @titan99_ sagte in Wechselgeld 5 besten Kombinationen:

    @TGGC sagte in Wechselgeld 5 besten Kombinationen:

    dann ist diese ganze Ausbildung Schwachsinn.

    Also das finde ich jetzt zumindest etwas gemein. Mit den Aufnahmeprüfungen und der Suche nach einem Betrieb, ist das glaube ich gar nicht so einfach eine solche Ausbildung zu bekommen. Wenn man dann so offen ist trotzdem sich am C++-Forum zu beteiligen. Sonst würde ich mir zumindest die Frage stellen, was ins Internet gehört und was nicht.

    Es geht nicht ums Forum, ich bestreite nicht, das man hier was lernen kann. Ich sagte das diese Art Ausbildung die Person nicht weiterbringt. Selbststudium kann man auch einfach so anfangen.


  • Gesperrt

    Dieser Beitrag wurde gelöscht!


  • @codinglea läuft es denn jetzt? wenn nein: hast du mal den debugger drüber laufen lassen?



  • @Wade1234 @codinglea
    Die Frage ist für mich eher: Wenn man Anfänger ist, und ein Erfahrener Entwickler zeigt einem Code ala "so macht man das"/"so kann man das machen"...
    Also ich würde da davon ausgehen dass man sich als Anfänger dann denkt "aha, so macht man das also". Und zwar genau so. Inklusive den 1-Buchstaben Variablennamen und was sonst noch schlecht ist an dem Code. Weil wieso sollte der mir als Anfänger Code zeigen wo ein paar Dinge gut sind aber andere total schlecht. Speziell ohne Erklärung dazu was gut ist und was schlecht -- bzw. wozu überhaupt Code herzeigen der in der Form niemals in einem Projekt landen sollte? Weil woher soll ich als Anfänger das wissen?



  • @Wade1234
    Nope... mach ich.



  • @hustbaer das kann man doch alles später noch mit arrays, unterfunktionen, einrückungen, tollen (und vor allem englischen) variablennamen usw. machen, nachdem das prinzip "iterative berechnung" verstanden wurde.

    berufsausbildungen gehen nicht zum spaß über 3 bzw. 3,5 jahre, auch wenn es heutzutage eher üblich ist, irgendwelche arbeitslosen mathematiker oder physiker mal eben so in 2 wochen anzulernen, ist man irgendwie selbst schuld, wenn man jemanden vor dem 3 ausbildungsjahr irgendwo am projekt mitarbeiten lässt.



  • Die Werte sind nicht richtig definiert, d.h. es kommen Zahlen raus wie zum Beispiel 8195224, 6356536 ...
    Kam beim Debugger raus.
    Und bei der Ausgabe durch Build and Run : paar 0 und einmal 5 und wieder paar 0 und 1x 1 und 1x 4. (wenn der Betrag 5 lautet)



  • @codinglea dann müsstest du jetzt mal gucken, ob da bei den berechnungen der werte irgendwas nicht stimmt.



  • @Wade1234 sagte in Wechselgeld 5 besten Kombinationen:

    @hustbaer das kann man doch alles später noch mit arrays, unterfunktionen, einrückungen, tollen (und vor allem englischen) variablennamen usw. machen, nachdem das prinzip "iterative berechnung" verstanden wurde.
    (...)

    Ja, klar. Aber ich verstehe trotzdem nicht wieso man es erstmal schlecht herzeigt. Zumindest nicht in einem Forum, wo diese späteren Schritte dann meist nicht mehr gezeigt/erklärt/begleitet werden. In einer Ausbildung mag das Sinn machen, z.B. schonmal um den Benefit zu demonstrieren, zu zeigen was "refactoring" ist und wie man einen qualmenden Haufen Exkrement Schritt für Schritt in guten, übersichtlichen Code verwandeln kann. Ohne "Big Bang" wo man alles neu macht, und dabei Gefahr läuft einen Haufen böse Bugs einzubauen.

    Aber wie gesagt in einem Forum... das ist es halt meist doch eher "wie geht das?" -> "so geht das" -> "ah OK danke und tschüss" - und weiter geht es nicht. Und dann finde ich es halt nicht gut wenn das "so geht das" Code ist der voll mit "bad practices" ist.


  • Gesperrt

    @codinglea Wie sieht dein Code bis jetzt aus?



  • #include <stdio.h>
    #include <stdlib.h>
    
    
    int main()
    {
        int betrag;
    
        int o, n, m, l, k, j, i, h, g, f, e, d, c, b, a;
        int o_wert= 1, n_wert = 2, m_wert = 5, l_wert = 10, k_wert = 20, j_wert = 50, i_wert = 100, h_wert = 200, g_wert = 500, f_wert = 1000, e_wert = 2000, d_wert = 5000, c_wert = 10000, b_wert = 20000, a_wert = 50000;
        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++)
             {
                 for(m = 0; m <= max_m; m++)
                 {
                     for(l = 0; l <= max_l; l++)
                     {
                         for(k = 0; m <= max_k; k++)
                         {
                             for(j = 0; j <= max_j; j++)
                             {
                                 for(i = 0; i <= max_i; i++)
                                 {
                                     for(h = 0; h <= max_h; h++)
                                     {
                                         for(g = 0; g <= max_g; g++)
                                         {
                                             for(f = 0; f <= max_f; f++)
                                             {
                                                 for(e = 0; e <= max_e; e++)
                                                 {
                                                     for(d = 0; d <= max_d; d++)
                                                     {
                                                         for(c = 0; c <= max_c; c++)
                                                         {
                                                             for(b = 0; b <= max_b; b++)
                                                             {
                                                                 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)
                                                                     {
                                                                     }
                                                                     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;
    
                                                                         //getchar();
                                                                        //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();
                                                                        //}
                                                                     }
                                                                 }
                                                             }
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
    
    
        return 0;
    }
    


  • lol



  • ???



  • Hast Du es schon mal mit einem Buch versucht?



  • @codinglea
    Wau! Einen Algorithmus mit der Komplexität von O(n^12) habe ich schon lange nicht mehr gesehen. Ist dein Betrag 50000, so berechnest du 50000*(50000/2)(50000/5)... = 50000^12/(1 * 2 * 5 * 10...) = 2.441410^21 = 2441406000000000000000 mal die Summe a * a_wert + .... Das ist etwas zuviel für jeden Rechner.

    Es heißt doch in der Aufgabe "Gib , wie beim Geldautomaten, eine Liste der 5 besten Kombinationen aus". Ei alla hopp, ich würde das als "Es gibt keinen 500€, 200€, 100€, 50€" Schein interpretieren. Und schon kannst du deinen Eingangscode wiederverwenden. Hauptsache du fängst bei der Berechnung immer mit dem größtmöglichen Schein/Geldstück an.

    PS:
    Hast du eine Ahnung wie grausam eine Verschachtelungstiefe von mehr als 5 ist, wenn man keinen Editor mit Syntax-Highlighting hat? Da sind Fehler vorprogrammiert.


  • Gesperrt

    @codinglea sagte in Wechselgeld 5 besten Kombinationen:

    ???

    Das ist ja schlimmer, als ich annahm, meinte er damit. 😃

    Ich meld mich später, muss jetzt erst weg, du kannst mir auch eine PN schreiben.



  • @codinglea sagte in Wechselgeld 5 besten Kombinationen:

    ???

    Naja das ist - ganz abgesehen davon dass es vermutlich relativ langsam sein wird - ein Paradebeispiel dafür was ich hier die ganze Zeit predige. Also nicht dafür wie man es machen sollte sondern wie man es nicht machen sollte.

    ps: Aber es geht natürlich noch viel schlimmer. Also dein Code ist nicht "maximal schlimm" - nur "sehr schlimm" 🙂



  • @Quiche-Lorraine

    Hauptsache du fängst bei der Berechnung immer mit dem größtmöglichen Schein/Geldstück an.

    Naja, der Teil sollte schon hinhauen. Sie rechnet ja das Limit für alle möglichen Scheine getrennt aus. Aber es werden trotzdem viel zu viele Möglichkeiten gecheckt die man mit einem anderen Algorithmus früher ausschliessen könnte.

    Dafür produziert der Algorithmus zumindest keine Duplikate.