Bin zu doof... Mathe 3. Klasse

a) x=12+z

b) y= z+v

c) w=v+5

d) x+y=47 -> einsetzen a) und b) -> 2z+v=35 -> v=35-2z
e) y+w=39 -> einsetzen b) und c) -> 2v+z=34 -> einzetzen d) -> 70-4z+z=34 -> z=12

Das in die Ursprungsgleichungen bringt direkt alles andere. Für 3te Klasse ganz schön viel, aber 4-5te hätte ich das schon gesehen und jeder mit Mittlerer Reife hat das zumindest selbst in der Schule vermittelt bekommen.
 
  • Gefällt mir
Reaktionen: henpara, Rickmer und CyborgBeta
@Keylan naja - wie du siehst würden so manche Erwachsene an 5te Klasse Mathe versagen, geschweige denn die mittlere Reife nochmal hinbekommen :D

Aber nett, dass du die ganzen Gleichungen noch umgestellt hast - ich wollte zumindest noch ein bisschen Zwang zur Eigeninitiative übrig lassen.
 
@Rickmer Das ändert nichts daran, dass das nichts mit der 3. Klasse zu tun hat.

Nimm eine der unteren beiden Zahlen weg, und ich könnte dir als jemand mit Abitur und Studium alle möglichen Lösungen nennen.
 
Mal Söder fragen 🤣
 
Und bevor wieder einer auf die Idee kommt, die KI bei mathematischen Fragen zu verwenden: Da ist Wolfram Alpha die deutlich bessere Variante. Da arbeitet im Hintergrund eine echte Mathematik-Engine statt eines Satzgenerators.

Die Suchanfrage für diese Aufgabe wäre:
https://www.wolframalpha.com/input?i=solve+linear+equations+x+y=47,+y+w=39,+12+z=x,+z+v=y,+v+5=w

Für 3. Klasse Mathematik finde ich das echt heftig. Die zugehörigen Lösungsverfahren lernt man meines Wissens nach erst in der gymnasialen Mittelstufe. Wüsste nicht, wie das Grundschüler anders als über Versuch und Irrtum lösen können.
 
  • Gefällt mir
Reaktionen: henpara, fandre, Suchender007 und 3 andere
@Faluröd Vielen Dank für die Erklärung! genau so ist es.
 
Hab mir die Antworten nicht durchgelesen, daher nur als ergänzend auffassen.

Es reicht, wenn du den obersten Stein des Turms nimmst und dessen Gleichung aufbaust.

Code:
Gl(1):  12 + 3z + 3v + 5 = 86
             3z + 3v     = 86 - 12 - 5
             3z + 3v     = 69
              z +  v     = 23

Damit hast du schon den Stein für y, denn:

Code:
Gl(2):  y = z + v
        y = 23

Der Rest bröselt nun von alleine auf ;)
 
  • Gefällt mir
Reaktionen: florian.
ShiftC schrieb:
Es reicht, wenn du den obersten Stein des Turms nimmst und dessen Gleichung aufbaust.
Das Pascalsche Dreieck ist definitiv nicht Stoff der 3. Klasse^^
 
@Rickmer endlich hat einer das Problem erkannt. Wir brauchen eine Schulreform. Außer natürlich jetzt kommt raus, dass die Aufgabe gerade zur Einführung des pascalschen Dreiecks dient.

Also halten wir fest.

Auch alle die die Aufgabe lösen können bestätigen, das dies eher nicht Stoff für die Grundschule ist, wenn dann eher im Übergang zur Mittelstufe.

KI kann das sicher lösen, aber bitte auch solche verwenden die für diese Aufgabenstellung ausgelegt ist (ChatGTP ist gebaut um eine Unterhaltung zu führen) und das Ergebnis prüfen/nachvollziehen.

Es gab einige interessierte die an der Aufgabe gescheitert sind, auch wenn schon erhebliche Teile der Überführung des Problems in formale Notation vorgeleistet waren. Es gibt also sowohl die Herrausforderung die Aufgabenstellung in ein formal Gleichungsproblen zu überführen, als auch dieses Gleichungsproblem zu lösen.

Ersteres wird in Schulen eigentlich bis einschließlich Mittelstufe immer vom Lehrer komplett eingeführt. Sprich Schüler bekommen das buchstäblich vorgemacht bevor sie Aufgaben dieser Art zum bearbeiten bekommen.

Zweiteres ist so ziemlich das Einfachse was man als Gleichungssystem mit 5 Unbekannten haben kann und deshalb durchaus zur Einführung geeignet. Allerdings geht es immernoch um ganze Gleichungssysteme und damit ist man schon ein paar Stufen über der Vermittlung von Grundrechenarten.
Die meisten Menschen tun sich Schwer ihre Altagsprobleme so zu Abstrahieren um diese Methoden außerhalb der Schule zu gebrauchen.
 
  • Gefällt mir
Reaktionen: CyborgBeta
Hm, hier ist mal ein (einfaches) C++ Programm zum Lösen von Koeffizientenmatrizen:

C++:
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <variant>
#include <cmath>

struct Value
{
    double value = 0.0;
    bool is_unknown = false;
};

using Row = std::vector<Value>;
using Matrix = std::vector<std::vector<Value>>;

struct System
{
    Matrix coefficients;
    Row constant_terms;
};

double round_to(double value, double precision = 0.01)
{
    return std::round(value / precision) * precision;
}

std::ostream &operator<<(std::ostream &out, const Value &v)
{
    if (!v.is_unknown)
    {
        out << std::setw(6) << std::setfill(' ') << round_to(v.value);
    }
    else
    {
        out << "    --";
    }
    return out;
}

std::ostream &operator<<(std::ostream &out, const Matrix &matrix)
{
    out << "Matrix: (" << matrix.size() << " x " << matrix[0].size() << ")\n";
    for (auto &row : matrix)
    {
        for (auto &value : row)
        {
            out << value;
        }
        out << '\n';
    }
    return out << '\n';
}

std::ostream &operator<<(std::ostream &out, const Row &row)
{
    out << "Matrix: (1 x " << row.size() << ")\n";
    for (size_t i = 0; i < row.size(); i++)
    {
        out << "     " << (char)('a' + i);
    }
    out << '\n';
    for (auto &value : row)
    {
        out << value;
    }
    out << '\n';
    return out << '\n';
}

void print_system(const System &system)
{
    std::cout << system.coefficients;
    std::cout << system.constant_terms;
}

System solve(const System &input)
{
    System result = input;

    bool changed = true;
    while (changed)
    {
        changed = false;
        print_system(result);

        for (size_t i = 0; i < result.coefficients.size(); i++)
        {
            size_t magic_n = 0;
            size_t magic_i = 0;
            for (size_t j = 0; j < result.coefficients[i].size(); j++)
            {
                if (result.coefficients[i][j].value != 0 && result.constant_terms[j].is_unknown)
                {
                    magic_n++;
                    magic_i = j;
                }
            }

            if (magic_n == 1)
            {
                double sum = 0;
                for (size_t j = 0; j < result.coefficients[i].size(); j++)
                {
                    if (j != magic_i && result.coefficients[i][j].value != 0)
                    {
                        sum -= result.coefficients[i][j].value * result.constant_terms[j].value;
                    }
                }

                result.constant_terms[magic_i].value = sum / result.coefficients[i][magic_i].value;
                result.constant_terms[magic_i].is_unknown = false;

                changed = true;
                break;
            }
        }
    }

    return result;
}

int main(int argc, char const *argv[])
{
    std::vector<std::string> args({"-1 1 1 0 0 0 0 0 0 0",
                                   "0 -1 0 1 1 0 0 0 0 0",
                                   "0 0 -1 0 1 1 0 0 0 0",
                                   "0 0 0 -1 0 0 1 1 0 0",
                                   "0 0 0 0 -1 0 0 1 1 0",
                                   "0 0 0 0 0 -1 0 0 1 1",
                                   "0",
                                   "86 47 - 24 - - 12 - - 5"});

    System input;
    for (int i = 1;; i++)
    {
        std::cout << "Koeffizienten " << i << ". Zeile oder 0:\n";
        std::string l;
        // getline(std::cin, l);
        l = args[i - 1];
        std::cout << l << '\n';

        if (l == "0")
        {
            break;
        }
        std::stringstream ss;
        ss << l;
        std::string segment;
        Row r;
        while (getline(ss, segment, ' '))
        {
            r.push_back(Value());
            r.back().value = stod(segment);
        }
        input.coefficients.push_back(r);
    }
    {
        std::cout << "Bekannte, oder nur -, wenn unbekannt:\n";
        std::string l;
        // getline(std::cin, l);
        l = args[args.size() - 1];
        std::cout << l << '\n';

        std::stringstream ss;
        ss << l;
        std::string segment;
        while (getline(ss, segment, ' '))
        {
            input.constant_terms.push_back(Value());
            if (segment == "-")
            {
                input.constant_terms.back().is_unknown = true;
            }
            else
            {
                input.constant_terms.back().value = stod(segment);
            }
        }
    }

    System result = solve(input);

    return 0;
}

Das Ergebnis ist:

Code:
Koeffizienten 1. Zeile oder 0:
-1 1 1 0 0 0 0 0 0 0
Koeffizienten 2. Zeile oder 0:
0 -1 0 1 1 0 0 0 0 0
Koeffizienten 3. Zeile oder 0:
0 0 -1 0 1 1 0 0 0 0
Koeffizienten 4. Zeile oder 0:
0 0 0 -1 0 0 1 1 0 0
Koeffizienten 5. Zeile oder 0:
0 0 0 0 -1 0 0 1 1 0
Koeffizienten 6. Zeile oder 0:
0 0 0 0 0 -1 0 0 1 1
Koeffizienten 7. Zeile oder 0:
0
Bekannte, oder nur -, wenn unbekannt:
86 47 - 24 - - 12 - - 5
Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    --    24    --    --    12    --    --     5

Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    39    24    --    --    12    --    --     5

Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    39    24    23    --    12    --    --     5

Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    39    24    23    16    12    --    --     5

Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    39    24    23    16    12    12    --     5

Matrix: (6 x 10)
    -1     1     1     0     0     0     0     0     0     0
     0    -1     0     1     1     0     0     0     0     0
     0     0    -1     0     1     1     0     0     0     0
     0     0     0    -1     0     0     1     1     0     0
     0     0     0     0    -1     0     0     1     1     0
     0     0     0     0     0    -1     0     0     1     1

Matrix: (1 x 10)
     a     b     c     d     e     f     g     h     i     j
    86    47    39    24    23    16    12    12    11     5

Aber fällt euch etwas auf? Ja, richtig, die 24 für x (bzw. "d") musste ich vorgeben, weil mein einfacher Algorithmus sonst nicht das Ergebnis hätte berechnen können.

Ich finde aber nach wie vor, dass das für die Grundschule zu schwer wäre.
 
Vielen Dank an alle. :)
Wir haben gestern Abend noch gebastelt und es dann auch hin bekommen, aber wie schon viele geschrieben haben, hat das wohl wenig mit dem Stoff der dritten Klasse zu tun.

Von der Lehrerin kam bisher auch nur das Ergebnis und kein Lösungsweg.
Da beschleicht einen das Gefühl dass die Fragen von irgendeiner App zusammen gestöpselt und dann nicht mehr kontrolliert wurden.
 
Drakrochma schrieb:
Da beschleicht einen das Gefühl dass die Fragen von irgendeiner App zusammen gestöpselt und dann nicht mehr kontrolliert wurden.
Na ja, so eine Aufgabe zu erstellen, ist jetzt nicht sooo schwer ... Einfach von oben nach unten mit beliebigen Zahlen füllen (die eine Summe ergeben) und danach schrittweise einige Zahlen wieder entfernen, die man nicht möchte, aber nur solange alles noch eindeutig lösbar ist.

Dennoch sind lineare Gleichungssysteme noch nix für die Grundschule, denke ich.
 
Ja, erstellen ist nicht schwer, man sollte aber auf altersgerechte Lösbarkeit kontrollieren. ;)
 
  • Gefällt mir
Reaktionen: CyborgBeta
Keylan schrieb:
Also schwer ist die Aufgabe nicht, aber überdefinierte Gleichungssysteme sind trotzdem heftig für 3-te Klasse.
Nicht wirklich. Die gleiche Aufgabe nur mit 3 Unbekannten hat meine Tochter in der zweiten Woche zweite Klasse bekommen.

Da waren die Zahlen dann im Zahlenraum bis 20 gegeben. Der Sinn dieser Art von Aufgaben ist es, dass der Schüler ein Gefühl für Zahlen/Lösungen bekommt und sich durch geschicktes raten, also eine Algorithmus iterativ an die Lösung ran arbeitet.

Bei den Dreiecken von meiner Tochter gab es z.b. immer eine Zahl als Ergebnis, die viel kleiner war als die anderen. Mit der musste man anfangen, weil man dann nur 3-8 zahlen probieren musste, bzw mit geschickten "raten" war man nach max 3 Zahlen fertig.
Faluröd schrieb:
Für 3. Klasse Mathematik finde ich das echt heftig. Die zugehörigen Lösungsverfahren lernt man meines Wissens nach erst in der gymnasialen Mittelstufe. Wüsste nicht, wie das Grundschüler anders als über Versuch und Irrtum lösen können.
Genau das sollen Sie ja auch machen. Also lösen über scharfes hinschauen. Das macht man im Studium auch GAAAANZ oft.
Drakrochma schrieb:
Wir haben gestern Abend noch gebastelt und es dann auch hin bekommen, aber wie schon viele geschrieben haben, hat das wohl wenig mit dem Stoff der dritten Klasse zu tun.
Doch siehe oben. Aufgrund der "schönen" Ergebnisse ist das genau Stoff der dritten Klasse.
 
  • Gefällt mir
Reaktionen: CyborgBeta
Skysnake schrieb:
Der Sinn dieser Art von Aufgaben ist es, dass der Schüler ein Gefühl für Zahlen/Lösungen bekommt und sich durch geschicktes raten, also eine Algorithmus iterativ an die Lösung ran arbeitet.
So kenne und ordne ich das auch ein.

Es wird nicht verlangt, dass ein 2. oder 3. Klässler irgendwelche Gleichungen mit x, y, z usw. aufstellt, sondern dass er sich Gedanken darüber macht, welche Zahlen dort passen könnten.

Ich persönlich kenne keinen einzigen 3. Klässler, der als Unterrichtsstoff schon Gleichungen mit Variablen aufstellt (Begabte etc. ausgenommen). Auch nicht in Bayern.

Im Lernplan steht das definitiv nicht. Wie das bei privaten Schulen aussieht, kann ich aber nicht sagen.
 
  • Gefällt mir
Reaktionen: Corto, konkretor, Khaotik und eine weitere Person
Ich hatte meiner Tochter mehrere Lösungswege gezeigt und erklärt. Also sowohl die Aufstellung eines Gleichungssystems, ein iteratives Verfahren abgeleitet aus dem Gleichungssystem, wo es zwei Lösungen gibt und man durch probieren herausfinden muss welche die richtige ist. Je nachdem ob man + oder - im Gleichungssystem hat.

Und dann halt noch das Verfahren durch stures raten. Aber halt geschickt. Man sucht sich die kleinste Zahl und probiert dann aus.

Sie hat dann am Ende den aus dem Gleichungssystem abgeleiteten Ansatz gewählt. Da musste Sie nur stur dem Algorithmus folgen und kam schnell zum Ziel MIT rechnen.

Die Herausforderung war da aber etwas, das man durch 2 teilen muss und teilen hatten Sie so noch nicht in der Schule. Sie fangen gerade mir Mal an.

Aber die Hälfte, also einen Bruch kennt Sie aber schon. Daher konnte Sie es trotzdem lösen. Wobei man aufpassen musste das eben keine reellen Zahlen bei rauskommen. Das kann Sie noch nicht.

negative Zahlen sind auch noch nichts für Sie.

Aber was ich damit sagen will. Wenn man die Zahlen schön wählt können die Schüler viel viel mehr lösen als man so denkt. Erst die Allgemeinen Lösungen erfordern dann schon beliebig viele Kenntnisse

So eine Zahlenpyramide kann man ja z.b. ganz leicht durch Brüche würzen. :D
 
  • Gefällt mir
Reaktionen: CyborgBeta
Rickmer schrieb:
naja - wie du siehst würden so manche Erwachsene an 5te Klasse Mathe versagen, geschweige denn die mittlere Reife nochmal hinbekommen :D
Ich habe so eine Pyramide noch nie gesehen, egal ob 3te oder 5te Klasse.
Mir fehlt daher die Aufgabenstellung, was überhaupt das Ziel ist.
Ich meine in der dritten Klasse hatten wir mit einfachen Brüchen rumgealbert und mit Geteilt Rechnungen Seitenweise Hefte vollgeschrieben.

Zumindest Gleichungen nebeneinander stellen und Variablen rauskürzen hatten wir definitiv noch nicht in der 3ten Klasse.

Aber das ist halt auch schon ewig her.
 
Zurück
Oben