É essencialmente a mesma coisa que esta pergunta, exceto mais difícil. Você deve escrever novamente um programa que vai do canto inferior esquerdo de um retângulo ao canto superior direito. No entanto, desta vez movimentos diagonais são permitidos.

O programa aceitará um par ordenado (width, height)e os usará como as dimensões de um retângulo. Seu programa criará uma arte ASCII da solução (use .para um quadrado vazio, #para parte da solução e Xpara iniciar o quadrado) e conte o número de movimentos necessários para alcançar o ponto final.

Exemplo

Entrada: (5, 6)

Resultado:

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

Menor resposta em bytes ganha!

MATL , 38 bytes

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

Experimente online!

Explicação

Seja me nsejam as entradas classificadas, de modo que msejam maiores ou iguais a n. O código inicialmente cria uma matriz mx da nseguinte maneira:

• Valor 2 ao longo da diagonal principal e na parte inferior da última coluna. Isso corresponde ao caractere #. O número dessas entradas menos 1 é a contagem de movimentos.
• Valor 3 na entrada (1,1), correspondente a X.
• As entradas restantes contêm 1, correspondente ao caractere .

Se necessário, a matriz agora é transposta para que ela tenha a forma desejada. Observe que a primeira dimensão de uma matriz é sua altura, não largura, portanto corresponde à segunda entrada.

A matriz é então virada de cabeça para baixo, para que Xapareça na parte inferior da primeira coluna, e suas entradas são usadas como índices na string '.#X'para produzir a matriz de caracteres 2D desejada.

'.#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

Pitão, 46 45 44 bytes

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

Experimente aqui.

Explicação:

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

Editar 2 bytes salvos 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)

Teste

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 (usando biblioteca externa) (235 bytes)

Caramba, isso foi difícil! Bem ... minha biblioteca não era realmente a tarefa certa para esse haha. Mas gostei do desafio

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

Link para lib: https://github.com/mvegh1/Enumerable

Explicação do código: Crie uma função de 2 variáveis. Armazene x-1 e y-1 em variáveis. Armazene max e min em variáveis. Crie um intervalo vertical decrescente de números de (y-1) para uma contagem de y. Para cada elemento na faixa vertical, escreva uma linha para o elemento atual, de acordo com o predicado complexo. Esse predicado cria um intervalo crescente de números inteiros a partir de 0, para uma contagem de x. Para cada elemento nesse intervalo, concatene em 1 sequência de acordo com um predicado complexo. Esse predicado verifica se na parte inferior esquerda, caso contrário, na diagonal; caso contrário, verifica se estamos na borda X ou Y. Finalmente, tudo isso foi armazenado em uma variável. Então, para obter a contagem de movimentos, basicamente contamos os números. Em seguida, concatene-o para a variável armazenada e retorne o resultado

Isso foi um bocado haha. A captura de tela tem o número de bytes errado porque eu encontrei uma maneira de salvar 4 bytes ao postar isso

EDIT: Vejo que outras respostas não estão colocando "Move count:" em sua saída, mas a minha é. Se isso não é um requisito, isso raspa vários bytes ...

Python 3, 161 156 bytes

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)

Uma função que recebe a entrada por meio de argumento e imprime a arte ASCII, seguida pela contagem de movimentação, em STDOUT.

Como funciona

O programa primeiro cria uma lista de listas, onde cada lista representa uma linha da grade e cada elemento das listas de componentes .. Cada elemento que deveria ser #possui a propriedade de que, se a grade de saída fosse quadrada, as ordenadas que representam sua localização seriam iguais; portanto, fazer um loop sobre algum índice ie inserir #no local (i, i)daria a saída desejada. No entanto, a grade nem sempre é quadrada e, portanto, os índices são fixados na grade, assumindo o mínimo do índice e a largura / altura (decrescentes devido à indexação zero) conforme necessário. Se o índice for zero, a posição atual deve ser a entrada inferior esquerda e, portanto,Xé inserido. Em seguida, os elementos em cada linha são concatenados e cada linha é impressa em STDOUT. O número de movimentos é o máximo da largura / altura diminuída; isso também é impresso.

Experimente no Ideone