Rekursion übergabe der Parameter



  • Hallo Leute, ich sitze gerade vor einer Aufgabe bei welcher es darum geht 3 Gegenstände herzustellen welche jeweils aus 3 verschiedenen Materialien zusammengesetzt sind (anz. der Materialien sind für jeden Gegenstand anders).
    Die Aufgabe soll rekursiv gelöst werden und die Anzahl an verfügbaren Materialien sollen vom Nutzer eingegeben werden.
    Doch wie übergebe ich die Materialien geeignet an die rekursive Funktion? ich bin schon seit Stunden am überlegen aber komme auf keine sinnvolle Lösung...

    Wäre mega wenn mir hier jemand einen Hinweis geben könnte, ich steh nämlich total auf dem Schlauch xD



  • Hier die Aufgabe falls das meine Frage besser erläutert:

    Ein Magier ben¨otigt zum Herstellen verzauberter Waffen und Rustungen 3 ver- ¨
    schiedene Materialien: feuerfeste Drachenhaut, goldene Federn eines Engels und
    magische Essenzen. Je nach Anzahl der eingesetzten verschiedenen Materialien
    entstehen beim Herstellen Gegenst¨ande unterschiedlicher Wertigkeit:
    • Stufe 1: normale Gegenst¨ande, ben¨otigt werden 2 Drachenh¨aute, 1 Feder und
    1 magische Essenz
    • Stufe 2: seltene Gegenst¨ande, ben¨otigt werden 5 Drachenh¨aute, 2 Federn und
    3 magische Essenzen
    • Stufe 3: legend¨are Gegenst¨ande, ben¨otigt werden 8 Drachenh¨aute, 10 Federn
    und 8 magische Essenzen
    Schreiben Sie eine Funktion, die rekursiv die Gesamtanzahl der Gegenst¨ande
    berechnet und zuruckgibt, deren Herstellung aus dem Inventar des Magiers m ¨ ¨oglich
    ist. Die Anzahl der Materialien im Inventar sind vom Nutzer einzulesen und der
    Funktion geeignet zu ubergeben. Es sollen dabei immer m ¨ ¨oglichst viele Gegenst¨ande
    der h¨oheren Wertigkeit entstehen.



  • wie wäre es mit

    std::map<string, int> createItems(int dragonSkins, int goldenFeathers, int magicalEssences)
    


  • Doch wie übergebe ich die Materialien geeignet an die rekursive Funktion?

    Drei ints nehmen f(int drachenhaeute, int federn, int essenzen) ?

    Der letzte Satz der Aufgabe "Es sollen dabei immer möglichst viele Gegenstände der höheren Wertigkeit entstehen." -> dann würde ich doch von höherer bis niedriger Wertigkeit einfach die Anzahl direkt berechnen, ist mir unklar, wie man da Rekursion einbauen soll.

    Ansonsten bekommst du hier keine fertigen Lösungen (zumindest nicht von mir). Was hast du schon geschafft? Woran haperts?



  • Also die Aufgabe MUSS Rekursiv gelöst werden.

    Anfangs habe ich auch alle 3 Parameter übergeben aber dann erschien mir das als eher weniger sinnvoll weil ich ja die Anzahl in der rekursiven Funktion nicht um mehr als 1 verringern kann (oder habe ich da was falsch verstanden?)

    momentan sieht mein Code wie folgt aus:

    #include <iostream>
    #include <fstream>

    using namespace std;

    int main()
    {
    int d,f,e;
    int ng,sg,lg;
    int summe=0;

    cout<<"Anzahl Drachenhaut: ";
    cin>>d;
    cout<<"Anzahl Federn: ";
    cin>>f;
    cout<<"Anzahl Essenz: ";
    cin>>e;
    cout<<endl;

    if(d>=8 && f>=10 && e>=8)
    {
    summe=d+f+e;
    }

    if(d<8&&d>=5 && f<10&&f>=2 && e<8&&e>=3)
    {
    summe=d+f+e;
    }

    if(d<5&&d>=2 && f==1 && e<3&&e>=1)
    {
    summe=d+f+e;
    }

    cout<<summe<<endl;

    return 0;
    }

    Hatte hierbei die Idee der Funktion die Summe zu übergeben aber bin grade unsicher ob das überhaupt irgendwas bringt...



  • Okey ich denke ich hab eine Lösung gefunden:

    #include <iostream>

    using namespace std;

    int magie(int d, int f, int e)
    {
    int anz=0;

    while(d>=8 && f>=10 && e>=8)
    {
    d=d-8;
    f=f-10;
    e=e-8;

    anz++;
    }

    if(d<8&&d>=5 && f<10&&f>=2 && e<8&&e>=3)
    {
    d-=5;
    f-=2;
    e-=3;
    anz++;
    }

    if(d<5&&d>=2 && f==1 && e<3&&e>=1)
    {
    d-=2;
    f-=1;
    e-=1;
    anz++;
    }
    return anz;

    }

    int main()
    {
    int d,f,e;
    int ng,sg,lg;
    int summe=0;

    cout<<"Anzahl Drachenhaut: ";
    cin>>d;
    cout<<"Anzahl Federn: ";
    cin>>f;
    cout<<"Anzahl Essenz: ";
    cin>>e;
    cout<<endl;

    cout<<magie(d,f,e)<<endl;

    return 0;
    }

    das Programm gibt mir zumindest das richtige aus 🙂

    Kann ich den Code viellciht noch irgendwie "verschönern" ?



  • Wo ist das bitte rekursiv?



  • Schlangenmensch schrieb:

    wie wäre es mit

    std::map<string, int> createItems(int dragonSkins, int goldenFeathers, int magicalEssences)
    

    zu magisch. nimm das:

    #include <stdio.h>
    
    int mult (int a, int b, int c)
    {
        int res = a;
        if (b > 1)
            res += mult (a, b-1, c);
        if (c > 1)
            res += mult (a, 1, c-1);
        return res;
    }
    
    int main()
    {
        int a = mult (2,1,1);
        int b = mult (2,5,2);
        int c = mult (10,8,8);
        printf ("%d %d %d\n", a, b, c);
    }
    


  • Oke stimmt, das was ich da fabriziert habe ist hat nichts mit Rekursion zu tuen xD

    Vielen Danke @fricky667 für deine Hilfe !!!! 🙂

    Klappt jetzt super und auch so wie ich mir das eigentlich auch vorgestellt habe 🙂



  • heyyy schrieb:

    Oke stimmt, das was ich da fabriziert habe ist hat nichts mit Rekursion zu tuen xD

    Vielen Danke @fricky667 für deine Hilfe !!!! 🙂

    Keine Ursache. Hast du auch mal den coolen Einzeiler von Schlangenmensch ausprobiert?



  • Fricky667 schrieb:

    heyyy schrieb:

    Oke stimmt, das was ich da fabriziert habe ist hat nichts mit Rekursion zu tuen xD

    Vielen Danke @fricky667 für deine Hilfe !!!! 🙂

    Keine Ursache. Hast du auch mal den coolen Einzeiler von Schlangenmensch ausprobiert?

    Dem noch die Implementierung fehlt? Die Frage ging ja um die Übergabe 😉 Daher habe ich den Rest mal nicht runter geschrieben. Außerdem soll ja auch irgendwo noch die Übung stattfinden...



  • okey warte irgendwie gibt es doch nicht dass aus was es soll.. hab erst grade gepeilt das ich die ganze zeit mein eigenes(nicht rekursives) Programm ausgeführt habe.. (richtig dumm ich weiß)

    aber wenn ich beispielsweiße bei der von dir eingegebenen rekursiven Variante 8, 10 und 8 eingebe, sollte es mir ja 1 zurückgeben aber stattdessen werd 640 ausgegeben 😞

    ach man diese Aufgabe macht mich verrückt 🙄



  • @Schlangenmensch

    Ja klar ich will es ja auch verstehen aber ich bräuchte irgendwie einen Ansatz mit dem ich weiter arbeiten kann 😕 hab in 2 Tagen Prüfung und das ist die Aufgabe einer Altklausur...



  • Das was Fricky hier gepostet hat ist eine rekursive Multiplikation.

    Hier mal als Anstoß eine Möglichkeit die rekursiv berechnet wie viele Items erstellt werden können. Ich habe mal nur die beiden höchstwertigen berücksichtigt, die unterste Stufe einzubauen lasse ich mal als minimal Übung offen.

    int createItems(int dragonSkins, int goldenFeathers, int magicalEssences, int i = 0)
    {
      if (dragonSkins >= 9 && goldenFeathers >= 10 && magicalEssences >= 8) {
        std::cout << "Stufe 3\n";
        return createItems(dragonSkins - 9, goldenFeathers - 10, magicalEssences - 8, ++i);
      }
      else if (dragonSkins >= 5 && goldenFeathers >= 2 && magicalEssences >= 3) {
        std::cout << "Stufe 2\n";
        return createItems(dragonSkins - 5, goldenFeathers - 2, magicalEssences - 3, ++i);
      }  
      return i;
    }
    

    Interessanter wäre natürlich wie viele Items pro Stufe erstellt werden, aber dass ist ja nicht die Aufgabe 😉



  • Mach es so:
    Du prüfst nacheinander von der höchsten Wertigkeit absteigend, ob von allen Materialien genug für die entsprechende Wertigkeit vorhanden sind und reduzierst, wenn es möglich ist, die Parameter. Am Ende rufst du die Funktion mit den reduzierten Materialen wieder auf. Die Abbruchbedingung ist dann erreicht, wenn auch nicht mehr genug Materialen für die niedrigste Wertigkeit vorhanden sind und eine static Variable für die Anzahl der Gegenstände wird zurückgegeben.

    Damit sollte es eigentlich möglich sein, die Funktion zu schreiben.

    Edit: Schlangenmensch war schneller. So in etwa meinte ich es.



  • @Schlagenmensch
    In etwa so hätte ich mir das auch vorgestellt, aber einige Anmerkungen.

    Wäre es nicht besser, jeweils Referenzen zu übergeben? Dann könnte man in auch nach Aufruf feststellen, wieviele Items jeweils noch vorhanden sind.
    Und statt der Ausgabe in der Funktion würde ich ein Array aus 3 ints übergeben (oder alternativ/besser direkt ein std::array), und die Ausgaben der Itemanzahl in main vornehmen. Der Parameter i und der Rückgabewert wären damit natürlich auch nicht nötig, stören aber natürlich nicht.

    Bsp.

    int createItems(int& dragonSkins, int& goldenFeathers, int& magicalEssences, int* items /*Zeiger auf 3 ints-nullinitialisiert*/,int i = 0) 
    { 
    	if (dragonSkins >= 9 && goldenFeathers >= 10 && magicalEssences >= 8) { 
    		++items[2];
    		return createItems(dragonSkins -= 9, goldenFeathers -= 10, magicalEssences -= 8, p,++i); 
    ...
    


  • Referenzen gehen natürlich auch. Es stellt sich halt immer die Frage was man hinter mit den Werten machen möchte. Die Ausgabe war nur zur Visualisierung bzw test. Wenn man wissen möchte wie viele Objekte welchen Typs erzeugt werden, kannst du das über ein Array oder Vektor oder eine Map machen. Ich würde das nicht über einen int pointer machen, denn dann muss der Aufrufer sich darum kümmern, dass genügend Speicher reserviert ist, damit deine Zugriffe funktionieren.
    Ich habe nur einen einzelnen int zurück gegeben, weil ich die Aufgabe so verstanden hatte.


Anmelden zum Antworten