Problem bei der Ausgabe - Falsche Bedingungen oder Logik-Fehler?

[royale]

Moin,

ich beearbeite grade folgende Aufgabe:

In folgendem Schema sollen alle Zahlen von 1- 8 untergebracht werden. Verbundene zahlen müssen sich um mehr als 1 unterscheiden.

Das Schema mit meiner Durchnummerierung fürs array sieht so aus:

http://www.bilder-hochladen.net/files/hxm-b-jpg-nb.html

ICh lasse bei meinem Programm erst alle Permutationen von 1 bis 8 berechnen. Danach soll über IF-Abfragen genau diese Beziehungen abgefragt werden, jedoch macht er einfach keine Ausgabe mehr. Nur ich entdecke einfach nicht den Fehler in den Bedingungen. Sieht wer anders mehr als ich?

Hier der Code:

#include <stdio.h>


void perm(int anz, int array[], int start);

void ausgabe(int anz, int array[]);



int main() {

	int loesung[8];

	int i;


	for (i = 0; i < 8; i++) {

		loesung[i] = i+1;

	}

	perm(8, loesung, 0);



}


void perm(int anz, int array[], int start) {

	int i, sav;

	if (start < anz) {

		sav = array[start];

		for (i = start; i < anz; i++) {

			array[start] = array[i];

			array[i] = sav;

			perm(anz, array, start + 1);

			array[i] = array[start];

		}

		array[start] = sav;

	}

	else {

		ausgabe(anz, array);

	}

}

/*Hier hackt es, keine Ahnung, warum er keine Ausgabe macht*/

void ausgabe(int anz, int array[]) {

	int i,hilf1,hilf2,hilf3,hilf4;

	for (i = 0; i < anz; i++) {


        hilf1 = array [0] - array[1];                            /*für 1*/

		hilf2 = array [0] - array[2];

		hilf3 = array [0] - array[3];


		if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1) && (hilf3 >1 || hilf3 < -1))   /* für 2*/

		   { hilf1 = array[1] - array [2];

		     hilf2 = array [1] - array[4];

		     hilf3 =array [1] -array [5];


             if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1) && (hilf3 >1 || hilf3 < -1) && (hilf4 >1 || hilf4 < -1))   /*für 3*/

              { hilf1 = array[2] -array [3];

                hilf2= array [2] - array [5];

                hilf3= array [2] - array [6];

                hilf4= array [2] -array[4];


                if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1) && (hilf3 >1 || hilf3 < -1))                      /*für 4*/

                {hilf1=array [3] -array[5];

                hilf2= array[3] -array[6];


                        if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1))                                      /*für 5*/

                           { hilf1 = array [4] - array[5];

                             hilf2 = array[4] -array [5];


                             if  ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1))                         /*für 6 */

                                 { hilf1=array[5]-array[7];

                                   hilf2=array[5]-array[6];


                                   if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1))  /*für 7*/

                                      {hilf1 = array[6] -array[7];


                                             if (hilf1 >1 || hilf1 < -1)

                                                {printf("%d ", array[i]);


	}}}}}}}}

	printf("\n");

}

[Klotzkopp]

if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1) && (hilf3 >1 || hilf3 < -1) && (hilf4 >1 || hilf4 < -1))   /*für 3*/

Hier ist schon mal ein Fehler: Du fragst hier hilf4 ab, ohne es jemals initialisiert zu haben.

hilf4= array [2] -array[4];

Hier ermittelst du dann hilf4, benutzt das Ergebnis aber nie wieder.

hilf1 = array [4] - array[5];

hilf2 = array[4] -array [5];[/code]
Hier füllst du hilf1 und hilf2 mit demselben Ausdruck. Ist bestimmt auch nicht Sinn der Sache.



Aber ich würde das grundsätzlich anders aufziehen. Du merkst ja selbst, wie schwierig die Fehlersuche in solchem Code ist.


Schreib dir doch erst mal eine Funktion, die zwei Arrayeinträge prüft und das Ergebnis zurückgibt. Dann kannst du dir die ganzen Hilfsvariablen und Größer-oder-Kleiner-Vergleiche sparen.

[IltisvdT]

Hi royale,

ich sitz an der selben Aufgabe. Ich mache sie aber ganz anders. In den HÜ Folien steht als Tipp eine Adjazenzmatrix. Die sagt dir praktisch, welche Knoten miteinander verbunden sind. Vom Ablauf her mache ich es so:

perm gibt eine Möglichkeit aus, die Zaheln 1 bis 8 anzuordnen. eine funktion (bei mir heißt sie pruefung) prüft mithilfe der adjazenzmatrix, ob die verbundenen Zahlen um mehr als 1 verschieden sind. Dann printet die funktion ausgabe das. Und perm geht von vorne los mit der nächsten Anordnungsmöglichkeit. Es läuft bei mir auch noch nciht richtig, aber ich denke, das ist ne Ecke überishctlicher als deins. Zumindest ist es das bei mir.

[royale]

if ((hilf1 >1 || hilf1 < -1) && ( hilf2 >1 || hilf2 < -1) && (hilf3 >1 || hilf3 < -1) && (hilf4 >1 || hilf4 < -1))   /*für 3*/

Hier ist schon mal ein Fehler: Du fragst hier hilf4 ab, ohne es jemals initialisiert zu haben.

hilf4= array [2] -array[4];

Hier ermittelst du dann hilf4, benutzt das Ergebnis aber nie wieder.

hilf1 = array [4] - array[5];

hilf2 = array[4] -array [5];

Hier füllst du hilf1 und hilf2 mit demselben Ausdruck. Ist bestimmt auch nicht Sinn der Sache.

Aber ich würde das grundsätzlich anders aufziehen. Du merkst ja selbst, wie schwierig die Fehlersuche in solchem Code ist.

Schreib dir doch erst mal eine Funktion, die zwei Arrayeinträge prüft und das Ergebnis zurückgibt. Dann kannst du dir die ganzen Hilfsvariablen und Größer-oder-Kleiner-Vergleiche sparen.

jau okay, habs geändert, jetzt funzt es auch, nur die ausgabe is nen bissel strange vom format her

sieht in etwa so aus:

2

6

8

5

4

1

3

7

a

d

f

w

e

h

g

Is zwar nicht schön, aber immerhin schonmal ein ergebnis^^