Esto es esencialmente lo mismo que esta pregunta, excepto que es más difícil. De nuevo, debe escribir un programa que vaya desde la esquina inferior izquierda de un rectángulo hasta la esquina superior derecha. Sin embargo, esta vez se permiten movimientos diagonales.

El programa aceptará un par ordenado (width, height)y los usará como las dimensiones de un rectángulo. Luego, su programa creará un arte ASCII de la solución (se usa .para un cuadrado vacío, #para parte de la solución y Xpara el cuadrado inicial) y contará el número de movimientos necesarios para llegar al punto final.

Ejemplo

Entrada: (5, 6)

Salida:

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

¡La respuesta más corta en bytes gana!

MATL , 38 bytes

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

Pruébalo en línea!

Explicación

Dejar my nser las entradas ordenadas, de modo que msea ​​mayor o igual que n. El código inicialmente construye una matriz mx de nla siguiente manera:

• Valor 2 a lo largo de la diagonal principal y en la parte inferior de la última columna. Esto corresponde al personaje #. El número de estas entradas menos 1 es el recuento de movimientos.
• Valor 3 en la entrada (1,1), correspondiente a X.
• Las entradas restantes contienen 1, correspondiente al carácter .

Si es necesario, la matriz ahora se transpone para que tenga la forma deseada. Tenga en cuenta que la primera dimensión de una matriz es su altura, no su ancho, por lo que corresponde a la segunda entrada.

La matriz se voltea para que Xaparezca en la parte inferior de la primera columna, y sus entradas se utilizan como índices en la cadena '.#X'para producir la matriz de caracteres 2D deseada.

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

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

Pruébalo aquí

Explicación:

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 guardados gracias a @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)

Prueba

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

Por Dios, esto fue difícil! Bueno ... mi biblioteca no era realmente la tarea correcta para esto jaja. Pero me gusto el reto

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

Enlace a lib: https://github.com/mvegh1/Enumerable

Explicación del código: Crear función de 2 variables. Almacene x-1 e y-1 en variables. Almacene max y min de esos en variables. Cree un rango de números verticalmente descendente desde (y-1) para un recuento de y. Para cada elemento en el rango vertical, escriba una línea para el elemento actual, de acuerdo con el predicado complejo. Ese predicado crea un rango ascendente de enteros desde 0, para un recuento de x. Para cada elemento en ese rango, concatene en 1 cadena de acuerdo con un predicado complejo. Ese predicado verifica si está en la parte inferior izquierda, de lo contrario verifica si está en diagonal, de lo contrario verifica que estamos en el borde X o Y. Finalmente, todo eso se almacenó en una variable. Luego, para obtener el recuento de movimientos, básicamente solo contamos los números. Luego concatene eso con la variable almacenada y devuelva el resultado

Eso fue un bocado jaja. La captura de pantalla tiene un bytecount incorrecto porque encontré una manera de guardar 4 bytes mientras publicaba esto

EDITAR: veo que otras respuestas no están poniendo "Move count:" en su salida, pero la mía sí. Si eso no es un requisito, eso reduce un montón de bytes ...

Python 3, 161156 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)

Una función que toma datos a través de argumentos e imprime el arte ascii, seguido del recuento de movimientos, en STDOUT.

Cómo funciona

El programa primero crea una lista de listas, donde cada lista representa una fila de la cuadrícula y cada elemento de las listas de componentes lo es .. Cada elemento que debería ser #tiene la propiedad de que si la cuadrícula de salida fuera cuadrada, las ordenadas que representan su ubicación serían iguales; por lo tanto, hacer un bucle sobre algún índice ie insertarlo #en la ubicación (i, i)daría el resultado deseado. Sin embargo, la cuadrícula no siempre es cuadrada y, por lo tanto, los índices se sujetan a la cuadrícula tomando el mínimo del índice y el ancho / alto (disminuido debido a la indexación cero) según sea necesario. Si el índice es cero, la posición actual debe ser la entrada inferior izquierda y, por lo tanto,Xse inserta en su lugar. A continuación, los elementos en cada línea se concatenan y cada línea se imprime en STDOUT. El número de movimientos es el máximo del ancho / alto decrementado; Esto también está impreso.

Pruébalo en Ideone