Autor |
Beitrag |
Horst_H
Beiträge: 1653
Erhaltene Danke: 243
WIN10,PuppyLinux
FreePascal,Lazarus
|
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
|
Verfasst: Mi 12.12.18 12:56
So war das nicht gemeint. War nur ne blöde Idee.
|
|
Delphi-Laie
Beiträge: 1600
Erhaltene Danke: 232
Delphi 2 - RAD-Studio 10.1 Berlin
|
Verfasst: Mi 12.12.18 13:38
_________________ Ordnung ist das halbe Leben - und sie zu schaffen die andere Hälfte.
|
|
Ralf Jansen
Beiträge: 4705
Erhaltene Danke: 991
VS2010 Pro, VS2012 Pro, VS2013 Pro, VS2015 Pro, Delphi 7 Pro
|
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 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
Beiträge: 2242
Erhaltene Danke: 55
Win10
VS Code, Delphi 2010 Prof.
|
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
Beiträge: 10182
Erhaltene Danke: 1255
W10ent
TP3 .. D7pro .. D10.2CE
|
Verfasst: Mi 12.12.18 14:43
_________________ There are 10 types of people - those who understand binary and those who don´t.
|
|
Hidden
Beiträge: 2242
Erhaltene Danke: 55
Win10
VS Code, Delphi 2010 Prof.
|
Verfasst: Mi 12.12.18 14:47
_________________ 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
Beiträge: 1600
Erhaltene Danke: 232
Delphi 2 - RAD-Studio 10.1 Berlin
|
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
Beiträge: 382
Erhaltene Danke: 67
Raspbian, Ubuntu, Win10
C, C++, Python, JavaScript, Lazarus, Delphi7, Casio Basic
|
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
Beiträge: 2622
Erhaltene Danke: 1447
Win 7, 8.1, 10
Delphi 5, 7, 10.1
|
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.
Und immer daran denken: Die Scheiben sind drehbar.
_________________ 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
|
Verfasst: Mi 12.12.18 23:58
Okay, also hier meine Lösung für die Zufallsanordnung.
Hinweis: Es wurde Zeile für Zeile geprüft (oben nach unten)
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!
Für diesen Beitrag haben gedankt: Mathematiker
|
|
Symbroson
Beiträge: 382
Erhaltene Danke: 67
Raspbian, Ubuntu, Win10
C, C++, Python, JavaScript, Lazarus, Delphi7, Casio Basic
|
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:
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 #define DTOI(d) (d - '0') #define P(i) DTOI(p[i]) #define PPERM(y,x) perm[P(y)][P(x)]
const char *cols[ROWS - 1] = { "0110,0313", "1020,1222,1323,1424,0120,0323", "2234,2233,0030,1131,1232,1433,0434", "" }, *sums[ROWS - 1] = { "\x08:01021011,\x0f:02031213,\x0f:03041314", "\x0a:00011020,\x11:0211122122,\x08:041424", "\x09:102030,\x0d:1011202131,\x0a:14243334", "\x0f:2030314041,\x13:212231324142,\x11:222324323343" "\0" };
char perm[COLS][ROWS] = {"12345", "12345", "12345", "12345", "12345"}; int r = -1;
int chksum() { const char *p = sums[r - 2];
if(*p) do { int sum = *p;
while(*(p += 2) && *p != ',') sum -= DTOI(PPERM(0, 1));
if(sum) return 1; } while(*++p);
return 0; }
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(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:
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)
Zuletzt bearbeitet von Symbroson am Do 13.12.18 08:01, insgesamt 1-mal bearbeitet
Für diesen Beitrag haben gedankt: Mathematiker
|
|
BenBE
Beiträge: 8721
Erhaltene Danke: 191
Win95, Win98SE, Win2K, WinXP
D1S, D3S, D4S, D5E, D6E, D7E, D9PE, D10E, D12P, DXEP, L0.9\FPC2.0
|
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:
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:
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:
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:
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.
_________________ 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.
Für diesen Beitrag haben gedankt: Mathematiker
|
|
pzktupel
Hält's aus hier
Beiträge: 129
Erhaltene Danke: 30
|
Verfasst: Do 13.12.18 10:51
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
Beiträge: 382
Erhaltene Danke: 67
Raspbian, Ubuntu, Win10
C, C++, Python, JavaScript, Lazarus, Delphi7, Casio Basic
|
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
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)
Für diesen Beitrag haben gedankt: BenBE
|
|
Ralf Jansen
Beiträge: 4705
Erhaltene Danke: 991
VS2010 Pro, VS2012 Pro, VS2013 Pro, VS2015 Pro, Delphi 7 Pro
|
Verfasst: Fr 14.12.18 14:25
Gausi hat das Puzzle in 46 Sekunden gelöst. Ich bin schwer beeindruckt
|
|
Gausi
Beiträge: 8538
Erhaltene Danke: 475
Windows 7, Windows 10
D7 PE, Delphi XE3 Prof, Delphi 10.3 CE
|
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.
(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.
Für diesen Beitrag haben gedankt: BenBE, Mathematiker
|
|
Horst_H
Beiträge: 1653
Erhaltene Danke: 243
WIN10,PuppyLinux
FreePascal,Lazarus
|
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 pzktupel auch ausgelastet ist :duckweg:
Gruß Horst
|
|
Mathematiker
Beiträge: 2622
Erhaltene Danke: 1447
Win 7, 8.1, 10
Delphi 5, 7, 10.1
|
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!
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
Für diesen Beitrag haben gedankt: BenBE, Gausi, Narses
|
|
Delphi-Laie
Beiträge: 1600
Erhaltene Danke: 232
Delphi 2 - RAD-Studio 10.1 Berlin
|
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 |
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.
|
|
|