Zeilen und Spaltenweise einlesen und als Bruch darstellen(Zweidimensionales Array)

Sekiro24

Mitglied
Also eigentlich ist es doch fasst wie beim Insertion -Sort oder ?
Da wird ja auch immer von der ausgehenden Zahl alle Zahlen verglichen und diese dann getauscht. Hier wird nur nicht das steigender Zahl geguckt sondern ob beide dann gleich sind oder ?
 

cwriter

Erfahrenes Mitglied
würde es denn mit der Variante davor also ohne den zwei geschachtelten for schleifen auch funktionieren.
1. 3/5 2. 4/2 2. 3/3 3. 4/1 4. 4/1 5. 2/5 6. 1/3 7. 1/4
Kommt bei mir wieder dieselbe Reihenfolge raus.
Eigentlich sollte rauskommen:
1. 3/2 2. 5/2 3. 2/4 4.4/1 5. 1/3 6.3/3
Hier wechselt der 1. Stein (von [3|5] auf [3|2]. Ok, ich sehe gerade, dass [3|2] gar nicht im Test-Set ist.
Also sag du es mir: Kann der Startstein wechseln?
Probiere deine Testdaten durch (die du ja offenbar hast). Stimmen die?

Der Extension-Algorithmus ist nur, falls der Startstein wechseln dürfen sollte. Wenn nicht, war der Code davor (mit den entsprechenden Fixes) schon weit genug.

Also eigentlich ist es doch fasst wie beim Insertion -Sort oder ?
Da wird ja auch immer von der ausgehenden Zahl alle Zahlen verglichen und diese dann getauscht. Hier wird nur nicht das steigender Zahl geguckt sondern ob beide dann gleich sind oder ?
Äh...
Das hier hat mit Sortieren nichts zu tun (falls der Algorithmus überhaupt gebraucht wird, ich habe ja keine (nicht-beschädigten) Testdaten...).
Es ist eine Suche, keine Sortierung. Wenn du es dir genauer überlegst, ist der innere Loop mit berechnen() kein Loop auf den Daten selbst - naja, doch: Fehler im Algorithmus, der annimmt, dass die ursprüngliche Reihenfolge der Steine gleich bleibt (was sie ja nicht tut).
Korrigierter Algorithmus:
Code:
SteineKopie = copy(Steine)
for s in SteineKopie:
    Steine = copy(SteineKopie)
    Tausche s mit Stein 0 in Steine (sodass s nach dem Tausch an Stelle 0 steht)
    for i in #Steine:
        if berechne(i, i + 1) == 0:
            best_run_value = max(i, best_run_value)
            best_run_index = (s == best_run_value) ? s : best_run_index

// Da wir nicht zwischenspeichern:
Steine = copy(SteineKopie)
tausche(0, best_run_index)
berechne(0, 1)

// Ausgabe
Dennoch ist die Idee, einen Wert zu suchen - nicht eine Sortierung.
(Was ist die Asymptotische Laufzeit, wenn man die Berechnung rausnimmt? Was ist die asymptotische Laufzeit von InsertionSort? Kann das passen?)

Aber wie gesagt: Vielleicht ist das alles gar nicht nötig...

Ich habe mir jetzt mehr darüber Gedanken gemacht .
Show, don't tell.

Gruss
cwriter
 

Sekiro24

Mitglied
Da mir die doppelt geschachtelte Schleife mit der Schleifenbedingung mit dem Steine Array schwer fällt, habe ich jetzt noch mal das von davor nochmal geschrieben.
Das mittels Insertion Sort zu lösen, fällt mir in der Umsetzung schwierig.
Deswegen habe ich nochmal das vom Anfang mit weiteren Funktionen geschrieben.
Vielleicht könnten wir ja da weiter machen.
Also der Code sieht bei mir folgendermassen aus:

C:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>

int Steine[7][2];
int berechnen(int, int);
int einlesen();
int i, j, temp, temp1;
bool passt(int, int);
int drehe(int);
int tausche(int, int);

int main(){
    printf("Bitte geben Sie nun 7 Dominosteine ein\n");
    einlesen();
    /*for(i = 0; i < 7; i++)printf("%d. %d/%d\n", (i+1) ,Steine[i][0], Steine[i][1]);*/
    for(i = 0; i < 7; i++)
    {
        if(berechnen(i, i+1) == 0)
        {

        }

    }
    for(i = 0; i < 7; i++)
    {
        printf("%d. %d/%d\n", (i+1), Steine[i][0], Steine[i][1]);
    }
    return 0;
}
int einlesen(){
    for(i = 0; i < 7; i++){
        printf("%d.\n", (i+1));
        for(j = 0; j < 2; j++)
          scanf("%d", &Steine[i][j]);
    }
    return 0;
}
int drehe(int j)
{
        temp = Steine[j][0];
        temp1 = Steine[j][1];

        Steine[j][0] = Steine[j][1];
        Steine[j][1] = Steine[j][0];

        Steine[j][1] = temp;
        Steine[j][0] = temp1;

}
bool passt(int i,int j)
{
        if(Steine[i][0] == Steine[j][0] && Steine[i][1] == Steine[j][1])
            return true;
        else
            return false;
}
int berechnen(int i, int j) {
    if(i > 7 || j > 7) return 1;
    if(passt(i, j)) return 1;
    else
    {
        drehe(j);
        if(passt(i,j))
        {
            /*Drehen*/
            drehe(j);
            return 1;
        }
    }
    else
    {
       if(berechnen(i,j+1) == 1)
        {
            tausche(i+1,j+1);
        }
    }
    return 0;
}
int tausche(int i, int j){
    temp = Steine[i][0];
    temp1 = Steine[i][1];

    Steine[i][0] = Steine[j][0];
    Steine[i][1] = Steine[j][1];

    Steine[j][0] = temp;
    Steine[j][1] = temp1;
}

Die Ausgabe ist damit wie folgt:

Bitte geben Sie nun 7 Dominosteine ein
1.
3
5
2.
4
2
3.
3
3
4.
4
1
5.
2
5
6.
1
3
7.
1
4
Ausgabe
1. 3/5
2. 4/2
3. 3/3
4. 4/1
5. 4/1
6. 3/1
7. 5/2
 

cwriter

Erfahrenes Mitglied
Da mir die doppelt geschachtelte Schleife mit der Schleifenbedingung mit dem Steine Array schwer fällt, habe ich jetzt noch mal das von davor nochmal geschrieben.
Ok

#include <stdbool.h>
ANSI-C, was? o_O
stdbool = C99, ANSI-C = C90 = C89.

Das mittels Insertion Sort zu lösen, fällt mir in der Umsetzung schwierig.
Insertion Sort hast du ins Gespräch gebracht. Warum willst du Insertion Sort haben?

C:
if(Steine[i][0] == Steine[j][0] && Steine[i][1] == Steine[j][1])
Wie spielst du denn Domino? Nimm ein Blatt Papier und zeichne dir auf, welche Steine so passen würden.

C:
int drehe(int j)
{
        temp = Steine[j][0];
        temp1 = Steine[j][1];

        Steine[j][0] = Steine[j][1];
        Steine[j][1] = Steine[j][0];

        Steine[j][1] = temp;
        Steine[j][0] = temp1;

}
Du willst 2 Werte vertauschen und brauchst dafür 2 Ausweichvariablen? (Hint: Dein Code ist äquivalent zu:
C:
int drehe(int j)
{
        temp = Steine[j][0];
        temp1 = Steine[j][1];

        Steine[j][1] = temp;
        Steine[j][0] = temp1;

}
)
Da kann man noch eine Zeile sparen.

Aber ich wundere mich schon ein bisschen, warum du einen gut funktionierenden Code hattest und jetzt wieder dieselben Fehler neubaust.

Die Ausgabe ist damit wie folgt:
Und? Was sollen wir jetzt damit? Stimmt die Ausgabe (da der Code an verschiedenen Stellen falsch ist: Nein), was ist falsch/muss anders sein?

Ich habe das Gefühl, dass wir uns ein bisschen im Kreis drehen...

Gruss
cwriter
 

Sekiro24

Mitglied
Bei mir wird noch angezeigt, dass das else ohne vorheriges if geschrieben wurde.
Die Funktion drehe sollte eigentlich die Funktion tausche sein.
Die bool Funktion habe ich jetzt wieder vom typ integer deklariert.
Die If-Bedingung der Funktion passt habe ich jetzt auch geändert.
Jetzt weiss ich nicht mehr weiter.

C:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int Steine[7][2];
int berechnen(int, int);
int einlesen();
int i, j, temp, temp1;
int passt(int, int);
void drehe(int);
void tausche(int, int);

int main(){
    printf("Bitte geben Sie nun 7 Dominosteine ein\n");
    einlesen();
    /*for(i = 0; i < 7; i++)printf("%d. %d/%d\n", (i+1) ,Steine[i][0], Steine[i][1]);*/
    for(i = 0; i < 7; i++)
    {
        if(berechnen(i, i+1) == 0)
        {

        }

    }
    for(i = 0; i < 7; i++)
    {
        printf("%d. %d/%d\n", (i+1), Steine[i][0], Steine[i][1]);
    }
    return 0;
}
int einlesen(){
    for(i = 0; i < 7; i++){
        printf("%d.\n", (i+1));
        for(j = 0; j < 2; j++)
          scanf("%d", &Steine[i][j]);
    }
    return 0;
}
void drehe(int j)
{
        temp = Steine[j][0];
        Steine[j][0] = Steine[j][1];
        Steine[j][1] = temp;

}
int passt(int i,int j)
{
        if(Steine[i][0] == Steine[j][0] || Steine[i][0] == Steine[j][1])
            return 1;
        else
            return 0;
}
int berechnen(int i, int j) {
    if(i > 7 || j > 7) return 1;
    if(passt(i, j)) return 1;
    else
    {
        drehe(j);
        if(passt(i,j) == 1)
        {
            /*Drehen*/
            drehe(j);
            return 1;
        }
    }
    else
    {
        if(berechnen(i,j+1) == 1)
        {
            tausche(i+1,j+1);
        }

    }
    return 0;
}
void tausche(int i, int j){
    temp = Steine[i][0];
    temp1 = Steine[i][1];

    Steine[i][0] = Steine[j][0];
    Steine[i][1] = Steine[j][1];

    Steine[j][0] = temp;
    Steine[j][1] = temp1;
}
 

Sekiro24

Mitglied
Ich habe jetzt nochmal was geändert und komme auf folgendes.
C:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int Steine[7][2];
int berechnen(int, int);
int einlesen();
int i, j, temp, temp1;
int passt(int, int);
void drehe(int);
void tausche(int, int);

int main(){
    printf("Bitte geben Sie nun 7 Dominosteine ein\n");
    einlesen();
    /*for(i = 0; i < 7; i++)printf("%d. %d/%d\n", (i+1) ,Steine[i][0], Steine[i][1]);*/
    for(i = 0; i < 7; i++)
    {
        if(berechnen(i, i+1) == 0)
        {

        }

    }
    for(i = 0; i < 7; i++)
    {
        printf("%d. %d/%d\n", (i+1), Steine[i][0], Steine[i][1]);
    }
    return 0;
}
int einlesen(){
    for(i = 0; i < 7; i++){
        printf("%d.\n", (i+1));
        for(j = 0; j < 2; j++)
          scanf("%d", &Steine[i][j]);
    }
    return 0;
}
void drehe(int j)
{
        temp = Steine[j][0];
        Steine[j][0] = Steine[j][1];
        Steine[j][1] = temp;

}
int passt(int i,int j)
{
        if(Steine[i][1] == Steine[j][0])
            return 1;
        else
            return 0;
}
int berechnen(int i, int j) {
    if(i > 7 || j > 7) return 1;
    if(passt(i, j) == 1) return 1;
    else
    {
        drehe(j);
        if(passt(i,j) == 1)
        {
            /*Drehen*/
            drehe(j);
            return 1;
        }
        else
        {
            if(berechnen(i, j+1) == 1)
            {
                tausche(i+1, j+1);
            }
        }
    }
    return 0;
}
void tausche(int i, int j){
    temp = Steine[i][0];
    temp1 = Steine[i][1];

    Steine[i][0] = Steine[j][0];
    Steine[i][1] = Steine[j][1];

    Steine[j][0] = temp;
    Steine[j][1] = temp1;
}
Ausgabe
1. 3/5
2. 2/5
3. 0/0
4. 3/3
5. 1/3
6. 1/4
7. 4/1

EDIT: Jo jetzt habe ichs Vielen Dank für deine Hilfe :D

Der Code sieht nun wie folgt aus:
C:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int Steine[7][2];
int berechnen(int, int);
int einlesen();
int i, j, temp, temp1;
int passt(int, int);
void drehe(int);
void tausche(int, int);

int main(){
    printf("Bitte geben Sie nun 7 Dominosteine ein\n");
    einlesen();
    /*for(i = 0; i < 7; i++)printf("%d. %d/%d\n", (i+1) ,Steine[i][0], Steine[i][1]);*/
    for(i = 0; i < 7; i++)
    {
        if(berechnen(i, i+1) == 0)
        {

        }

    }
    for(i = 0; i < 7; i++)
    {
        printf("%d. %d/%d\n", (i+1), Steine[i][0], Steine[i][1]);
    }
    return 0;
}
int einlesen(){
    for(i = 0; i < 7; i++){
        printf("%d.\n", (i+1));
        for(j = 0; j < 2; j++)
          scanf("%d", &Steine[i][j]);
    }
    return 0;
}
void drehe(int j)
{
        temp = Steine[j][0];
        Steine[j][0] = Steine[j][1];
        Steine[j][1] = temp;

}
int passt(int i,int j)
{
        if(Steine[i][1] == Steine[j][0])
            return 1;
        else
            return 0;
}
int berechnen(int i, int j) {
    if(i > 7 || j > 7) return 0;
    if(passt(i, j) == 1) return 1;
    else
    {
        drehe(j);
        if(passt(i,j) == 1)
        {
            /*Drehen*/
            return 1;
        }
        else
        {
            if(berechnen(i, j+1) == 1)
            {
                tausche(i+1, j+1);
            }
        }
    }
    return 0;
}
void tausche(int i, int j){
    temp = Steine[i][0];
    temp1 = Steine[i][1];

    Steine[i][0] = Steine[j][0];
    Steine[i][1] = Steine[j][1];

    Steine[j][0] = temp;
    Steine[j][1] = temp1;
}
Und die Ausgabe wie folgt:
1. 3/5
2. 5/2
3. 2/4
4. 4/1
5. 1/3
6. 3/3
7. 1/4
 
Zuletzt bearbeitet:

Neue Beiträge