C'est essentiellement la même chose que cette question, sauf plus difficile. Vous devez à nouveau écrire un programme qui va du coin inférieur gauche d'un rectangle au coin supérieur droit. Cependant, cette fois, les mouvements diagonaux sont autorisés.

Le programme acceptera une paire commandée (width, height)et les utilisera comme dimensions pour un rectangle. Votre programme créera ensuite un art ASCII de la solution (utilisez. pour un carré vide, #pour une partie de la solution et Xpour le carré de départ) et comptera le nombre de mouvements nécessaires pour atteindre le point final.

Exemple

Contribution: (5, 6)

Production:

....#
....#
...#.
..#..
.#...
X....
Move count: 5

La réponse la plus courte en octets gagne!

MATL , 38 octets

'.#X'!iSPXytf0)Jh1w(tzqDQI1()Gd0<?!]XP

Essayez-le en ligne!

Explication

Soit met nsoit les entrées triées, telles qu'elles msoient supérieures ou égales à n. Le code construit initialement une matrice mx ncomme suit:

• Valeur 2 le long de la diagonale principale et dans la partie inférieure de la dernière colonne. Cela correspond au caractère #. Le nombre de ces entrées moins 1 est le nombre de mouvements.
• Valeur 3 à l'entrée (1,1), correspondant à X.
• Les entrées restantes contiennent 1, correspondant au caractère .

Si nécessaire, la matrice est maintenant transposée pour avoir la forme souhaitée. Notez que la première dimension d'une matrice est sa hauteur et non sa largeur, elle correspond donc à la deuxième entrée.

La matrice est ensuite retournée à l'envers pour Xapparaître en bas de la première colonne, et ses entrées sont utilisées comme indices dans la chaîne '.#X'pour produire le tableau de caractères 2D souhaité.

'.#X'    % push this string
!        % transpose into a column
i        % input array
SP       % sort it in non-increasing order
Xy       % identity matrix with that size: fill diagonal with 1, rest entries are 0
tf0)     % linear index of last 1
Jh       % append 1j (imaginary unit): linear index of lowest part of last column
1w(      % fill those entries with 1
tzq      % duplicate. Number of nonzero entries minus 1: this is the move count
D        % display move count (and remove it from the stack)
Q        % add 1. Matrix now contains values 1 and 2
I1(      % set first entry (in linear order) to value 3
)        % use matrix as index into the initial string. Gives 2D char array
Gd0<     % push input array again. Is it decreasing?
?        % if so
  !      %   transpose char array
]        % end
XP       % flip upside down. Implicitly display

Pyth, 46 45 44 octets

eSKtMQjsM_mm?sJ,kd?q#J.umtWbbNeSKK\#\.\XhQeQ

Essayez-le ici.

Explication:

move-count-printing:

  K     assign K to...
     Q  the input, a 2-length array...
   tM   with each element decremented
eS      take the max and output it (this is the number of moves)


main path-finding logic:

    mm                     hQeQ  map over x-values and y-values...
        J,kd                     assign J to [x,y]
      ?s                         if both x and y are NOT zero (sum is truthy)...
            ?q#J[...]              if [x,y] is present in [...] (see below)...
                     \#            ... put a # at this position in the output
                       \.          ... else, put a . at this position
                         \X      ... else, put the X here (at [0,0])
jsM_                             reverse and output in the proper format


the [...] part in the code above, which finds positions where #s go:

.u      eSKK  cumulative reduce on <number of moves> elements, starting at K,
                which is [max_x, max_y] as assigned at the beginning
  m    N      map over x and y...
   tWbb       decrement, only if the value is > 0

JavaScript (ES6), 132

Modifier 2 octets enregistrés thx @Neil

(w,h)=>[...Array(--h)].map((_,i)=>R(w-i)+'#'+R(i),--w,R=(n,c='.')=>c.repeat(n>w?w:n>0&&n)).join`
`+`
x${R(w-h,'#')+R(h)}
`+(h>w?h:w)

Tester

f=(w,h)=>[...Array(--h)].map((_,i)=>R(w-i)+'#'+R(i),--w,R=(n,c='.')=>c.repeat(n>w?w:n>0&&n)).join`
`+`
x${R(w-h,'#')+R(h)}
`+(h>w?h:w)

function test() {
  var w,h
  [w,h]=I.value.match(/\d+/g)
  O.textContent=f(w,h)
}  

test()

Test <input id=I value="4 5"><button onclick="test()">-></button>
<pre id=O></pre>

Javascript (à l'aide d'une bibliothèque externe) (235 octets)

Bon sang c'était dur! Eh bien ... ma bibliothèque n'était pas vraiment la bonne tâche pour ce haha. Mais j'ai aimé le défi

(x,y)=>{r=x-1;s=y-1;m=Math.max(r,s);n=Math.min(r,s);l=_.RangeDown(s,y).WriteLine(z=>_.Range(0,x).Write("",w=>z==0&&w==0?"X":(z==w||(z==s&&w>=n)||(w==r&&z>=n))?"#":"."));return l+"\r\nMove count: "+(l.length-l.split("#").join("").length)}

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication du code: créer une fonction de 2 variables. Stockez x-1 et y-1 dans des variables. Stockez max et min de ceux-ci dans des variables. Créez une plage de nombres descendant verticalement à partir de (y-1) pour un nombre de y. Pour chaque élément de la plage verticale, écrivez une ligne pour l'élément actuel, en fonction du prédicat complexe. Ce prédicat crée une plage ascendante d'entiers de 0, pour un nombre de x. Pour chaque élément de cette plage, concaténez en 1 chaîne selon un prédicat complexe. Ce prédicat vérifie s'il est en bas à gauche, sinon vérifie s'il est en diagonale, sinon vérifie que nous sommes à la frontière X ou Y. Enfin, tout cela a été stocké dans une variable. Ensuite, pour obtenir le nombre de mouvements, nous comptons simplement les #. Concaténer ensuite cela à la variable stockée et renvoyer le résultat

C'était une bouchée haha. La capture d'écran a le mauvais octet parce que j'ai trouvé un moyen d'économiser 4 octets en publiant ce

EDIT: Je vois que d'autres réponses ne mettent pas "Move count:" dans leur sortie, mais la mienne l'est. Si ce n'est pas une exigence, cela rase un tas d'octets ...

Python 3, 161 156 octets

def f(w,h):
 x=[['.']*w for i in[0]*h];i=0
 while i<w or i<h:x[~min(i,h-1)][min(i,w-1)]=['#','X'][i<1];i+=1
 for i in x:print(''.join(i))
 print(max(w,h)-1)

Une fonction qui prend l'entrée via un argument et imprime l'ascii-art, suivi du nombre de mouvements, dans STDOUT.

Comment ça fonctionne

Le programme crée d'abord une liste de listes, où chaque liste représente une ligne de la grille et chaque élément des listes de composants l'est .. Chaque élément qui devrait être #a la propriété que si la grille de sortie était carrée, les ordonnées représentant son emplacement seraient égales; par conséquent, une boucle sur un indexi et une insertion #à l'emplacement (i, i)donneraient la sortie souhaitée. Cependant, la grille n'est pas toujours carrée, et donc les index sont fixés à la grille en prenant le minimum d'index et de largeur / hauteur (décrémenté en raison de l'indexation zéro) comme requis. Si l'indice est nul, la position actuelle doit être l'entrée en bas à gauche, et doncXest inséré à la place. Ensuite, les éléments de chaque ligne sont concaténés et chaque ligne est imprimée sur STDOUT. Le nombre de mouvements est le maximum de la largeur / hauteur décrémentée; ceci est également imprimé.

Essayez-le sur Ideone