Ein Zahlenproblem

[PICture]

Hallo!

Mir ist dazu nur eingefallen (falls ich mich nicht irre), dass zum Abspeichern von allen Kombinationen werden in BCD Kodierung 5 * 3628800 = 18 144 000 Bytes, also über 18 MB benötigt.

[radbruch]

Rekursiv in C (für den asuro):

// Zahlenproblem rekursiv in C :)                                       29.7.2011 mic

#include "asuro-probot.h"
#include "asuro-probot.c"

#define ziffern 4

uint8_t muster[ziffern];
uint8_t x[10], gefunden;
uint32_t nr=0;

void suchen(uint8_t z)
{
	uint8_t y;

	for(x[z]=0; x[z]<10; x[z]++)
	{
		gefunden=0;
		for(y=0; y<z; y++)
		   if(muster[y]==x[z]) gefunden=1;
		if(!gefunden)
		{
			muster[z]=x[z];
			if(z < (ziffern-1))
			{
				suchen(z+1); // Rekursion!
			}
			else
			{
				if(0) // 1 bedeutet: Ausgabe der Ziffernkombinationen
				{
					PrintInt(nr);
					SerWrite(": ", 2);
					for(y=0; y<ziffern; y++)
					{
						while(!(UCSRA & 0x20));
						UDR = muster[y]+'0';
					}
					SerWrite("\r\n", 2);
				}
				nr++;
			}
		}
	}
}

int main(void)
{
	Init();
	PORTC |= 3; // Odo-PullUps simulieren für PollSwitch()
	StatusLED(RED);

	for(x[0]=0; x[0]<10; x[0]++)
	{
   	muster[0]=x[0];
		suchen(1);
	}
	while(1)
	{
   	PrintInt(nr);
		SerWrite("\r\n", 2);
		Beep(50);
	}
return(0);
}

Probelauf mit 4 Ziffern ergibt wieder 5040. Speichern will ich das Ergebniss natürlich nicht. Fragt sich nun, wie man die Symmetrien der Ziffernfolgen einbauen könnte.

Gruß

mic

[Edit]
Nach der Optimierung:

// Zahlenproblem rekursiv in C :)                                       31.7.2011 mic

#include <avr/io.h>
#include <stdlib.h>

#define ziffern 3

uint8_t x[10], y, gefunden;
uint32_t nr=1;

void SerWrite(char *data, uint8_t length); // char???
void PrintInt32(uint32_t wert);
void ausgabe(void);

void suchen(uint8_t z)
{
	for(x[z]=0; x[z]<10; x[z]++)
	{
		gefunden=0;
		for(y=0; y<z; y++) if(x[y]==x[z]) gefunden=1;
		if(!gefunden)
		{
			if(z < (ziffern-1)) suchen(z+1); // Rekursion!
			else
			{
				ausgabe(); // Ausgabe der Ziffernkombinationen in x[0] bis x[ziffern-1]
				nr++;
			}
		}
	}
}

int main(void)
{
	SerWrite("\033[1;1H", 6); // home  VT100-Emulation
	SerWrite("\033[2J", 4); //clear terminal screen

	for(x[0]=0; x[0]<5; x[0]++) suchen(1);

	nr--;
	DDRD |= (1<<PD5); // Led
	while(1)
	{
   	PrintInt32(nr);
		SerWrite("\r\n", 2);
		if(PIND & (1<<PD5)) PORTD &= ~(1<<PD5); else PORTD |= (1<<PD5); // blinken
	}
return(0);
}

void SerWrite(char *data, uint8_t length) // aus der asuro-Lib
{
	unsigned char i = 0;
	UCSRB = 0x08; // enable transmitter
	while (length > 0) {
		if (UCSRA & 0x20) { // wait for empty transmit buffer
			UDR = data[i++];
			length --;
		}
	}
	while (!(UCSRA & 0x40));
	//for (i = 0; i < 0xFE; i++)
		//for(length = 0; length < 0xFE; length++);
}

void PrintInt32(uint32_t wert) // aus der asuro-Lib
{  char text[7]="       ";
	itoa(wert,text,10);
	SerWrite(text,7);
}

void ausgabe(void)
{
	for(y=0; y<ziffern; y++)
	{
		while(!(UCSRA & 0x20));
		UDR = x[y]+'0';
	}
 	SerWrite("  ",2);
	for(y=0; y<ziffern; y++)
	{
		while(!(UCSRA & 0x20));
		UDR = 9-x[y]+'0';
	}
 	SerWrite("  ",2);
	PrintInt32(nr);
 	SerWrite("\r\n",2);
}

Ohne Ausgabe schafft mein asuro die 10-stelligen Kombinationen in knapp 22 Minuten :)

[iBot]

@radbruch:
Du bist echt ein Held. Hab das Programm für Bascom mal eben im Simulator laufen lassen und es funktioniert wirklich einwandfrei.
Sag mal wie hast du das so schnell hinbekommen? Ich hätte dafür sicher noch einige Wochen grübeln müssen…
Und jetz auch noch in C …
Allerdings hab ich mal noch eine Frage: Warum kommst du nur auf 362880 Möglichkeiten ? Es müssten doch 3628800 sein…
bzw. was meinst du mit "Da der Zähler voreilt…"?

@PICture:
Na zum Glück muss es nur Ausgegeben und nicht gespeichert werden .

[PICture]

Ich bin eher an Hexzahlen gewöhnt um alle mögliche Kombinationen zu erstellen, da es am einfachsten geht. Die grösste Zahl wäre 9876543210 d = 24CB016EA h was "nur" 34 Bits braucht und die grössere bis 2FFFFFFFF h könnte man weg lassen. Danach muss man natürlich jede Hexzahl in eine Dezimale wandeln.

Es müssten natürlich noch dezimale Zahlen, wo sich gleiche Ziffern wiederholen, entfernt werden.

[radbruch]

Sag mal wie hast du das so schnell hinbekommen?

Das ist reine Übungssache :) Allerdings war es zufällig auch mein erstes C-Programm mit Rekursion.

...Danach muss man natürlich jede Hexzahl in eine Dezimale wandeln.

Und dann muss mannur noch alle Zahlen mit doppelten Ziffern entfernen...

Allerdings hab ich mal noch eine Frage: Warum kommst du nur auf 362880 Möglichkeiten ? Es müssten doch 3628800 sein…
bzw. was meinst du mit "Da der Zähler voreilt…"?

Die Ausgabe des Zählerstandes erfolgt am Ende der For-Schleife für die erste Ziffer:

    Print "Zwischenstand: " ; Nr ; " Kombinationen erzeugt"
Next N(1)

Decr Nr

Zu diesem Zeitpunkt sind alle Kombinationen die mit "0" anfangen generiert. Allerdings wurde die Nr-Variable schon für die nächste Runde erhöht, deshalb eilt der Zähler an dieser Stelle immer um 1 vor.

Ich denke, auch das Symmetrieproblem ist gelöst:

				if(0) // 1 bedeutet: Ausgabe der Ziffernkombinationen
				{
					PrintInt(nr);
					SerWrite(": ", 2);
					for(y=0; y<ziffern; y++)
					{
						while(!(UCSRA & 0x20));
						UDR = muster[y]+'0';
					}
					SerWrite("  ", 2);
					for(y=0; y<ziffern; y++)
					{
						while(!(UCSRA & 0x20));
						UDR = 9-muster[y]+'0';
					}
					SerWrite("\r\n", 2);
				}

Damit kann man die äußerste Schleife im Hauptprogramm von 0 bis 4 laufen lassen und durch die Spiegelung der Werte wird der Bereich 5 bis 9 generiert.

Wozu kann man solche Kombinationen eigentlich nutzen?

[SprinterSB]

Falls das Problem noch aktuell ist, hier meine Lösung in C.

Eingegeben wird die Anzahl der zu permutierenden Zeichen (N)
und die Nummer der auszugebenden Permutation (n).

Beispiel mit N = 5, n = 1
#1: 12345

Beispiel mit N = 5, n = 120
#120: 54321

Beispiel mit N = 3, n = 0
#1: 123
#2: 132
...
#6: 321

Beispiel mit n = 12, n = 100000
#100000: 12368AB59704

#include <stdio.h>
#include <string.h>

#define DIGITS "1234567890ABCDEF"

int print_perm (unsigned int N, unsigned int n0)
{
    char *l, letters[] = DIGITS;
    int j, digit[N];
    unsigned int n = n0;
    
    // n0 in faktorielle Darstellung umwandeln
    
    for (unsigned int i = 1; i <= N; i++)
    {
        digit[i-1] = n % i;
        n /= i;
    }
    
    if (n)
        return 0;
        
    // n0-te Permutation ausdrucken
    
    printf ("#%d: ", n0 + 1);
    
    for (int i = N-1; i >= 0; i--)
    {
        for (j = -1, l = letters - 1; j < digit[i]; j += *++l != ' ');
        printf ("%c", *l);

        // Gedruckte Zeichen aus Liste entfernen
        *l = ' ';
    }
    
    printf ("\n");
    
    return 1;
}

int main ()
{
    unsigned int n, N;
    
    printf ("\nAnzahl Zeichen: ");
    scanf ("%u", &N);

    printf ("\nPermutation Nr. (0 fuer alle): ");
    scanf ("%u", &n);
    
    if (N == 0 || N > strlen (DIGITS))
    {
        printf ("Ungueltige Eingabe: Anzahl Zeichen in 1..%d\n",
                strlen (DIGITS));
        return 1;
    }
    
    if (n)
        print_perm (N, n-1);
    else
        while (print_perm (N, n++));
    
    return 0;
}

Der Code ist einfach gehalten und berechnet die faktorielle Darstellung für jede Permutation neu.
Für eine effiziente Implementierung falls alle Permutationen gebraucht werden oder nur eine Teilmenge aus einer Obermenge auszuwählen ist, kann man eine Arithmetik auf der faktoriellen Darstellung implementieren.

[radbruch]

Ja, das sieht echt clever aus, vor allem die imponierende for-Schleife. Allerdings funktioniert es irgendwie nicht richtig. Da mein asuro die stdio.h nicht richtig anwendet habe ich versucht, das Programm anzupassen:

#include "asuro-probot.h"
#include "asuro-probot.c"
//#include <stdio.h>
//#include <string.h>

#define DIGITS "1234567890ABCDEF"

int print_perm (unsigned int N, unsigned int n0)
{
    char *l, letters[] = DIGITS;
    int j, digit[N];
    unsigned int n = n0;
    unsigned int i;
    
    // n0 in faktorielle Darstellung umwandeln

    for (i = 1; i <= N; i++)
    {
        digit[i-1] = n % i;
        n /= i;

			//while(!(UCSRA & 0x20));
			//UDR = digit[i-1]+'0';
    }
		//SerWrite("\r\n\n",3);

    if (n)
        return 0;

    // n0-te Permutation ausdrucken

    //printf ("#%d: ", n0 + 1);
      PrintInt(n0+1);
      SerWrite(": ",2);

    for (i = N-1; i >= 0; i--)
    {
        for (j = -1, l = letters - 1; j < digit[i]; j += *++l != ' ');
        //printf ("%c", *l);

			while(!(UCSRA & 0x20)); // Warten bis USART fertig ist
			//UDR = *l; // Wert an Adresse l senden
			UDR = *l+'0'; // Wert an Adresse l als Ascii-Zeichen senden
			//UDR = i+'0'; // i als Ascii-Zeichen senden

        // Gedruckte Zeichen aus Liste entfernen
        *l = ' ';
    }

    //printf ("\n");
 		SerWrite("\r\n",2); // neue Zeile

    return 1;
}

int main (void)
{
    unsigned int n=0, N=3;

/*    printf ("\nAnzahl Zeichen: ");
    scanf ("%u", &N);

    printf ("\nPermutation Nr. (0 fuer alle): ");
    scanf ("%u", &n);

    if (N == 0 || N > strlen (DIGITS))
    {
        printf ("Ungueltige Eingabe: Anzahl Zeichen in 1..%d\n",
                strlen (DIGITS));
        return 1;
    }
*/
 		SerWrite("\r\n\n",3); // neue Zeile

    if (n)
        print_perm (N, n-1);
    else
        while (print_perm (N, n++));
        
	 while(1);
    return 0;
}

Die Ausgabe:

1    : 123R 6Eƈ "¤    "×"  ˆ Cø (usw....)

Liegts an mir oder am Programm?

Gruß

mic

[Edit]
Die Lösung sollte doch so aussehen:

Beispiel mit N = 3, n = 0
#1: 123
#2: 132
...
#720: 098

[iBot]

Ok also ich hänge immer noch bei der ersten guten Idee von radbruch fest.
Aber ich glaube das Problem ist jetzt im Großen und Ganzen gelöst.

Wozu kann man solche Kombinationen eigentlich nutzen?

ich sag nur Brute Force-Angriffe
Nein natürlich nicht.
In der Zeitschrift "Gong" gibt es jede Woche ein neues sogenanntes "Rechenproblem" , dabei hat man 6 in einander verschachtelte Gleichungen die aus Symbolen bestehen welche je für eine Zahl von 0-9 Stehen. Das Ganze ist oft ziemlich kniffelig zu lösen und weil ich oft nicht bis zur nächsten Ausgabe warten kann und weil es mich irgendwie interessierte, wie das ein Computer lösen könnte, musste ich als erstes erst einmal einen Weg finden, alle erdenklichen Kombinationen für die Variablen bzw. Symbole des Rechenproblems zu finden. Das Einsetzen lassen und auf Richtigkeit überprüfen dürfte da deutlich leichter gehen.

[SprinterSB]

Ja, das sieht echt clever aus, vor allem die imponierende for-Schleife. Allerdings funktioniert es irgendwie nicht richtig. [...] Liegts an mir oder am Programm?

Die Folge "123" wird ja ausgegeben; irgendwas hast du da geändert oder veränderst Optionen, die das ABI verändern (unsigned-char?).

Ich hab's eben genau so auf einem ATmega88 getestet: Funktioniert ebenso wie das PC-Original. Ich verwende Zusatzmodule, so daß ich ganz normal mit printf etc arbeiten kann ohne immer die Quelle für AVR/PC umändern zu müssen. Für solche kleinen Tests ist das super praktisch.

Wenn du alle Permutationen nacheinander willst, ist es wie gesagt günstiger, immer 1 auf die faktorielle Darstellen zu addieren anstatt für jedes n die Darstellung neu zu berechnen. Bei der faktoriellen Darstellung wächst die Wertigkeit der Stellen: 1, 2, 3, 4, ... während sie z.B. beim Dualsystem 2, 2, 2, ... oder beim Zezimalsystem 10, 10, 10, ... ist. Einfach bei der kleinsten Ziffer Eins aufaddieren und stellenweise Überträge berücksichtigen.

Anstsatt "Brutaler Gewalt" würd ich eher bissl Hirnschmalz auf die Lösung inverstieren; so schwer sind die Rätsel ja nicht. Bisher hab ich von denen noch keins gesehen, das nicht durch Überlegen zu knacken gewesen wäre.

[justin]

Nur so als Hinweis:

http://de.wikipedia.org/wiki/Prolog_...n_R.C3.A4tsels