Advents-Gewinnspiel 2018

Horst_H · Verfasst: Mi 12.12.18 12:48

Hallo,

Gnade, warum immer schwerer machen, die Herausfordeungen ständig steigern wollen.
Ein gutes Lehrer hält das Niveau einer x.ten Klasse auf dem Niveau einer x.ten Klasse und steigert das nicht.
Die Aufgaben müssen lösbar bleiben und nicht zu viel Zeit beanspruchen.
Bei Bedarf nach mehr:
Rätsel, Puzzles und anderer Denksport

Gruß Horst

pzktupel · Hält's aus hier Beiträge: 129 Erhaltene Danke: 30

So war das nicht gemeint. War nur ne blöde Idee.

Delphi-Laie · Verfasst: Mi 12.12.18 13:38

Horst_H hat folgendes geschrieben :

Ein gutes Lehrer hält das Niveau einer x.ten Klasse auf dem Niveau einer x.ten Klasse und steigert das nicht.

Einspruch: Ein guter Lehrer holt m.E. aus seinen Schützlingen heraus, was - zeitlich und intellektuell - möglich ist.

Horst_H hat folgendes geschrieben :

Die Aufgaben müssen lösbar bleiben und nicht zu viel Zeit beanspruchen.

Solang es am 24.12. immer noch welche mit voller Punkt(e)zahl gibt (was mir rätselhaft ist), wurde das Niveau m.E. angemessen dosiert. Zweiteres ist der Knackpunkt: Wenn es zunehmend dauert und man ahnt, daß man es womöglich gar nicht schafft, jedenfalls nicht innerhalb der 24-h-Frist, läßt so mancher wieder davon ab.

_________________
Ordnung ist das halbe Leben - und sie zu schaffen die andere Hälfte.

Ralf Jansen · Verfasst: Mi 12.12.18 14:09

Horst_H hat folgendes geschrieben :

Die Aufgaben müssen lösbar bleiben und nicht zu viel Zeit beanspruchen.

Und das bekommt user profile icon

Mathematiker ja auch immer wunderbar hin. Darüber liegt aber immer noch die Schicht der persönlichen Interessen die bestimmte Aufgaben auf persönlicher Ebene leichter oder schwerer machen.

Ich persönlich freu mich dieses Jahr riesig das es bisher keine Krypto Aufgabe gab. Ist halt vollständig vorbei an meinen Interessen. Ist aber auch gut so denn ich bin mir gleichzeitig sicher das andere hier genau auf diese Sorte Aufgaben gespannt warten. Vermutlich verlässt mich diesbezüglich mein Glück auch bald

Hidden · Verfasst: Mi 12.12.18 14:41

Hmm, die Advents-App sagt mir seit heute Nacht, dass der Server nicht erreichbar ist. Geht das nur mir so?

_________________
Centaur spears can block many spells, but no one tries to block if they see that the spell is a certain shade of green. For this purpose it is useful to know some green stunning hexes. (HPMoR)

Narses · Verfasst: Mi 12.12.18 14:43

Hidden hat folgendes geschrieben :

Hmm, die Advents-App sagt mir seit heute Nacht, dass der Server nicht erreichbar ist. Geht das nur mir so?

Schau mal in deine PNs. :zwinker:

_________________
There are 10 types of people - those who understand binary and those who don´t.

Hidden · Verfasst: Mi 12.12.18 14:47

Narses hat folgendes geschrieben :

Hidden hat folgendes geschrieben :

Hmm, die Advents-App sagt mir seit heute Nacht, dass der Server nicht erreichbar ist. Geht das nur mir so?

Schau mal in deine PNs. :zwinker:

Japp, falsche Reihenfolge :oops:

Nächstes Mal lese ich erst die PM, dann den Thread^^
Danke!

Edit: Fixed :zustimm:

_________________
Centaur spears can block many spells, but no one tries to block if they see that the spell is a certain shade of green. For this purpose it is useful to know some green stunning hexes. (HPMoR)

Delphi-Laie · Verfasst: Mi 12.12.18 22:40

Ich hätte noch einen kleinen Verbesserungsvorschlag, der auf meinen mißglückten "Umzugsversuch" Anfang Dezember zurückgeht: Der Adventskalender bezieht seine Informationen, an welchem Tage das jeweilige Rätsel schon gelöst wurde, aus (s)einer Ini-Datei, jedenfalls werden dort die (Miß-)Erfolge gespeichert und auch mit Sternchen angezeigt. Könnte das, um die Portierbarkeit zu verbessern, nicht auch serverbasiert geschehen? Oder wird das schon so gelöst?

_________________
Ordnung ist das halbe Leben - und sie zu schaffen die andere Hälfte.

Symbroson · Verfasst: Mi 12.12.18 22:51

Delphi-Laie hat folgendes geschrieben :

Könnte das, um die Portierbarkeit zu verbessern, nicht auch serverbasiert geschehen? Oder wird das schon so gelöst?

Es gibt oben rechts so ein Einstellungssymbol wo man dann auch seine Daten mit dem Server synchronisieren kann - also gehe ich davon aus

_________________
most good programmers do programming not because they expect to get paid or get adulation by the public, but because it's fun to program. (Linus Torvalds)

Mathematiker · Verfasst: Mi 12.12.18 22:59

Hallo,
alle Hinweise und Verbesserungsvorschläge, die von euch kommen, werden sorgfältig gespeichert und wenn möglich im nächsten Jahr (vorausgesetzt es gibt dann wieder ein EE-Adventsspiel) berücksichtigt.

Für alle, die auf die Auflösung des Summenrätsels (Rätsel 11) warten, kann ich schon jetzt sagen, dass ich keine besondere Lösungsidee vorweisen kann. Ich löse so etwas einfach durch logisches Überlegen.

Eine Bitte hätte ich aber: Der letzte Lösungsversuch läuft erst heute 23:10 Uhr ab. Deshalb bitte vorher keine Hinweise posten. Danach bin ich sehr gespannt, denn es wurden ja schon elegante und sehr schnelle Lösungen durch euch angekündigt.

Danke
Steffen

Nachtrag: Morgen, also in etwa 90 Minuten, ist die "beliebte" Verschlüsselungsscheibe wieder dran. Ich weiß, einige mögen das nicht, aber es gehört doch zum Adventsspiel dazu. :roll:

Und immer daran denken: Die Scheiben sind drehbar. :wink:

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

pzktupel · Hält's aus hier Beiträge: 129 Erhaltene Danke: 30

Okay, also hier meine Lösung für die Zufallsanordnung.
Hinweis: Es wurde Zeile für Zeile geprüft (oben nach unten)

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:

#INCLUDE "windows.bi"
#INCLUDE "vbcompat.bi" 

DIM AS UBYTE a12,a13,a14,a16,a18
DIM AS UBYTE a21,a22,a25,a26,a28
DIM AS UBYTE a31,a33,a34,a35,a37
DIM AS UBYTE a41,a45,a46,a47,a48
DIM AS UBYTE a51,a53,a55,a56,a57
DIM AS UBYTE a62,a63,a64,a67,a68
DIM AS UBYTE a72,a73,a74,a75,a77
DIM AS UBYTE a81,a82,a84,a86,a88

S1:
FOR a12=1 TO 5
FOR a13=1 TO 5
FOR a14=1 TO 5
FOR a16=1 TO 5
FOR a18=1 TO 5
IF a12*a13*a14*a16*a18<>120 THEN GOTO E1 
GOTO S2
E1:
NEXT a18
NEXT a16
NEXT a14
NEXT a13
NEXT a12

S2:
FOR a21=1 TO 5
FOR a22=1 TO 5
FOR a25=1 TO 5
FOR a26=1 TO 5
FOR a28=1 TO 5
IF a21*a22*a25*a26*a28<>120 THEN GOTO E2 

IF a12+a22+a21<>7 THEN GOTO E2 
IF a14+a16+a25+a26<>17 THEN GOTO E2
IF a16+a18+a26+a28<>13 THEN GOTO E2
REM "ok"
GOTO S3
E2:
NEXT a28
NEXT a26
NEXT a25
NEXT a22
NEXT a21
GOTO E1

S3:
FOR a31=1 TO 5
FOR a33=1 TO 5
FOR a34=1 TO 5
FOR a35=1 TO 5
FOR a37=1 TO 5
IF a31*a33*a34*a35*a37<>120 THEN GOTO E3 

IF a12+a13+a14+a22+a33+a34<>17 THEN GOTO E3
IF a13+a14+a25+a35+a34+a33<>19 THEN GOTO E3
IF a16+a18+a26+a28+a37<>17 THEN GOTO E3
REM "ok"
GOTO S4
E3:
NEXT a37
NEXT a35
NEXT a34
NEXT a33
NEXT a31
GOTO  E2

S4:
FOR a41=1 TO 5
FOR a45=1 TO 5
FOR a46=1 TO 5
FOR a47=1 TO 5
FOR a48=1 TO 5
IF a41*a45*a46*a47*a48<>120 THEN GOTO E4 

IF a21+a22+a33+a31+a41<>10 THEN GOTO E4
IF a25+a26+a37+a47+a46+a45+a35<>25 THEN GOTO E4
IF a28+a37+a47+a48<>14 THEN GOTO E4
REM "ok"
GOTO S5
E4:
NEXT a48
NEXT a47
NEXT a46
NEXT a45
NEXT a41
GOTO E3
REM "*"

S5:

FOR a51=1 TO 5
FOR a53=1 TO 5
FOR a55=1 TO 5
FOR a56=1 TO 5
FOR a57=1 TO 5
IF a51*a53*a55*a56*a57<>120 THEN GOTO E5 

IF a31+a33+a53+a51+a41<>15 THEN GOTO E5
IF a33+a34+a53<>11 THEN GOTO E5
IF a33+a34+a35+a45+a55+a53<>19 THEN GOTO E5
REM "ok"
GOTO S6
E5:
NEXT a57
NEXT a56
NEXT a55
NEXT a53
NEXT a51
GOTO E4
REM "***"

S6:

FOR a62=1 TO 5
FOR a63=1 TO 5
FOR a64=1 TO 5
FOR a67=1 TO 5
FOR a68=1 TO 5
IF a62*a63*a64*a67*a68<>120 THEN GOTO E6 

IF a41+a51+a62+a63+a53<>16 THEN GOTO E6
IF a53+a63+a64+a55+a45<>17 THEN GOTO E6
IF a48+a47+a57+a67+a68<>15 THEN GOTO E6
REM "ok"
GOTO S7
E6:
NEXT a68
NEXT a67
NEXT a64
NEXT a63
NEXT a62
GOTO E5





S7:
FOR a72=1 TO 5
FOR a73=1 TO 5
FOR a74=1 TO 5
FOR a75=1 TO 5
FOR a77=1 TO 5
IF a72*a73*a74*a75*a77<>120 THEN GOTO E7 

IF a51+a62+a72<>9 THEN GOTO E7
IF a55+a64+a74+a75+a56<>13 THEN GOTO E7
IF a55+a56+a57+a67+a77+a75<>14 THEN GOTO E7

GOTO S8
E7:
NEXT a77
NEXT a75
NEXT a74
NEXT a73
NEXT a72
GOTO E6


S8:
FOR a81=1 TO 5
FOR a82=1 TO 5
FOR a84=1 TO 5
FOR a86=1 TO 5
FOR a88=1 TO 5
IF a81*a82*a84*a86*a88<>120 THEN GOTO E8 

IF a62+a72+a81+a82<>14 THEN GOTO E8
IF a67+a77+a86+a75<>8 THEN GOTO E8
IF a67+a68+a77+a88<>14 THEN GOTO E8
IF a72+a73+a74+a84+a82<>15 THEN GOTO E8
IF a74+a75+a86+a84<>6 THEN GOTO E8
IF a77+a86+a88<>8 THEN GOTO E8

IF a21*a31*a41*a51*a81<>120 THEN GOTO E8
IF a12*a22*a62*a72*a82<>120 THEN GOTO E8
IF a13*a33*a53*a63*a73<>120 THEN GOTO E8
IF a14*a34*a64*a74*a84<>120 THEN GOTO E8
IF a25*a35*a45*a55*a75<>120 THEN GOTO E8
IF a16*a26*a46*a56*a86<>120 THEN GOTO E8
IF a37*a47*a57*a67*a77<>120 THEN GOTO E8
IF a18*a28*a48*a68*a88<>120 THEN GOTO E8
GOTO S9
E8:
NEXT a88
NEXT a86
NEXT a84
NEXT a82
NEXT a81
GOTO E7
S9:

PRINT " ";a12;a13;a14;" ";a16;" ";a18
PRINT a21;a22;" ";" ";a25;a26;" ";a28
PRINT a31;" ";a33;a34;a35;" ";a37;" "
PRINT a41;" ";" ";" ";a45;a46;a47;a48
PRINT a51;" ";a53;" ";a55;a56;a57;" "
PRINT " ";a62;a63;a64;" ";" ";a67;a68
PRINT " ";a72;a73;a74;a75;" ";a77;" "
PRINT a81;a82;" ";a84;" ";a86;" ";a88

SLEEP

Einloggen, um Attachments anzusehen!

Symbroson · Verfasst: Do 13.12.18 00:31

Ich hab mir bei Tag 11 'Listen' der freien Felder für jede Zeile angelegt, die ich der Reihe nach permutiert und daran die Bedingungen geprüft habe. Diese beinhalten zum Einen die Summenfelder mit den Positionen der umgebenen (leeren) Felder und die Positionen sämtliche Paare die in einer Spalte untereinander liegen, um gleiche Zajlen in einer Spalte abzufangen.
Ich habe mir nicht die Arbeit gemacht das Eingabefeld zu parsen, sondern stattdessen die Bedingungen erst alle hardgecodet und dann nochmal für eine kompaktere Eingabe etwas zusammengefasst, jedoch der Einfachheit halber nur 5 Reihen berechnet, weil es da schon nur noch eine Lösung gab. Den rest hab ich einfach selber errechnet.
Bei mir dauern beide Varianten 2 bzw. 3 millisekunden mit der gegebenen Eingabe. Ich stelle beide Varianten + Eingabefeld in den Anhang

LG,
Symbroson

EEAK18112.c:

markieren

C++-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:

#define ROWS 5
#define COLS 5
// schreibfauleit
#define DTOI(d) (d - '0') // digit to integer
#define P(i) DTOI(p[i])   // p(i) -> int
#define PPERM(y,x) perm[P(y)][P(x)]

const char
    // fields in same coloumn  "yxyx[,yxyx,..]"
    *cols[ROWS - 1] = {
        "0110,0313",                          // until row 2
        "1020,1222,1323,1424,0120,0323",      // until row 3
        "2234,2233,0030,1131,1232,1433,0434", // until row 4
        ""                                    // until row 5
    // sum with surroundig fields "<sum>:xyxy..[,<sum>:xyxy..]"
    }, *sums[ROWS - 1] = {
        "\x08:01021011,\x0f:02031213,\x0f:03041314", // until row 2
        "\x0a:00011020,\x11:0211122122,\x08:041424", // until row 3
        "\x09:102030,\x0d:1011202131,\x0a:14243334", // until row 4
        "\x0f:2030314041,\x13:212231324142,\x11:222324323343" // until row 5
        "\0"
    };


char perm[COLS][ROWS] = {"12345", "12345", "12345", "12345", "12345"};
int r = -1;

// check sums
int chksum() {
    const char *p = sums[r - 2];

    // c vom feinsten
    if(*p) do {
        int sum = *p;

        // subtract surr. fields from sum
        while(*(p += 2) && *p != ',')
            sum -= DTOI(PPERM(0, 1));

        if(sum) return 1;
    } while(*++p);

    return 0;
}

// check coloumns
int chkcol() {
    const char *p = cols[r - 2];

    if(*p) do {
        if(PPERM(0, 1) == PPERM(2, 3)) return 1;
        p += 4;
    } while(*p++);

    return 0;
}

void permute(char *c, int n) {
    if (n == 0) return test();

    if(r >= 2 && (chksum() || chkcol())) return;

    // permute algorithm
    permute(c, n - 1);
    for (int i = 0; i < n; i++) {
        swap(c, i, n);
        permute(c, n - 1);
        swap(c, i, n);
    }
}

void test() {
    if(++r < 5)
        permute(perm[r], COLS - 1);
    else if(!chksum()) {
        for(int i = 0; i < COLS; i++)
            printf("%.*s\n", ROWS, perm[i]);
        printf("\n");
    }
    r--;
}

int main() { test(); }

Ausgabe:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

$ gcc EEAK18112.c -o EEAK18112.out && time ./EEAK18112.out
42351
12345
34512
53412
31245

real  0m0.003s
user  0m0.000s
sys  0m0.003s

Eingabe:

Einloggen, um Attachments anzusehen!

_________________
most good programmers do programming not because they expect to get paid or get adulation by the public, but because it's fun to program. (Linus Torvalds)

BenBE · Verfasst: Do 13.12.18 00:37

Okay, da wir jetzt soweit sind, gibt's hier meine Lösung.

Da ich keine Lust hatte, das rekursiv mit allen Constraints selber zu implementieren, und mit Prolog eine Sprache existiert, die Constraints auf diskreten Integer-Problemen sehr gut lösen kann, ist meine Lösung in Prolog.

Nun hatte ich aber keine Lust, die ganzen Constraints per Hand zu schreiben, also musste ein Code-Generator her. An dieser Stelle kam ein kleines PHP-Script zum Einsatz:

markieren

PHP-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:

<?php

$a = array(
    array(  0,  0, 11,  0, 15,  0, 13,  0 ),
    array( 14,  0,  0, 13,  0,  0, 18,  0 ),
    array(  0,  0, 12,  0,  0, 22,  0, 10 ),
    array(  0,  0, 20,  0, 15,  0,  0,  8 ),
    array( 11,  0,  0,  0, 15,  0, 21,  0 ),
    array(  6, 15,  0, 21,  0,  0,  0,  0 ),
    array(  0, 15,  0,  0,  0, 19,  0, 15 ),
    array(  0, 12,  0, 19,  0, 12,  0,  0 )
    );

echo "digit(1).\n";
echo "digit(2).\n";
echo "digit(3).\n";
echo "digit(4).\n";
echo "digit(5).\n";

echo "solve(...) :-\n";
for($r = 0; $r < 8; $r++) {
    for($c = 0; $c < 8; $c++) {
        if($a[$r][$c] == 0) {
            printf("digit(A%d%d),\n", $r, $c);
        }
    }
}
for($r = 0; $r < 8; $r++) {
    for($c = 0; $c < 8; $c++) {
        if($a[$r][$c] != 0) {
            $d = array();
            for($dr = -1; $dr <= 1; $dr++) {
                for($dc = -1; $dc <= 1; $dc++) {
                    if($r + $dr >= 0 && $r + $dr < 8) {
                        if($c + $dc >= 0 && $c + $dc < 8) {
                            if(!$a[$r + $dr][$c + $dc]) {
                                $d[] = sprintf("A%d%d", $r + $dr, $c + $dc);
                            }
                        }
                    }
                }
            }
            echo implode("+", $d) . " =:= " . $a[$r][$c] . ",\n";
        }
    }
}

for($r = 0; $r < 8; $r++) {
    $d = array();
    for($c = 0; $c < 8; $c++) {
        if(!$a[$r][$c]) {
            $d[] = sprintf("A%d%d", $r, $c);
        }
    }
    echo "permutation([1,2,3,4,5],[" . implode(",", $d) . "]),\n";
}
for($c = 0; $c < 8; $c++) {
    $d = array();
    for($r = 0; $r < 8; $r++) {
        if(!$a[$r][$c]) {
            $d[] = sprintf("A%d%d", $r, $c);
        }
    }
    echo "permutation([1,2,3,4,5],[" . implode(",", $d) . "]),\n";
}

echo "true.\n";

Die Ausgabe davon ist (in Reinform) erstmal nur sowas:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:

digit(1).
digit(2).
digit(3).
digit(4).
digit(5).
solve(...) :-
digit(A00),
digit(A01),
digit(A03),
digit(A05),
digit(A07),
digit(A11),
digit(A12),
digit(A14),
digit(A15),
digit(A17),
digit(A20),
digit(A21),
digit(A23),
digit(A24),
digit(A26),
digit(A30),
digit(A31),
digit(A33),
digit(A35),
digit(A36),
digit(A41),
digit(A42),
digit(A43),
digit(A45),
digit(A47),
digit(A52),
digit(A54),
digit(A55),
digit(A56),
digit(A57),
digit(A60),
digit(A62),
digit(A63),
digit(A64),
digit(A66),
digit(A70),
digit(A72),
digit(A74),
digit(A76),
digit(A77),
A01+A03+A11+A12 =:= 11,
A03+A05+A14+A15 =:= 15,
A05+A07+A15+A17 =:= 13,
A00+A01+A11+A20+A21 =:= 14,
A03+A12+A14+A23+A24 =:= 13,
A05+A07+A15+A17+A26 =:= 18,
A11+A12+A21+A23+A31+A33 =:= 12,
A14+A15+A24+A26+A35+A36 =:= 22,
A17+A26+A36 =:= 10,
A21+A23+A31+A33+A41+A42+A43 =:= 20,
A23+A24+A33+A35+A43+A45 =:= 15,
A26+A36+A47 =:= 8,
A30+A31+A41 =:= 11,
A33+A35+A43+A45+A54+A55 =:= 15,
A35+A36+A45+A47+A55+A56+A57 =:= 21,
A41+A60 =:= 6,
A41+A42+A52+A60+A62 =:= 15,
A42+A43+A52+A54+A62+A63+A64 =:= 21,
A52+A60+A62+A70+A72 =:= 15,
A54+A55+A56+A64+A66+A74+A76 =:= 19,
A56+A57+A66+A76+A77 =:= 15,
A60+A62+A70+A72 =:= 12,
A62+A63+A64+A72+A74 =:= 19,
A64+A66+A74+A76 =:= 12,
permutation([1,2,3,4,5],[A00,A01,A03,A05,A07]),
permutation([1,2,3,4,5],[A11,A12,A14,A15,A17]),
permutation([1,2,3,4,5],[A20,A21,A23,A24,A26]),
permutation([1,2,3,4,5],[A30,A31,A33,A35,A36]),
permutation([1,2,3,4,5],[A41,A42,A43,A45,A47]),
permutation([1,2,3,4,5],[A52,A54,A55,A56,A57]),
permutation([1,2,3,4,5],[A60,A62,A63,A64,A66]),
permutation([1,2,3,4,5],[A70,A72,A74,A76,A77]),
permutation([1,2,3,4,5],[A00,A20,A30,A60,A70]),
permutation([1,2,3,4,5],[A01,A11,A21,A31,A41]),
permutation([1,2,3,4,5],[A12,A42,A52,A62,A72]),
permutation([1,2,3,4,5],[A03,A23,A33,A43,A63]),
permutation([1,2,3,4,5],[A14,A24,A54,A64,A74]),
permutation([1,2,3,4,5],[A05,A15,A35,A45,A55]),
permutation([1,2,3,4,5],[A26,A36,A56,A66,A76]),
permutation([1,2,3,4,5],[A07,A17,A47,A57,A77]),
true.

Das funktioniert (abgesehen von der Aufruf-Zeile für solve) auch soweit, wäre aber extrem unperformant. Das kann man aber durch kurzes Umsortieren der Constraints stark beschleunigen:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

digit(1).
digit(2).
digit(3).
digit(4).
digit(5).

solve(A00,A01,A03,A05,A07,A11,A12,A14,A15,A17,A20,A21,A23,A24,A26,A30,A31,A33,A35,A36,A41,A42,A43,A45,A47,A52,A54,A55,A56,A57,A60,A62,A63,A64,A66,A70,A72,A74,A76,A77) :-
digit(A00),
digit(A01),
digit(A03),
digit(A05),
digit(A07),
permutation([1,2,3,4,5],[A00,A01,A03,A05,A07]),
digit(A11),
digit(A12),
A01+A03+A11+A12 =:= 11,
digit(A14),
digit(A15),
A03+A05+A14+A15 =:= 15,
digit(A17),
permutation([1,2,3,4,5],[A11,A12,A14,A15,A17]),
A05+A07+A15+A17 =:= 13,
digit(A20),
digit(A21),
A00+A01+A11+A20+A21 =:= 14,
digit(A23),
digit(A24),
A03+A12+A14+A23+A24 =:= 13,
digit(A26),
permutation([1,2,3,4,5],[A20,A21,A23,A24,A26]),
A05+A07+A15+A17+A26 =:= 18,
digit(A30),
digit(A31),
digit(A33),
A11+A12+A21+A23+A31+A33 =:= 12,
digit(A35),
digit(A36),
permutation([1,2,3,4,5],[A30,A31,A33,A35,A36]),
A17+A26+A36 =:= 10,
A14+A15+A24+A26+A35+A36 =:= 22,
digit(A41),
A30+A31+A41 =:= 11,
digit(A42),
digit(A43),
A21+A23+A31+A33+A41+A42+A43 =:= 20,
digit(A45),
A23+A24+A33+A35+A43+A45 =:= 15,
digit(A47),
permutation([1,2,3,4,5],[A41,A42,A43,A45,A47]),
A26+A36+A47 =:= 8,
digit(A52),
digit(A54),
digit(A55),
A33+A35+A43+A45+A54+A55 =:= 15,
digit(A56),
digit(A57),
permutation([1,2,3,4,5],[A52,A54,A55,A56,A57]),
A35+A36+A45+A47+A55+A56+A57 =:= 21,
digit(A60),
A41+A60 =:= 6,
digit(A62),
A41+A42+A52+A60+A62 =:= 15,
digit(A63),
digit(A64),
A42+A43+A52+A54+A62+A63+A64 =:= 21,
digit(A66),
permutation([1,2,3,4,5],[A60,A62,A63,A64,A66]),
digit(A70),
digit(A72),
A52+A60+A62+A70+A72 =:= 15,
A60+A62+A70+A72 =:= 12,
digit(A74),
A62+A63+A64+A72+A74 =:= 19,
digit(A76),
A64+A66+A74+A76 =:= 12,
A54+A55+A56+A64+A66+A74+A76 =:= 19,
digit(A77),
permutation([1,2,3,4,5],[A70,A72,A74,A76,A77]),
A56+A57+A66+A76+A77 =:= 15,

permutation([1,2,3,4,5],[A00,A20,A30,A60,A70]),
permutation([1,2,3,4,5],[A01,A11,A21,A31,A41]),
permutation([1,2,3,4,5],[A12,A42,A52,A62,A72]),
permutation([1,2,3,4,5],[A03,A23,A33,A43,A63]),
permutation([1,2,3,4,5],[A14,A24,A54,A64,A74]),
permutation([1,2,3,4,5],[A05,A15,A35,A45,A55]),
permutation([1,2,3,4,5],[A26,A36,A56,A66,A76]),
permutation([1,2,3,4,5],[A07,A17,A47,A57,A77]),
true.

Die Regel zum Umsortieren ist, dass die Zeilen-Permutation direkt nach der letzten der Variablen-Instantiierung jeweils geprüft wird und die Summen-Bedingungen jeweils direkt nach der letzten dafür nötigen Variable aufgelöst/ausgewertet werden.

Die ersten 5 Zeilen sagen einfach nur den Fakt an, dass das Argument von digit die Werte 1 bis 5 annehmen kann.

Läd man diese leicht optimierte Datei in SWI Prolog, erhält man:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

$ swipl 
?- [solve].
true.

?- solve(A00,A01,A03,A05,A07,A11,A12,A14,A15,A17,A20,A21,A23,A24,A26,A30,A31,A33,A35,A36,A41,A42,A43,A45,A47,A52,A54,A55,A56,A57,A60,A62,A63,A64,A66,A70,A72,A74,A76,A77).
A00 = A11, A11 = A24, A24 = A36, A36 = A43, A43 = A55, A55 = A62, A62 = A77, A77 = 2,
A01 = A17, A17 = A20, A20 = A33, A33 = A45, A45 = A52, A52 = A66, A66 = A74, A74 = 3,
A03 = A15, A15 = A26, A26 = A30, A30 = A41, A41 = A57, A57 = A64, A64 = A72, A72 = 5,
A05 = A12, A12 = A23, A23 = A31, A31 = A47, A47 = A54, A54 = A60, A60 = A76, A76 = 1,
A07 = A14, A14 = A21, A21 = A35, A35 = A42, A42 = A56, A56 = A63, A63 = A70, A70 = 4 ;
false.

?-

Danach muss man die Lösung nur noch abtippen.

Ach ja: Dass die letzte Zeile in meinem Prolog-Skript true. lautet, ist übrigens Absicht. Damit wird der Code-Generator etwas übersichtlicher. :mrgreen:

_________________

Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.

pzktupel · Hält's aus hier Beiträge: 129 Erhaltene Danke: 30

Hallo ,gibt es paar Hinweise zu heute ?

Was habe ich gemacht. Die Scheibe in ein Programm übertragen, aber es kommt nur Käse raus.

Deshalb paar Fragen:

Stimmt ein Buchstabe mit der Zurücksetzfunktion ?
Wird alternativ nach links und rechts gedreht ?
Ist der Positionswechsel konstant ?

Gruß

Symbroson · Verfasst: Do 13.12.18 11:51

pzktupel hat folgendes geschrieben :

Hallo ,gibt es paar Hinweise zu heute ?

Was habe ich gemacht. Die Scheibe in ein Programm übertragen, aber es kommt nur Käse raus.

Hinweis 1: Vielleicht ist der Programmatische Weg ist nicht immer unbedingt der erste Schritt den man tun sollte :mahn:

Sicher ist das Programm ein Zweizeiler wenn man weiß wie es funktioniert, jedoch...

Hinweis 2: Die Ringe der Scheibe können mit der Maus gedreht werden

Gruß zurück

_________________
most good programmers do programming not because they expect to get paid or get adulation by the public, but because it's fun to program. (Linus Torvalds)

Ralf Jansen · Verfasst: Fr 14.12.18 14:25

Gausi hat das Puzzle in 46 Sekunden gelöst. Ich bin schwer beeindruckt :shock:

Gausi · Verfasst: Fr 14.12.18 14:52

Tja, ich bin eben ein Meister-Puzzler. Ich habe sogar das legendäre Giraffen-Puzzle in weniger als drei Wochen gelöst, und zwar ganz ohne Video-Guide. :mrgreen:

(ggf. sag ich morgen was dazu, falls mir Steffen nicht zuvor kommt. Hab ihn schon angeschrieben deswegen. Das ist nämlich nicht so beeindruckend, wie es den Anschein hat. ;-)

)

_________________
We are, we were and will not be.

Horst_H · Verfasst: Fr 14.12.18 14:53

Hallo,

meine Güte, kannte er das Bild?
Mir war es etwas zu wenig Platz auf der Fensterfläche und die Teile ließen sich leider nicht auf dem gesamten Bildschirm verteilen :-)

Dieser magnetische Effekt, wenn man an der richtigen Stelle mit einem Nachbarn ist, ist immer wieder toll.
Nächstes Jahr muss man die Teile wie bei Pentomino noch drehen und spiegeln, damit user profile icon

pzktupel auch ausgelastet ist

:duckweg:

Gruß Horst

Mathematiker · Verfasst: Fr 14.12.18 15:38

Hallo,

Gausi hat das Puzzle entsprechend den Möglichkeiten korrekt gelöst. Da ist keine Hexerei dabei.
Ich kann nur gratulieren! :beer:

In der Auflösung wird er es sicher erklären.

Die 12.Aufgabe muss nicht erklärt werden, da sie extrem einfach war.
Für die Kodierungsscheibe gibt es noch sehr viele offene Versuche. Irgendwann heute Nacht, werde ich es erklären.

Viel Spaß noch
Steffen

_________________
Töten im Krieg ist nach meiner Auffassung um nichts besser als gewöhnlicher Mord. Albert Einstein

Delphi-Laie · Verfasst: Fr 14.12.18 20:38

Ralf Jansen hat folgendes geschrieben :

Gausi hat das Puzzle in 46 Sekunden gelöst. Ich bin schwer beeindruckt :shock:

Das kommt mir wie Hexerei vor.

Man kann sich natürlich "vorbereiten". Das erste Mal fast bis zum Schluß lösen, die Teile "numerieren", und im nächsten Durchlauf den Turbogang einlegen. Vielleicht liegen die Teile anfangs auch immer an derselben (oder der gleichen) Stelle, was das ungmein erleichtern würde. Aber allein das Sichten und Schieben kostet soviel Zeit, daß weniger als eine Minute nicht realistisch erscheint.

Ich hätte noch einen Verbesserungsvorschlag für die Puzzles, wenn das genehm und nicht zu aufwendig zu implementieren ist: Daß die Einrastfunktion nicht nur existiert, wenn man die Teile (fast) an die richtige Position geschoben hat, sondern auch dann, wenn sich zwei - oder mehr - Teile außerhalb der korrekten Position gefunden haben. Wie im richtigen Puzzleleben eben. Damit ließen sich solche Teile dann allerdings auch nicht mehr voneinander trennen, sofern man die anderen angedockten Teile mit verschiebt, wenn man das mit nur einem Teile tut.

Gruß Delphi-Laie

_________________
Ordnung ist das halbe Leben - und sie zu schaffen die andere Hälfte.

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme