Lineare Gleichung aus Textaufgabe: Menge von Abraumbagger

Hallo,
ich hab mal ne Fragen bezüglich einer Textaufgabe einer linearen Gleichung.
Zunächst mal die Aufgabe:
Drei Abraumbagger bewegen täglich 31k Abraum. Dabei schafft der zweite Bagger 1000 mehr als der dritte und der erste 4000 weniger als das Doppelte des Zweiten. Welche Abraummenge wird täglich von jedem der drei Bagger bewegt.

Haben tu ich folgendes:

  1. Bagger (a): a = (2b-4000)
  2. Bagger (b): b = c+1000
  3. Bagger ©: -

Wie komm ich denn auf die einzelnen Mengen ? Muss ich die Bagger jeweils noch durch 31.000 teilen? Ich hab schon versucht c auszurechnen und komm dann auf “17000-b”, aber das bringt mich auch nicht weiter!

Wäre nett wenn mir jemand nen Denkanstoß geben könnte!
Grüße Swoop

Drei Abraumbagger bewegen täglich 31k Abraum: b1 + b2 + b3 = 31.000
Dabei schafft der zweite Bagger 1000 mehr als der dritte: b2 = b3 + 1000
und der erste 4000 weniger als das Doppelte des Zweiten: b1 = 2*b2-4000

3 Gleichungen, 3 Unbekannte, ist ohne Probleme lösbar.
Gruß

Ich steh leider irgendwie aufm Schlauch. Ka wie ich das machen soll. Dass was du geschrieben hast, hab ich so doch schon geschrieben?`
Die Frage die sich mir stellt, wie muss ich fortfahren, wenn ich die 31.000 = b1+b2+b3 auflösen will? So bleiben doch immer 2 variablen übrig ? Wie soll ich denn dann auf einen Wert kommen?

Lösung mit dem Gauß-Verfahren könnte so aussehen:

Lösung
[spoiler]

Konstanten auf rechte Seite bringen:

b2 - b3 = 1.000
b1-2*b2 = -4.000```

Aufstellung als Koeffizientenmatrix:
```1 1 1 | 31.000
0 1 -1 | 1.000
1 -2 0 | -4.000```
3. Zeile - 1. Zeile:
```1 1 1 | 31.000
0 1 -1 | 1.000
0 -3 -1 | -35.000```
1. Zeile - 2. Zeile
```1 0 2 | 30.000
0 1 -1 | 1.000
0 -3 -1 | -35.000```
3. Zeile + 3* 2. Zeile
```1 0 2 | 30.000
0 1 -1 | 1.000
0 0 -4 | -32.000```
3. Zeile / -4
```1 0 2 | 30.000
0 1 -1 | 1.000
0 0 1 | 8.000```
2. Zeile + 3. Zeile
```1 0 2 | 30.000
0 1 0 | 9.000
0 0 1 | 8.000```
1. Zeile - 2* 3. Zeile
```1 0 0 | 14.000
0 1 0 | 9.000
0 0 1 | 8.000```
b1 = 14k
b2 = 9k
b3 = 8k
[/spoiler]

Mit dem Gauß-Verfahren hats super geklappt. Da wär ich von selbst glaub ich nie darauf gekommen.

Bei so kleinen Systemen mit drei, vier Gleichungen ist meiner Meinung nach das Determinantenverfahren (a.k.a. Cramersche Regel) am einfachsten. Bei größeren System steigt der Rechenaufwand an, und es gibt numerische Probleme, aber hier wäre es ideal. Determinanten berechnen für Dreiermatritzen kann man mit der Regel von Sarrus.

Man könnte das auch in Java lösen lassen. Eine IDE bietet ja recht gute Refactoring-Möglichkeiten.
Ausgangssituation.


    static int a() {
        return (2 * b()) - 4000;
    }

    static int b() {
        return 1000 + c();
    }

    static int c() {
        return 31000 - a() - b();
    }
}```

Dann ein Click auf c() in der Methode b(). Refactor -> Inline (only inline and Keep Method)

```public class Bagger {

    static int a() {
        return (2 * b()) - 4000;
    }

    static int b() {
        return 1000 + 31000 - a() - b();
    }

    static int c() {
        return 31000 - a() - b();
    }
}```

1000 + 31000 -a() -b() soll b() ergeben.  Also wird das Manuell geändert in 1000 + 31000 -a soll  2 * b() ergeben, was zu 
(1000 + 31000 -a()) / 2 soll b() ergeben führt.

public class Bagger {

static int a() {
    return (2 * b()) - 4000;
}

static int b() {
    return (1000 + 31000 - a()) / 2;
}

static int c() {
    return 31000 - a() - b();
}

}


In Methode a einfach nur b() markieren und Inlinen lassen.

```public class Bagger {

    static int a() {
        return (2 * (1000 + 31000 - a()) / 2) - 4000;
    }

    static int b() {
        return (1000 + 31000 - a()) / 2;
    }

    static int c() {
        return 31000 - a() - b();
    }
}```


(2 * (1000 + 31000 - a()) / 2) - 4000;
((1000 + 31000 - a())) - 4000;
32000 - a() - 4000;
28000 - a();

a() ist irgendws - a(), also ist a() die hälfte von Irgendwas.

```public class Bagger {

    static int a() {
        return (28000 / 2);
    }

    static int b() {
        return (1000 + 31000 - a()) / 2;
    }

    static int c() {
        return 31000 - a() - b();
    }
    public static void main(String[] args){
        System.out.printf("A:%d%nB:%d%nC:%d%n",a(),b(),c());
    }
}```

Was zum Ergebnis führt.
A:14000
B:9000
C:8000

Ich würde es echt super finden wenn Intellij, dass ja bei Boolschen Ausdrücken ein Simplify anbietet, dieses auch für Berechnungen anbieten würde. Also 28000 / 2 gelb hinterlegen und nach einem click auf Simplify 14.000 einsetzen.

Wenn ich Alt+Enter drücke, bekomme ich eine Option “Compute constant value of ‘1000 + 31000’” angeboten, die genau das macht. Gelb hinterlegt wird das allerdings nicht.

Warum eigentlich so kompliziert?
Durch einfaches einsetzen kann man eine einfache Gleichung lösen. Ganz ohne Determinanten und co.

a+b+c = 31000 / a = 2*b-4000 / b = c + 1000

(2*(c+1000)-4000) +(c +1000) + c = 31000

Auflösen nach c und die anderen beiden ausrechnen, fertig.

[QUOTE=Jezira]Warum eigentlich so kompliziert?
Durch einfaches einsetzen kann man eine einfache Gleichung lösen. Ganz ohne Determinanten und co.

a+b+c = 31000 / a = 2*b-4000 / b = c + 1000

(2*(c+1000)-4000) +(c +1000) + c = 31000

Auflösen nach c und die anderen beiden ausrechnen, fertig.[/QUOTE]

Solche Aufgaben finden sich auch oft in Rätseln und (IQ-)Tests. Solange sie entsprechend Linear aufgebaut sind, wie es in diesem Fall war, ist der einfachste Weg durch simples Gleichung auflösen. Bin daher recht überrascht, was in diesem Fall alles für Lösungswege vorgeschlagen wurden.

@Sonecc Ich vermute mal, die gewählte Lösung hängt auch ein bisschen damit zusammen, womit man normalerweise arbeitet.

Verfahren wie Gauß oder das Determinantenverfahren haben den Vorteil, dass sie auch bei einer hohen Anzahl an Gleichungen noch gut zu bewältigen sind.
Einsetzen per Hand ist bei den 2-3 gleichungen natürlich intuitiver :slight_smile:

Die Version von @Majora finde ich allerdings extrem abgefahren :cool:
Auf die Idee, eine Java-IDE mit Refactoring-Unterstützung zum Lösen von Gleichungssystemen zu verwenden, muss man erstmal kommen.

Gruß