Ziffernwechsler

Inspiriert von dieser Aufgabe in Spiegel Online habe ich ein C-Programm geschrieben, welches diese Aufgabe löst. Anschließend habe ich dies so erweitert, dass alle möglichen Ziffernwechsel bei sechsstelligen Zahlen (100000 < x < 999999) betrachtet, bei denen gilt, dass nach einem Ziffernwechsel die resultierende Zahl das Dreifache der Ausgangszahl ist:

 

#include <stdio.h>
#include <stdlib.h>

#define MIN 100000  // kleinste sechsstellige Zahl
#define MAX 333333  // größte sechstellige Zahl, deren Dreifaches noch sechsstellig ist


int main(int argc, char *argv[]) {
    int i, j, k;
    int stellenwerte[] = {1, 10, 100, 1000, 10000, 100000};
    
    for (i = MIN; i <= MAX; i++){
        for (k = 0; k < 6; k++) {
            for (j = 0; j < 6; j++) {            
                if (3 * i == ziffernwechsler(i, stellenwerte[k], stellenwerte[j])
                    && k > j) {
                    printf("%d * 3 = %d\n",
                        i, ziffernwechsler(i, stellenwerte[k], stellenwerte[j]));
                }
            }    
        }
    }
    //system("PAUSE");
    return 0;
}

int ziffernwechsler (int i, int stellenwert1, int stellenwert2)
{
    switch (stellenwert1) {
        case 100000:
            switch (stellenwert2) {
                case 100000:
                    return i;
                case 1:        // abcdef -> fabcde (a bis f Ziffern)
                    return 10 * (i % 100000)
                        + (i / 100000);
                case 10:    // abcdef -> ebcdaf
                
                case 100:     // abcdef -> dbcaef
                    return i % 100
                        + 100 * (i / 100000)
                        + 1000 * ((i % 1000) % 100)
                        + 100000 * ((i / 100) % 10);
                case 1000:    // abcdef -> cbadef
                    return i % 1000
                        + 1000 * (i / 100000)
                        + 10000 * ((i / 10000) % 10)
                        + 100000 * ((i / 1000) % 10);
                case 10000:    // abcdef -> bacdef
                    return i % 10000
                        + 10000 * (i / 100000)
                        + 100000 * ((i / 10000) % 10);
                default:
                    return -1;
            }
        case 10000:
            switch (stellenwert2) {
                case 10000:
                    return i;
                case 1:        // abcdef die Zahl afcdeb (a bis f Ziffern)
                    return (i / 10000) % 10
                        + 10 * ((i / 10) % 100)
                        + 10000 * (i % 10)
                        + 100000 * ( i / 100000);
                case 10:    // abcdef -> aecdbf
                    return i % 10
                        + 10 * ((i / 10000) % 10)
                        + 100 * ((i / 10) % 1000)
                        + 10000 * ((i / 10) % 10)
                        + 100000 * ( i / 100000);
                case 100:    // abcdef -> adcbef
                    return i % 100
                        + 100 * ((i / 10000) % 10)
                        + 1000 * ((i / 1000) % 10)
                        + 10000 *((i / 100) % 10)
                        + 100000 * (i / 100000);
                case 1000:    // abcdef -> acbdef
                    return i % 1000
                        + 1000 * ((i / 10000) % 10)
                        + 10000 * ((i / 1000) % 10)
                        + 100000 * (i / 100000);
                case 100000:
                    return ziffernwechsler(i, 100000, 10000);
                default:
                    return -1;
            }
        case 1000:
            switch (stellenwert2) {
                case 1000:
                    return i;
                case 1:        // abcdef -> abfdec (a bis f Ziffern)
                    return (i / 1000) % 10
                        + 10 * ((i / 10) % 100)
                        + 1000 * (i % 10)
                        + 10000 * (i / 10000);
                case 10:    // abcdef -> abedcf
                    return i % 10
                        + 10 * ((i / 1000) % 10)
                        + 100 * ((i / 100) % 10)
                        + 1000 * ((i / 10) % 10)
                        + 10000 * (i / 10000);
                case 100:    // abcdef -> abdcef
                    return i % 100
                    + 100 * ((i / 1000) % 10)
                    + 1000 * ((i / 100) % 10)
                    + 10000 * (i / 10000);
                case 10000:
                case 100000:
                    return ziffernwechsler(i, stellenwert2, stellenwert1);
                default:
                    return -1;
            }
        case 100:
            switch (stellenwert2){
                case 100:
                    return i;
                case 1:        // abcdef -> abcfed (a bis f Ziffern)
                    return (i / 100) % 10
                        + 10 * ((i / 10) % 10)
                        + 100 * (i % 10)
                        + 1000 * (i / 1000);
                case 10:    // abcdef -> abcedf
                    return i % 10
                        + 10 * ((i / 100) % 10)
                        + 100 * ((i / 10) % 10)
                        + 1000 * (i / 1000);
                case 1000:
                case 10000:
                case 100000:
                    return ziffernwechsler(i, stellenwert2, stellenwert1);
                default:
                    return -1;
            }
        case 10:
            switch (stellenwert2) {
                case 10:
                    return i;
                case 1:        //abcdef -> abcdfe (a bis f Ziffern)
                    return (i / 10) % 10
                        + 10 * (i % 10)
                        + 100 * (i / 100);
                case 100:
                case 1000:
                case 10000:
                case 100000:
                    return ziffernwechsler(i, stellenwert2, stellenwert1);
                default:
                    return -1;
            }
        case 1:
            switch (stellenwert2) {
                case 1:
                    return i;
                case 10:
                case 100:
                case 1000:
                case 10000:
                case 100000:
                    return ziffernwechsler(i, stellenwert2, stellenwert1);
                default:
                    return -1;
            }
        default:
            return -1;
    }
   

Das Ergebnis liest sich dann wie folgt:

142857 * 3 = 428571
247500 * 3 = 742500
285714 * 3 = 857142

--------------------------------
Process exited after 3.439 seconds with return value 0
Drücken Sie eine beliebige Taste . . .