Anzahl der Gewichtscheiben berechnen

[The Pi]

Hallo Leute!

Ich hoffe mir kann jemand helfen. Ich möchte gerne ein Programm erstellen, das mir berechnet, wie viele Gewichtscheiben ich auf einer Langhantel brauche.

Zum Beispiel:
Ich habe eine Langhantel die 8 kg wiegt. Ich würde gerne mit 30 kg trainieren. Dann berechnet mir das Programm, dass ich eine 10 kg Scheibe und eine 1 kg Scheiben an jeder Seite der Langhantel brauche.

Natürlich muss ich ja auch einberechnen, dass jedes Studio nicht jede Scheibe zur Verfügung hat und es zum Beispiel nur 1 kg, 2 kg, 5 kg und 10 kg Scheiben hat.
Hat irgendjemand eine Idee wie man hier rechnen muss? Ich habe da nämlich keinen Plan wie ich da rangehen soll.

Mit freundlichen Grüßen,
The Pi 😉

 

[Phänox]

Also du meinste das der Benutzer zB eingibt mit wie viel gewicht er Trainieren will und wie viel die Langhantel wiegt und man dann als ausgabe hat wie viel an eine seite muss ?

 

[The Pi]

Genau so meinte ich das.

Ich gebe ein, dass ich mit z.B. 40 kg trainieren will und die Langhantel 10 kg wiegt. Das Programm gibt dann aus, das an jede Seite ein 5 und eine 10 kg Scheibe dran kommen...

 

[Phänox]

Alles klar
So könnte der Anfang der Methode aussehen als kleiner Denkanstoß

public void gewichtAusrechnen(int langhantelGewicht,int trainierGewicht)
    {
        int restGewicht = trainierGewicht - langhantelGewicht;
    }

Als Variablen der Klasse kannst du dann die gewichte machen als 1kg 2kg usw.

 

[Xyz1]

Eigentlich schreibe ich keine Lösung(en), aber ich finde die Aufgabe ganz interessant, auch das das Problem (schwach) NP-vollständig ist:

    static void scheiben() {
        System.out.print("Gesamt-Gewicht (in kg): ");
        int g = Integer.parseInt(new Scanner(System.in).nextLine());
        g -= 8; // Stange
        ArrayList<Integer> z = new ArrayList<>();
        scheiben2(z, g);
        System.out.println(8 + " " + z);
    }

    static boolean scheiben2(ArrayList<Integer> z, int g) {
        int count = z.stream().mapToInt(Integer::intValue).sum();
        if (count > g) {
            return false;
        }
        if (count == g) {
            return true;
        }
        for (int i = 0; i < 4; i++) {
            int g2;
            switch (i) {
                case 0:
                    g2 = 10;
                    break;
                case 1:
                    g2 = 5;
                    break;
                case 2:
                    g2 = 2;
                    break;
                case 3:
                    g2 = 1;
                    break;
                default:
                    throw new AssertionError();
            }
            z.add(g2);
            if (scheiben2(z, g)) {
                return true;
            }
            z.remove(z.size() - 1);
        }
        return false;
    }

Gesamt-Gewicht (in kg): 77
8 [10, 10, 10, 10, 10, 10, 5, 2, 2]

Übersah ich etwas? lässt sich auch noch besser schreiben.

 

[The Pi]

Ich habe eine viel einfachere Methode gefunden:

double gewicht = 100, gewichthantel = 10;
        int[] gewichte = {10, 5, 2, 1};
        boolean wiederholen = false;
        String ausgabe = "";

        gewicht = gewicht - gewichthantel;
        gewicht = gewicht / 2;

        for (int i = 0; i < gewichte.length; i++) {
            do {
                if (gewicht - gewichte[i] >= 0) {
                    gewicht = gewicht - gewichte[i];
                    if (ausgabe == "") {
                        ausgabe = ausgabe + String.valueOf(gewichte[i]) + " ";
                    } else {
                        ausgabe = ausgabe + " " + String.valueOf(gewichte[i]) + " ";
                    }
                    wiederholen = true;
                } else {
                    wiederholen = false;
                }
            } while (wiederholen);
        }

        System.out.println(ausgabe + "------ " + ausgabe);

 

[Phänox]

Also ich bin eher noch anfänger ^^ und daher versteh ich deinen Code nicht ganz 😀 aber ich schaffe das selbe in weniger code 🙂 und ist etwas einfacher zu verstehen ^^ hab mal die selben zahlen genommen wie du 🙂

public static void gewichtAusrechnen(int langhantelGewicht,int trainierGewicht)
    {
        int restGewicht = (trainierGewicht - langhantelGewicht)/2;
        ArrayList<Integer> gewichte = new ArrayList<Integer>();
        while(restGewicht!=0)
        {
            if(restGewicht>=10)
            {
                restGewicht = restGewicht -10;
                gewichte.add(10);
            }
            else if(restGewicht>=5)
            {
                restGewicht = restGewicht -5;
                gewichte.add(5);
            }
            else if(restGewicht>=2)
            {
                restGewicht = restGewicht -2;
                gewichte.add(2);
            }
            else if(restGewicht==1)
            {
                restGewicht = restGewicht -1;
                gewichte.add(1);
            }
        }
        System.out.println("Wenn Sie "+trainierGewicht+" trainieren wollen und ein Stangengewicht von "+
        langhantelGewicht+" haben"+"brauchen Sie jeweils auf beiden seiten: ");
        System.out.println(gewichte);
}}

Wenn Sie 146 trainieren wollen und ein Stangengewicht von 8 habenbrauchen Sie jeweils auf beiden seiten: 
[10, 10, 10, 10, 10, 10, 5, 2, 2]

 

[Tobse]

@DerWissende Ach herrje... dass du mal solchen Code in kein Echtes Projekt einbaust...

Ach und @All: Kürzer ist bei Code nicht immer besser 😉

 

[Phänox]

@Tobse Ich weiß 🙂

 

[Phänox]

@The Pi wenn du das noch hinzufügst

for (int i = 0; i < gewichte.length; i++) {
            if(gewicht==0)// das hier
                break;
            do {
               
                if (gewicht - gewichte[i] >= 0) 
                {
                    gewicht = gewicht - gewichte[i];
                    if (ausgabe == "") 
                    {
                        ausgabe = ausgabe + String.valueOf(gewichte[i]) + " ";
                    } else 
                    {
                        ausgabe = ausgabe + " " + String.valueOf(gewichte[i]) + " ";
                    }
                    wiederholen = true;
                } 
                else 
                {
                    System.out.println("test");
                    wiederholen = false;
                   
                }
            } while (wiederholen);
        }

        System.out.println(ausgabe + "------ " + ausgabe);
   
    }

ersparst du dir unnötige durchläufe ^^

 

[Xyz1]

Ich nochmal^^
@Tobse , @Phänox und @The Pi hat recht, das ganze zu kompliziert gedacht^^
Das Problem ist NICHT (schwach) NP-vollständig, denn
gesucht ist ein Greedy-Algorithmus für ein Maximierungsproblem, wobei
die "Scheibenmengen" 1, 2, 5, 10 linear (un-)abhängig sind (und ein Matroid bilden).

Also nochmal, der greedy-Ansatz kann gewählt werden, und
es ist nur eine Schleife notwendig, eine Schleife in einer Schleife ist nicht notwendig?

Also das ist,

    static boolean scheiben2(ArrayList<Integer> z, int g1) {
        int count = z.stream().mapToInt(Integer::intValue).sum();
        if (count > g1) {
            return false;
        }
        if (count == g1) {
            return true;
        }
        for (int i = 0; i < 4; i++) {
            int g2;
            switch (i) {
                case 0:
                    g2 = 10;
                    break;
                case 1:
                    g2 = 5;
                    break;
                case 2:
                    g2 = 2;
                    break;
                case 3:
                    g2 = 1;
                    break;
                default:
                    throw new AssertionError();
            }
            z.add(g2);
            if (scheiben2(z, g1)) {
                return true;
            }
            z.remove(z.size() - 1);
        }
        return false;
    }

abgesehen davon, dass das switch und das .sum() überflüssig ist,
unnötig.

Es wäre aber auch möglich, das meine mathematische Erklärung "Pfusch" ist^^
Nicht zu weit aus dem Fenster lehnen, liegt zu weit zurück^^

 

[Xyz1]

Quelle: https://de.wikipedia.org/wiki/Greedy-Algorithmus

Ein Greedy-Algorithmus findet für ein Optimierungsproblem auf Unabhängigkeitssystemen genau dann die optimale Lösung für alle Bewertungsfunktionen, wenn die zulässigen Lösungen die unabhängigen Mengen eines Matroids sind.