Mythic squares/rectangles - Page 3

WraithX · 2018-08-14, 04:10

Quote:

Originally Posted by Till

The first 6x6 square with score 42 turned up after testing 300k squares, nothing new within 10 mio square tests. So I am quite confident that it has the maximum score.

The first 7x7 square with score 64 turned up after testing 15mio squares, nothing new within 63.7 mio square tests. Less confidence here, but still some (75% maybe).

So the central term sequence might be 1, 3, 7, 15, 26, 42, 64, ...
The only possible match in OEIS is A131076 then.

I'm really impressed by your numbers. I don't have a good algorithm for filling up and checking alternate versions of grids. Could you share how you are generating your grids?

I'm just filling the squares up randomly, scoring them, and then looping through all numbers in the base at each cell and checking to see if that gives a higher score. It's not very good at finding good results. But, here are the numbers I've come up with so far:

Code:

base-2 m x n
 m/n  1  2  3  4  5  6  7  8  9 10 11
--+----------------------------------
 1|   1  2  3  4  4  6  7  8  8  8 14
 2|   2  3  5  6  8 10 15 16 16 20 20
 3|   3  5  7 10 13 16 16 20 23 27 31
 4|   4  6 10 15 18 20 22 26 32 33 36
 5|   4  8 13 18 26 32 32 35 38 39 44
 6|   6 10 16 20 32 37 44 47 50 63 64
 7|   7 15 16 22 32 44 63 67 70 78 85 
 8|   8 16 20 26 35 47 67 71 76 84 87
 9|   8 16 23 32 38 50 70 76 91 98 115
10|   8 20 27 33 39 63 78 84 98 128 130
11|  14 20 31 36 44 64 85 87 115 130 134



base-3 m x n
 m/n  1  2  3  4  5  6  7  8  9 10 11
--+----------------------------------
 1|   1  2  3  5  7  8  9  9 10 12 14
 2|   2  7  9 10 12 15 16 17 19 25 27
 3|   3  9 14 20 26 27 29 29 30 32 38
 4|   5 10 20 27 30 34 39 47 51 62 
 5|   7 12 26 30 
 6|   8 15 27 34 
 7|   9 16 29 39 
 8|   9 17 29 47 
 9|  10 19 30 51 
10|  12 25 32 62 
11|  14 27 38

Also, I did some random checking of large nxn grids to see how high I could get. At 20x20, base-10, I got up to 289. At 25x25 I got up to 443. And at 30x30 I got up to 1001. I'll post them here in case anyone has some grid altering algorithms they'd like to try on these:

Code:

Best 20,20 base-10 grid score so far = 289
90350892771301586263
59056468348141822196
88742311110834230599
43989968202268267752
93212235610081861250
89104720180800374226
86416794609054850493
60251326144798379215
40980093254168138128
34771647358505660641
51300003067385728937
52057618615114572542
77258439181867471615
56160895062948987516
12865221517903371976
90622224122369841665
90988450501758713685
26268065447514986466
83667797273953386319
74097429262226166910

Best 25,25 base-10 grid score so far = 443
4878041232441514917877850
1400052450422051321055964
7354557632584853939131025
6561002770536142284009682
3556489375811486212053491
3265657330700088658192174
9841207259929838935776937
7178203018842663769212787
7151859441674100140284371
7274950613929262864818410
6202805328435159586367753
6204114910359072826725053
4271269867737392077424395
0689283774224850350949055
8812813429721464004562379
8307840441889073003957373
0688503227966939138751661
7916914050495956079710405
6399099226510922343191237
1170834983334812009320567
4875443030893662995845801
1448121174086048157503558
2038350647288114303214943
1685807947327438615751480
3095039558031161909193318


Best 30,30 base-10 grid score so far = 1001
474709470127203313966133065225
961276693573805168681741450213
991421306066271265347909850409
068664564407090658963966587086
500028622091070779749850357932
934814123266829536470976906761
985500660996297655942862993987
670507174469810528035828560541
023509417410638645525552670378
091468704206918733548313620121
267193679695451881523086760832
910305409652622634639401275728
615246992237006427028592627183
862856084763475967583539219761
087985119136882881217677782447
118046443443431263283046541355
254494299444461633799656104701
011764071250320331584217939696
951184842557380817724107982083
375542173040181260220405312857
631837589877663931083211664349
698974403795911505039453102264
201884727345148351388869745478
835339193985730065081810200766
269452674231379322959173334137
292351382989671995924434092877
796379927154045397588440296352
410085231988819912351826955175
848555645999968319105723020954
177026707183796807130737498217

LaurV · 2018-08-14, 06:55

wait till Gerbicz reads this thread...

Till · 2018-08-14, 14:23

Quote:

Originally Posted by WraithX

Could you share how you are generating your grids?

Sure, though it's not so impressive either.
1. I start with rectangles containing each of 1 to 9 once at least, the rest filled randomly.

2. I keep track of the best score of random rectangles. When a new highscore turns up, I compute dd=(floor) ((highscore+1)/11), the biggest digit that needs to appear as a neighbor pair if we want to achieve a new highscore. The following rectangles are generated accordingly.

Example: highscore=32 -> dd=3 -> we need "11", "22" and "33" as neighbors. So the next rectangles contain "11", "22", "33" and 4 to 9 at least once.

3. When a good random rectangle turns up (say score >= highscore-5), then I try to refine it using point mutations or swaps. Currently in that case I do 1000 attempts with 1 to 10 of such operations.

Actually I think that one can do much better. More analysis would help, and maybe something like a good "repair algorithm" could turn out useful.

Till · 2018-08-14, 19:52

Using a new "iterative repair algorithm" I found better base 10 solutions for most mxn-rectangles with m+n>8. Here is the updated data table:

Code:

2x6: score=21
[7, 1, 1, 4, 1, 8]
[0, 2, 6, 5, 3, 9]

2x7: score=32
[9, 2, 7, 5, 2, 1, 8]
[6, 1, 1, 3, 0, 2, 4]

2x8: score=37
[8, 2, 7, 3, 6, 1, 1, 0]
[9, 1, 5, 3, 4, 2, 2, 3]

2x9: score=46
[8, 3, 4, 4, 5, 3, 3, 9, 2]
[2, 1, 0, 2, 6, 1, 1, 7, 2]
 
3x4: score=26
[5, 1, 0, 7]
[4, 2, 1, 8]
[2, 3, 6, 9]
 
3x5: score=38
[3 4 7 0 3]
[5 1 2 3 1]
[9 2 6 8 1]

3x6: score=47
[3, 2, 7, 9, 3, 6]
[5, 4, 1, 3, 2, 2]
[6, 1, 4, 0, 8, 1]

3x7: score=65
[8, 4, 7, 5, 5, 8, 1]
[4, 3, 1, 2, 6, 0, 2]
[5, 9, 2, 1, 4, 3, 3]

3x8: score=78
[4, 6, 5, 5, 2, 2, 5, 3]
[6, 4, 9, 1, 0, 7, 7, 8]
[8, 2, 3, 3, 6, 4, 1, 1]

3x9: score=88
[5, 2, 7, 4, 6, 1, 7, 4, 7]
[2, 5, 0, 6, 1, 9, 4, 8, 7]
[6, 8, 1, 3, 3, 2, 5, 3, 8]

4x4: score=43
[3, 6, 2, 8]
[5, 9, 1, 3]
[2, 1, 0, 3]
[4, 2, 7, 4]

4x5: score=58
[5, 5, 3, 3, 0]
[2, 7, 6, 1, 9]
[2, 4, 1, 2, 4]
[4, 0, 5, 8, 3]
     
4x6: score=76
[8, 5, 2, 3, 1, 3]
[5, 7, 0, 4, 6, 8]
[3, 1, 9, 6, 4, 2]
[1, 3, 2, 5, 7, 2]

4x7: score=99
[1, 7, 7, 5, 6, 1, 9]
[8, 3, 2, 5, 1, 6, 9]
[5, 8, 9, 2, 0, 4, 3]
[4, 0, 6, 7, 4, 3, 2]

4x8: score=102
[6, 9, 1, 2, 8, 3, 5, 7]
[1, 0, 2, 4, 3, 8, 6, 7]
[1, 7, 9, 0, 0, 1, 4, 6]
[4, 8, 3, 9, 5, 5, 2, 4]

5x5: score=78
[2, 7, 6, 7, 4]
[7, 8, 5, 0, 1]
[3, 5, 2, 3, 8]
[3, 1, 9, 2, 4]
[1, 6, 6, 4, 5]

5x6: score=100
[0, 9, 4, 6, 7, 7]
[0, 3, 9, 2, 1, 0]
[1, 7, 5, 4, 6, 6]
[8, 1, 4, 5, 8, 3]
[9, 8, 0, 2, 2, 3]

5x7: score=108
[8, 1, 1, 0, 7, 4, 9]
[0, 0, 0, 7, 6, 3, 4]
[1, 4, 2, 6, 7, 5, 8]
[5, 0, 1, 9, 9, 8, 2]
[5, 1, 0, 3, 3, 2, 6]

6x6: score=108
[6, 4, 3, 5, 8, 6]
[1, 0, 4, 0, 6, 8]
[1, 0, 1, 1, 9, 7]
[5, 2, 0, 3, 1, 3]
[5, 7, 2, 8, 3, 9]
[7, 9, 4, 6, 9, 5]

6x7: score=120
[8, 5, 0, 8, 4, 1, 1]
[1, 0, 8, 7, 0, 1, 9]
[1, 1, 9, 3, 1, 6, 9]
[0, 0, 5, 3, 6, 1, 2]
[1, 6, 2, 5, 4, 8, 2]
[3, 7, 7, 1, 4, 4, 9]

7x7: score=131
[3, 1, 4, 8, 6, 8, 5]
[7, 3, 3, 9, 7, 4, 8]
[5, 7, 6, 0, 2, 1, 4]
[7, 1, 1, 2, 1, 2, 3]
[1, 0, 1, 3, 1, 9, 6]
[2, 0, 1, 0, 9, 6, 0]
[8, 5, 4, 5, 5, 2, 1]



Table of best scores:

  x |  1  2  3   4   5   6   7   8  9 10  11  12  13
 ---+------------------------------------------------------
  1 |  1  2  3   4   5   6   7   8  9 10  12  14  16
  2 |  2  4  6   8  10  21  32  37 46
  3 |  3  6  9  26  38  47  65  78 88
  4 |  4  8 26  43  58  76  99 102
  5 |  5 10 38  58  78 100 108
  6 |  6 21 47  76 100 108 120
  7 |  7 32 65  99 108 120 131
  8 |  8 37 78 102
  9 |  9 46 88
 10 | 10
 11 | 12
 12 | 14
 13 | 16

As proposed before, the mxn-rectangle solutions with m+n<=8 remained stable.

Till · 2018-08-14, 20:28

My new algorithm is much stronger than the first one for "large" rectangles, like 10x10 or 20x20.

For 20x20, the first algorithm found a top score of 297.
The new algorithm gives me 1020 (and that may not be the end, last results were pouring in quickly)

Code:

[6, 1, 5, 7, 0, 5, 3, 8, 6, 4, 6, 6, 6, 2, 9, 3, 2, 6, 6, 2]
[0, 7, 8, 3, 7, 8, 6, 1, 6, 3, 2, 2, 5, 8, 5, 6, 2, 7, 0, 7]
[0, 1, 1, 1, 7, 9, 0, 8, 8, 2, 0, 6, 5, 2, 3, 3, 8, 8, 0, 3]
[1, 4, 7, 5, 7, 0, 9, 8, 5, 7, 9, 7, 5, 7, 7, 0, 6, 8, 5, 7]
[0, 3, 7, 2, 7, 5, 3, 0, 3, 6, 7, 3, 1, 2, 2, 8, 9, 8, 2, 5]
[9, 6, 2, 9, 6, 8, 1, 5, 0, 7, 8, 6, 1, 0, 1, 5, 9, 4, 7, 5]
[3, 8, 1, 1, 3, 2, 4, 0, 3, 9, 7, 2, 1, 0, 1, 6, 3, 3, 0, 0]
[5, 4, 9, 9, 1, 0, 0, 1, 8, 5, 0, 3, 2, 1, 7, 7, 8, 6, 1, 6]
[8, 4, 1, 0, 3, 8, 5, 2, 4, 2, 9, 5, 0, 0, 7, 4, 9, 4, 4, 1]
[6, 7, 0, 8, 4, 0, 2, 1, 7, 4, 7, 6, 9, 0, 3, 2, 3, 4, 5, 5]
[0, 0, 0, 0, 6, 9, 4, 9, 8, 4, 9, 9, 1, 5, 1, 4, 3, 9, 0, 2]
[6, 2, 8, 2, 1, 9, 4, 5, 5, 2, 2, 5, 1, 4, 9, 7, 3, 4, 3, 9]
[5, 7, 5, 4, 9, 9, 1, 7, 8, 6, 8, 1, 6, 2, 0, 6, 4, 6, 6, 9]
[8, 8, 8, 5, 9, 2, 2, 6, 4, 2, 4, 8, 1, 9, 5, 0, 5, 3, 1, 5]
[5, 3, 5, 1, 3, 6, 7, 6, 0, 1, 3, 7, 3, 7, 7, 6, 2, 4, 9, 6]
[4, 1, 3, 5, 3, 2, 4, 8, 4, 6, 4, 2, 3, 6, 6, 9, 5, 0, 5, 5]
[8, 7, 3, 4, 2, 1, 1, 6, 5, 0, 2, 6, 4, 3, 4, 6, 2, 4, 4, 2]
[9, 2, 9, 4, 2, 2, 4, 7, 9, 2, 3, 5, 6, 0, 1, 9, 1, 8, 3, 3]
[7, 3, 8, 4, 8, 5, 7, 2, 6, 3, 4, 1, 1, 0, 1, 0, 0, 9, 3, 0]
[2, 3, 8, 2, 7, 6, 7, 2, 8, 9, 2, 0, 9, 8, 1, 0, 1, 9, 8, 4]

Good luck to whoever wants to check that by hand...

P.S. While writing, I already obtained an new record score 1022...

science_man_88 · 2018-08-15, 00:32

Quote:

Originally Posted by Till

Good luck to whoever wants to check that by hand...

only ~624 values need to be checked the others are palindromic to another value checked. I got up to the number 142 checked.

WraithX · 2018-08-15, 10:39

Quote:

Originally Posted by Till

My new algorithm is much stronger than the first one for "large" rectangles, like 10x10 or 20x20.

For 20x20, the first algorithm found a top score of 297.
The new algorithm gives me 1020 (and that may not be the end, last results were pouring in quickly)

Good luck to whoever wants to check that by hand...

P.S. While writing, I already obtained an new record score 1022...

Wow, that's an amazing improvement! I've written a web page that can score a given grid in bases from base-2 to base-10. I'm trying to find a good way to host it online. In the meantime, it verified that the grid you posted does have a score of 1020. Excellent work.

I'm very interested to hear more about the iterative repair algorithm you've come up with. I've automated the process to score mxn grids with my own code, but my numbers will end up being much lower than yours.

Till · 2018-08-15, 19:45

Thanks for the compliments and for verifying (also to science_man).

The main difference in my second algorithm is that I have a stack of "good rectangles".
I initialize the stack with (random rectangle, iterations=0). Elements are subsequently popped from the stack and modified like in my first algorithm (1000 attempts of up to 10 swaps or point mutations). If a modified rectangle is good relative to other results for the number of iterations, then (modified rectangle, iterations+1) are pushed onto the stack.

Interestingly, it seems to be no problem that many identical "rectangles" are added to the stack, because they are randomly-manipulated afterwards. Each copy has its own worth.

Till · 2018-08-15, 19:50

Today I found better solutions for a few elementary base 10 rectangles, i.e. for 4x6, 4x7, 5x5, 5x6:

Code:

4x6: score=78
[3, 9, 6, 2, 7, 0]
[0, 6, 1, 8, 2, 4]
[5, 1, 4, 3, 5, 9]
[6, 7, 7, 4, 3, 5]

4x7: score=100
[9, 1, 0, 0, 7, 1, 6]
[9, 1, 5, 9, 4, 8, 0]
[3, 2, 6, 4, 8, 3, 2]
[3, 6, 2, 7, 7, 5, 5]

5x5: score=87
[2, 3, 5, 7, 1]
[8, 9, 7, 5, 2]
[4, 1, 6, 4, 2]
[1, 3, 4, 6, 0]
[3, 0, 5, 8, 7]

5x6: score=101
[9, 5, 6, 6, 8, 9]
[0, 7, 4, 4, 9, 8]
[3, 0, 7, 1, 3, 2]
[3, 2, 1, 8, 6, 4]
[2, 5, 5, 1, 0, 1]

The 5x5 improvement is the most notable; I already thought that the previous solution was correct.

R. Gerbicz · 2018-08-15, 23:24

While waiting for a bus I have found a grid with +3e13 score for base=2;m=10;n=10; so you would need a terrible good scorer to verify even that small grid. For base=3; I have some not so bad result, but the larger bases are much harder.

base=10 results: (lots of these could be non-optimal)

Code:

 x |    1    2    3    4    5    6    7    8    9   10
---+--------------------------------------------------
 1 |    1    2    3    4    5    6    7    8    9   10
 2 |         4    6    8   10   21   32   37   46   54
 3 |              9   26   38   48   66   78   98  116
 4 |                  43   65   88  126  189  236  277
 5 |                       98  161  231  291  346  395
 6 |                           232  304  359  458  488
 7 |                                375  473  558  665
 8 |                                     584  797  928
 9 |                                          959 1148
10 |                                              1525

m=1;n=1;score=1;
1 

m=1;n=2;score=2;
2 1 

m=1;n=3;score=3;
2 3 1 

m=1;n=4;score=4;
1 4 2 3 

m=1;n=5;score=5;
1 3 5 4 2 

m=1;n=6;score=6;
1 6 3 2 4 5 

m=1;n=7;score=7;
7 5 2 4 3 1 6 

m=1;n=8;score=8;
1 7 2 6 5 4 8 3 

m=1;n=9;score=9;
1 2 3 7 4 6 5 8 9 

m=1;n=10;score=10;
1 0 7 2 4 8 5 9 6 3 

m=2;n=2;score=4;
1 2 
4 3 

m=2;n=3;score=6;
1 5 3 
2 4 6 

m=2;n=4;score=8;
1 7 5 4 
3 2 8 6 

m=2;n=5;score=10;
2 0 6 4 3 
9 8 1 7 5 

m=2;n=6;score=21;
0 1 6 5 4 8 
1 2 7 3 1 9 

m=2;n=7;score=32;
6 2 1 5 2 1 4 
7 1 8 0 3 2 9 

m=2;n=8;score=37;
9 1 7 0 4 1 5 3 
8 2 2 3 1 2 6 3 

m=2;n=9;score=46;
2 7 1 1 5 2 0 3 2 
2 9 3 3 4 4 6 1 8 

m=2;n=10;score=54;
2 6 4 1 9 3 3 4 0 2 
3 8 1 4 7 2 2 5 1 3 

m=3;n=3;score=9;
1 2 3 
9 4 8 
5 7 6 

m=3;n=4;score=26;
4 1 6 9 
0 2 1 8 
2 3 5 7 

m=3;n=5;score=38;
2 8 5 6 1 
1 2 3 1 2 
9 0 4 3 7 

m=3;n=6;score=48;
4 7 2 8 4 6 
1 5 3 2 1 4 
1 3 6 9 0 3 

m=3;n=7;score=66;
5 1 1 7 3 5 2 
6 0 2 4 5 3 8 
3 6 4 2 9 1 4 

m=3;n=8;score=78;
1 3 7 5 3 3 6 6 
8 7 0 2 4 9 5 8 
4 4 6 1 1 5 2 2 

m=3;n=9;score=98;
2 5 7 8 3 0 1 1 2 
9 2 8 6 9 5 7 3 4 
6 4 0 1 6 7 5 4 3 

m=3;n=10;score=116;
8 3 3 2 2 8 5 1 9 0 
9 6 5 1 0 4 8 7 0 2 
4 9 6 5 1 1 4 3 7 6 

m=4;n=4;score=43;
3 6 9 8 
7 2 1 3 
2 1 3 5 
8 0 4 2 

m=4;n=5;score=65;
8 5 7 4 4 
2 1 3 2 8 
1 6 9 3 2 
0 4 5 5 0 

m=4;n=6;score=88;
9 3 0 7 9 5 
4 6 3 2 1 5 
7 5 8 1 2 6 
7 8 0 4 4 6 

m=4;n=7;score=126;
8 5 5 2 2 1 9 
7 8 3 4 1 0 5 
2 9 4 3 0 1 6 
9 6 6 7 7 8 2 

m=4;n=8;score=189;
1 7 3 3 0 0 8 1 
7 8 4 1 1 6 7 8 
1 5 2 4 6 1 2 9 
5 1 0 9 5 3 9 2 

m=4;n=9;score=236;
5 1 2 1 9 5 8 6 1 
1 5 6 2 0 1 7 8 6 
9 4 3 0 2 7 1 9 9 
4 2 1 8 4 1 3 3 2 

m=4;n=10;score=277;
2 7 2 2 1 8 2 5 4 9 
0 1 3 5 2 4 5 4 9 3 
6 0 1 9 0 7 1 6 3 1 
2 2 1 8 7 1 6 2 8 8 

m=5;n=5;score=98;
8 7 1 6 6 
6 0 3 5 9 
2 4 5 3 2 
2 7 4 8 1 
7 0 9 1 8 

m=5;n=6;score=161;
1 1 5 8 2 2 
4 5 6 0 1 4 
7 4 3 1 0 9 
8 3 1 2 7 6 
8 9 9 5 6 7 

m=5;n=7;score=231;
5 6 6 4 4 9 1 
8 5 1 2 1 7 9 
1 2 2 1 7 6 5 
3 9 0 8 3 0 1 
3 0 8 1 4 5 2 

m=5;n=8;score=291;
2 3 0 2 3 1 9 4 
1 2 7 1 5 3 4 8 
2 4 1 0 2 6 8 2 
5 8 0 1 6 1 7 5 
1 9 2 2 9 9 5 7 

m=5;n=9;score=346;
3 4 1 9 2 5 1 9 2 
2 3 9 1 5 7 7 0 2 
1 2 8 6 1 2 6 3 0 
7 8 2 0 4 2 1 6 3 
1 4 5 1 3 4 5 3 2 

m=5;n=10;score=395;
0 2 3 6 3 7 1 2 5 9 
3 0 1 7 6 1 7 1 9 2 
4 1 5 2 0 8 3 4 6 1 
2 4 8 3 2 9 1 3 2 5 
2 9 3 8 2 7 3 9 5 3 

m=6;n=6;score=232;
5 5 1 2 7 1 
8 1 2 8 3 7 
8 0 1 4 6 9 
9 7 4 6 1 2 
1 9 5 0 0 2 
1 3 3 1 2 3 

m=6;n=7;score=304;
8 1 3 2 1 3 4 
3 8 7 0 3 4 2 
5 2 1 7 0 2 9 
1 5 4 9 2 1 3 
9 1 6 8 5 6 1 
9 2 1 0 2 7 6 

m=6;n=8;score=359;
1 5 5 2 1 3 4 2 
2 1 6 4 2 0 8 4 
2 6 1 0 3 2 9 1 
5 9 3 1 0 5 7 9 
5 3 2 7 8 2 1 4 
3 4 7 6 1 8 3 3 

m=6;n=9;score=458;
2 9 9 4 5 6 1 2 0 
9 7 7 1 4 5 6 9 5 
4 3 2 6 3 2 3 1 3 
2 2 0 3 8 7 1 3 4 
9 8 4 1 5 1 0 0 4 
3 1 8 4 2 2 9 4 5 

m=6;n=10;score=488;
7 6 4 1 5 8 3 5 4 6 
8 4 3 2 8 1 6 2 2 2 
4 5 2 0 4 3 7 8 9 1 
3 9 5 4 1 0 2 9 1 0 
8 3 7 1 6 9 0 3 4 7 
3 7 1 2 5 6 3 2 3 4 

m=7;n=7;score=375;
3 1 0 2 7 7 1 
4 1 5 0 6 1 8 
3 4 8 3 1 8 9 
6 2 7 2 3 9 2 
6 2 9 1 4 6 1 
1 5 2 0 2 5 3 
0 7 3 3 3 7 5 

m=7;n=8;score=473;
1 9 3 9 5 7 1 3 
3 5 2 3 0 4 6 8 
8 1 7 6 3 5 6 2 
3 8 1 2 2 4 5 2 
2 9 2 1 4 0 8 1 
9 0 6 4 1 7 3 4 
1 1 0 3 9 2 7 3 

m=7;n=9;score=558;
9 7 4 5 7 4 9 2 5 
3 8 0 1 4 3 4 9 7 
1 2 8 0 3 2 8 1 1 
4 1 7 2 9 5 6 3 3 
6 7 2 6 2 1 4 6 9 
3 3 5 0 1 2 8 4 0 
0 8 3 5 1 5 5 5 4 

m=7;n=10;score=665;
9 0 3 2 8 8 5 4 4 6 
1 1 6 6 0 2 7 3 2 4 
8 3 1 7 4 4 1 7 6 9 
8 0 9 3 1 9 8 5 3 9 
3 4 8 5 0 2 6 3 1 5 
3 5 4 0 5 7 2 1 2 9 
3 9 6 6 5 2 9 4 5 3 

m=8;n=8;score=584;
8 4 1 1 6 3 9 6 
9 4 7 0 1 8 3 3 
5 7 3 3 4 8 0 5 
4 6 2 4 2 0 1 5 
5 0 4 1 5 2 7 5 
1 3 9 1 6 8 2 6 
1 7 5 2 3 6 9 1 
0 8 4 5 4 9 1 2 

m=8;n=9;score=797;
1 6 1 9 9 5 2 7 9 
6 7 7 3 1 3 2 9 4 
5 8 7 2 8 5 6 6 7 
0 7 5 0 2 1 3 0 6 
9 5 4 1 1 2 0 4 5 
5 6 3 7 4 9 6 4 4 
6 8 0 3 2 3 8 2 9 
1 4 4 7 3 7 1 8 5 

m=8;n=10;score=928;
0 7 4 8 5 4 7 1 6 7 
5 0 2 8 1 3 1 1 7 9 
9 1 2 6 7 5 8 2 0 8 
1 3 0 4 6 4 5 9 7 3 
5 2 3 1 3 0 4 1 9 6 
4 3 8 6 9 5 8 4 2 4 
9 8 7 8 6 5 7 2 7 2 
8 3 0 0 6 2 5 7 9 3 

m=9;n=9;score=959;
3 4 7 4 1 6 4 7 9 
4 6 7 1 2 4 8 5 7 
4 9 1 8 6 5 0 9 2 
5 5 3 6 2 0 4 2 3 
2 0 5 7 3 7 1 3 1 
1 3 8 3 6 6 5 9 3 
7 2 4 8 0 1 6 7 9 
2 9 2 9 1 8 5 7 0 
9 0 8 6 9 6 8 8 7 

m=9;n=10;score=1148;
2 7 5 1 2 0 4 9 5 4 
2 9 5 0 2 2 9 3 0 0 
4 5 4 7 6 9 1 1 7 9 
8 2 6 1 7 1 0 1 8 9 
8 5 6 7 4 2 5 3 2 3 
1 8 5 4 8 7 3 6 1 5 
9 0 4 6 9 8 6 0 4 1 
7 7 4 3 5 6 0 8 3 8 
7 3 3 9 5 9 1 0 2 2 

m=10;n=10;score=1525;
0 5 1 8 7 5 0 1 0 8 
1 4 9 8 1 6 8 0 3 3 
5 0 5 4 8 1 4 3 4 1 
7 7 9 3 1 9 5 8 2 5 
2 8 0 1 2 6 5 5 3 7 
8 0 2 2 6 8 3 1 1 7 
9 9 1 3 1 4 7 2 9 3 
5 2 9 0 6 1 4 7 6 9 
4 4 6 6 5 5 2 0 7 3 
7 1 4 7 0 2 1 1 3 9

Uncwilly · 2018-08-16, 00:29

Quote:

Originally Posted by LaurV

wait till Gerbicz reads this thread...

Quote:

Originally Posted by R. Gerbicz

While waiting for a bus
......
base=10 results: (lots of these could be non-optimal)

Code:

 x |    1    2    3    4    5    6    7    8    9   10
---+--------------------------------------------------
 1 |    1    2    3    4    5    6    7    8    9   10
 2 |         4    6    8   10   21   32   37   46   54
 3 |              9   26   38   48   66   78   98  116
 4 |                  43   65   88  126  189  236  277
 5 |                       98  161  231  291  346  395
 6 |                           232  304  359  458  488
 7 |                                375  473  558  665
 8 |                                     584  797  928
 9 |                                          959 1148
10 |                                              1525

Wow, just wow.

Similar Threads
Thread	Thread Starter	Forum	Replies	Last Post
Find the Squares	a1call	Puzzles	18	2018-03-02 16:47
Regarding Squares	a1call	Miscellaneous Math	42	2017-02-03 01:29
Counting Latin rectangles	Dougy	Math	3	2010-02-16 10:20
squares or not squares	m_f_h	Puzzles	45	2007-06-15 17:46
Prime squares/rectangles	roger	Puzzles	10	2007-05-04 16:07

2018-08-14, 06:55	#24
LaurV Romulan Interpreter Jun 2011 Thailand 22613₈ Posts	wait till Gerbicz reads this thread...

2018-08-15, 19:45	#30
Till "Tilman Neumann" Jan 2016 Germany 448₁₀ Posts	Thanks for the compliments and for verifying (also to science_man). The main difference in my second algorithm is that I have a stack of "good rectangles". I initialize the stack with (random rectangle, iterations=0). Elements are subsequently popped from the stack and modified like in my first algorithm (1000 attempts of up to 10 swaps or point mutations). If a modified rectangle is good relative to other results for the number of iterations, then (modified rectangle, iterations+1) are pushed onto the stack. Interestingly, it seems to be no problem that many identical "rectangles" are added to the stack, because they are randomly-manipulated afterwards. Each copy has its own worth.