1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

procedure TForm1.Button1Click(Sender: TObject);
var x,y:integer;
    gefunden:boolean;
begin
    gefunden:=false;
    x:=1;
    repeat
      y:=1;
      repeat
        if x*x=114*y*y+1 then begin
          edit1.Text:=inttostr(x*x);
          gefunden:=true;
        end;  
        inc(y);
      until (y>=x) or gefunden;
      inc(x);
    until gefunden;
end;                    

1:
2:
3:
4:

XX__
_X__
____
____                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

{Apptype Console}
Var
  n,m,n2,m2:Uint64;

begin
  n := 0;
  repeat
    inc(n);
    n2 := 114*n*n+1;
    m := 32*n div 3; //32/3 ~ sqrt(114)
    repeat
      inc(m);
      m2 := m*m;
    until n2 <= m2;
    IF n2 = m2 then
    Begin
      writeln(n:10,m:10,n2:10,m2:10);
      BREAK;
    end;
  until n > 1000*1000*1000;
end.                    

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

int main() {
    unsigned int n = 0;
    float f;
    
    do f = sqrt(114.0 * ++n * n + 1);
    while (f != floor(f));
    
    printf("Result: n = %i %i\n", 114 * n * n + 1, n);
}                    

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:

procedure magisches_quadrat(n:integer); //n = 4,8,12,16,20
type
    matrix = array[1..20,1..20] of integer;
var
    a:matrix;
  
procedure quadrat;
var n2:integer;
  procedure markieren;
  var i,j,k,m,sgn:integer;
  begin
    k:=n div 2;
    n2:=n*n;
    sgn:=1;
    m:=k;
    for i:=1 to k do begin
      for j:=1 to k do begin
        a[((m-j)div n)+1,((m-j)mod n) +1]:=sgn;
        a[((m+j-1)div n)+1,((m+j-1)mod n) +1]:=sgn;
        sgn:=-sgn;
      end;
      m:=m+n;
      sgn:=-sgn;
    end;
  end;
  procedure einsetzen;
  var i,h:integer;
  begin
    for i:=1 to n2 div 2 do begin
      h:=i;
      if a[(i-1) div n+1,(i-1) mod n +1]<0 then h:=n2+1-i;
      a[(h-1) div n+1,(h-1) mod n+1]:=i;
      a[(n2-h)div n+1,(n2-h)mod n+1]:=n2+1-i;
    end;
  end;
begin
  markieren;
  einsetzen;
end;

begin
  fillchar(a,sizeof(a),0);
  if n mod 4 = 0 then quadrat;
  //in a steht magisches quadrat;
end;                    

1:
2:
3:
4:
5:
6:

     4  8  3 15 = 30
    11 14  5  0 = 30
     6  1 10 13 = 30
     9  7 12  2 = 30
   = =  =  =  = =
30  30 30 30 30   30                    

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:

#define NUMS 16

// row:  current row index
// p:    current mag.sq. number selection
// perm: selected permution for current row
uint8_t row = 0, p[16], used[16], **avail, perm[4];

int main() {
    // remaining range for rows
    uint8_t i, av1[16], av2[12], av3[8], av4[4],
        *av[4] = {av1, av2, av3, av4};
    avail = av;
    
    // reset used states
    for(i = 0; i < NUMS; i++) used[i] = 0;
    row = 0;
    fillrow();
}

void fillrow() {
    // save remaining range to list
    uint8_t i, n = 0;
    for(i = 0; i < NUMS; i++)
        if(!used[i])
            avail[row][n++] = i;
    select_mn(4, 0);
}

// select d elements of remaining range starting from s
// range = 16 - 4 * row (first row(0): 16, last row(3): 4) remaining
void select_mn(uint8_t d, uint8_t s) {
    uint8_t i;
    
    if (d) {
        // pick next element from remaining range
        for (i = s; i < 16 - 4 * row; i++) {
            perm[4 - d] = avail[row][i];    // save chosen element
            used[(uint) avail[row][i]] = 1; // store used state
            select_mn(d - 1, i + 1);        // fill next element
            used[(uint) avail[row][i]] = 0; // reset used state
        }
        // check sum of chosen selection
    } else if(perm[0] + perm[1] + perm[2] + perm[3] == 30) {
        memcpy(p + (4 * row), perm, 4);
        
        if(row == 3) checkCol(p, 0);
        else { // fill next row
            row++;
            fillrow();
            row--;
        }
    }
}

// permute rows to solve coloumns
void checkCol(uint8_t *p, uint8_t col) {

    if(col == 3) { // finished.
        if(p[3] + p[6] + p[ 9] + p[12] == 30 &&
           p[0] + p[5] + p[10] + p[15] == 30)
            print(p);
        return;
    }
    
    uint8_t a, b, c, d, sum;
    uint8_t tp[16];
    
    // permute first 3 elements of coloumn
    for(a = col + 0; a <  4; a++) {
    for(b = col + 4; b <  8; b++) {
    for(c = col + 8; c < 12; c++) {
        
        // sum of first 3 elements < 30 || >= 15
        // otherwise 30 not reachable
        sum = p[a] + p[b] + p[c];
        if(sum + p[c] >= 30 || sum + p[c] < 15) continue;
        
        // permute last element of coloumn
        for(d = col + 12; d < 16; d++) {
            if(sum + p[d] == 30) {
                // if sum = 30 -> swap elements to correct position
                memcpy(tp, p, 16);
                swap(tp, col +  0, a);
                swap(tp, col +  4, b);
                swap(tp, col +  8, c);
                swap(tp, col + 12, d);
                checkCol(tp, col + 1); // check next coloumn
            }
        }
    }}}
}

// print found square
void print(uint8_t* p) {
    uint8_t sum1, sum2[4] = {0, 0, 0, 0};
    printf("   ");
    
    for(uint8_t i = 0; i < NUMS; i++) {
        sum1 += p[i];
        sum2[i % 4] += p[i];
        printf("%3i", p[i]);
        
        if(i % 4 == 3) {
            printf(" = %i\n   ", sum1);
            sum1 = 0;
        }
    }
    
    printf("= =  =  =  = =\n");
    printf("%2i%4i%3i%3i%3i%5i\n",
        p[3] + p[6] + p[ 9] + p[12],
        sum2[0], sum2[1], sum2[2], sum2[3],
        p[0] + p[5] + p[10] + p[15]);
}                    

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:

#define uint uint8_t

// p:    current magic square
uint p[16], used[16], **avail;
int c = 0;

int main() {
    // remaining range for rows
    uint i, av1[16], av2[12], av3[8], av4[4],
        *av[4] = {av1, av2, av3, av4};
    avail = av;
    
    // reset used states
    for(i = 0; i < 16; i++) used[i] = 0;
    fillrow(0);
    printf("found %i solutions!\n",c);
}

void fillrow(uint row) {
    // save remaining range to list
    uint n = 0;
    for(uint i = 0; i < 16; i++){
        if(!used[i])
      avail[row][n++] = i;
  }
    select_mn(4, 0, row);
}

// select d elements of remaining range starting from s
// range = 16 - 4 * row (first row(0): 16, last row(3): 4) remaining
#define RP(i) p[4 * row + i]
void select_mn(uint d, uint s, uint row) {
    if (d) {
        // pick next element from remaining range
        for (uint i = s; i < 16 - 4 * row; i++) {
            RP(4 - d) = avail[row][i];      // save chosen number
            used[(uint) avail[row][i]] = 1;  // set number used
            select_mn(d - 1, i + 1, row);   // fill next element
            used[(uint) avail[row][i]] = 0;  // set number unused
        }
        // check sum of chosen selection
    } else if(RP(0) + RP(1) + RP(2) + RP(3) == 30) {
        if(row == 3) checkCol(p, 0);
        else fillrow(row + 1);
    }
}

// permute rows to solve coloumns
void checkCol(uint *p, uint col) {

    if(col == 3) { // finished.
        if(p[3] + p[6] + p[ 9] + p[12] == 30 &&
           p[0] + p[5] + p[10] + p[15] == 30)
            print(p);
        return;
    }
    
    uint a, b, c, d, sum, tp[16];
    
    // permute first 3 elements of coloumn
    for(a = col + 0; a <  4; a++) {
    for(b = col + 4; b <  8; b++) {
    for(c = col + 8; c < 12; c++) {
        
        // sum of first 3 elements < 30 && >= 15
        // otherwise 30 not reachable
        sum = p[a] + p[b] + p[c];
        if(sum + p[c] >= 30 || sum + p[c] < 15) continue;
        
        // choose last element of column
        for(d = col + 12; d < 16; d++) {
            if(sum + p[d] == 30) {
                // if sum = 30 -> swap elements to correct position
                memcpy(tp, p, 16);
                swap(tp, col +  0, a);
                swap(tp, col +  4, b);
                swap(tp, col +  8, c);
                swap(tp, col + 12, d);
                checkCol(tp, col + 1); // check next coloumn
            }
        }
    }}}
}

// print found square
void print(uint* p) {
    uint sum1 = 0, sum2[4] = {0, 0, 0, 0};
    printf("---%3i--------------\n   ", ++c);
    
    for(uint i = 0; i < 16; i++) {
        sum1 += p[i];
        sum2[i % 4] += p[i];
        printf("%3i", p[i]);
        
        if(i % 4 == 3) {
            printf(" = %i\n   ", sum1);
            sum1 = 0;
        }
    }
    
    printf("= =  =  =  = =\n%2i%4i%3i%3i%3i%5i\n\n",
        p[3] + p[6] + p[ 9] + p[12],
        sum2[0], sum2[1], sum2[2], sum2[3],
        p[0] + p[5] + p[10] + p[15]);
}                    

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:

var Numbers: Array[0..15] of Integer;

procedure TForm2.OutputArray;
begin
    Memo1.Lines.Add(IntTostr(Numbers[0]) + '  ' + IntTostr(Numbers[1]) + '  ' + IntTostr(Numbers[2]) + '  ' + IntTostr(Numbers[3]) + '  ');
    Memo1.Lines.Add(IntTostr(Numbers[4]) + '  ' + IntTostr(Numbers[5]) + '  ' + IntTostr(Numbers[6]) + '  ' + IntTostr(Numbers[7]) + '  ');
    Memo1.Lines.Add(IntTostr(Numbers[8]) + '  ' + IntTostr(Numbers[9]) + '  ' + IntTostr(Numbers[10]) + '  ' + IntTostr(Numbers[11]) + '  ');
    Memo1.Lines.Add(IntTostr(Numbers[12]) + '  ' + IntTostr(Numbers[13]) + '  ' + IntTostr(Numbers[14]) + '  ' + IntTostr(Numbers[15]) + '  ');
    Memo1.Lines.Add('-----------------------')
end;

procedure swap (idxA, idxB: Integer);
var tmp : Integer;
begin
    tmp := Numbers[idxA];
    Numbers[idxA] := Numbers[idxB];
    Numbers[idxB] := tmp;
end;

function CheckLine(x: Integer): Boolean;
begin
    result := Numbers[4*x]
       + Numbers[4*x + 1]
       + Numbers[4*x + 2]
       + Numbers[4*x + 3] = 30;
end;

function CheckColumn(x: Integer): Boolean;
begin
    result := Numbers[x]
       + Numbers[x + 4]
       + Numbers[x + 8]
       + Numbers[x + 12] = 30;
end;

function CheckDiags: boolean;
begin
    result := (Numbers[0]
        + Numbers[5]
        + Numbers[10]
        + Numbers[15] = 30)
    and (Numbers[3]
        + Numbers[6]
        + Numbers[9]
        + Numbers[12] = 30)
end;

function CheckAll: Boolean;
begin
    result := CheckColumn(0) and CheckColumn(1) and CheckColumn(2) and CheckColumn(3)
          and CheckLine(0) and CheckLine(1) and CheckLine(2) and CheckLine(3)
          and CheckDiags;
end;

procedure Permutate(startIdx: Integer);
var i: Integer;
    DoPerm: Boolean;
begin
    DoPerm := True;
    if (startIdx=4) and (NOT CheckLine(0)) then
        DoPerm := False;

    if (startIdx=8) and (NOT CheckLine(1)) then
        DoPerm := False;

    if (startIdx=12) and (NOT CheckLine(2)) then
        DoPerm := False;

    if DoPerm then
    begin
        for i := startIdx + 1 to 15 do
        begin
            swap(startIdx, i);
            if CheckAll then
                Form2.OutputArray;
            Permutate(startIdx+1);
        end;
    end;
end;

// Aufruf über
for i := 0 to 15 do
    Numbers[i] := i;
Permutate(0);                    

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

     ░       |     ░
  ░░░░       |  ░░░░
 ░░ ░░       | ░░ ░░
 ░░░░░       | ░░░░░
  ░░░░       |  ░░░░
    ░░     ░ |    ░░     ░
    ░░░░░░░░ |    ░░░░░░░░
    ░░░░░░░░ |    ░░░░░░░░
    ░░░░░░░░ |    ░░░░░░░░
    ░░    ░░ |    █░    ░░
   ███    ░░ |   ██░    ░░
   █ ░     ░ |   █ ░     ░
   █ ░     ░ |   █ ░     ░                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

procedure TForm1.Button1Click(Sender: TObject);
var a,b,c,d,e,f,g : integer;
begin
  listbox1.Clear;
  for a:=1 to 7 do begin
    for b:=1 to 7 do begin
      if (a<>b) then
      for c:=1 to 7 do begin
        if (a<>c) and (b<>c) then
        for d:=1 to 7 do begin
          if (a<>d) and (b<>d) and (c<>d) then
          for e:=1 to 7 do begin
            if (a<>e) and (b<>e) and (c<>e) and (d<>e) then
            for f:=1 to 7 do begin
              for g:=1 to 7 do begin
                if (a+b+c=12) and (a+d+g=12) and (b+d+f=12) and (c+d+e=12)
                   and (e+f+g=12) then
                     listbox1.Items.add(inttostr(a)+#9+inttostr(b)+#9+inttostr(c)+#9
                       +inttostr(d)+#9+inttostr(e)+#9+inttostr(f)+#9+inttostr(g));
  end; end; end; end; end; end; end;
  label1.caption:=inttostr(listbox1.Items.Count)+' Möglichkeiten';
end;                    

1:
2:
3:

a b c
  d
e f g                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

DIM AS UBYTE a,b,c,d,e,f,g,v
v=0
FOR a=1 TO 7
FOR b=1 TO 7
FOR c=1 TO 7
FOR d=1 TO 7
FOR e=1 TO 7
FOR f=1 TO 7
FOR g=1 TO 7
IF a*b*c*d*e*f*g<>5040 THEN GOTO G
IF a+b+c<>12 THEN GOTO G
IF e+f+g<>12 THEN GOTO G
IF a+d+g<>12 THEN GOTO G
IF c+d+e<>12 THEN GOTO G
PRINT a,b,c
PRINT " ",d
PRINT e,f,g
v+=1:PRINT "Nr.";v
SLEEP 
G:NEXT g:NEXT f:NEXT e:NEXT d:NEXT c:NEXT b:NEXT a
PRINT "Fertig":SLEEP                    

1:
2:
3:
4:
5:
6:
7:

g(A, B, C, D, E, F, G) :-
    permutation([1,2,3,4,5,6,7],[A,B,C,D,E,F,G]),
    A + B + C =:= 12,
    A + D + G =:= 12,
    B + D + F =:= 12,
    C + D + E =:= 12,
    E + F + G =:= 12.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

?- [zahlen].
true.

?- g(A,B,C,D,E,F,G).
A = 1, B = 5, C = 6, D = 4, E = 2, F = 3, G = 7 ;
A = 1, B = 6, C = 5, D = 4, E = 3, F = 2, G = 7 ;
A = 2, B = 3, C = 7, D = 4, E = 1, F = 5, G = 6 ;
A = 2, B = 7, C = 3, D = 4, E = 5, F = 1, G = 6 ;
A = 3, B = 2, C = 7, D = 4, E = 1, F = 6, G = 5 ;
A = 3, B = 7, C = 2, D = 4, E = 6, F = 1, G = 5 ;
A = 5, B = 1, C = 6, D = 4, E = 2, F = 7, G = 3 ;
A = 5, B = 6, C = 1, D = 4, E = 7, F = 2, G = 3 ;
A = 6, B = 1, C = 5, D = 4, E = 3, F = 7, G = 2 ;
A = 6, B = 5, C = 1, D = 4, E = 7, F = 3, G = 2 ;
A = 7, B = 2, C = 3, D = 4, E = 5, F = 6, G = 1 ;
A = 7, B = 3, C = 2, D = 4, E = 6, F = 5, G = 1 ;
false.                    

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:

{$IFDEF FPC}{$MOde Delphi}{$ELSE}{$APPTYPE CONSOLE}{$IFEND}
type
  tElement = NativeUint;

var
  Zahl : array[0..7] of tElement;
  cnt,rekCount : NativeInt;
function Summe :boolean;
Begin
  result := (Zahl[1]+Zahl[2]+Zahl[3]) =12;
  If Not result then EXIT;
  result := (Zahl[1]+Zahl[4]+Zahl[7]) =12;
  If Not result then EXIT;
  result := (Zahl[2]+Zahl[4]+Zahl[6]) =12;
  If Not result then EXIT;
  result := (Zahl[3]+Zahl[4]+Zahl[5]) =12;
  If Not result then EXIT;
  result := (Zahl[5]+Zahl[6]+Zahl[7]) =12;
end;

procedure Ausgabe;
Begin
  inc(cnt);
  writeln('Variante ', cnt);
  writeln(Zahl[1]:3,Zahl[2]:3,Zahl[3]:3);
  writeln(Zahl[4]:6);
  writeln(Zahl[5]:3,Zahl[6]:3,Zahl[7]:3);
end;
procedure SwapElements(i,j:tElement);inline;
var
  tmp:tElement;
Begin
  if i<>j then
  Begin
    tmp := Zahl[i];Zahl[i]:= zahl[j];Zahl[j] := tmp;
  End;
end;

procedure rekurs(i:NativeInt);
var
  j : NativeInt;
begin
  inc(rekCount);
  j:= i;
  repeat
    SwapElements(i,j);
    case i of
      0..2: rekurs(i+1);
      3: IF  (Zahl[1]+Zahl[2]+Zahl[3]) = 12 then rekurs(4);
      4: rekurs(i+1);
      5: IF  (Zahl[3]+Zahl[4]+Zahl[5]) = 12 then rekurs(6);
      6: IF  (Zahl[2]+Zahl[4]+Zahl[6]) = 12 then rekurs(7);
    else
      If summe then
        Ausgabe;
    end;
    SwapElements(i,j);
    inc(j);
  until j>High(Zahl);
end;

var
 i : Integer;
Begin
  cnt := 0;
  rekCount := 0;
  For i := 0 to 7 do
    Zahl[i]:= i;
  rekurs(1);
  writeln;
  writeln('Es gibt ',cnt,' Loesungen');
  writeln('Es gab ',rekCount,' rekursive Aufrufe');
end.                    

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:

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

Es gibt 12 Loesungen
Es gab 308 rekursive Aufrufe                    

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                    

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(); }                    

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                    

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";                    

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.                    

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.                    

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.

?-                    

1:
2:
3:
4:
5:
6:
7:

    S1 := 'MVLKZGHPDEYAONIQS4UBRTXJF#';
    S2 := Ansiuppercase('apnwerbk7zguqjclmoitshvyf#');
    crypt := Ansiuppercase('jmyluw7hleslu');
    plain := '';
    for i := 1 to length(crypt)  do
        plain := plain + S1[length(S1) - pos(crypt[i], S2)];
    Memo1.Lines.Add(plain);                    

1:
2:
3:
4:
5:

18[min] * -v2 + d = 18[min] * v1
22[min] * +v2 - d = 22[min] * v1

-18 * v2 + d = 18
+22 * v2 - d = 22