Seu trabalho é escrever um programa que encontre o número ideal de movimentos necessários para ir do canto inferior esquerdo de um retângulo ao canto superior direito, diretamente oposto.

Seu programa aceitará entrada como um par ordenado (width, height). Essas serão as dimensões do retângulo com as quais você trabalhará. Seu programa criará uma arte ASCII da solução (use .para quadrado vazio e #parte da solução, Xpara iniciar quadrado) e conte o número de movimentos necessários para alcançar o ponto final. Movimentos diagonais não são permitidos. Se houver várias soluções, escolha uma para saída.

O programa mais curto em bytes vence.

Exemplo

Entrada: (4, 5)

Resultado:

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

Contagem de movimentos: 7

05AB1E , 27 24 bytes

Código:

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

Explicação:

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

Experimente online! . Usa a codificação CP-1252 .

Retina , 54 53 bytes

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

Separa a entrada por um avanço de linha e gera a grade da solução seguida pela contagem de movimentos.

Experimente online!

Explicação

\d+
$*.

Transforme ambos os números inteiros em muitos .s, ou seja, converta-os para unários.

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

Isso cria uma grade de .s, combinando cada um .na altura unária e capturando a representação unária da largura. A Sativa modo de divisão que retorna as cordas capturados, eo |\De _juntos garantir que tudo o resto é removido da corda.

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

Isso transforma o último caractere de cada linha e a última linha inteira em #s.

:m-1=`^#
X

Isso usa várias opções para converter apenas o primeiro #da última linha em X(precisamos garantir que apenas a última linha seja afetada devido às entradas de largura 1). mativa o modo de várias linhas, que faz ^corresponder o início das linhas. -1=diz à Retina para fazer a substituição apenas na última partida. Por fim, :desativa o modo silencioso padrão, de modo que a grade seja impressa em STDOUT como um resultado intermediário.

#

Finalmente, contamos simplesmente o número #na string, que corresponde ao número de movimentos.

Pyke, 26 bytes

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

Experimente aqui

Ou 34 bytes não competitivos, adicione nó de aplicação com um ast)

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

Experimente aqui!

Ou 30 bytes, se houver espaço permitido como preenchimento

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

Pitão, 32 29 24 bytes

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

Experimente online!

Entrada de amostra:

(4, 5)

Saída de amostra:

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

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

Tentativa anterior:

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

Experimente online!

Entrada de amostra:

(4, 5)

Saída de amostra:

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

Como 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*

Recebe entrada no formulário width height e gera a contagem de movimentação na primeira linha, seguida pela grade da solução.

Teste aqui.

Isso também funciona para a mesma contagem de bytes:

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

Ruby, 48 bytes

Esta é uma função anônima que, de acordo com esta meta post é aceitável, a menos que a pergunta indique "programa completo". Normalmente, eu não seria pedante sobre isso, mas o problema é muito simples e fazer um programa seria um aumento significativo de% na pontuação.

Entrada são dois argumentos. O valor de retorno é uma matriz que contém a sequência de arte ASCII e o número do #caminho.

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

No programa de teste

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

puts f[4,5]

Resultado

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

É apenas uma sequência de h-1 linhas de w-1 pontos, seguidas por #ae newline. Coloquei #no final para usar um único #\nliteral para ambos #e nova linha (o código contém uma nova linha real, em vez de uma sequência de escape.) A linha final é então Xseguida por w-1 #'s.

Foi mais curto diminuir os valores de we durante a geração de arte ASCII, para que o cálculo final seja simples 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

EDIT (10 de junho de 2016): o link abaixo inclui uma modificação ( 5Lsubstituída por IL) para se adaptar às alterações no idioma

Experimente online!

Explicação

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

Exemplo de uso:

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

Como 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

Experimente online!

Golfe:

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)

Para usá-lo, adicione f=antes da linha acima e chame-a assim:

f(4, 5)

Resultado:

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