Hilfe bei Aufgaben

[darktrym]

Ich wünschte mir, man würde den Allgemeine-Fragen-Bereich nicht als "Ich bin zu faul um mich einzulesen" missbrauchen. Die gestellten Aufgaben haben doch ziemlichen Übungsaufgabencharakter und sollten mit ein wenig einlesen machbar sein.

[needphython]

hi,

also ich habe mit bluej die java grundlagen gelernt. ich habe aber schon paar monate mit bluej nicht gearbeitet. ich muss mich wieder ein bisschen einarbeiten. die if, while, for scheifen kenne ich. ich behersche sie jetzt nicht so gut, aber kann sie anwenden. mit python arbeite ich zum ersten mal. ich sollte schon in der lage sein die aufgaben zu lösen. ich muss mich halt ein bisschen einarbeiten und die befehle von python kennen lernen. befehle wie input(), append() kannte ich noch nicht. vielleicht gibt es die auch in java, aber ich kannte diese nicht.

meine lösung für aufgabe 1-3:

Code: Alles auswählen

L1 = []
z1 = input("zahl eingeben:")
z2 = input("zahl eingeben:")
z3 = input("zahl eingeben:")

Z1 = float(z1)
Z2 = float(z2)
Z3 = float(z3)
L1.append(Z1)
L1.append(Z2)
L1.append(Z3)
L2 = 2*L1
print(L2)

die restlichen aufgaben mache ich morgen

[darktrym]

Erklärt aber nicht warum man "z1 = float" schreibt, wenn man eine Typumwandlung ausführen will. Das ist in allen Programmiersprachen Blödsinn².

[BlackJack]

@needphython: Teilweise ist Python deutlich anders als Java. Zum Beispiel ist Python's ``for``-Schleife das was in Java die ``for (Typ var: iterable)``-Schleife ist. Ein Gegenstück zu Java's ``for (init; test; update)``-Schleife gibt es in Python nicht. Das müsste man sich mit ``while`` nachbauen, falls man es denn wirklich braucht. Aber eigentlich braucht man so etwas nicht.

Wie man eine Zählschleife schreibt, muss man deswegen in Python aber ”neu” lernen, denn in Java schreibt man die in der Regel anders. Wenn man die in Java so wie in Python schreiben wollte, müsste man ein externe Bibliothek einbinden die so etwas wie `range()` in Python 3 bereit stellt, oder sich so einen Datentyp selber schreiben.

`input()` und `append()` sind keine Befehle sondern das eine ist eine Funktion und das andere eine Methode, in diesem Fall auf dem `list`-Datentyp. Befehle oder Anweisungen gehören zum Kern der Sprache den man nicht selber schreiben könnte, also so etwas wie ``import``, ``for``, und so weiter.

Wenn Du in Java schon die Grundlagen kannst, wirst Du dort sicher auch schon mit Container-Objekten wie Listen (`List`-Interface und beispielsweise `ArrayList` als konkrete Implementierung) oder Abbildungen (`Map`-Interface und beispielsweise `HashMap` als konkrete Implementierung) in Kontakt gekommen sein. Bei Java's `List`-Typen heisst die Methode `add()` statt `append()`.

Was in Python auch dazu kommt sind überladene Operatoren bei beliebigen Typen. ``*`` funktioniert in Java ja nur bei primitiven Zahltypen, was zum Beispiel das Rechnen mit anderen als den primitiven Zahltypen ziemlich blöd zu lesen macht, weil die keine Operatoren verwenden können, sondern man das alles mit Methoden schreiben muss.

Das mit den klein geschriebenen Namen und den gross geschriebenen Namen für die Eingaben und Zahlen ist keine gute Idee. Man muss auch nicht jeden Zwischenwert überhaupt an einen eigenen Namen binden. Und wie schon gesagt, man sollte dringend vermeiden nahezu den selben Quelltext mehrfach zu schreiben. Wenn der Code drei mal das gleiche machen soll, dann schreibt man das nicht dreimal als Quelltext sondern nur *einmal*, und zwar in einer Schleife die dreimal durchlaufen wird.

Es läuft wie schon mal gesagt darauf hinaus, dass Du erst einmal die *Python*-Grundlagen lernen solltest, bevor Du dir Aufgaben löst. Für jede Aufgabe einzeln nach einer Lösung zu suchen ist schwieriger und umständlicher. Die Aufgaben sehen sehr stark danach aus um zu überprüfen ob man die Grundlagen von Listen und allen möglichen darauf definierten Operationen kennt und anwenden kann.

Du kannst die Aufgaben ja auch mal in Java lösen um zu sehen wie unterschiedlich die Ergebnisse letztendlich aussehen.

[Hyperion]

@needphython: Bitte benutze für Code die dazugehörigen Tags (über das Menü direkt über der Nachrichteneingabe einfach auswählbar!). Damit wird Dein Code korrekt eingerückt und erhält obendrein ein hübschen Syntax-Highlighting.

[needphython]

hi,

ich bin gerade in der siebten aufgabe. hier muss ich eine if schleife anwenden:

Code: Alles auswählen

if( L3[0] < 3):
L4[0] = 0

wie erzeuge ich aber eine liste, die die selbe länge hat wie L3? mit range()?

[darktrym]

Indem du range mit mit dem Parameter L3 L4 zuweist?
Ich muss jetzt schnell weg, eine IF-Schleife programmieren.

[BlackJack]

@needphython: Du erzeugst nicht erst eine Liste mit der selben Länge sondern Du erstellst eine Liste mit einem Element für jedes Element aus L3. Dann ist die Liste ja automatisch gleich lang wie L3. Syntaktisch drängt sich bei dieser Aufgabe eine „list comprehension” nahezu auf. Ansonsten fängst Du halt mit einer leeren Liste an, und hängst da die entsprechenden Elemente an.

Wichtig: http://if-schleife.de/

[BlackJack]

So könnte es in Java aussehen:

Code: Alles auswählen

package de.python_forum.blackjack;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // Aufgabe 1:
        List<Double> L1 = new ArrayList<Double>(3);

        // Aufgabe 2:
        Scanner scanner = new Scanner(System.in);
        for (int i = 1; i <= 3; i++) {
            System.out.printf("Zahl %d eingeben: ", i);
            L1.add(scanner.nextDouble());
        }

        // Aufgabe 3:
        List<Double> L2 = new ArrayList<Double>(L1);
        L2.addAll(L1);
        assert L2.size() == 2 * L1.size();
        System.out.println("L2 = " + L2);

        // Aufgabe 4:
        List<Double> L3 = L2.subList(0, 2);
        //noinspection MagicNumber
        L3.add(42.0);
        L3.addAll(L1);
        assert L3.size() == 2 + 1 + L1.size();

        // Aufgabe 5:
        L3.set(1, Math.pow(L3.get(1), 2));

        // Aufgabe 6:
        System.out.println("L3 =");
        for (Double x : L3) System.out.println(x);

        // Aufgabe 7:
        List<Integer> L4 = new ArrayList<Integer>(L3.size());
        for (Double x : L3) L4.add((x < 3) ? 1 : 0);
        assert L4.size() == L3.size();
        System.out.println("L4 = " + L4);

        // Aufgabe 8:
        for (int i = 0; i < 3; i++) {
            int digitCount = L4.size();
            System.out.printf(
                    "Folge von %d 0-1 Werten eingeben:%n", digitCount);
            List<Integer> L5 = new ArrayList<Integer>(digitCount);
            while (L5.size() < digitCount) {
                int j = scanner.nextInt();
                if (j != 0 && j != 1) {
                    System.out.println("Nur 0 oder 1 bitte.");
                } else {
                    L5.add(j);
                }
            }
            assert L5.size() == L4.size();
            boolean isEqual = true;
            int k;
            for (k = 0; k < L4.size(); k++) {
                if (!(isEqual = L4.get(k).equals(L5.get(k)))) break;
            }
            if (isEqual) {
                assert L4.equals(L5);
                System.out.println("Eingabe ist korrekt.");
                break;
            } else {
                System.out.printf(
                        "Eingabe stimmt mindestens an Stelle %d nicht.%n", k);
            }
        }
    }
}

[EyDu]

So könnte es in Java aussehen:

Sind das nicht ein bisschen wenig Klassen?

[BlackJack]

@EyDu: Jetzt wo Du es sagst — vielleicht sollte ich mit einem Interface `Aufgabe` anfangen…

[Hyperion]

Vergiss die Factory dafür nicht!

Wobei ich bei so einer Aufgabe Unittests ja durchaus für sinnvoll hielte... das wäre quasi ideal für TDD

[snafu]

@EyDu: Jetzt wo Du es sagst — vielleicht sollte ich mit einem Interface `Aufgabe` anfangen…

Jepp, mit zu implementierender ``void solve()``-Methode. Zudem ist ein ``UserInputScanner()`` mit ordentlicher Fehlerbehandlung ja wohl das Mindeste, was man erwarten kann...

[BlackJack]

@snafu: Den `UserInput` als Interface oder abstrakte Klasse braucht man auch damit man sich zwischen konkreten Implementierungen (`BufferedReader` + `parse*()` oder `Scanner`) entscheiden kann.

[EyDu]

Prima, dann ist es jetzt auch schon komplex genug, dass sich die Anfertigung diverser UML-Diagramm lohnt