Strukturierte Programmierung Hilfe

enjoykimii

enjoykimii

Mitglied
Hallo zusammen,
nach der 3. Vorlesung 1. Semester Programmierung habe ich diese Aufgaben bekommen und weiß nicht mehr weiter. Mit den Basics bin ich vertraut, aber an der Umsetzung dieser Aufgaben bin ich trotzdem gescheitert.
Vielleicht könnt ihr mir mit Lösungsansätzen bei den folgenden Aufgaben behilflich sein.
Schon mal ein großes Dankeschön!


1.Lottozahlen-Paare
Erzeugen Sie – wie in der Vorlesung vorgeführt – Lottozahlen. Wiederholen Sie die Ziehung
mehere tausend Mal und ermitteln Sie, wie hoch die Wahrscheinlichkeit ist, dass bei einer
Lottoziehung Zahlenpärchen (2-3, 17-18, 42-43 o. ä) auftreten.
Tipp: Bedenken Sie, dass die Division der Günstigen durch die Möglichen bei ganzzahligen
Datentypen immer 0 ergibt, weil ganzzahlige Werte eben keine Nachkommastellen haben.
Schiffe verstecken
Verstecken Sie vier Schiffe! Dazu legen Sie zwei Arrays an, die die X- und die Y-Koordinate der

2.Schiffe darstellen.
final int SCHIFFE = 4;
int[] schiffx = new int[SCHIFFE];
int[] schiffy = new int[SCHIFFE];
Positionieren Sie die vier Schiffe im Bermudadreieck. Wie Sie sicher wissen, liegt die XKoordinate
des Bermudadreiecks zwischen 0 und 9 und die Y-Koordinate zwischen 0 und 7. Das
Programm soll dafür sorgen, dass keine zwei Schiffe auf der gleichen Position sind.
Geben Sie zu guter Letzt die Positionen der Schiffe auf dem Bildschirm aus.

Diesen Lösungsansatz habe ich:
Zu 1.
Java: 
public class lotto {

    public static void main(String[] args) {
        java.util.Random zufall = new java.util.Random();
         
        int lottozahl = zufall.nextInt(48);
     
        int[] lotto = new int[6];
        for (int i=0; i < 6; i++) {
            lotto[i]= zufall.nextInt(48)+1;
         
            for (int j=0; j>i; j++) {
             
                if (lotto [i] == lotto[j]) {
                 
                    i = i-1;
                }
            }
         
        } for (int zahl: lotto) {
         
            System.out.println(zahl);
            }
       
        int ergebnis = 0;
        int test = 49;
        int versuch = 10000000;
        while (versuch > 0) {
            java.util.Random ran = new java.util.Random();
            int i = ran.nextInt(4);
            if (i == test) {
                ergebnis += 1;
            }
            versuch--;
        }
        System.out.println("Ein 4 kam : " + ergebnis + " vor");
    }
   }
 
Zuletzt bearbeitet:
Hi!
enjoykimii hat gesagt.:
1.Lottozahlen-Paare
Erzeugen Sie – wie in der Vorlesung vorgeführt – Lottozahlen. Wiederholen Sie die Ziehung
mehere tausend Mal und ermitteln Sie, wie hoch die Wahrscheinlichkeit ist, dass bei einer
Lottoziehung Zahlenpärchen (2-3, 17-18, 42-43 o. ä) auftreten.
Tipp: Bedenken Sie, dass die Division der Günstigen durch die Möglichen bei ganzzahligen
Datentypen immer 0 ergibt, weil ganzzahlige Werte eben keine Nachkommastellen haben.
Zum Vergrößern anklicken....

So könntest du anfangen:

Java: 
import java.util.Arrays;
import java.util.Random;

public class Lotto {
    public static int[] ziehung() {
        Random random = new Random();
        int[] z = new int[6];
        int i = 0;
        a:
        while (i < 6) {
            int t = random.nextInt(49) + 1;
            for (int j = 0; j < i; j++) {
                if (z[j] == t) {
                    continue a;
                }
            }
            z[i] = t;
            i++;
        }
        Arrays.sort(z);
        return z;
    }

    public static int aufeinanderfolgendeZahlen(int[] ziehung) {
        int sum = 0;
        for (int i = 0; i < ziehung.length - 1; i++) {
            if (ziehung[i] + 1 == ziehung[i + 1]) {
                sum++;
            }
        }
        return sum;
    }

    public static void simulation(int n) {
        long sum = 0;
        for (int i = 0; i < n; i++) {
            int[] ziehung = ziehung();
            System.out.println("Ziehung = " + Arrays.toString(ziehung));
            int s = aufeinanderfolgendeZahlen(ziehung);
            sum += s;
        }
        System.out.println((double) sum / (n * 5));
    }

    public static void main(String[] args) {
        simulation(10);
    }
}

Für n = 10 ergibt sich zum Beispiel:

Code: 
Ziehung = [14, 21, 22, 33, 35, 38]
Ziehung = [2, 18, 27, 33, 40, 48]
Ziehung = [20, 21, 30, 42, 47, 48]
Ziehung = [3, 26, 31, 32, 37, 43]
Ziehung = [14, 26, 29, 35, 37, 38]
Ziehung = [5, 18, 30, 33, 34, 42]
Ziehung = [4, 19, 25, 28, 32, 49]
Ziehung = [23, 24, 27, 36, 37, 38]
Ziehung = [6, 16, 31, 33, 36, 46]
Ziehung = [3, 19, 20, 22, 34, 45]
0.2

Das heißt, ca. 20% der gezogenen Zahlen sind aufeinanderfolgend.

Erhöhst du n weiter, so ergeben sich genauere Wahrscheinlichkeiten. 🙂
 
Danke für die Hilfe! Bei Aufgabe 2: Wie programmiere ich denn ein zweidimensionales Array für das Schiffe versenken versenken? Es soll ja auch eine X- und Y-Koordinatenachsen dargestellt sein.
 
Also in der Vorlesung hat der Dozent so ein Schachbrett mithilfe eines zweidimensionalen Array dargestellt und die Schiffe als großes X, die leeren Stellen als kleines x. Ich weiß nur nicht, wie ich es schaffe, dass das Programm dafür sorgt, dass keine zwei Schiffe auf der gleichen Position sind, und wie ich die Positionen der Schiffe auf dem Bildschirm ausgebe.
 
Soweit bin ich jetzt für Aufgabe 2:

Java: 
import java.util.*;

public class schiffeversenken {
    public static void main(String[] args) {

        char[][] board = new char[7][9];
        
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[i].length; j++) {
                board[i][j] = '+';
                }
            }
        
        board[2][4] = 'X';
        board[2][5] = 'X';
        board[2][6] = 'X';
        board[2][7] = 'X';
        
        board[4][4] = 'X';
        board[5][4] = 'X';
        
        board[2][1] = 'X';
        board[2][0] = 'X';
        
        board[0][3] = 'X';
        board[0][4] = 'X';
        board[0][5] = 'X';
        
        final int schiffe = 4;
        int[] schiffx = new int[schiffe];
        int[] schiffy = new int[schiffe];
        
        schiffx[3] = 2;
        
        for(char[] line : board) {
            for(char c : line) {
                System.out.print(c + " ");
                
            }
            System.out.println(" ");
        }
}}

Die Frage ist nur, ob ich die Schiffe auch mithilfe von Random zusammenhängend jede Runde neu positionieren lassen oder ob ich das so per Hand richtig gemacht habe? Ich verstehe den vorgegebenen Code in der Aufgabenstellung auch nicht.
 
enjoykimii hat gesagt.:
Ich verstehe den vorgegebenen Code in der Aufgabenstellung auch nicht.
Zum Vergrößern anklicken....
Also, ich würde die Aufgabenstellung so interpretieren: eine Position wird durch x- und y-Koordinate angegeben. Die x-Koordinaten der Schiffe befinden sich im Array schiffx, die y-Koordinaten im Array schiffy.

Im Prinzip machst Du genau das gleiche, wie in Aufgabe 1 - mit dem Unterschied, dass Du es jetzt eben mit zwei Arrays zu tun hast.

Die Ausgabe der Positionen wäre dann einfach die Ausgabe der Koordinatenpaare.
 
Hallo alter Besserwisser,
Bitte sag mir, was daran falsch ist oder wie die Aufgabenstellung zu verstehen ist... Sonst kann ich heut Nacht nicht schlafen. 🙁
 
NullCharm hat gesagt.:
Hallo alter Besserwisser,
Bitte sag mir, was daran falsch ist oder wie die Aufgabenstellung zu verstehen ist... Sonst kann ich heut Nacht nicht schlafen. 🙁
Zum Vergrößern anklicken....
Es wurde nicht gefragt, wie viele Zahlenpaare auftreten, sondern wie viele Ziehungen mit Zahlenpaaren auftreten.
enjoykimii hat gesagt.:
ermitteln Sie, wie hoch die Wahrscheinlichkeit ist, dass bei einer
Lottoziehung Zahlenpärchen (2-3, 17-18, 42-43 o. ä) auftreten.
Zum Vergrößern anklicken....
 
achso, also einfach true, wenn mindestens ein Zahlenpärchen existiert, ansonsten false 🙁

Du weißt aber schon, dass das aus der Wahrscheinlichkeit 12,24...% herleitbar ist, oder? 😀

Eine Ziehung müsste zu 52% mindestens ein Zahlenpärchen beinhalten...
 
NullCharm hat gesagt.:
Eine Ziehung müsste zu 52% mindestens ein Zahlenpärchen beinhalten...
Zum Vergrößern anklicken....
Ne, stimmt nicht. 49,5% habe ich jetzt ermittelt:
Java: 
import java.util.Arrays;
import java.util.Random;

public class Lotto {
    public static int[] ziehung() {
        Random random = new Random();
        int[] z = new int[6];
        int i = 0;
        a:
        while (i < 6) {
            int t = random.nextInt(49) + 1;
            for (int j = 0; j < i; j++) {
                if (z[j] == t) {
                    continue a;
                }
            }
            z[i] = t;
            i++;
        }
        Arrays.sort(z);
        return z;
    }

    public static boolean pärchen(int[] ziehung) {
        for (int i = 0; i < ziehung.length - 1; i++) {
            if (ziehung[i] + 1 == ziehung[i + 1]) {
                return true;
            }
        }
        return false;
    }

    public static int aufeinanderfolgendeZahlen(int[] ziehung) {
        int sum = 0;
        for (int i = 0; i < ziehung.length - 1; i++) {
            if (ziehung[i] + 1 == ziehung[i + 1]) {
                sum++;
            }
        }
        return sum;
    }

    public static void simulation(int n) {
        long sum = 0;
        for (int i = 0; i < n; i++) {
            int[] ziehung = ziehung();
            //System.out.println("Ziehung = " + Arrays.toString(ziehung));
            sum += pärchen(ziehung) ? 1 : 0;
        }
        System.out.println((double) sum / n);
    }

    public static void main(String[] args) {
        simulation(10_000_000);
    }
}
Also irgendwo ist ein Wurm drin.
 
NullCharm hat gesagt.:
Java: 
import java.util.Arrays;
import java.util.Random;

public class Lotto {
    public static int[] ziehung() {
        Random random = new Random();
        int[] z = new int[6];
        int i = 0;
        a:
        while (i < 6) {
            int t = random.nextInt(49) + 1;
            for (int j = 0; j < i; j++) {
                if (z[j] == t) {
                    continue a;
                }
            }
            z[i] = t;
            i++;
        }
        Arrays.sort(z);
        return z;
    }

    public static boolean pärchen(int[] ziehung) {
        for (int i = 0; i < ziehung.length - 1; i++) {
            if (ziehung[i] + 1 == ziehung[i + 1]) {
                return true;
            }
        }
        return false;
    }

    public static int aufeinanderfolgendeZahlen(int[] ziehung) {
        int sum = 0;
        for (int i = 0; i < ziehung.length - 1; i++) {
            if (ziehung[i] + 1 == ziehung[i + 1]) {
                sum++;
            }
        }
        return sum;
    }

    public static void simulation(int n) {
        long sum = 0;
        for (int i = 0; i < n; i++) {
            int[] ziehung = ziehung();
            //System.out.println("Ziehung = " + Arrays.toString(ziehung));
            sum += pärchen(ziehung) ? 1 : 0;
        }
        System.out.println((double) sum / n);
    }

    public static void main(String[] args) {
        simulation(10_000_000);
    }
}
Zum Vergrößern anklicken....
Unabhängig von der Richtigkeit bzw thema, code zu lesen wo z.b. in einer Rechnung diese Variablen exisitieren
n sum i usw. ist es unglaublich schwer mitzukommen um was es geht bzw. wie es gemeint ist

es ist kein geschriebenes gesetz in einer for schleife nur mit i j k zu arbeiten VORALLEM nicht wenn es pure mathematik ist

es sind jetzt schon um die 10 Posts die sich nur um die mathematische Problematik drehen, da hilft ein "schlechter" code durch ungünstige variablen benennung überhaupt nicht, da das mathematische problem schon komplex genug ist

wenn du vllt mal in zukunft die dimension von fraktalen simulieren möchtest wirst du niemals deinen code entziffern können weil das sehr komplexe mathematik ist die dahinter steht und da gibts viele probleme die dazu gehören aber schlechter code sollte es nicht sein
 
NullCharm hat gesagt.:
So könntest du anfangen:
Zum Vergrößern anklicken....
Hier der Code etwas übersichtlicher.
[CODE lang="java" highlight="8-18,23-27,31-41,45-49"]import java.util.Arrays;
import java.util.Random;

public class TestLotto {
private final static Random rnd = new Random(System.currentTimeMillis());

public static void main(String[] args) {
int num = 1500;
int sumPositivPair = 0;
for (int i = 0; i < num; i++) {
int[] numbers = getLottoNumbers();
boolean hasPair = hasPair(numbers);
if (hasPair)
sumPositivPair++;
System.out.println((hasPair ? "O" : "-") + "\t" + Arrays.toString(numbers));
}
System.out.println(String.format("\nBei %d Ziehungen waren %d mal Paare dabei!\n%.2f %%", num, sumPositivPair,
(100 * sumPositivPair / (double) num)));

}

public static boolean containsNumber(int num, int[] numbers) {
for (int i = 0; i < numbers.length; i++) {
if (num == numbers)
return true;
}
return false;
}

public static int[] getLottoNumbers() {
int[] numbers = new int[6];
int id = 0;
while (id < 6) {
int num;
do {
num = rnd.nextInt(49) + 1;
} while (containsNumber(num, numbers));
numbers[id++] = num;
}
Arrays.sort(numbers);
return numbers;
}

public static boolean hasPair(int[] numbers) {
for (int i = 1; i < numbers.length; i++) {
if (numbers[i - 1] + 1 == numbers)
return true;
}
return false;
}

}[/CODE]
 
So meine Lösungen, die auch funktionieren:

[CODE lang="java" title="Aufgabe 1"]import java.util.Random;

public class Lottoziehung {

public static void main(String[] args) {

final int LENGTH = 6; // Anzahl der Zahlen einer Ziehung
double paare = 0; // Variable für Berechnung von Zahlenpaaren
Random rnd = new Random();

for (int z = 0; z < 10000; z++) {
int[] lotto = new int[LENGTH]; // lotto Array befüllen
for (int i = 0; i < lotto.length; i++) {
lotto = rnd.nextInt(48) + 1; //49Zahlen
for (int j = 0; j < i; j++) {
if (lotto == lotto[j]) // Lottozahlen ohne Doppelte
{
i--;
}
}
}

System.out.println();

for (int i = 0; i < lotto.length; i++) // Zahlen in Ziehung sortieren
{
for (int j = 0; j < i; j++) {
if (lotto < lotto[j]) {
int temp = lotto;
lotto = lotto[j]; //Tauschen und Sortieren der Zahlen
lotto[j] = temp;
}
}
}

int x = 0;

for (int i = 5; i > 0; i--) // Berechnung der Zahlenpaare
{
x = lotto - lotto[i - 1];

if (x == 1) {
paare = paare + 1;
}
}

for (int number : lotto) // Ausgabe der Zahlen
{
System.out.print(number + " ");
}
}

double w = (paare / 10000) * 100; // Wahrscheinlichkeitsberechnung

System.out.println();
System.out.print("Anzahl der Zahlenpaare in 10.000 Ziehungen: " + paare);
System.out.println();
System.out.print("Die Wahrscheinlichkeit für Zahlenpaare beträgt " + w + "%");

}

}[/CODE]

[CODE lang="java" title="Aufgabe 2 Schiffe versenken"]import java.util.*;

public class schiffeversenken {
public static void main(String[] args) {

char[][] board = new char[7][9]; // Spielboard erstellen mit zweidimensionalen Array

for (int i = 0; i < board.length; i++) { // mit + füllen
for (int j = 0; j < board.length; j++) {
board[j] = '+';
}
}

final int SCHIFFE = 4; // Anzahl Schiffe

int[] schiffx = new int[SCHIFFE]; // x Koordinate der Schiffe
int[] schiffy = new int[SCHIFFE]; // y Koordinate der Schiffe

Random rnd = new Random(); // Schiffe verstecken

for (int e = 0; e < SCHIFFE; e++) {
schiffx[e] = rnd.nextInt(7);
schiffy[e] = rnd.nextInt(9);

if (board[schiffx[e]][schiffy[e]] == '+') { //Schiffe nicht doppelt an selbe Stelle setzen
board[schiffx[e]][schiffy[e]] = 'X';
} else {
e = e - 1;
}
}

for (int line = 0; line < board.length; line++) {
for (int j = 0; j < board[line].length; j++) {
char field = board[line][j];

System.out.print(" " + field);
}

System.out.println();
}

for (int e = 0; e < SCHIFFE; e++) {
System.out.println("Positionen: Schiff " + (e + 1) + " X: " + (schiffx[e] + 1) + ", Y: "+ (schiffy[e] + 1));
}
} // X Achse verläuft von oben nach unten (oben links 1), Y Achse von links nach rechts
}
[/CODE]
 
Java: 
        final int LENGTH = 6; // Anzahl der Zahlen einer Ziehung
        double paare = 0; // Variable für Berechnung von Zahlenpaaren
        Random rnd = new Random();

        for (int z = 0; z < 10000; z++) {
            int[] lotto = new int[LENGTH]; // lotto Array befüllen
            for (int i = 0; i < lotto.length; i++) {
                lotto[i] = rnd.nextInt(48) + 1; //49Zahlen
                for (int j = 0; j < i; j++) {
                    if (lotto[i] == lotto[j]) // Lottozahlen ohne Doppelte
                    {
                        i--;
                    }
                }
            }

            System.out.println();

            for (int i = 0; i < lotto.length; i++) // Zahlen in Ziehung sortieren
            {
                for (int j = 0; j < i; j++) {
                    if (lotto[i] < lotto[j]) {
                        int temp = lotto[i];
                        lotto[i] = lotto[j]; //Tauschen und Sortieren der Zahlen
                        lotto[j] = temp;
                    }
                }
            }

            int x = 0;

            for (int i = 5; i > 0; i--) // Berechnung der Zahlenpaare
            {
                x = lotto[i] - lotto[i - 1];

                if (x == 1) {
                    paare = paare + 1;
                }
            }

            for (int number : lotto) // Ausgabe der Zahlen
            {
                System.out.print(number + " ");
            }
        }

        double w = (paare / 10000) * 100; // Wahrscheinlichkeitsberechnung

        System.out.println();
        System.out.print("Anzahl der Zahlenpaare in 10.000 Ziehungen: " + paare);
        System.out.println();
        System.out.print("Die Wahrscheinlichkeit für Zahlenpaare beträgt " + w + "%");
das sind 52 Zeilen an Code die was weis ich nicht alles machen, diese machen sehr wahrscheinlich auch das richtige da dies die Lösung ist nur da durchzublicken ist unmöglich nach einer Woche

es macht sinn probleme in einzelne methoden aufzuteilen und vllt mit objekten zu arbeiten in java .. behaupte ich einfach mal 😉

und rein aus dem Afekt heraus kommen dann die Variablen dann auch zu ihren modifieren wenn das mal aufgedröselt wird
 
Kann sein. Nur ist das nicht das, was du im Post vorher gesagt hast. Du hattest behauptet, dass dort alles public sei. Was halt einfach nicht stimmt, weil es nur methodenlokale Variable sind.
Und jetzt postulierst du etwas ganz anderes, nämlich, dass es Sinn macht, einzelne Aspekte in Methoden/Klassen auszulagern. Natürlich hätte man _dann_ auch Access Modifier an den Methoden/Klassen/Feldern.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Tutorial für strukturierte Programmierung (MVC)
Antworten: 2
Trennung Gui und Logik - Strukturierte Client Anwendung
Antworten: 4
Unterschied elementare und zusammengesetzte/strukturierte Datentypen
Antworten: 5
Funktionale Programmierung, OO- Programmierung, ...
Antworten: 9
Android-App-Programmierung - Ähnlich normaler Java-Programmierung?
Antworten: 6

Zurück
Oben