Créez un programme ou une fonction pour supprimer un carré de chiffres en inversant (en inversant le point central) uniquement les lignes et les colonnes.

Contribution

L'entrée sera une grille de chiffres 9x9 sous la forme d'une chaîne de 9 lignes comme celle-ci:

986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378

Ce format d’entrée n’est pas négociable. Toute solution "créative" avec le format d’entrée sera considérée comme non valide.

Sortie

La sortie doit être une liste de mouvements d'inversion qui, lorsqu'ils sont appliqués à l'entrée dans l'ordre donné, doivent recréer la grille cible.

Un exemple de sortie (pas une solution à l'exemple d'entrée précédent):

28IF5D3EAB9G3

Ce format de sortie est également non négociable. Il ne doit y avoir aucune nouvelle ligne ni espace dans la sortie, seuls les caractères 1- 9et A- I(les minuscules sont acceptables à la place des majuscules si vous préférez).

La grille cible (l'état que vous devez recréer) est la suivante:

123456789
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

Les chiffres 1- 9doivent être utilisés comme instructions pour retourner les lignes, et les lettres A- Idoivent être utilisés pour les colonnes. Ceci est montré ci-dessous avec la grille dans son état restauré.

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

Donc, un 8moyen retourne la deuxième ligne à partir du bas et un Fmoyen retourne la sixième colonne.

Si aucune solution n'est possible, le programme doit se terminer sans rien afficher.

Exemples

Contribution:

987654321
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

Sortie:

1

Dans ce cas, seule la rangée supérieure doit basculer pour revenir à l'état d'objectif.

Contribution:

123456788
234567897
345678916
456789125
567891234
678912343
789123452
891234561
912345679

Sortie:

I

Dans ce cas, seule la dernière colonne (colonne I) doit être retournée pour recréer l'état de l'objectif.

Contribution:

123456788
798765432
345678916
456789125
567891234
678912343
789123452
891234561
912345679

Sortie:

2I

Dans ce cas, nous devons retourner une ligne 2puis une colonne Ipour revenir à l'état d'objectif.

Remarques:

• Veuillez inclure un exemple d'utilisation dans votre réponse.
• La sortie donnée ne doit pas nécessairement être la séquence la plus courte qui retournera l'état de l'objectif - toute séquence renvoyant l'état de l'objectif fera l'affaire aussi longtemps que cela fonctionnera (c'est-à-dire tant que je pourrai le tester)
• Je vais essayer de tester chaque réponse et de lever le vote vers tous ceux qui travaillent et qui ont manifestement tenté de jouer au golf.
• Il s'agit d'un concours ouvert - j'accepterai la réponse la plus courte la semaine prochaine, mais si une nouvelle réponse valide est fournie, elle est plus courte à l'avenir, je modifierai la réponse acceptée en conséquence .
• La prime a été fixée à 200 points de réputation pour la réponse la plus courte reçue le 26/01/2014 à 23:59:59 (GMT). La prime a été attribuée à Howard pour sa solution GolfScript à 268 caractères .

Essai

Veuillez fournir la réponse de votre programme pour les trois grilles de test suivantes:

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

J'ai créé un petit programme Python pour générer des grilles valides à des fins de test:

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 caractères

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

Notez que ce code est extrêmement lent (également en raison d'une manipulation lourde de bloc de code) et peut s'exécuter pendant plusieurs minutes. Le code est très peu-golfscript-ish avec beaucoup de variables et de boucles explicites.

J'avais écrit une solution plus analytique qui durait moins d'une seconde. Je l'ai complètement cassé en jouant au golf. Malheureusement, je n'ai pas pu revenir en arrière ou réparer le code au cours des deux derniers jours. Par conséquent, j’ai produit cette version d’essai et de vérification qui est de toute façon plus courte.

Les réponses aux énigmes données ci-dessus:

1A2C4D9G9G9G9G1C1C1C1C9F9F9F9F1D1D1D1D2A2A2A2A8H8H8H8H2B2B2B2B2C2C8F8F2D2D2D2D3A3A7I7I3B3B7H7H7G7G7G7G3D3D7F7F6I6I6I6I4A4A4A4A6H6H6H6H6G6G4C4C4C4C6F6F4D4D

1AB39I9I1A1A9I9I1B1B9F9F8I8I8I8I2B2B8H8H8G8G8G8G2D2D2D2D3A3A3A3A7H7H7H7H3C3C3C3C3D3D7F7F6I6I4A4A6I6I4B4B4B4B6G6G4C4C4C4C6F6F6F6F4D4D

1A34D9I9I9I9I1A1A1A1A1B1B1B1B9G9G1C1C1C1C9F9F9F9F1D1D9F9F8I8I2A2A2A2A8H8H8H8H2C2C2C2C8F8F2D2D8F8F7I7I7I7I3A3A3B3B7G7G7G7G3C3C3C3C6I6I6I6I6H6H6H6H4B4B4B4B6G6G6G6G4C4C6G6G6F6F4D4D6F6F

Mathematica 582 575 503 464 282

Pour me battre avec les golfeurs, je dois utiliser de l'artillerie lourde!

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

Sortie:

g69g69g8g8g7g7gd96d96d8d8d7d7dh6h64a6a46d6d4g4g6b6b7h7h7c7c2a8a27b7bd8db8b7f7fg8g82c2c94a4a3a3aigfdc91

Ici, PermutationGroup[...]met en place des retournements possibles et GroupElementToWord[...]résout le problème (environ 0.2seconde). Le problème principal est qu’il est difficile d’identifier la correspondance entre la position de 9dans la grille initiale et la grille finale. Pour le golf, je le fais au hasard (cela prend plusieurs secondes). Il y a des avertissements mais on peut les ignorer.

Autre pour tester les grilles:

g69g69g8g8g7g7gh89h89h7h7h6h6hf6f6g6g64f4f4h4hg7g73g3g2a8a28d8db8b83d3dg8g82c2c9a3a643a3a2g9f9d9c9ga
h89h89h7h7h6h6h6h6h6f6f6g6g6d6d3a7a37g7g7h7h3c3c2a8a27b7b8d8d2f2f8b8b3f3f2b2ba2a764a8aih9g9c9gb1i

Il reproduit complètement les exemples:

1
i
2i

Solution précédente (464)

sans fonctions intégrées intelligentes et avec un temps d'exécution de 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

Toutes les nouvelles lignes ici ne sont pas nécessaires.

Sortie:

3b9i9i1a1a1a1a9i9i1a1a9h9h1b1b1b1b9h9h9g9g1c1c9g9g9f9f1d1d9f9f8h8h2b2b8f8f8f8f7i7i7h7h3b3b3b3b7h7h3b3b7h7h7g7g3c3c7g7g3c3c7f7f6i6i4a4a6h6h4b4b4b4b6g6g4c4c6g6g4c4c6f6f4d4d4d4d6f6f4d4d6f6f4d4d

Deux autres grilles de test:

13ab9i9i1a1a9i9i9h9h1b1b1b1b9h9h9f9f8i8i8i8i8h8h2b2b2b2b8h8h8h8h8g8g8g8g8f8f2d2d2d2d8f8f2d2d7i7i3a3a3a3a7i7i7h7h3b3b7h7h3b3b7g7g3c3c3c3c7g7g3c3c7f7f3d3d3d3d7f7f7f7f6i6i4a4a6i6i6h6h4b4b4b4b6h6h4b4b6g6g4c4c4c4c6f6f4d4d4d4d6f6f4d4d6f6f
2bc9i9i1a1a9i9i9g9g1c1c9g9g1c1c9f9f1d1d1d1d8i8i8i8i8h8h2b2b2b2b8f8f2d2d7i7i7h7h3b3b3b3b7h7h3b3b7g7g3c3c7f7f3d3d3d3d7f7f3d3d6i6i4a4a4a4a6h6h4b4b6g6g6g6g6f6f4d4d

Visualisation:

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]

La chaîne de saisie ipeut être générée aléatoirement par

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

Brève discussion

• Les flips peuvent uniquement interchanger ces éléments ("quadruple"):

  

• Il est possible d'échanger ces éléments séparément des autres éléments uniquement si l'ordre initial et l'ordre final ont la même signature.

• Des flips de ces quatre éléments forment le groupe alternant du degré 4 (= groupe de rotations du tétraèdre). Chaque élément de ce groupe est une composition de 2 éléments générateurs. Donc, si nous connaissons la position initiale et finale, nous pouvons décomposer la transformation correspondante en combinant de simples retournements.

Détails

Pour l'esprit sportif, j'affiche les détails avant la fin de la prime!

M=ToCharacterCode@StringSplit@i-48;

Convertissez la chaîne ien matrice M.

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

Nous allons ajouter des caractères à S. Maintenant c'est la chaîne vide. H[i,j]ajoutera le caractère i( 1,2,3,...,9) et le caractère j( a,b,c,...,ien base 36).

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

Je convertis des éléments en tant que

pour obtenir la matrice cible sous la forme suivante

Ensuite, il y a deux étapes principales dans mon algorithme

1. Trouvez des flips pour obtenir les signatures comme dans la matrice cible (par exemple, la signature de {-7,-1,1,7}is 1et la signature de {-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. Faites pivoter chaque "quadruple" pour obtenir le bon ordre:

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

   C'est la partie la plus non triviale de l'algorithme. Par exemple, la transformation 1b1bsera convertie {-7,-1,1,7}en {-1,1,-7,7}. La transformation 9h9hsera convertie {-7,-1,1,7}en {-7,7,-1,1}. Donc nous avons deux cartes

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

   et nous voulons convertir un ordre arbitraire {x,y,z,w}en {1,2,3,4}. La méthode simple est (sauf une recherche aléatoire)

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

   Je ne peux pas le prouver, mais ça marche!

La dernière étape est

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

Il effectue des retournements triviaux de la ligne centrale et de la colonne centrale et renvoie le résultat.

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 est un verbe qui prend une chaîne de grille au format spécifié et renvoie une chaîne de solution au format spécifié.

Exemple d'utilisation:

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

Accepte maintenant l'un ou l'autre type de nouvelle ligne.

Solutions aux grilles de test:

b3a1a11b1bc9c99g9gd9d99f9fb8b8f8f87i7i7h7hc3c3g7g77f7fa6a64b4bh6h6c4c4g6g6d6d6f6f6
cd24a9a91c1c1d1d9f9fa2a2i8i88h8hc2c2g8g82d2d3b3bh7h7d3d37f7fa6a64b4bg6g64d4d6f6f
bc2a9a99i9ic1c1g9g91d1df9f9i8i8b2b2h8h82c2cd8d87i7ib3b3c7c7d3d34a4ai6i6b6b6g6g6d6d6

Je suis assez nouveau pour J; cela pourrait probablement être joué au golf encore plus loin.

La vérification des grilles invalides / insolubles entraîne une pénalité de 123 caractères. Je ne pense pas que les autres réponses à ce jour comportent une telle vérification d'erreur.

Pour ce faire, changez la première ligne den ceci:

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

et la dernière ligne à ceci:

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

J'ai choisi de revenir 0sur des erreurs telles que renvoyer une chaîne vide serait impossible à distinguer de la résolution correcte d'une grille entièrement résolue. Notez que cela suppose (encore une fois) les retours à la ligne UNIX.

C # 540 399

Eh bien, performance sacrifiée (cela prend maintenant jusqu’à 30 secondes), introduction de variables dynamiques, modification légèrement de la logique de la solution. Et oui, il attend maintenant une entrée sous la forme d'une chaîne avec des sauts de ligne (comme requis dans les règles).

Bien sûr, C # n’a pas de fonctions mathématiques prédéfinies, il serait donc difficile de se battre avec des gars de Mathematica. Néanmoins, c'était un grand défi, merci à l'auteur!

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;

Grilles de test:

3B9A9A9B9B9C9C9D9D9F9F9G9G9H9H9I9I9B9B9C9C9D9D9F9F9G9G9H9H9C9C9D9D9C9C9D9D8B8B8F8F8H8H8B8B8F8F8B8B8H8H7B7B7C7C7F7F7H7H7I7I7H7H6A6A6B6B6C6C6D6D6F6F6H6H6A6A6B6B6D6D6F6F6D6D6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

13AB9A9A9B9B9F9F9H9H9A9A9B9B9H9H9I9I8B8B8D8D8F8F8G8G8H8H8I8I8B8B8G8G8H8H8I8I8H8H7A7A7B7B7C7C7D7D7F7F7G7G7I7I7A7A7D7D7F7F7I7I7F7F6A6A6B6B6C6C6D6D6F6F6G6G6H6H6I6I6A6A6C6C6F6F6I6I6A6A6A6A5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

2BC9A9A9C9C9D9D9F9F9A9A9D9D9I9I8B8B8D8D8H8H8I8I8B8B8D8D8I8I7B7B7C7C7D7D7F7F7G7G7H7H7I7I7C7C7C7C7G7G6A6A6B6B6D6D6F6F6G6G6I6I6A6A6B6B6D6D6G6G6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

Ancienne Solution (540)

Fonctionne en moins d’une seconde sur n’importe quelle entrée (testé sur des milliers de grilles générées aléatoirement). La longueur maximale de la chaîne de sortie est de 165 (au départ, toute grille était résolue en moins de 82 retournements, mais au cours du golf, je l'avais sacrifié).

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;

Réponse par exemple 1:

15A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

Réponse par exemple 2:

19AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5D
5DE5E55F5F5G5G5H5H5I5I

Réponse par exemple 3:

129AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5
D5DE5E55F5F5G5G5H5H5I5I

Réponses pour les carrés d'essai:

346B9A9AH1H1C9C9D9D99F9F9G9GH9H99I9IB8B8F8F87B7B7C7C7F7FH7H77I7I6A6A6B6BC6C66D6DG6G6H6H66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

1346ABA9A9H1H19F9FH9H99I9IH2H28D8D8F8FG8G8I8I8I3I37B7B7C7CF3F37G7GI7I7H4H4D6D66F6F5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

2BCA9A99C9CF1F19F9F9I9IH2H2D8D88H8HI8I87B7BC7C77D7D7F7F7H7H7I7II4I4B6B6D6D6G6G66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I