Questo è essenzialmente la stessa cosa di questa questione, a meno difficile. Devi ancora scrivere un programma che va dall'angolo inferiore sinistro di un rettangolo all'angolo superiore destro. Tuttavia, questa volta diagonale mosse sono ammessi.

Il programma accetterà una coppia ordinata (width, height)e le utilizzerà come dimensioni per un rettangolo. Il programma creerà quindi un'arte ASCII della soluzione (utilizzare .per un quadrato vuoto, #per parte della soluzione e Xper il quadrato iniziale) e conteggerà il numero di mosse necessarie per raggiungere l'endpoint.

Esempio

Ingresso: (5, 6)

Produzione:

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

risposta più breve in byte vince!

MATL , 38 byte

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

Provalo online!

Spiegazione

Consenti med nessere gli input ordinati, in modo che msia maggiore o uguale a n. Il codice inizialmente crea una matrice mx ncome segue:

• Valore 2 lungo la diagonale principale e nella parte inferiore dell'ultima colonna. Ciò corrisponde a carattere #. Il numero di queste voci meno 1 è il conteggio delle mosse.
• Valore 3 all'ingresso (1,1), corrispondente al valore X.
• Le voci rimanenti contengono 1, corrispondente al carattere .

Se necessario, la matrice viene ora trasposta in modo che abbia la forma desiderata. Nota che la prima dimensione di una matrice è la sua altezza, non la larghezza, quindi corrisponde al secondo input.

La matrice viene quindi capovolta in modo da Xapparire nella parte inferiore della prima colonna e le sue voci vengono utilizzate come indici nella stringa '.#X'per produrre l'array di caratteri 2D desiderato.

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

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

Provalo qui.

Spiegazione:

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

Modifica 2 byte salvati grazie 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)

Test

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 (utilizzando una libreria esterna) (235 byte)

Accidenti, è stato difficile! Beh ... la mia biblioteca non era davvero il compito giusto per questo haha. Ma mi è piaciuta la sfida

(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 alla lib: https://github.com/mvegh1/Enumerable

Spiegazione del codice: creare una funzione di 2 variabili. Conservare x-1 e y-1 in variabili. Memorizza il massimo e il minimo di quelli in variabili. Crea un intervallo di numeri decrescente verticalmente da (y-1) per un conteggio di y. Per ciascun elemento nell'intervallo verticale, scrivere una riga per l'elemento corrente, in base al predicato complesso. Tale predicato crea un intervallo crescente di numeri interi da 0, per un conteggio di x. Per ogni elemento in quell'intervallo, concatenare in 1 stringa in base a un predicato complesso. Quel predicato controlla se in basso a sinistra, altrimenti controlla se in diagonale, altrimenti controlla che siamo sul bordo X o Y. Alla fine, tutto ciò è stato archiviato in una variabile. Quindi per ottenere il conteggio delle mosse, in pratica contiamo solo i #. Quindi concatenarlo nella variabile memorizzata e restituire il risultato

Quello è stato un boccone ahah. Lo screenshot ha un byte errato perché ho trovato un modo per salvare 4 byte durante la pubblicazione

EDIT: vedo che altre risposte non stanno inserendo "Move count:" nel loro output, ma il mio lo è. Se questo non è un requisito, ciò rade un mucchio di byte ...

Python 3, 161 156 byte

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 funzione che accetta input tramite argomento e stampa la ASCII-art, seguita dal conteggio delle mosse, su STDOUT.

Come funziona

Il programma crea innanzitutto un elenco di elenchi, in cui ciascun elenco rappresenta una riga della griglia e ogni elemento degli elenchi dei componenti è .. Ogni elemento che dovrebbe avere #ha la proprietà che se la griglia di output fosse quadrata, le ordinate che rappresentano la sua posizione sarebbero uguali; quindi, il ciclo su un certo indice ie l'inserimento #nella posizione (i, i)darebbe l'output desiderato. Tuttavia, la griglia non è sempre quadrata, e quindi gli indici vengono bloccati sulla griglia prendendo il minimo dell'indice e larghezza / altezza (decrementato a causa dell'indicizzazione zero) come richiesto. Se l'indice è zero, la posizione corrente deve essere la voce in basso a sinistra, e quindiXviene invece inserito. Successivamente, gli elementi in ciascuna riga vengono concatenati e ogni riga viene stampata su STDOUT. Il numero di mosse è il massimo della larghezza / altezza decrementata; anche questo è stampato.

Provalo su Ideone