Dies ist im Wesentlichen das Gleiche wie diese Frage, außer schwieriger. Sie müssen wieder ein Programm schreiben, das von der unteren linken Ecke eines Rechtecks ​​in die obere rechte Ecke gelangt. Diesmal sind jedoch diagonale Bewegungen erlaubt.

Das Programm akzeptiert ein geordnetes Paar (width, height)und verwendet diese als Bemaßung für ein Rechteck. Ihr Programm erstellt dann eine ASCII-Grafik der Lösung ( .für ein leeres Quadrat, #für einen Teil der Lösung und Xfür das Startquadrat) und zählt die Anzahl der Züge, die erforderlich sind, um den Endpunkt zu erreichen.

Beispiel

Eingang: (5, 6)

Ausgabe:

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

Kürzeste Antwort in Bytes gewinnt!

MATL , 38 Bytes

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

Probieren Sie es online!

Erläuterung

Sei mund nsei die sortierte Eingabe, so dass mgrößer oder gleich ist n. Der Code erstellt zunächst eine mx- nMatrix wie folgt:

• Wert 2 entlang der Hauptdiagonale und im unteren Teil der letzten Spalte. Das entspricht dem Charakter #. Die Anzahl dieser Einträge minus 1 ist die Anzahl der Züge.
• Wert 3 bei Eintrag (1,1), entsprechend dem X.
• Die restlichen Einträge enthalten 1, entsprechend dem Zeichen .

Bei Bedarf wird die Matrix nun so transponiert, dass sie die gewünschte Form hat. Beachten Sie, dass die erste Dimension einer Matrix die Höhe und nicht die Breite ist, sodass sie der zweiten Eingabe entspricht.

Die Matrix wird dann umgedreht, sodass sie Xam unteren Rand der ersten Spalte angezeigt wird, und ihre Einträge werden als Indizes in die Zeichenfolge verwendet '.#X', um das gewünschte 2D-Zeichenarray zu erstellen.

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

Probieren Sie es hier aus.

Erläuterung:

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

Bearbeite 2 Bytes, die dank @Neil gespeichert wurden

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

Prüfung

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 (mit externer Bibliothek) (235 Bytes)

Meine Güte, das war schwer! Nun ... meine Bibliothek war nicht wirklich die richtige Aufgabe für dieses Haha. Aber ich mochte die Herausforderung

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

Codeerklärung: Funktion aus 2 Variablen erstellen. Speichern Sie x-1 und y-1 in Variablen. Speichere max und min davon in Variablen. Erstellen Sie einen vertikal absteigenden Zahlenbereich von (y-1) für eine Anzahl von y. Schreiben Sie für jedes Element im vertikalen Bereich eine Linie für das aktuelle Element entsprechend dem komplexen Prädikat. Dieses Prädikat erstellt einen aufsteigenden Bereich von ganzen Zahlen von 0 für eine Anzahl von x. Verketten Sie für jedes Element in diesem Bereich eine Zeichenfolge gemäß einem komplexen Prädikat. Dieses Prädikat prüft, ob links unten, sonst, ob diagonal, sonst, ob wir am X- oder Y-Rand sind. Schließlich wurde alles in einer Variablen gespeichert. Um die Anzahl der Züge zu ermitteln, zählen wir im Grunde genommen nur die # -Zahlen. Verknüpfen Sie das dann mit der gespeicherten Variablen und geben Sie das Ergebnis zurück

Das war ein Schluck haha. Der Screenshot hat den falschen Bytecount, weil ich beim Posten einen Weg gefunden habe, 4 Bytes zu sparen

BEARBEITEN: Ich sehe, dass andere Antworten nicht "Move count:" in ihre Ausgabe einfügen, aber meine ist. Wenn das keine Voraussetzung ist, werden ein paar Bytes gespart ...

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)

Eine Funktion, die Eingaben über Argumente entgegennimmt und die ASCII-Grafik, gefolgt von der Anzahl der Verschiebungen, an STDOUT ausgibt.

Wie es funktioniert

Das Programm erstellt zunächst eine Liste von Listen, wobei jede Liste eine Zeile des Rasters darstellt und jedes Element der Komponentenlisten ist .. Jedes Element, das sein sollte, #hat die Eigenschaft, dass die Ordinaten, die seine Position darstellen, gleich wären, wenn das Ausgaberaster quadratisch wäre. daher würde ein Durchlaufen eines Indexes iund Einfügen #an einer Stelle (i, i)die gewünschte Ausgabe ergeben. Das Raster ist jedoch nicht immer quadratisch, und daher werden die Indizes an das Raster geklemmt, indem das Minimum von Index und Breite / Höhe (verringert aufgrund der Null-Indexierung) nach Bedarf verwendet wird. Wenn der Index Null ist, muss die aktuelle Position der Eintrag links unten seinXwird stattdessen eingefügt. Als nächstes werden die Elemente in jeder Zeile verkettet und jede Zeile wird auf STDOUT gedruckt. Die Anzahl der Züge ist das Maximum der um eins verminderten Breite / Höhe. Dies wird auch gedruckt.

Probieren Sie es auf Ideone