34

通过仅翻转（绕中心点反转）行和列，创建一个程序以消除数字的平方。

输入项

输入将是9x9的数字网格，格式为9行字符串，如下所示：

此输入格式不可协商-输入格式“具有创造性”的任何解决方案都将被视为无效。

输出量

输出应为翻转动作列表，当以给定顺序应用于输入时，应重新创建目标网格。

示例输出（不是先前输入示例的解决方案）：

28IF5D3EAB9G3

此输出格式也是不可协商的。输出中不应包含换行符或空格，只能使用1- 9和A- I字符（如果需要，可以使用小写字母代替大写字母）。

目标网格（您需要重新创建的状态）如下：

数字1- 9应该用作翻转行的说明，字母A- I应该用于列。网格处于还原状态时，如下所示。

     ABCDEFGHI
     |||||||||
     vvvvvvvvv
1 -> 123456789
2 -> 234567891
3 -> 345678912
4 -> 456789123
5 -> 567891234
6 -> 678912345
7 -> 789123456
8 -> 891234567
9 -> 912345678

因此，一个8装置从底部翻转第二行，一个F装置从第六列翻转。

在无法解决的情况下，程序应完全不输出任何内容而结束。

例子

输入：

输出：

在这种情况下，只需翻转第一行即可返回到目标状态。

输入：

输出：

在这种情况下，只需I翻转最后一列（列）即可重新创建目标状态。

输入：

输出：

2I

在这种情况下，我们需要先翻转行2然后翻转列I以返回到目标状态。

笔记：

请在回答中包含示例用法。
给定的输出不必是将返回目标状态的最短序列-任何返回目标状态的序列都将在可行的前提下运行（即只要我可以对其进行测试）
我将尽力测试每个答案，并对所有有用的显然是打高尔夫球的作品进行投票。
这是一个开放式竞赛-我将在下周的某个时候接受最短的答案，但是如果出现了一个新的有效答案，而该答案在将来的任何时候都更短，那么我将更改接受的答案以反映这一点。
~~2014~~年1 ~~月26~~日~~23:59:59（GMT）收到的最短答案的赏金设置为200声望。~~霍华德因其268个角色的GolfScript解决方案而被授予赏金。

测试中

请提供以下三个测试网格的程序输出以及答案：

我创建了一个小的Python程序来生成有效的网格以进行测试：

import random

def output(array):
  print '\n'.join([''.join(row) for row in array])

def fliprow(rownum, array):
  return [row[::1-2*(rownum==idx)] for idx,row in enumerate(array)]

def flipcol(colnum, array):
  return zip(*fliprow(colnum, zip(*array)))

def randomflip(array):
  op=random.randint(0,1)
  row=random.randint(0,9)
  if(op==1):
    return fliprow(row, array)
  else:
    return flipcol(row, array)

def jumble(array):
  arraycopy=array
  for i in range(10, 1000):
    arraycopy=randomflip(arraycopy)
  return arraycopy

startarray=[
['1','2','3','4','5','6','7','8','9'],
['2','3','4','5','6','7','8','9','1'],
['3','4','5','6','7','8','9','1','2'],
['4','5','6','7','8','9','1','2','3'],
['5','6','7','8','9','1','2','3','4'],
['6','7','8','9','1','2','3','4','5'],
['7','8','9','1','2','3','4','5','6'],
['8','9','1','2','3','4','5','6','7'],
['9','1','2','3','4','5','6','7','8']]

print output(jumble(startarray))

code-golf

— 加雷斯
source

8

我只是写了一个简短的解决方案，随机翻转行/列，直到排序完成。经过5亿次迭代，它仍然没有解决您给出的第一个难题（您只需要翻转第1行）。随机性似乎不是解决此问题的可用方法！

— 2014年

3

@Josh并不奇怪。这个问题似乎与解决魔方的问题非常相似。我认为某种广度优先的搜索将是最好的蛮力。就是说，理论上随机算法必须最终终止，并且看起来符合指定的规则。

— Cruncher 2014年

4

不需要蛮力。考虑以下事实：每个网格图块只能以以下四个位置之一结束：其正确位置，X翻转，Y翻转或XY翻转。它可以帮助您从心理上将栅格视为（0,0）为最中心的图块。如果您正在解决瓦（-2,4），唯一的位置目标人数可能是(-2, 4)，(2, 4)，(2, -4)，或(-2, -4)。

— 拉玛先生2014年

2

@Cruncher：使用整个行/列的翻转使得这不可能。例如，尝试取最左上角的1（A1）并将其移到B1。您可以到达1该位置B1，但这将是来自的图块B9，而不是来自的图块A1。因为我们只允许整行/每列翻转，所以最左上角的1永远只能位于四个最外角之一。如果我误解了规则，请告诉我。

— 骆

7

恭喜，加雷斯。这是一个设计很好的问题。另外，很有挑战性。

— DavidC 2014年

7

GolfScript，300个 279 268字

n%`{\5,{.9+}%{;.2/\2%},\;''{1${.9/7+7*+}%+:z;}:?~{{.9<77*{\zip\9-}>:Z~{1$!{-1%}*\(\}@%\Z;}/}:E~{:^;{:c;.`{[\E[.^=\8^-=]{.c=\8c-=}%[^c+^8c-+8^-c+16c-^-]{9%49+}%=}+[[]]:K[[8^- 17c-][^9c+]1$]{:s;{[[]s.+.2$+]{1$+}/}%.&}/\,K+0=z?E}5,/}5,/{{+9%)}+9,%''*}9,%={z:u;}*}+1024,/u

请注意，此代码非常慢（也是由于繁琐的代码块操作），可能会运行几分钟。该代码非常不实用，带有许多变量和显式循环。

我写了一个分析性更强的解决方案，运行了不到一秒钟。我在打高尔夫球时完全摔坏了那个。不幸的是，最近两天我无法回溯或修复代码。因此，我制作了这个尝试检查版本，但无论如何它都更短。

上面给出的谜题的答案：

1A2C4D9G9G9G9G1C1C1C1C9F9F9F9F1D1D1D1D2A2A2A2A8H8H8H8H2B2B2B2B2C2C8F8F2D2D2D2D3A3A7I7I3B3B7H7H7G7G7G7G3D3D7F7F6I6I6I6I4A4A4A4A6H6H6H6H6G6G4C4C4C4C6F6F4D4D

1AB39I9I1A1A9I9I1B1B9F9F8I8I8I8I2B2B8H8H8G8G8G8G2D2D2D2D3A3A3A3A7H7H7H7H3C3C3C3C3D3D7F7F6I6I4A4A6I6I4B4B4B4B6G6G4C4C4C4C6F6F6F6F4D4D

1A34D9I9I9I9I1A1A1A1A1B1B1B1B9G9G1C1C1C1C9F9F9F9F1D1D9F9F8I8I2A2A2A2A8H8H8H8H2C2C2C2C8F8F2D2D8F8F7I7I7I7I3A3A3B3B7G7G7G7G3C3C3C3C6I6I6I6I6H6H6H6H4B4B4B4B6G6G6G6G4C4C6G6G6F6F4D4D6F6F

— 霍华德
source

好吧，要击败这个将是非常艰苦的工作……

— Gareth 2014年

似乎我错了...

— Gareth 2014年

@Gareth我知道这是一个挑战，用golfscript对抗例如mathematica很难。

— 霍华德

1

@Howard-您使用什么方法？您提到的“试用版”是什么？

— SergeyS 2014年

24

数学582 575 503 464 282

要与golfscripters打架，我必须使用重型火炮！

i = "986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378";

a=Array;h@M_:=Join@@a[9(M〚##〛/. 9->9⌈2Random[]⌉)+Abs[{##}-5]&,n={9,9}];
For[i_~t~j_:=i{#2,10-#2}+j#-9&~a~{9,4},!ListQ[e=GroupElementToWord[
PermutationGroup[Cycles/@Join[1~t~9,9~t~1]],
h[ToCharacterCode@StringSplit@i-48]~FindPermutation~h@a[Mod[8+##,9,1]&,n]]],];
e~IntegerString~36<>""

输出：

g69g69g8g8g7g7gd96d96d8d8d7d7dh6h64a6a46d6d4g4g6b6b7h7h7c7c2a8a27b7bd8db8b7f7fg8g82c2c94a4a3a3aigfdc91

在这里PermutationGroup[...]设置可能的翻转并GroupElementToWord[...]解决问题（大约0.2几秒钟）。主要问题在于，很难识别9初始网格和最终网格中的位置之间的对应关系。对于打高尔夫球，我会随机进行（需要几秒钟）。有一些警告，但可以忽略它们。

其他测试网格：

g69g69g8g8g7g7gh89h89h7h7h6h6hf6f6g6g64f4f4h4hg7g73g3g2a8a28d8db8b83d3dg8g82c2c9a3a643a3a2g9f9d9c9ga
h89h89h7h7h6h6h6h6h6f6f6g6g6d6d3a7a37g7g7h7h3c3c2a8a27b7b8d8d2f2f8b8b3f3f2b2ba2a764a8aih9g9c9gb1i

它完全重现了示例：

1
i
2i

先前的解决方案（464）

没有任何巧妙的内置函数，运行时间为4毫秒：

M=ToCharacterCode@StringSplit@i-48;
S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;
A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};
u=s/@Join@@A;
H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;
MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

此处不需要所有新行。

输出：

3b9i9i1a1a1a1a9i9i1a1a9h9h1b1b1b1b9h9h9g9g1c1c9g9g9f9f1d1d9f9f8h8h2b2b8f8f8f8f7i7i7h7h3b3b3b3b7h7h3b3b7h7h7g7g3c3c7g7g3c3c7f7f6i6i4a4a6h6h4b4b4b4b6g6g4c4c6g6g4c4c6f6f4d4d4d4d6f6f4d4d6f6f4d4d

其他两个测试网格：

13ab9i9i1a1a9i9i9h9h1b1b1b1b9h9h9f9f8i8i8i8i8h8h2b2b2b2b8h8h8h8h8g8g8g8g8f8f2d2d2d2d8f8f2d2d7i7i3a3a3a3a7i7i7h7h3b3b7h7h3b3b7g7g3c3c3c3c7g7g3c3c7f7f3d3d3d3d7f7f7f7f6i6i4a4a6i6i6h6h4b4b4b4b6h6h4b4b6g6g4c4c4c4c6f6f4d4d4d4d6f6f4d4d6f6f
2bc9i9i1a1a9i9i9g9g1c1c9g9g1c1c9f9f1d1d1d1d8i8i8i8i8h8h2b2b2b2b8f8f2d2d7i7i7h7h3b3b3b3b7h7h3b3b7g7g3c3c7f7f3d3d3d3d7f7f3d3d6i6i4a4a4a4a6h6h4b4b6g6g6g6g6f6f4d4d

可视化：

anim = Reap[Fold[Function[{m, i}, 
 If[i > 9, (Sow@Grid[#, Background -> {i - 9 -> Pink, None}] & /@ {m, #}; #) &@
   Transpose@MapAt[Reverse, Transpose@m, i - 9], (Sow@Grid[#, 
         Background -> {None, i -> Pink}] & /@ {m, #}; #) &@
   MapAt[Reverse, m, i]]], M, IntegerDigits[FromDigits[S, 36], 36]]];

ListAnimate[Join[{#, #} &@Grid@M, anim[[2, 1]], {#, #} &@Grid@anim[[1]]], 5]

在此处输入图片说明

输入字符串i可以通过以下方式随机生成

M = Array[Mod[8 + ##, 9, 1] &, {9, 9}];
(M[[#]] = Reverse@M[[#]]; M[[All, #2]] = Reverse@M[[All, #2]];) & @@@
   RandomInteger[{1, 9}, {10000, 2}];
i = ToString /@ # <> "\n" & /@ M <> ""

简短讨论

翻转只能交换以下元素（“四重”）：
仅当初始和最终顺序具有相同的签名时，才可以将这些元素与其他元素分开互换。
这四个元素的翻转形成4度的交替组（=四面体的旋转组）。该组中的每个元素都是2个生成元素的组合。因此，如果我们知道初始位置和最终位置，就可以将相应的变换分解为简单翻转的组合。

细节

对于体育精神，我会在赏金结束之前发布详细信息！

M=ToCharacterCode@StringSplit@i-48;

将字符串转换i为矩阵M。

S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;

我们将字符附加到S。现在是空字符串。H[i,j]将添加字符i（1,2,3,...,9）和字符j（a,b,c,...,i在base-36中）。

A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};

我将元素转换为

在此处输入图片说明

获得以下形式的目标矩阵

在此处输入图片说明

然后我的算法有两个主要步骤

查找翻转以获取目标矩阵中的签名（例如{-7,-1,1,7}is 1的签名和{-6,2,-2,6}is 的签名-1）：

u=s/@Join@@A;
H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;

旋转每个“四元组”以获得正确的顺序：
```
MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
```
它是算法中最重要的部分。例如，转换1b1b将转换{-7,-1,1,7}为{-1,1,-7,7}。转换9h9h将转换{-7,-1,1,7}为{-7,7,-1,1}。所以我们有两张地图
```
{1,2,3,4} -> {2,3,1,4}
{1,2,3,4} -> {1,4,2,3}
```
并且我们想将任意顺序转换{x,y,z,w}为{1,2,3,4}。简单的方法是（随机搜索除外）
```
repeat   
{x, y, z, w} -> If[z < 3, {y, z, x, w}, {x, w, y, z}]
until {1,2,3,4}
```
我无法证明，但是可以！

最后一步是

M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

它执行中心行和中心列的琐碎翻转，并返回结果。

— 伊贝尔图科夫
source

@Gareth我可以在输出中使用小字符吗？它为我节省了许多字符。

— ybeltukov 2014年

是的，我将在输出中接受小写字符（我将更改问题以对此加以注意）。我没有Mathematica，所以其他Mathematica用户可以确认该代码实际上生成了输出吗？我已经验证了这三个测试解决方案，它们都是正确的，所以+1。不错的工作！

— Gareth 2014年

只是好奇-您的方法表现如何？您是否测试了数千次翻转产生的输入？

— SergeyS 2014年

@SergeyS是的，大约需要50毫秒:)

— ybeltukov 2014年

@Gareth我重写了程序，您可以检查结果吗？我的测试表明一切都正确。

— ybeltukov 2014年

7

Ĵ 487 438

q=:3 :'(>:9|+/~i.9)=/&((,{;/(,.8&-)y){])g'
l=:2 :0
:
o=:o,(m+x){a.
x&(|.@{`[`]})&.v y
)
r=:49 l]
c=:97 l|:
w=:2 :'g=:4 v^:(4=(<m){g)g'
p=:_1=C.!.2@,@:I.@q
t=:2 :'for_i.>:i.3 do.g=:i v^:(p m*i)g end.'
z=:2 :0
'i j I J'=.y,8-y
g=:".'(',(,' ',.,(I.m{q y){,;._1 n),'])^:2 g'
)
d=:3 :0
g=:9 9$".,_ list,' ',.y
o=:''
0 4 w c
4 0 w r
0 1 t c
g=:0 c^:(-.(p 1 0)=p 1 2)g
1 0 t r
for_k.>,{;~i.4 do.0 z';;jcir;irjc;Irjc'k
3 z';;IrJc;JcIr;'k end.o
)

d 是一个动词，它采用指定格式的网格字符串并返回指定格式的解决方案字符串。

使用示例：

   d '987654321',LF,'234567891',LF,'345678912',LF,'456789123',LF,'567891234',LF,'678912345',LF,'789123456',LF,'891234567',LF,'912345678'
bcda2341a1a1b1b1c1c1d1da2a2b2b2c2c2d2d2a3a3b3b3c3c3d3d3a4a4b4b4c4c4d4d4

现在接受任一换行类型。

测试网格的解决方案：

b3a1a11b1bc9c99g9gd9d99f9fb8b8f8f87i7i7h7hc3c3g7g77f7fa6a64b4bh6h6c4c4g6g6d6d6f6f6
cd24a9a91c1c1d1d9f9fa2a2i8i88h8hc2c2g8g82d2d3b3bh7h7d3d37f7fa6a64b4bg6g64d4d6f6f
bc2a9a99i9ic1c1g9g91d1df9f9i8i8b2b2h8h82c2cd8d87i7ib3b3c7c7d3d34a4ai6i6b6b6g6g6d6d6

我对J很陌生；这可能会打得更远。

检查无效/不可解决的网格会导致123个字符的罚款。我不认为迄今为止的其他答案都具有这种错误检查功能。

为此，将其第一行更改为d：

if.-.+./89 90=#y do.0 return.end.if.-.*./(/:~y)=/:~(#y)$'123456789',LF do.0 return.end.g=:9 9$".,_ list,' ',.y

最后一行：

3 z';;IrJc;JcIr;'k end.if.*./,g=>:9|+/~i.9 do.o return.end.0

我选择返回0此类错误，因为返回空字符串与正确解决完全解决的网格难以区分。请注意，这再次假设使用UNIX换行符。

— 联盟嫉妒
source

恭喜，您已经取得了领先。:-)

— Gareth 2014年

看起来您输入的内容不是规则要求的一个字符串，还是我错过了什么？

— SergeyS 2014年

@SergeyS：您可能会感到困惑。据我所知，J无法在字符串文字中放置转义符（例如换行符）。J中的结构'a'，LF，'b'与+可以附加字符串的语言中的“ a” +“ \ n” +“ b”相似。

— AlliedEnvy 2014年

好的，谢谢。

— SergeyS 2014年

我刚刚阅读了1962年APL书中有关文件的部分，我认为@AlliedEnvy是正确的。如果以问题的格式从文件中读取数据，这将是数据在程序中显示的方式。该LFs为分区的顺序文件。

— luser droog 2014年

5

C＃ 540 399

好吧，牺牲了性能（现在需要30秒），引入了动态变量，解决方案的逻辑略有改变。是的，现在它期望输入作为带换行符的一个字符串（按规则要求）。

当然，C＃没有预定义的数学函数，因此很难与Mathematica的家伙抗衡。尽管如此，这还是一个巨大的挑战，这要感谢作者！

string S(string _){for(i=0,e=1>0;e;){
for(h=v=j=0;j<89;)m[j/10,j%10+9]=_[j++]-49;a="";
for(j=i++;j>0;v++,j/=2)if(j%2>0)F(v);
for(;h<9&(h<4|!e);h+=j/36,j%=36)if((e=m[h,g=j++%9+9]!=(t=(h+g)%9))|m[v=8-h,g]==t){F(v);F(g);F(v);F(g);}
}return a;}void F(int z){for(f=z<9;++l<9;)m[0,l]=m[f?z:l,f?9+l:z];for(;l-->0;)m[f?z:l,f?9+l:z]=m[0,8-l];a+=(char)(z+=f?49:56);}
dynamic h,v,i,j,e,t,l=-1,g,a,m=new int[9,19],f;

测试网格：

3B9A9A9B9B9C9C9D9D9F9F9G9G9H9H9I9I9B9B9C9C9D9D9F9F9G9G9H9H9C9C9D9D9C9C9D9D8B8B8F8F8H8H8B8B8F8F8B8B8H8H7B7B7C7C7F7F7H7H7I7I7H7H6A6A6B6B6C6C6D6D6F6F6H6H6A6A6B6B6D6D6F6F6D6D6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

13AB9A9A9B9B9F9F9H9H9A9A9B9B9H9H9I9I8B8B8D8D8F8F8G8G8H8H8I8I8B8B8G8G8H8H8I8I8H8H7A7A7B7B7C7C7D7D7F7F7G7G7I7I7A7A7D7D7F7F7I7I7F7F6A6A6B6B6C6C6D6D6F6F6G6G6H6H6I6I6A6A6C6C6F6F6I6I6A6A6A6A5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

2BC9A9A9C9C9D9D9F9F9A9A9D9D9I9I8B8B8D8D8H8H8I8I8B8B8D8D8I8I7B7B7C7C7D7D7F7F7G7G7H7H7I7I7C7C7C7C7G7G6A6A6B6B6D6D6F6F6G6G6I6I6A6A6B6B6D6D6G6G6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

旧解决方案（540）

在任何输入上不到一秒钟的工作时间（在数千个随机生成的网格上进行了测试）。输出字符串的最大长度为165（最初，任何网格都不超过82次翻转即可解决，但在打高尔夫球时我牺牲了这一点）。

string S(string[]_){for(i=0;i<1<<18;){
for(j=0;j<81;)m[j/9+49,j%9+65]=_[j/9][j++%9]-49;a="";char g,h='1',v='9',b,x=h,y;
for(j=i;j>0;x=x==v?'A':++x,j/=2)if(j%2>0)F(x);j=i+1;
for(i+=1<<19;h<58;h++,v--)for(g='A',b='I';g<74;g++,b--){
t=(h+g-6)%9;e=m[h,g];q=m[v,g];i=h>52&t!=e?j:i;
if(e!=t|q==t){x=q==t?v:g;y=q==t?g:v;
if(m[h,b]==t){x=b;y=h;}
F(x);F(y);F(x);F(y);}}}return a;}
void F(char z){var f=z<65;for(l=0;l<4;l++){n=m[d=f?z:49+l,s=f?65+l:z];m[d,s]=m[o=f?z:57-l,u=f?73-l:z];m[o,u]=n;}a+=z;}
int i,j,q,e,t,l,s,d,n,u,o;int[,]m=new int[99,99];string a;

回答示例1：

15A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

回答示例2：

19AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5D
5DE5E55F5F5G5G5H5H5I5I

回答示例3：

129AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5
D5DE5E55F5F5G5G5H5H5I5I

测试方格的答案：

346B9A9AH1H1C9C9D9D99F9F9G9GH9H99I9IB8B8F8F87B7B7C7C7F7FH7H77I7I6A6A6B6BC6C66D6DG6G6H6H66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

1346ABA9A9H1H19F9FH9H99I9IH2H28D8D8F8FG8G8I8I8I3I37B7B7C7CF3F37G7GI7I7H4H4D6D66F6F5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

2BCA9A99C9CF1F19F9F9I9IH2H2D8D88H8HI8I87B7BC7C77D7D7F7F7H7H7I7II4I4B6B6D6D6G6G66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

— 谢尔盖
source

我现在只是为Mac下载Mono，以便可以测试程序本身，但是我已经有一个验证程序，该验证程序可以在给定的网格上运行给定的解决方案，并告诉我该解决方案对于该网格是否是有效的解决方案-并且告诉我，您提供给我的三个示例解决方案无效。我只是在调查为什么。

— Gareth 2014年

啊哈！我知道这里发生了什么！您给出的答案似乎是对3个示例的回答，而不是对3个测试网格的回答（在问题中排在下面）。它们确实是这些网格的正确解决方案，尽管它们比1，更长A，并且2I是最简单的解决方案-但这实际上并不重要，因为我不判断网格解决方案的长度:-)如果可以编辑并给出3个测试网格的答案（我现在看看是否可以在Mac上运行它）我可以给您+1。

— Gareth 2014年

@Gareth-糟糕，我确实错过了测试方格的答案，感谢您指出。我现在将它们添加到我的答案中。

— SergeyS 2014年

太好了，谢谢。他们都通过了验证。Xamarin由于某些原因无法在Mac上运行，因此我将不得不在几个小时内对程序进行测试。

— Gareth 2014年

@Gareth-实际上，在该代码中没有特定于C＃的代码，人们可以毫不费力地将其转换为Java甚至C ++。简洁-这可能出现两次或更短;）

— SergeyS 2014年

Flippin广场

GolfScript，300个 279 268字

数学582 575 503 464 282

先前的解决方案（464）

简短讨论

细节

Ĵ 487 438

C＃ 540 399

旧解决方案（540）