# Ein Rätsel (das man rekursiv lösen kann?)



## VanHellsehn (30. November 2009)

Hi,
Ich habe seit einigen Tagen ein Rätsel in C.
Und war soll ich z.B. diese Gleichungen lösen:


```
(x[0]*1000+x[1]*100+x[2]*10+x[3]) /
		(x[4]*10+x[5]) ==
		(x[4]*100+x[6]*10+x[3])
		&&
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) -
		(x[7]*1000+x[8]*100+x[1]*10+x[6])==
		(x[5]*10+x[4])
		&&
		(x[9]*1000+x[8]*100+x[3]*10+x[1]) -
		(x[7]*1000+x[8]*100+x[3]*10+x[5]) ==
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
		&&
		(x[0]*1000+x[1]*100+x[2]*10+x[3]) -
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) ==
		(x[9]*1000+x[8]*100+x[3]*10+x[1])
		&&
		(x[4]*10+x[5]) +
		(x[7]*1000+x[8]*100+x[1]*10+x[6]) ==
		(x[7]*1000+x[8]*100+x[3]*10+x[5])
		&&
		(x[4]*100+x[6]*10+x[3]) *
		(x[5]*10+x[4]) == 
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
```

Wobei jeder jede Vaiable für eine Zahl stehen darf! D.h. wenn x[0] = 0 darf keine andere Variable den Wert 0 haben.

Als Tipp steht noch das man es mit Selektion und Interation gelöst werden kann.

Doch bisher fehlt mir der ansatz wie ich die Variablen mit Werten füllen soll.

Kann mir da einer helfen?


MfG,
Marvvvv =)


----------



## KD3 (30. November 2009)

Naja ich würde mal sagen Bruteforcing(Ger) (Eng) wäre der Ansatz an den man sich richten sollte


----------



## VanHellsehn (30. November 2009)

das Problem ist ich möchte Später auch die werte für die einzelnen Variablen haben und so wie ich das verstanden habe "prüft" man mit Brutforce immer ein wert nach dem anderen das heißt 1, 2, 3.. a, b ,c.. 01, 02, 03.. a3, a4, a5...


----------



## KD3 (30. November 2009)

Auszug aus Wiki: Lösungsmethode für Probleme aus den Bereichen Informatik, Kryptologie und Spieltheorie, die auf dem *Ausprobieren* aller (oder zumindest vieler) *möglicher* Fälle beruht


----------



## VanHellsehn (30. November 2009)

KD3 hat gesagt.:


> Auszug aus Wiki: Lösungsmethode für Probleme aus den Bereichen Informatik, Kryptologie und Spieltheorie, die auf dem *Ausprobieren* aller (oder zumindest vieler) *möglicher* Fälle beruht


Ja schonklar das man alles was möglich ist ausprobieren soll aber wie mache ich das?


----------



## Matthias Reitinger (30. November 2009)

Hallo,

wenn ich das richtig verstanden habe, dann könnte man hier einfach alle Permutationen der Ziffern 0-9 durchprobieren. Die englische Wikipedia liefert dazu auch einige hilfreiche Algorithmen.

Grüße,
Matthias


----------



## sheel (30. November 2009)

Mal eine grundlegene Frage: Sind die Unbekannten wenigstens ganze Zahlen?


----------



## Jennesta (30. November 2009)

Irre ich mich oder ist das ein stink-normales Gleichungssystem?


----------



## Matthias Reitinger (1. Dezember 2009)

Jennesta hat gesagt.:


> Irre ich mich oder ist das ein stink-normales Gleichungssystem?


Falls deine Definition von „stink-normal“ bedeutet, dass das Gleichungssystem nichtlinear ist und man nur an speziellen ganzzahligen Lösungen interessiert ist, dann irrst du dich nicht 

Grüße,
Matthias


----------



## VanHellsehn (1. Dezember 2009)

sheel hat gesagt.:


> Mal eine grundlegene Frage: Sind die Unbekannten wenigstens ganze Zahlen?


Hi,
Ja das sind 10 Variablen das heißt 0-9 und jede Variable hat einen aderen Wert d.h. es darf z.B. die 1 nur in einer variable vorkommen.

Das Rätsel sah voher so aus (zwar mit Symbolen anstatt Zeichen aber naja):


```
a b c d  :    e f    =  e g d
   -           +          *
h i j e  -  h i b g  =   f e
   =           =          =
j i d b  -  h i d f  = c g g c
```

Eventuell zeigt euch das was ich vor mir haben =)
Vobei da oben ein Buchstabe natürlich auch nur ein Wert sein darf.
Summen ergeben sie eine Zahl.
D.h. wenn man a = 1, b = 2, c = 3, d = 4 hat heißt die erste Zahl 1234 



> Hallo,
> 
> wenn ich das richtig verstanden habe, dann könnte man hier einfach alle Permutationen der Ziffern 0-9 durchprobieren. Die englische Wikipedia liefert dazu auch einige hilfreiche Algorithmen.
> 
> ...



Der ansatz ist super doch komme ich nicht ganz damit klar..


----------



## Vereth (1. Dezember 2009)

Als erstes würde ich die Gleichungen so umformen, dass du nur Additionen und Multiplikationen hast; den Ärger mit Subtraktionen und Divisionen kannst du dir damit ersparen. Als zweites wäre es hilfreich, welche Schlussfolgerungsregeln es gibt, die man nutzen kann. Erst dann sollte man sich an das Brute-Force heranwagen.
In puncto Brute-Force-Algorithmen gilkt Donald Knuth's Dancing Links Algorithmus als effizient, den ich selber mal als solver-Klasse in C++/wxWidgets sowie in PHP und JavaScript (ja, es geht!) implementiert habe; wenn man das Grundprinzip erstmal begriffen hat, ist es gar nicht so schwer nachzuvollziehen, wie er funktioniert.
Oder du löst es in PROLOG.

PS: Vielleicht kann man es auch mit Genetischen Algorithmen lösen.


----------



## sheel (1. Dezember 2009)

Ich hab mal ein kleines Programm geschrieben, in ca 800 Minuten hab ich das Ergebnis 

(Man könnte sicher einiges besser machen, aber hab nicht so viel Zeit investiert)


----------



## colblake (1. Dezember 2009)

Hallo VanHellsehn,

im prinzip ist das ähnlich eines Sudoku-Rätzels. Du hast eine Menge an Bedngungen die erfüllt sein müssen und eine Menge an Zahlen die in der richtigen Kombination die Bedingungen erfüllen.
Schwierig ist hier nur, wie man die Bedingungen formuliert. 

Ich hab mal ein Sudoku-Solver geschrieben und das nach folgendem Alg. gemacht: (Der Alg hat auch einen Namen, der mir aber mom nicht mehr einfallen will) 


start: funktion(erste variable)

```
function(Variable)
{
	for(Variable = 0; Variable < 10; Variable++)
	{
		IF(checkBedingungen() == true)
		{
			funktion(nächste variable)
		}
	}
}
```
vlt. hilfts ja

gruß 
Col.Blake


----------



## Vereth (1. Dezember 2009)

Der Vergleich mit Sudoku ist gar nicht so schlecht. Bei Sudoku wird mit Kandidaten gearbeitet, das sind Zahlen, die in den Zellen platziert sein könnten. Nach und nach werden die Kandidaten ermittelt, die ausgeschlossen werden können, weil sie bestimmte Bedingungen nicht erfüllen; so wird allmählich die Lösung ermittelt.
Bei deinem Rätsel hast du die Kandidaten 0-9 für deine Variablen. Du kannst z.B. die Null für diejenigen Variablen ausschließen, die als erste Ziffer für eine Zahl erscheinen. Und wenn bei einer Addition die Summe mehr Ziffern hat als die Summanden, kannst du alle Ziffern außer 1 ausschließen. Allerdings verkompliziert die Mölglichkeit von Überträgen die Lösungssuche.
Bestünde das Rätsel nur aus Additionen, wäre es wesentlich einfacher, denn dann könntest du mit möglichen Zahlentripeln für die Stellen arbeiten, z.B. ist 7/8/6 eine mögliche Konstellation, wenn ein Übertrag vorhanden ist, denn 7+8+1=16, 7/8/3 ist aber keine, denn weder 7+8+1 noch 7+8 ergibt 3 oder 13.

Übrigens: Brute-Force-Solver für Sudoku verwenden meistens den oben erwähnten Dancing-Links-Algorithmus.


----------



## VanHellsehn (1. Dezember 2009)

Hi,
Die Aufgabe die mir gestellt wurde soll aber mit C und ausschließlich mit der stdio.h libary gelöst werden..
also mit keiner anderen Sprache.. ^^


----------



## deepthroat (1. Dezember 2009)

Hi.





VanHellsehn hat gesagt.:


> Hi,
> Die Aufgabe die mir gestellt wurde soll aber mit C und ausschließlich mit der stdio.h libary gelöst werden..
> also mit keiner anderen Sprache.. ^^


Es hat doch niemand etwas von einer anderen Sprache gesagt. \edit: Ach, es ist PROLOG genannt worden. Sorry.

Außerdem hat Matthias ja schon einen Hinweis gegeben wie man das relativ einfach lösen kann.

Gruß

PS: Ich hab grad mal den Permutationsansatz implementiert und das Programm liefert im Grunde sofort die einzige Lösung.


----------



## VanHellsehn (1. Dezember 2009)

Hi,
Ja Mathias hat mir schöne mölichkeiten gezeigt doch kann ich diese nich umsetzten.
Mein Problem ist auch ich kenne nicht alle Funktionen von C.
Ich habe Jahre lang nur OOP mit PHP gemacht.


----------



## deepthroat (1. Dezember 2009)

VanHellsehn hat gesagt.:


> Hi,
> Ja Mathias hat mir schöne mölichkeiten gezeigt doch kann ich diese nich umsetzten.
> Mein Problem ist auch ich kenne nicht alle Funktionen von C.
> Ich habe Jahre lang nur OOP mit PHP gemacht.


Und warum kannst du nicht suchen? ;-]

http://www.tutorials.de/forum/c-c/313236-c-permutation-mit-10-zahlen.html


----------



## Vereth (2. Dezember 2009)

Also: allgemein gesprochen hast musst du eine verträgliche Zuordnung von Aktionen zu Ressourcen finden. Bei dir ist eine Aktion das Zuordnen einer Ziffer zu einem Ort in deiner Rätseltabelle. Die Ressourcen sind die Variablen und die möglichen Zahlentripel. Eine Aktion verbraucht eine Ressource, und aufgrund der verbrauchten Ressourcen sind alle die Möglichkeiten auszuschliessen, die diese verbrauchten Ressourcen benötigen. Du hast genau dann eine Lösung gefunden, wenn deine verwendeten Möglichkeiten nicht mehr und nicht weniger Ressourcen verbrauchen als du hast.
Du kannst dann eine Tabelle der Möglichkeiten und Ressourcen anlegen, mit der du die Information verwaltest, welche Möglichkeiten und Ressourcen noch zur Verfügung stehen und welche auszuschließen sind, und diese dann rekursiv abarbeiten.
Der Dancing-Links-Algorithmus verwendet , wie es für schwach besetzte Matrizen üblich ist, für diese Tabelle Listenelemente, die sowohl in der Zeile (die Ressourcen, die eine bestimmte Aktion verbraucht) als auch in der Spalte (die Aktionen, die eine bestimmte Ressource benötigen) doppelt verzeigert sind. Elemente, die nicht verwendet werden, werden aus der Liste herausgenommen und beim Rollback in umgekehrter Reihenfolge wieder eingehängt. Wegen der doppelten Verzeigerung beinhaltet das herausgenommene Element die Information, bei welchen Nachbarn es wieder einzuhängen ist. So etwas kann man auch mit ANSI-C implementieren, man braucht allerdings schon etwas Übung.
Wenn du nur stdio.h verwenden darfst, dann musst du diese Tabelle als Array implementieren, denn für dynamische Speicherverwaltung brauchst du malloc.h; die Möglichkeiten der Verzeigerung kannst du trotzdem nutzen, wenn du dir eine passende struct definierst.


----------



## VanHellsehn (13. Dezember 2009)

Der Tipp mit dem Suchen war überflüssig.. ich habe gesucht und diesen Artikel gefunden doch erzeugte der Code bei mir nen Error.. nach diesem Fehler habe ich diesen Thread erröffnet 
Aber ich bin einfach zu schlecht ><
Also ein guter hacker würde ich aufjedenfall nicht werden 
Hmm.. 


```
#include <stdio.h>

bool pruefe(int x[10])
{
	// Rechnungen pruefen
	if( (x[0]*1000+x[1]*100+x[2]*10+x[3]) /
		(x[4]*10+x[5]) ==
		(x[4]*100+x[6]*10+x[3])
		&&
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) -
		(x[7]*1000+x[8]*100+x[1]*10+x[6])==
		(x[5]*10+x[4])
		&&
		(x[9]*1000+x[8]*100+x[3]*10+x[1]) -
		(x[7]*1000+x[8]*100+x[3]*10+x[5]) ==
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
		&&
		(x[0]*1000+x[1]*100+x[2]*10+x[3]) -
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) ==
		(x[9]*1000+x[8]*100+x[3]*10+x[1])
		&&
		(x[4]*10+x[5]) +
		(x[7]*1000+x[8]*100+x[1]*10+x[6]) ==
		(x[7]*1000+x[8]*100+x[3]*10+x[5])
		&&
		(x[4]*100+x[6]*10+x[3]) *
		(x[5]*10+x[4]) == 
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
	)
	{
		return true;
	}
	else
		return false;
}

int erhoehe(int symbol)
{
	int i;

	if(symbol==9)
		symbol=0;
	else
		symbol++;
	
	return symbol;
}

void main(void)
{
	int symbol[10]={0,1,2,3,4,5,6,7,8,9},x[10],i=0;
	
	while(true)
	{		
		// Zahlen mit den Rechnungen pruefen
		if(pruefe(x)==true)
		{
			for(i;i<=9;i++)
			{
				// Zahlen ausgeben
				printf("\n\tSymbol %i: %i",i+1,x[i]);
			}
			printf("\n\n\tIch habs geschaft! ! ! !\n\n\n\t");
			break;
		}

		for(i=0;i<=9;i++)
			symbol[i] = erhoehe(symbol[i]);
	}
}
```

Das war mein aller erster Versuch.. nur dieser Versuch Testet ja eindeutig immer nur in der gleichein Rheinfolge die Zahlen ab. 
Also 0 1 2 3 4 5 6 7 8 9 dann 9 0 1 2 3 4 5 6 7 8 das macht er bis 0 9 8 7 6 5 4 3 2 1 und fängt von vorne an.. also  0 7 8 2 3 4 9 5 6 würde er z.B. nicht Testen..


----------



## deepthroat (13. Dezember 2009)

VanHellsehn hat gesagt.:


> Der Tipp mit dem Suchen war überflüssig.. ich habe gesucht und diesen Artikel gefunden doch erzeugte der Code bei mir nen Error..


Dann versuche den Fehler zu verstehen und berichtige ihn. Alles was du tun müßtest ist statt "char" "int" einzusetzen.

Gruß


----------



## VanHellsehn (13. Dezember 2009)

Er spuckt bei mir Folgenden Error aus wenn ich den Code so wie er dort steht in einem neuen Projekt ausführe:

c:\...\Visual Studio Projects\test\main.cpp(18) : error C3861: 'strlen': Bezeichner wurde auch mit einer argumentbezogenen Suche nicht gefunden

Wieso findet er die Funktion nicht?
Und wie soll ich es dann machen?


----------



## deepthroat (13. Dezember 2009)

VanHellsehn hat gesagt.:


> Er spuckt bei mir Folgenden Error aus wenn ich den Code so wie er dort steht in einem neuen Projekt ausführe:
> 
> c:\...\Visual Studio Projects\test\main.cpp(18) : error C3861: 'strlen': Bezeichner wurde auch mit einer argumentbezogenen Suche nicht gefunden
> 
> Wieso findet er die Funktion nicht?


Weil die Funktion in string.h deklariert ist und du in C++ deshalb cstring include'n müßtest.


VanHellsehn hat gesagt.:


> Und wie soll ich es dann machen?


Du willst ja keine Strings (bzw. char Arrays) verarbeiten sondern ein int-Array. Deswegen brauchst du strlen nicht, da du ja weißt wie groß dein Array ist.

Da wo println in der permut Funktion steht müßtest du deine Prüfung einbauen.

Gruß


----------



## VanHellsehn (13. Dezember 2009)

```
/*
 * File:   Main.c
 * Author: Tom
 *
 */
 
#include <stdio.h>
#include <stdlib.h>
 
void swap(int c, int firstIndex, int secondIndex);
void permut(int c, int endIndex);
 
int main(int argc, int argv) {
    int c[10];
    printf("Chars: ");
    scanf("%i",&c);
    fflush(stdin);
    permut(c,9);
    return (EXIT_SUCCESS);
}
 
void swap(int c, int firstIndex, int secondIndex){
    int tmp = c[firstIndex];
    c[firstIndex] = c[secondIndex];
    c[secondIndex] = tmp;
}
 
void permut(int c, int endIndex){
    if(endIndex == 0){
       printf("%i\n",c);
    }else{
       permut(c,endIndex-1);
       int i;
       for(i = 0; i<endIndex;i++){
           swap(c,i,endIndex);
           permut(c,endIndex-1);
           swap(c,i,endIndex);
       }
    }
}
```

Das kommt mir alles vor wie Müll.. 
Also entweder ich habe wieder alles falsch gemacht oder ich hab alles falsch gemacht ^^


----------



## deepthroat (13. Dezember 2009)

Also ein bißchen mitdenken solltest du schon. Wozu liest du denn da jetzt irgendwas mit scanf ein? Das brauchst du doch alles gar nicht. 


```
int main(int argc, char** argv) {
  int num[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  permut(num, 9);
}


void permut(int *c, int endIndex){
    if(endIndex == 0){
      if (pruefe(c)) {
        for (int i = 0; i < 10; ++i) {
          printf("%d = %d\n", i, c[i]);
        }
        puts("");
      }
    }else{
       permut(c,endIndex-1);
       int i;
       for(i = 0; i<endIndex;i++){
           swap(c,i,endIndex);
           permut(c,endIndex-1);
           swap(c,i,endIndex);
       }
    }
}
```
Gruß


----------



## VanHellsehn (13. Dezember 2009)

Er spuckt mir die gnaze zeit folgende Fehler aus:


```
c:\...\Visual Studio Projects\test\main.cpp(15) : error C2664: 'permut': Konvertierung des Parameters 1 von 'int [10]' in 'int' nicht möglich
        Diese Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat
c:\...\Visual Studio Projects\test\main.cpp(20) : error C3861: 'pruefe': Bezeichner wurde auch mit einer argumentbezogenen Suche nicht gefunden
c:\...\Visual Studio Projects\test\main.cpp(30) : error C2664: 'swap': Konvertierung des Parameters 1 von 'int *' in 'int' nicht möglich
        Diese Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat
c:\...\Visual Studio Projects\test\main.cpp(32) : error C2664: 'swap': Konvertierung des Parameters 1 von 'int *' in 'int' nicht möglich
        Diese Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat
c:\...\Visual Studio Projects\test\main.cpp(38) : error C2109: Index erfordert ein Array oder einen Zeigertyp
c:\...\Visual Studio Projects\test\main.cpp(39) : error C2109: Index erfordert ein Array oder einen Zeigertyp
c:\...\Visual Studio Projects\test\main.cpp(39) : error C2109: Index erfordert ein Array oder einen Zeigertyp
c:\...\Visual Studio Projects\test\main.cpp(40) : error C2109: Index erfordert ein Array oder einen Zeigertyp
c:\...\Visual Studio Projects\test\main.cpp(44) : error C2365: 'pruefe': Erneute Definition; vorherige Definition war 'Ehemals unbekannter Bezeichner'
```

Das ist mein Code

```
/*
 * File:   Main.c
 * Author: Tom
 *
 */
 
#include <stdio.h>
#include <stdlib.h>
 
void swap(int c, int firstIndex, int secondIndex);
void permut(int c, int endIndex);

int main(int argc, char** argv) {
  int num[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  permut(num, 9);
}

void permut(int *c, int endIndex){
    if(endIndex == 0){
      if (pruefe(c)) {
        for (int i = 0; i < 10; ++i) {
          printf("%d = %d\n", i, c[i]);
        }
        puts("");
      }
    }else{
       permut(c,endIndex-1);
       int i;
       for(i = 0; i<endIndex;i++){
           swap(c,i,endIndex);
           permut(c,endIndex-1);
           swap(c,i,endIndex);
       }
    }
}

void swap(int c, int firstIndex, int secondIndex){
    int tmp = c[firstIndex];
    c[firstIndex] = c[secondIndex];
    c[secondIndex] = tmp;
}

bool pruefe(int x[10])
{
	// Rechnungen pruefen
	if( (x[0]*1000+x[1]*100+x[2]*10+x[3]) /
		(x[4]*10+x[5]) ==
		(x[4]*100+x[6]*10+x[3])
		&&
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) -
		(x[7]*1000+x[8]*100+x[1]*10+x[6])==
		(x[5]*10+x[4])
		&&
		(x[9]*1000+x[8]*100+x[3]*10+x[1]) -
		(x[7]*1000+x[8]*100+x[3]*10+x[5]) ==
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
		&&
		(x[0]*1000+x[1]*100+x[2]*10+x[3]) -
		(x[7]*1000+x[8]*100+x[9]*10+x[4]) ==
		(x[9]*1000+x[8]*100+x[3]*10+x[1])
		&&
		(x[4]*10+x[5]) +
		(x[7]*1000+x[8]*100+x[1]*10+x[6]) ==
		(x[7]*1000+x[8]*100+x[3]*10+x[5])
		&&
		(x[4]*100+x[6]*10+x[3]) *
		(x[5]*10+x[4]) == 
		(x[2]*1000+x[6]*100+x[6]*10+x[2])
	)
	{
		return true;
	}
	else
		return false;
}
```


----------



## sheel (13. Dezember 2009)

Fehler 1: Die Signatur und Die Funktion permut selber passen nicht zusammen
Fehler 2, 9: pruefe hat keine Signatur
Fehler 3-8: swap-Param 1 sollte eigentlich ein Pointer sein


----------



## Vereth (14. Dezember 2009)

Ich habe hier mal ein auf die Schnelle zusammengehacktes Programm, das die fehleranfällige Permutations-Implementierung vermeidet. Es arbeitet rekursiv und verwendet deine pruefe-Funktion; an ihr wurde lediglich die Deklaration verändert, alles andere wurde unbesehen übernommen. Ich habe es zwar nicht getestet, aber es müsste so funktionieren wie gewünscht. Ich hoffe, die Anzahl der Syntaxfehler hält sich in erträglichen Grenzen und wünsche dir viel Erfolg.


```
#define ZIFFERN 10

int pool[ZIFFERN];
int loesung[ZIFFERN];

void main()
{
  init();
  if ( solve(0) )
  { output(); }
  else
  { printf("Keine Lösung gefunden\n"); }
}

void output()
{
  for ( int i = 0; i < ZIFFERN; i++ )
  { printf("%d",solution[i]); }
  printf("\n");
}

void init()
{
  for ( int i = 0; i < ZIFFERN; i++ ) 
  { pool[i] = i; }
}

bool solve ( int tiefe )
{
  // das limit gibt an, wie viele Ziffern zum Ausprobieren verfuegbar sind
  int limit = ZIFFERN - tiefe;

  // Wenn alle Ziffern feststehen, dann pruefen und Ergebnis zurueckliefern
  if ( tiefe == ZIFFERN )
  { return pruefe(loesung); }

  // alle verfuegbaren Ziffern ausprobieren
  for ( int i = 0; i < limit; i++ )
  {
    // die aktuelle Versuchs-Ziffer aus dem pool entnehmen
    loesung[tiefe] = pool[i];
    // letzte verfügbare Ziffer an die Stelle der alten kopieren
    // damit sie beim naechsten Verringern des limits nicht verloren geht
    pool[i] = pool[limit-1];
    // Rekursion: bei Erfolg zurückkehren
    if ( solve(tiefe+1) )
    { loesung[tiefe] = n; return true; }
    // keine loesung gefunden, also alten Zustand wieder herstellen
    pool[limit-1] = pool[i];
    pool[i] = loesung[tiefe];
  }
  return false;
}

bool pruefe(int *x)
{
    // Rechnungen pruefen
    if( (x[0]*1000+x[1]*100+x[2]*10+x[3]) /
        (x[4]*10+x[5]) ==
        (x[4]*100+x[6]*10+x[3])
        &&
        (x[7]*1000+x[8]*100+x[9]*10+x[4]) -
        (x[7]*1000+x[8]*100+x[1]*10+x[6])==
        (x[5]*10+x[4])
        &&
        (x[9]*1000+x[8]*100+x[3]*10+x[1]) -
        (x[7]*1000+x[8]*100+x[3]*10+x[5]) ==
        (x[2]*1000+x[6]*100+x[6]*10+x[2])
        &&
        (x[0]*1000+x[1]*100+x[2]*10+x[3]) -
        (x[7]*1000+x[8]*100+x[9]*10+x[4]) ==
        (x[9]*1000+x[8]*100+x[3]*10+x[1])
        &&
        (x[4]*10+x[5]) +
        (x[7]*1000+x[8]*100+x[1]*10+x[6]) ==
        (x[7]*1000+x[8]*100+x[3]*10+x[5])
        &&
        (x[4]*100+x[6]*10+x[3]) *
        (x[5]*10+x[4]) ==
        (x[2]*1000+x[6]*100+x[6]*10+x[2])
    )
    {
        return true;
    }
    else
        return false;
}
```


----------

