Tạo một chương trình hoặc hàm để làm xáo trộn một hình vuông các chữ số bằng cách lật (đảo quanh điểm trung tâm) chỉ các hàng và cột.

Đầu vào

Đầu vào sẽ là một lưới các chữ số 9x9 dưới dạng một chuỗi 9 dòng như sau:

986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378

Định dạng đầu vào này không thể thương lượng - mọi giải pháp "sáng tạo" với định dạng đầu vào sẽ được coi là không hợp lệ.

Đầu ra

Đầu ra phải là một danh sách các động tác lật, khi được áp dụng cho đầu vào theo thứ tự nhất định, sẽ tạo lại lưới đích.

Một đầu ra ví dụ (không phải là giải pháp cho ví dụ đầu vào trước đó):

28IF5D3EAB9G3

Định dạng đầu ra này cũng không thể thương lượng. Không nên có dòng mới hoặc khoảng trắng trong đầu ra, chỉ có các ký tự 1- 9và A- I(ký tự chữ thường được chấp nhận thay cho các ký tự chữ hoa nếu bạn thích).

Lưới đích (trạng thái bạn cần tạo lại) như sau:

123456789
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

Các số 1- 9nên được sử dụng làm hướng dẫn để lật các hàng và các chữ cái A- Inên được sử dụng cho các cột. Điều này được hiển thị dưới đây với lưới ở trạng thái được khôi phục.

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

Vì vậy, một 8phương tiện lật hàng thứ hai từ dưới lên, và một Fphương tiện lật cột thứ sáu.

Trong trường hợp không có giải pháp nào khả thi, chương trình sẽ kết thúc mà không xuất ra bất cứ điều gì cả.

Ví dụ

Đầu vào:

987654321
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

Đầu ra:

1

Trong trường hợp này, chỉ có hàng trên cùng cần lật để trở về trạng thái mục tiêu.

Đầu vào:

123456788
234567897
345678916
456789125
567891234
678912343
789123452
891234561
912345679

Đầu ra:

I

Trong trường hợp này, chỉ cột cuối cùng (cột I) cần lật để tạo lại trạng thái mục tiêu.

Đầu vào:

123456788
798765432
345678916
456789125
567891234
678912343
789123452
891234561
912345679

Đầu ra:

2I

Trong trường hợp này, chúng ta cần lật hàng 2và sau đó lật cột Iđể trở về trạng thái mục tiêu.

Ghi chú:

• Vui lòng bao gồm một ví dụ sử dụng trong câu trả lời của bạn.
• Đầu ra đưa ra không phải là chuỗi ngắn nhất sẽ trả về trạng thái mục tiêu - bất kỳ chuỗi nào trả về trạng thái mục tiêu sẽ hoạt động miễn là nó hoạt động (miễn là tôi có thể kiểm tra nó)
• Tôi sẽ nỗ lực để kiểm tra từng câu trả lời và nâng cao tất cả những câu hỏi có hiệu quả và rõ ràng đã có một nỗ lực chơi gôn.
• Đây là một cuộc thi kết thúc mở - tôi sẽ chấp nhận câu trả lời ngắn nhất vào tuần tới, nhưng nếu một câu trả lời hợp lệ mới hơn xuất hiện trong thời gian ngắn hơn thì tôi sẽ thay đổi câu trả lời được chấp nhận để phản ánh điều đó .
• Tiền thưởng đã được đặt ở mức 200 danh tiếng cho câu trả lời ngắn nhất nhận được vào 23:59:59 (GMT) vào ngày 26/01/2014 Tiền thưởng đã được trao cho Howard cho giải pháp GolfScript có ký tự 268 .

Kiểm tra

Vui lòng cung cấp đầu ra của chương trình cho ba lưới kiểm tra sau với câu trả lời của bạn:

986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378

927354389
194762537
319673942
351982676
567891234
523719844
755128486
268534198
812546671

813654789
738762162
344871987
341989324
567891234
576217856
619623552
194435598
926543271

Tôi đã tạo một chương trình Python nhỏ để tạo các lưới hợp lệ cho mục đích thử nghiệm:

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))

GolfScript, 300 279 268 ký tự

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

Lưu ý rằng mã này cực kỳ chậm (cũng do thao tác khối mã nặng) và có thể chạy vài phút. Mã này rất không phải là golf-ish với rất nhiều biến số và các vòng lặp rõ ràng.

Tôi đã viết một giải pháp phân tích hơn trong ít hơn một giây. Tôi đã phá vỡ hoàn toàn cái đó trong khi chơi golf. Thật không may, tôi đã không thể quay lại hoặc sửa chữa mã trong hai ngày qua. Do đó, tôi đã sản xuất phiên bản thử và kiểm tra này ngắn hơn.

Các câu trả lời cho các câu đố được đưa ra ở trên:

1A2C4D9G9G9G9G1C1C1C1C9F9F9F9F1D1D1D1D2A2A2A2A8H8H8H8H2B2B2B2B2C2C8F8F2D2D2D2D3A3A7I7I3B3B7H7H7G7G7G7G3D3D7F7F6I6I6I6I4A4A4A4A6H6H6H6H6G6G4C4C4C4C6F6F4D4D

1AB39I9I1A1A9I9I1B1B9F9F8I8I8I8I2B2B8H8H8G8G8G8G2D2D2D2D3A3A3A3A7H7H7H7H3C3C3C3C3D3D7F7F6I6I4A4A6I6I4B4B4B4B6G6G4C4C4C4C6F6F6F6F4D4D

1A34D9I9I9I9I1A1A1A1A1B1B1B1B9G9G1C1C1C1C9F9F9F9F1D1D9F9F8I8I2A2A2A2A8H8H8H8H2C2C2C2C8F8F2D2D8F8F7I7I7I7I3A3A3B3B7G7G7G7G3C3C3C3C6I6I6I6I6H6H6H6H4B4B4B4B6G6G6G6G4C4C6G6G6F6F4D4D6F6F

Toán học 582 575 503 464 282

Để chiến đấu với những người chơi golf tôi phải sử dụng pháo hạng nặng!

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

Đầu ra:

g69g69g8g8g7g7gd96d96d8d8d7d7dh6h64a6a46d6d4g4g6b6b7h7h7c7c2a8a27b7bd8db8b7f7fg8g82c2c94a4a3a3aigfdc91

Ở đây PermutationGroup[...]thiết lập các lần lật có thể và GroupElementToWord[...]giải quyết vấn đề (khoảng 0.2giây). Vấn đề chính là rất khó xác định sự tương ứng giữa vị trí của 9lưới ban đầu và lưới cuối cùng. Để chơi golf tôi làm điều đó một cách ngẫu nhiên (phải mất vài giây). Có một số cảnh báo nhưng người ta có thể bỏ qua chúng.

Khác để kiểm tra lưới:

g69g69g8g8g7g7gh89h89h7h7h6h6hf6f6g6g64f4f4h4hg7g73g3g2a8a28d8db8b83d3dg8g82c2c9a3a643a3a2g9f9d9c9ga
h89h89h7h7h6h6h6h6h6f6f6g6g6d6d3a7a37g7g7h7h3c3c2a8a27b7b8d8d2f2f8b8b3f3f2b2ba2a764a8aih9g9c9gb1i

Nó hoàn toàn tái tạo các ví dụ:

1
i
2i

Giải pháp trước đó (464)

không có bất kỳ chức năng tích hợp thông minh nào và với thời gian chạy 4 ms:

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

Tất cả các dòng mới ở đây là không cần thiết.

Đầu ra:

3b9i9i1a1a1a1a9i9i1a1a9h9h1b1b1b1b9h9h9g9g1c1c9g9g9f9f1d1d9f9f8h8h2b2b8f8f8f8f7i7i7h7h3b3b3b3b7h7h3b3b7h7h7g7g3c3c7g7g3c3c7f7f6i6i4a4a6h6h4b4b4b4b6g6g4c4c6g6g4c4c6f6f4d4d4d4d6f6f4d4d6f6f4d4d

Hai lưới thử nghiệm khác:

13ab9i9i1a1a9i9i9h9h1b1b1b1b9h9h9f9f8i8i8i8i8h8h2b2b2b2b8h8h8h8h8g8g8g8g8f8f2d2d2d2d8f8f2d2d7i7i3a3a3a3a7i7i7h7h3b3b7h7h3b3b7g7g3c3c3c3c7g7g3c3c7f7f3d3d3d3d7f7f7f7f6i6i4a4a6i6i6h6h4b4b4b4b6h6h4b4b6g6g4c4c4c4c6f6f4d4d4d4d6f6f4d4d6f6f
2bc9i9i1a1a9i9i9g9g1c1c9g9g1c1c9f9f1d1d1d1d8i8i8i8i8h8h2b2b2b2b8f8f2d2d7i7i7h7h3b3b3b3b7h7h3b3b7g7g3c3c7f7f3d3d3d3d7f7f3d3d6i6i4a4a4a4a6h6h4b4b6g6g6g6g6f6f4d4d

Hình dung:

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]

Chuỗi đầu vào icó thể được tạo ngẫu nhiên bở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 <> ""

Thảo luận ngắn

• Flips chỉ có thể trao đổi các yếu tố này ("bộ tứ"):

  

• Có thể trao đổi các yếu tố này tách biệt với các yếu tố khác chỉ khi lệnh ban đầu và lệnh cuối cùng có cùng chữ ký.

• Flips của bốn yếu tố này tạo thành nhóm 4 độ xen kẽ (= nhóm các phép quay của tứ diện). Mỗi phần tử của nhóm này là một thành phần của 2 phần tử tạo. Vì vậy, nếu chúng ta biết vị trí ban đầu và cuối cùng, chúng ta có thể phân tách phép biến đổi tương ứng dưới dạng kết hợp của một lần lật đơn giản.

Chi tiết

Đối với thể thao, tôi đăng chi tiết trước khi kết thúc tiền thưởng!

M=ToCharacterCode@StringSplit@i-48;

Chuyển đổi chuỗi ithành ma trận M.

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

Chúng tôi sẽ nối thêm ký tự vào S. Bây giờ nó là chuỗi rỗng. H[i,j]sẽ thêm ký tự i( 1,2,3,...,9) và ký tự j( a,b,c,...,itrong cơ sở-36).

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

Tôi chuyển đổi các yếu tố như

để có được ma trận đích ở dạng sau

Sau đó, có hai bước chính trong thuật toán của tôi

1. Tìm các lần lật để có được các chữ ký như trong ma trận đích (ví dụ: chữ ký của {-7,-1,1,7}is 1và chữ ký của {-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}〛;
   

2. Xoay mọi "bộ tứ" để có được thứ tự đúng:

   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}];
   

   Đây là phần không cần thiết nhất của thuật toán. Ví dụ, chuyển đổi 1b1bsẽ chuyển đổi {-7,-1,1,7}thành {-1,1,-7,7}. Việc chuyển đổi 9h9hsẽ chuyển đổi {-7,-1,1,7}thành {-7,7,-1,1}. Vì vậy, chúng tôi có hai bản đồ

   {1,2,3,4} -> {2,3,1,4}
   {1,2,3,4} -> {1,4,2,3}
   

   và chúng tôi muốn chuyển đổi một thứ tự tùy ý {x,y,z,w}sang {1,2,3,4}. Phương pháp đơn giản là (ngoại trừ tìm kiếm ngẫu nhiên)

   repeat   
   {x, y, z, w} -> If[z < 3, {y, z, x, w}, {x, w, y, z}]
   until {1,2,3,4}
   

   Tôi không thể chứng minh, nhưng nó hoạt động!

Bước cuối cùng là

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

Nó thực hiện các cú lật tầm thường của hàng trung tâm và cột trung tâm và trả về kết quả.

J 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 là một động từ lấy một chuỗi lưới ở định dạng đã chỉ định và trả về một chuỗi giải pháp ở định dạng đã chỉ định.

Ví dụ sử dụng:

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

Bây giờ chấp nhận một trong hai loại dòng mới.

Giải pháp cho lưới kiểm tra:

b3a1a11b1bc9c99g9gd9d99f9fb8b8f8f87i7i7h7hc3c3g7g77f7fa6a64b4bh6h6c4c4g6g6d6d6f6f6
cd24a9a91c1c1d1d9f9fa2a2i8i88h8hc2c2g8g82d2d3b3bh7h7d3d37f7fa6a64b4bg6g64d4d6f6f
bc2a9a99i9ic1c1g9g91d1df9f9i8i8b2b2h8h82c2cd8d87i7ib3b3c7c7d3d34a4ai6i6b6b6g6g6d6d6

Tôi khá mới với J; điều này có thể có thể được chơi golf hơn nữa.

Kiểm tra các lưới không hợp lệ / không thể giải quyết phải chịu hình phạt 123 ký tự. Tôi không nghĩ rằng các câu trả lời khác cho đến nay có kiểm tra lỗi như vậy.

Để làm như vậy, thay đổi dòng đầu tiên của dđiều này:

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

và dòng cuối cùng này:

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

Tôi đã chọn trả 0về các lỗi như trả về một chuỗi trống sẽ không thể phân biệt được với việc giải quyết chính xác một lưới được giải quyết đầy đủ. Lưu ý rằng điều này giả định các dòng mới UNIX (một lần nữa).

C # 540 399

Vâng, hy sinh hiệu suất (bây giờ mất đến 30 giây), giới thiệu các biến động, logic thay đổi của giải pháp. Và vâng, bây giờ nó đang mong đợi đầu vào là một chuỗi có ngắt dòng (theo yêu cầu trong quy tắc).

Tất nhiên C # không có các hàm toán học được xác định trước, vì vậy sẽ rất khó để chiến đấu với những kẻ Mathicala. Tuy nhiên, đây là một thách thức lớn, cảm ơn tác giả!

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;

Lưới kiểm tra:

3B9A9A9B9B9C9C9D9D9F9F9G9G9H9H9I9I9B9B9C9C9D9D9F9F9G9G9H9H9C9C9D9D9C9C9D9D8B8B8F8F8H8H8B8B8F8F8B8B8H8H7B7B7C7C7F7F7H7H7I7I7H7H6A6A6B6B6C6C6D6D6F6F6H6H6A6A6B6B6D6D6F6F6D6D6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

13AB9A9A9B9B9F9F9H9H9A9A9B9B9H9H9I9I8B8B8D8D8F8F8G8G8H8H8I8I8B8B8G8G8H8H8I8I8H8H7A7A7B7B7C7C7D7D7F7F7G7G7I7I7A7A7D7D7F7F7I7I7F7F6A6A6B6B6C6C6D6D6F6F6G6G6H6H6I6I6A6A6C6C6F6F6I6I6A6A6A6A5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

2BC9A9A9C9C9D9D9F9F9A9A9D9D9I9I8B8B8D8D8H8H8I8I8B8B8D8D8I8I7B7B7C7C7D7D7F7F7G7G7H7H7I7I7C7C7C7C7G7G6A6A6B6B6D6D6F6F6G6G6I6I6A6A6B6B6D6D6G6G6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

Giải pháp cũ (540)

Hoạt động trong chưa đầy một giây trên bất kỳ đầu vào nào (được thử nghiệm trên hàng ngàn lưới được tạo ngẫu nhiên). Độ dài tối đa của chuỗi đầu ra là 165 (ban đầu, bất kỳ lưới nào được giải quyết không quá 82 lần lật, nhưng trong quá trình chơi golf tôi đã hy sinh điều này).

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;

Trả lời ví dụ 1:

15A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

Trả lời ví dụ 2:

19AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5D
5DE5E55F5F5G5G5H5H5I5I

Trả lời ví dụ 3:

129AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5
D5DE5E55F5F5G5G5H5H5I5I

Đáp án cho bình phương kiểm tra:

346B9A9AH1H1C9C9D9D99F9F9G9GH9H99I9IB8B8F8F87B7B7C7C7F7FH7H77I7I6A6A6B6BC6C66D6DG6G6H6H66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

1346ABA9A9H1H19F9FH9H99I9IH2H28D8D8F8FG8G8I8I8I3I37B7B7C7CF3F37G7GI7I7H4H4D6D66F6F5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

2BCA9A99C9CF1F19F9F9I9IH2H2D8D88H8HI8I87B7BC7C77D7D7F7F7H7H7I7II4I4B6B6D6D6G6G66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I