Ihre Aufgabe ist es, ein Programm zu schreiben, das die optimale Anzahl von Zügen findet, die erforderlich sind, um von der linken unteren Ecke eines Rechtecks ​​zur rechten oberen Ecke direkt gegenüber zu gelangen.

Ihr Programm akzeptiert Eingaben als geordnetes Paar (width, height). Dies sind die Abmessungen des Rechtecks, mit dem Sie arbeiten werden. Ihr Programm erstellt eine ASCII-Grafik der Lösung ( .für leeres Quadrat und #für einen Teil der Lösung Xfür das Startquadrat) und zählt die Anzahl der Züge, die erforderlich sind, um den Endpunkt zu erreichen. Diagonale Bewegungen sind nicht erlaubt. Wenn es mehrere Lösungen gibt, wählen Sie eine aus, die ausgegeben werden soll.

Das kürzeste Programm in Bytes gewinnt.

Beispiel

Eingang: (4, 5)

Ausgabe:

..##
..#.
.##.
.#..
X#..

Zugzahl: 7

05AB1E , 27 24 Bytes

Code:

+Í,¹<'.×'#¶J²<×'X'#¹<×J,

Erläuterung:

+                         # Add the length and the height.
 Í                        # Decrease by two.
  ,                       # Print this value with a newline.
   ¹<'.×                  # Take the first input, decrease by 1 and multiply with ".".
        '#¶               # Push a "#"-character and a newline character.
           J              # Join the string.
            ²<            # Take the second input and decrease by 1.
              ×           # Multiply the joined string with this value.
               'X         # Push the "X"-character.
                 '#¹<×J   # Multiply the "#"-character with (first input - 1).
                       ,  # Pop and print with a newline.

Probieren Sie es online! . Verwendet die CP-1252- Codierung.

Retina , 54 53 Bytes

\d+
$*.
S_`(?<=(.+)¶.*).|\D
T`.`#`.¶|.*$
:m-1=`^#
X
#

Nimmt Eingaben getrennt durch einen Zeilenvorschub auf und gibt das Lösungsraster gefolgt von der Bewegungszahl aus.

Probieren Sie es online!

Erläuterung

\d+
$*.

Wandle beide Ganzzahlen in so viele .s um, dh wandle sie in unäre um.

S_`(?<=(.+)¶.*).|\D

Dadurch wird ein Raster von .s erstellt, indem jedes .in der unären Höhe abgeglichen und die unäre Darstellung der Breite erfasst wird. Das Saktiviert den Split-Modus, der die erfassten Zeichenfolgen zurückgibt, und das |\Dund _zusammen stellen sicher, dass alles andere aus der Zeichenfolge entfernt wird.

T`.`#`.¶|.*$

Dadurch wird das letzte Zeichen jeder Zeile sowie die gesamte letzte Zeile in #s umgewandelt.

:m-1=`^#
X

Dabei werden unzählige Optionen verwendet, um nur die erste #in der letzten Zeile in zu konvertieren X(wir müssen sicherstellen, dass nur die letzte Zeile aufgrund von Eingaben mit der Breite 1 betroffen ist). mAktiviert den Mehrzeilenmodus, der das ^Anpassen des Zeilenanfangs ermöglicht. -1=weist Retina an, die Auswechslung nur beim letzten Spiel durchzuführen. Schließlich :wird der standardmäßige stille Modus ausgeschaltet, sodass das Raster als Zwischenergebnis auf STDOUT gedruckt wird.

#

Schließlich zählen wir einfach die Zahl #in der Zeichenfolge, die der Anzahl der Züge entspricht.

Pyke, 26 Bytes

DtQ+RtF; Q\.*t\#+)\X\#Qt*+

Probieren Sie es hier aus

Oder nicht konkurrierende 34 Bytes, fügen Sie einen Apply-Knoten mit einem Ast hinzu.)

jUa]Dm!X|RZjht]q+".#X"R@)Fs
);jmts

Probieren Sie es hier aus!

Oder 30 Bytes, wenn Leerzeichen als Auffüllung zulässig sind

jUa]Dm!X|RZjht]q+".#X"R@)Pjmts

Pyth, 32 29 24 Bytes

AtMQVH+*\.G\#;+\X*\#G+GH

Probieren Sie es online!

Beispieleingabe:

(4, 5)

Beispielausgabe:

...#
...#
...#
...#
X###
7

Wie es funktioniert:

AtMQVH+*\.G\#;+\X*\#G+GH
                           assign('Q',eval_input())
AtMQ                       assign('[G,H]',Pmap(lambda d:tail(d),Q))
    VH       ;             for N in range(H):
      +*\.G\#                  implicit_print(plus(times(".",G),"#"))
              +\X*\#G      implicit_print(plus("X",times("#",G)))
                     +GH   implicit_print(plus(G,H))

Vorheriger Versuch:

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK

Probieren Sie es online!

Beispieleingabe:

(4, 5)

Beispielausgabe:

...#
...#
...#
...#
X###
7

Wie es funktioniert:

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK
                                 assign('Q',eval_input())        --Q is now an official pair of numbers (4, 5)
JthQ                             assign("J",decrement(first(Q))) --gets the first element, and then take 1 from it, and assign it to J
    K@Q1                         assign("K",lookup(Q,1))         --K is now the second element (count from 0) of the pair.
        +            +\X*\#J     concat(-----------------------------------------------------------,concat("X",times("#",J)))
         *         tK                   repeat(--------------------------------------,decrement(K))
          +       b                            concat(-------------------------,"\n")
           +    \#                                    concat(-------------,"#")
            *\.J                                             repeat(".",J)
                            t+JK decrement(add(J,K)) <--- auto-print

CJam, 35 33 Bytes

q~\(_2$(+p'.*a*'#f+)W%_"X#"era+N*

Nimmt Eingaben in das Formular auf width heightund gibt die Bewegungszahl in der ersten Zeile gefolgt vom Lösungsraster aus.

Teste es hier.

Dies funktioniert auch für die gleiche Byteanzahl:

q~\('.*a*'#f+)W%_"X#"era+N*_'#e=p

Ruby, 48 Bytes

Dies ist eine anonyme Funktion, die gemäß diesem Meta-Post akzeptiert wird, sofern in der Frage nicht "Volles Programm" angegeben ist. Normalerweise wäre ich nicht pedantisch, aber das Problem ist sehr einfach, und ein Programm durchzuführen, würde die Punktzahl um einen erheblichen Prozentsatz erhöhen.

Die Eingabe besteht aus zwei Argumenten. Der Rückgabewert ist ein Array, das die ASCII-Zeichenfolge und die Nummer #im Pfad enthält.

->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

Im Testprogramm

f=->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

puts f[4,5]

Ausgabe

...#
...#
...#
...#
X###
7

Es ist nur eine Folge von h-1 Zeilen mit w-1 Punkten, gefolgt von a #und newline. Ich setze das #am Ende, um ein einzelnes #\nLiteral für beide #und newline zu verwenden (der Code enthält eine tatsächliche newline anstelle einer Escape-Sequenz.) Die letzte Zeile wird dann Xvon w-1 gefolgt #.

Es war kürzer, die Werte von w und h während der ASCII-Kunstgeneration zu dekrementieren, damit die endgültige Berechnung einfach ist w+h.

JavaScript (ES6), 60 Byte

w=>h=>--w+--h+`
${"."[r="repeat"](w)}#`[r](h)+`
X`+"#"[r](w)

Verwendung

f(4)(5)

7
...#
...#
...#
...#
X###

MATL , 28 26 25 Bytes

+qq35IMwX"46 5Lt4$(88HG(c

BEARBEITEN (10. Juni 2016): Der unten stehende Link enthält eine Änderung ( 5Lwird ersetzt durch IL), um sich an Änderungen in der Sprache anzupassen

Probieren Sie es online!

Erläuterung

+       % take two inputs. Add them
qq      % subtract 2
35      % push ASCII for '#'
IMw     % push the two inputs again. Swap them
X"      % 2D char array of '#'  repeated as indicated by inputs
46      % push ASCII for '.'
5Lt4$(  % fill all but last and row columns with that
88HG(   % fill 88 (ASCII for 'X') at linear index given by second input
c       % convert to char

Scala, 118 Bytes

(w:Int,h:Int)=>{print(Array.fill(h-1,w-1)('.')map(new String(_))mkString("","#\n","#\nX"));Seq.fill(w-1)(print("#"))}


(w:Int,h:Int)=>{...}           //define a function with 2 Ints as parameters
print(                        //print ...   
  Array.fill(h-1,w-1)('.')    //an array of arrays with dimensions (h-1,w-1)
                              //and fill it with a dot
  map(new String(_))          //map each inner array of chars to a string
  mkString("","#\n","#\nX")   //create a string from the array, with
                              //an empty string before the array,
                              //"#\n" as a seperator between the elements
                              //and "#\nX" at the end   
);
Seq.fill(w-1)(print("#"))     //w-1 times print "#"

Haskell, 64 Bytes

c!n=c<$[2..n]
w#h=unlines$('.'!w++"#")!h++['X':'#'!w,show$w+h-2]

Anwendungsbeispiel:

*Main> putStr $ 4 # 5
...#
...#
...#
...#
X###
7

Wie es funktioniert:

c!n = c <$ [2..n]                       -- helper function: make (n-1) copies of c

                                        -- main function
                     !h                 -- (h-1) times
       ('.'!w ++ "#")                   --    (w-1) dots and a hash sign
                       ++[      ,     ] -- followed by
                          'X' : '#'!w   --    an 'X' and (w-1) hash signs
                            show$w+h-2  --    and the number of steps
unlines                                 -- join everything with newlines in-between

Java, 137 132 Bytes

w->h->{String s="";int i=0,j;for(;i<h;i++){for(j=1;j<w;j++)s+=".";s+="#\n";}s+="X";for(j=1;j<w;j++)s+=".";s+="\n"+(w+h-2);return s;}

Lua, 81 Bytes

Probieren Sie es online!

Golf gespielt:

w,h=(...)print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))print(w+h-2)

Ungolfed:

w,h=4,5
print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))
print(w+h-2)

Python, 48.

lambda w,h:('.'*(w-1)+'#\n')*(h-1)+'X'+'#'*(w-1)

Um es zu benutzen, füge es f=vor der obigen Zeile hinzu und rufe es so auf:

f(4, 5)

Ergebnis:

...#
...#
...#
...#
X###