Un tableau bidimensionnel de taille n × n est rempli de n * n nombres, à partir du nombre 1. Ces nombres doivent être triés par ligne dans l'ordre croissant; le premier numéro d'une ligne doit être supérieur au dernier numéro de la ligne précédente (le plus petit nombre de tous (1) sera en [0,0]). Ceci est similaire au puzzle 15 .

Il s'agit, par exemple, d'un tableau trié de taille n = 3 .

1 2 3
4 5 6
7 8 9

Contribution

L'entrée est un tableau brouillé. Il peut être de n'importe quelle taille jusqu'à n = 10. Exemple pour n = 3:

4 2 3
1 8 5
7 9 6

Production

Générez une liste des swaps nécessaires pour trier le tableau. Un échange est défini comme suit: Deux numéros adjacents échangent des positions, horizontalement ou verticalement; l'échange en diagonale n'est pas autorisé.

Exemple de sortie pour l'exemple ci-dessus:

• Échange 4 et 1
• Échange 8 et 5
• Échange 8 et 6
• Échanger 9 et 8

Moins il faut de swaps, mieux c'est. Le temps de calcul doit être réalisable.

Voici un autre exemple d'entrée, avec n = 10:

41 88 35 34 76 44 66 36 58 28
6 71 24 89 1 49 9 14 74 2
80 31 95 62 81 63 5 40 29 39
17 86 47 59 67 18 42 61 53 100
73 30 43 12 99 51 54 68 98 85
13 46 57 96 70 20 82 97 22 8
10 69 50 65 83 32 93 45 78 92
56 16 27 55 84 15 38 19 75 72
33 11 94 48 4 79 87 90 25 37
77 26 3 52 60 64 91 21 23 7

Si je ne me trompe pas, cela nécessiterait environ 1000 à 2000 swaps.

Mathematica, non golfé

towards[a_,b_]:={a,a+If[#==0,{0,Sign@Last[b-a]},{#,0}]&@Sign@First[b-a]};
f[m_]:=Block[{m2=Map[QuotientRemainder[#-1,10]+1&,m,{2}]},
  Rule@@@Apply[10(#1-1)+#2&,#,{2}]&@
    Reap[Table[
      m2=NestWhile[
        Function[{x},x/.(Sow[#];Thread[#->Reverse@#])&[x[[##]]&@@@towards[First@Position[x,i,{2}],i]]]
        ,m2,#~Extract~i!=i&];
      ,{i,Reverse/@Tuples[Range[10],2]}];][[2,1]]]

Explication :

L'algorithme est similaire au "tri à bulles". Ces 100 numéros sont mis dans l'ordre correct un par un 1, 11, 21, ..., 91; 2, ..., 92; ...; 10, ..., 100,. Ils sont d'abord déplacés vers le haut / bas vers les lignes appropriées, puis vers la gauche vers les colonnes appropriées.

La fonction towardsdonne les deux positions pour permuter. Par exemple, si {5,2}se déplace vers {1,1}, towards[{5,2},{1,1}]donne {{5,2},{5,1}}(déplacer vers le haut); et towards[{5,1},{1,1}]donne {{5,1},{4,1}}(bouge à gauche).

Résultats :

Pour le scénario de test, le nombre total de swaps est de 558. Les premiers swaps sont,

{1->76,1->34,1->35,1->88,1->41,11->16,11->69,11->46, ...

Pour une configuration aléatoire, le nombre total de swaps est de 558,5 ± 28,3 (1σ).