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

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 ?
 
Sekiro24 hat gesagt.:
würde es denn mit der Variante davor also ohne den zwei geschachtelten for schleifen auch funktionieren.
Zum Vergrößern anklicken....
Sekiro24 hat gesagt.:
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
Zum Vergrößern anklicken....
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.

Sekiro24 hat gesagt.:
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 ?
Zum Vergrößern anklicken....
Ä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...

Sekiro24 hat gesagt.:
Ich habe mir jetzt mehr darüber Gedanken gemacht .
Zum Vergrößern anklicken....
Show, don't tell.

Gruss
cwriter
 
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
 
Sekiro24 hat gesagt.:
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.
Zum Vergrößern anklicken....
Ok

Sekiro24 hat gesagt.:
#include <stdbool.h>
Zum Vergrößern anklicken....
ANSI-C, was? o_O
stdbool = C99, ANSI-C = C90 = C89.

Sekiro24 hat gesagt.:
Das mittels Insertion Sort zu lösen, fällt mir in der Umsetzung schwierig.
Zum Vergrößern anklicken....
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.

Sekiro24 hat gesagt.:
Die Ausgabe ist damit wie folgt:
Zum Vergrößern anklicken....
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
 
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;
}
 
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:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück