Su trabajo es escribir un programa que encuentre el número óptimo de movimientos necesarios para llegar desde la esquina inferior izquierda de un rectángulo a la esquina superior derecha directamente opuesta.

Su programa aceptará entradas como un par ordenado (width, height). Estas serán las dimensiones del rectángulo con el que trabajará. Su programa creará un arte ASCII de la solución (use .para el cuadrado vacío y #para parte de la solución, Xpara el cuadrado inicial) y contará el número de movimientos que se necesitan para llegar al punto final. Los movimientos diagonales no están permitidos. Si hay varias soluciones, elija una para generar.

El programa más corto en bytes gana.

Ejemplo

Entrada: (4, 5)

Salida:

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

Recuento de movimientos: 7

05AB1E , 27 24 bytes

Código:

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

Explicación:

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

Pruébalo en línea! . Utiliza la codificación CP-1252 .

Retina , 54 53 bytes

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

Toma la entrada separada por un salto de línea y genera la cuadrícula de la solución seguida del recuento de movimientos.

Pruébalo en línea!

Explicación

\d+
$*.

Convierta ambos enteros en esa .s, es decir, conviértalos en unarios.

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

Esto crea una cuadrícula de .s, haciendo coincidir cada uno .en la altura unaria y capturando la representación unaria del ancho. La Sactiva el modo de separación que devuelve las cadenas capturadas, y el |\Dy _juntos aseguran que todo lo demás se elimina de la cadena.

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

Esto convierte el último carácter de cada línea, así como toda la última línea en #s.

:m-1=`^#
X

Utiliza una tonelada de opciones para convertir solo la primera #en la última fila X(necesitamos asegurarnos de que solo la última fila se vea afectada debido a las entradas de ancho-1). mactiva el modo multilínea que hace ^coincidir el comienzo de las líneas. -1=le dice a Retina que realice la sustitución solo en el último partido. Finalmente, :desactiva el modo silencioso predeterminado de modo que la cuadrícula se imprima en STDOUT como resultado intermedio.

#

Finalmente, simplemente contamos el número #en la cadena, que corresponde al número de movimientos.

Pyke, 26 bytes

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

Pruébalo aquí

O 34 bytes no competitivos, agregue el nodo de aplicación con un ast)

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

Pruébalo aquí!

O 30 bytes si se permiten espacios como relleno

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

Pyth, 32 29 24 bytes

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

Pruébalo en línea!

Entrada de muestra:

(4, 5)

Salida de muestra:

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

Cómo funciona:

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

Intento anterior:

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

Pruébalo en línea!

Entrada de muestra:

(4, 5)

Salida de muestra:

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

Cómo funciona:

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*

Toma datos en el formulario width heighty genera el recuento de movimientos en la primera línea, seguido de la cuadrícula de la solución.

Pruébalo aquí.

Esto también funciona para el mismo número de bytes:

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

Ruby, 48 bytes

Esta es una función anónima, que según esta meta publicación es aceptable a menos que la pregunta indique "programa completo". Normalmente no sería pedante con esto, pero el problema es muy simple y hacer un programa sería un aumento significativo del% en la puntuación.

La entrada es dos argumentos. El valor de retorno es una matriz que contiene la cadena de arte ASCII y el número de #en la ruta.

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

En programa de prueba

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

puts f[4,5]

Salida

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

Es solo una cadena de h-1 filas de puntos w-1, seguidas por una #y nueva línea. Puse el #al final para usar un solo #\nliteral para ambos #y nueva línea (el código contiene una nueva línea real en lugar de una secuencia de escape). La fila final es luego Xseguida por w-1 #.

Fue más corto disminuir los valores de w y h durante la generación de arte ASCII, por lo que el cálculo final es simple w+h.

JavaScript (ES6), 60 bytes

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

Uso

f(4)(5)

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

MATL , 28 26 25 bytes

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

EDITAR (10 de junio de 2016): el siguiente enlace incluye una modificación ( 5Lse reemplaza por IL) para adaptarse a los cambios en el idioma

Pruébalo en línea!

Explicación

+       % 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]

Ejemplo de uso:

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

Cómo funciona:

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

Pruébalo en línea!

Golfizado:

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

Sin golf:

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)

Para usarlo, agregue f=antes de la línea de arriba y llámelo así:

f(4, 5)

Resultado:

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