Von der Uni aus sollen wir ein Sudoku Solver schreiben, viel quelltext ist schon vorgegeben, aber leider nicht alles. Ich gebe euch mal vor, was vorgebenen ist, dazukommen sollen die Teile bei den // ** INSERT ** // und die funktionen korrekt und weiter

Leider habe ich gar keinen plan, wie das gehen soll

#include <stdio.h>

struct sud
{ char mat[9][9][10];
       // m[i][j][k] Feld Element
       //   i = {0..8} Zeilen Index
	   //   j = {0..8} Spalten Index
	   //
	   // m[i][j][0]
	   //  := 0     : Feldwert offen
	   //  := {1..9}: Feldwert fest
	   //
	   //          m :={1..9}
	   // m[i][j][m] Feldwert
	   //  := 0    == m möglich
	   //  := 1    == m verboten  
  char next[3];
       // Test-Element-Parameter
	   // next[0] := Zeile
	   // next[1] := Spalte
	   // next[2] := Wert

};

typedef struct sud SUDOK;

int start(SUDOK *res);
void ausgabe(SUDOK *res);
void ausschluss(SUDOK *res);
int einzeln(SUDOK *res);
int probe (SUDOK *alt);
int weiter(SUDOK *neu);
int korrekt(SUDOK *neu);

// Hauptfunktion

int main(void)
{ SUDOK res ={{0}};
  int i,j;

  printf(" Willkommen zum Sudoku-Programm \n\n\n");

  start(&res);

  printf(" __Originalmatrix: __");
  ausgabe(&res);
  printf(" ^^Originalmatrix: ^^");

  printf("\n\n\n ");

  for (i=0; i<9; i++)
	  for (j=0; j<9; j++)
		  { res.next[0] = i;
	        res.next[1] = j;
			res.next[2] = res.mat[i][j][0];
			ausschluss(&res);
		  }

  ausgabe(&res);

  res.next[0]=res.next[1]=res.next[2] = 0;
  probe(&res);

  return(-100);

}

// Startwertfunktion:

int start(SUDOK *res)    //Vorgaben festlegen
{ char i,j;
  char vor[9][9] =
    { 0, 7, 0,   6, 0, 0,   0, 8, 0,
	  6, 0, 0,   5, 0, 0,   0, 0, 0,
	  0, 0, 9,   0, 0, 4,   0, 5, 0,

	  1, 2, 0,   0, 0, 0,   9, 6, 0,
	  0, 0, 0,   0, 2, 0,   4, 0, 0,
	  0, 0, 6,   0, 0, 0,   0, 0, 0,

	  0, 0, 0,   4, 3, 0,   1, 0, 7,
	  2, 0, 5,   1, 0, 0,   0, 0, 0,
	  0, 0, 0,   0, 0, 0,   8, 0, 0

    };

  for (i=0; i<9; i++)
	  for (j=0; j<9; j++)
		  res->mat[i][j][0] = vor [i][j];

  return(0);

}

// Ausgabe der Matrix

void ausgabe(SUDOK *res)
  { char i,j;

  for (i=0; i<9; i++)
	  { printf("\n ");
        if ((i==3)||(i==6))
		   printf("\n ");

		for(j=0; j<9; j++)
			{ if ((j==3)||(j==6))
		         printf(" ");

			  if (res->mat[i][j][0] != 0)
				 printf("%2d",res->mat[i][j][0]);
	          else printf(" .");
		    }
	  }
  printf("\n");
  return;
}

// Ausschluss-Funktion
// Eindeutige Vorgaben löschen Möglichkeiten in
// Zeile Spalte und Block

void ausschluss(SUDOK *res)
{ char i, j, k, m, n, r, s;
  if (res->next[2] == 0)
	  return;

  i = res->next[0];
  j = res->next[1];
  k = res->next[2];

  for (m=0; m<9; m++)         // Ausschluss Werte: Spalte
	  res->mat[m][j][k] = 1;

  for (n=0; n<9; n++)         // Ausschluss Werte: Zeile
	  res->mat[i][n][k] = 1;

  r = i/3;
  s = j/3;

  for (m=0; m<3; m++)         // Ausschluss Werte: Block
	  for (n=0; n<3; n++)
		  res->mat[m+r*3][n+s*3][k] = 1;

  for (m=1; m<10; m=m+1)
	  res->mat[i][j][m] = 1;

  res->mat[i][j][k] = 0;
  res->mat[i][j][0] = k;

  return;

}

// Einzeln-Funktion
// Diese Funktion sucht nach Feldern mit nur einer Möglichkeit
// Das Feld Next bekommt diese Werte übergeben
// Bei Negativ endet sie mit 0

int einzeln(SUDOK *res)
{ int i, j, k, kneu, n;
  for (i=0; i<9; i++)
  { for (j=0; j<9; j++)
    { if(res->mat[i][j][0])
	  continue;

	  n=0;
	  for (k=1; k<10; k++)
	  { if(res->mat[i][j][k]==0)
        { n = n+1;
		  kneu = k;
        }
      }
      if (n==1)
	  { res->next[0] = i;
        res->next[1] = j;
		res->next[2] = kneu;
		return(1);
      }
    }
  }
  return(0);
}

int probe (SUDOK *alt)
{ SUDOK neu;
  char i,ip, j,jp, k,kp, korr =-1;
  static int s =0;

  i = alt->next[0];
  j = alt->next[1];
  k = alt->next[2];

  neu = *alt;

  printf(" %d %d %d ", i,j,k);

ip=jp=0;

  do{
         // INSERT //

            {

			  do { ausschluss(&neu);
				 } while (einzeln(&neu));

         // INSERT //

				 }
            }

			if (ip || kp || jp )
				korr = korrekt(&neu);

			if (korr > 0)
			{ printf(" Lösung gefunden!!!");  //Lösung richtig
	          ausgabe(&neu);
		      break;
		    }

            if (korr < 0)
		    { neu = *alt;
		      if( (weiter(&neu) == 0) || (i != neu.next[0]) || (j != neu.next[1])) break;

              k = alt->next[2] = neu.next[2];
			  continue;
		    }

            do { if( weiter(&neu) == 0) return(s);
			   } while (i == neu.next[0] && j == neu.next[1]);

			probe(&neu);
			neu = *alt;
			if (weiter(&neu) == 0) return(s);

            k = alt->next[2] = neu.next[2];

   } while ( (i == neu.next[0]) && (j == neu.next[1]));

  return(s);

}

Wäre super wenn ihr mir sagen könntet wie ich den Quelltext vervollständigen kann, damit das Programm läuft.

Vielen Dank

sollen wir jetzt raten oder auswürfeln was da noch fehlt? Wo sind deine Anfänge/Vermutungen? Wir machen hier für dich nicht Hausaufgaben, wir geben dir nur Hilfe zur Felbsthilfe. Und da du auch nichts C++ spezifisches gepostet hast wirst du sicher auch erstmal ins Ansi-C Forum verschoben.

bis bald
akari

1. studiere ich kein informatik, es ist also nur ein nebenfach was wir belegen müssen
2. sitze ich seit mehreren tagen daran, und versuche auf des rätsels lösung zu kommen

und last but not least 3.
Hilft mir deine Antwort leider kein bißchen

Also im Grunde siehts so aus: Der Teil der Fehlt sieht so aus das ein element was noch möglich wäre genommen wird, und dann wird durchprobiert, und dann wieder eins genommen und so weiter.
und wenn das nicht klappt, stellt man alles auf anfang zurück und versucht es mit anderen werten

die weiterfunktion gibt dabei "wahrscheinlich" an mit welchem element weiter gemacht wird, bzw ob noch möglichkeiten vorhanden sind

die korrekt funktion schaut nach ob das vollständig eingetragene sudoku korrekt ist ob es fehler gibt

in der theroie ist es mir also bekannt aber ich kriegs nicht hin

1. studiere ich kein informatik, es ist also nur ein nebenfach was wir belegen müssen

was du hier schreibst hört sich eher nach null plan von garnix und null bock an. ihr bekommt sicher nicht so eine aufgabe ohne vorbereitung.

2. sitze ich seit mehreren tagen daran, und versuche auf des rätsels lösung zu kommen

dann zeig doch mal, was du schon versucht hat.

1. studiere ich kein informatik, es ist also nur ein nebenfach was wir belegen müssen

Mein Beileid. Wer hätte denn auch ahnen können, dass man für die Leistungsnachweise im Nebenfach Leistung erbringen muss?!

ich habe das gleiche problem mit dem sudoku programm.
@McSeth: hast du schon ne lösung dazu? und du studierst nicht zufällig in brandenburg?

cu Paul12

McSeth schrieb:

1. studiere ich kein informatik, es ist also nur ein nebenfach was wir belegen müssen

was du hier schreibst hört sich eher nach null plan von garnix und null bock an. ihr bekommt sicher nicht so eine aufgabe ohne vorbereitung.

Nur noch so nebenbei: Eine Aufgabenstellung an ner Uni gibts immer OHNE vorbereitung dazu...

da gibts das nächste Übungsblatt, meistens noch nichtmal persönlich ausgeteilt, sondern steht auf de internetseite, hat mit der aktuellen Vorlesung gar nichts zu tun, und es einzigst was man dazu weiß ist.

"Deadline: ...."