Twoim zadaniem jest napisanie programu, który znajdzie optymalną liczbę ruchów potrzebnych do przejścia od lewego dolnego rogu prostokąta do prawego górnego rogu naprzeciwko.

Twój program zaakceptuje dane wejściowe jako uporządkowaną parę (width, height). Będą to wymiary prostokąta, z którymi będziesz pracować. Twój program utworzy ASCII-art rozwiązania (użyj .dla pustego kwadratu i #dla części rozwiązania, Xdla kwadratu początkowego) i policz liczbę ruchów potrzebnych do osiągnięcia punktu końcowego. Ruchy po przekątnej są niedozwolone. Jeśli istnieje wiele rozwiązań, wybierz jedno z nich.

Najkrótszy program w bajtach wygrywa.

Przykład

Wejście: (4, 5)

Wynik:

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

Liczba ruchów: 7

05AB1E , 27 24 bajtów

Kod:

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

Wyjaśnienie:

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

Wypróbuj online! . Wykorzystuje kodowanie CP-1252 .

Retina , 54 53 bajtów

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

Pobiera dane wejściowe oddzielone od linii i generuje siatkę rozwiązania, a następnie liczbę ruchów.

Wypróbuj online!

Wyjaśnienie

\d+
$*.

Zamień obie liczby całkowite na tyle .s, tzn. Przekonwertuj je na unary.

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

To buduje siatkę .s, dopasowując każdą .na jednostkowej wysokości i przechwytując jednoznaczną reprezentację szerokości. SAktywuje tryb podziału, która zwraca przechwyconych ciągi, a |\Di _razem upewnić się, że wszystko jest usuwane z łańcucha.

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

To zmienia ostatni znak każdej linii, a także całą ostatnią linię na #s.

:m-1=`^#
X

Wykorzystuje to mnóstwo opcji do przekonwertowania tylko pierwszego #z ostatniego wiersza na X(musimy upewnić się, że dotyczy to tylko ostatniego wiersza ze względu na dane wejściowe o szerokości 1). maktywuje tryb wieloliniowy, który ^dopasowuje początek linii. -1=mówi Retinie, aby wykonała zmianę tylko w ostatnim meczu. Na koniec :wyłącza domyślny tryb cichy, tak że siatka jest drukowana do STDOUT jako wynik pośredni.

#

Na koniec po prostu liczymy liczbę #w ciągu, która odpowiada liczbie ruchów.

Pyke, 26 bajtów

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

Wypróbuj tutaj

Lub niekonkurencyjne 34 bajty, dodaj zastosuj węzeł z ast)

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

Wypróbuj tutaj!

Lub 30 bajtów, jeśli dozwolone spacje jako dopełnienie

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

Pyth, 32 29 24 bajtów

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

Wypróbuj online!

Przykładowe dane wejściowe:

(4, 5)

Przykładowe dane wyjściowe:

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

Jak to działa:

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

Poprzednia próba:

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

Wypróbuj online!

Przykładowe dane wejściowe:

(4, 5)

Przykładowe dane wyjściowe:

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

Jak to działa:

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 bajtów

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

Pobiera dane wejściowe w formularzu width heighti wyświetla liczbę ruchów w pierwszym wierszu, a następnie siatkę rozwiązania.

Sprawdź to tutaj.

Działa to również dla tej samej liczby bajtów:

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

Rubinowy, 48 bajtów

Jest to funkcja anonimowa, która zgodnie z tym meta postem jest akceptowalna, chyba że pytanie brzmi „pełny program”. Normalnie nie byłbym pedantyczny w tej kwestii, ale problem jest bardzo prosty, a wykonanie programu byłoby znaczącym% wzrostem wyniku.

Dane wejściowe to dwa argumenty. Zwracana wartość to tablica zawierająca ciąg znaków ASCII i liczbę #w ścieżce.

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

W programie testowym

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

puts f[4,5]

Wynik

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

To tylko ciąg h-1 rzędów kropek w-1, po których następuje a #i nowa linia. Umieszczam #na końcu, aby użyć pojedynczego #\nliterału zarówno dla #nowej linii, jak i nowej linii (kod zawiera rzeczywistą nową linię zamiast sekwencji specjalnej). W ostatnim rzędzie następuje następnie Xw-1 #.

Krótsze było zmniejszenie wartości wih podczas generacji sztuki ASCII, tak że końcowe obliczenia są proste w+h.

JavaScript (ES6), 60 bajtów

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

Stosowanie

f(4)(5)

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

MATL , 28 26 25 bajtów

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

EDYCJA (10 czerwca 2016 r.): Poniższy link zawiera modyfikację ( 5Lzastępuje ją IL), aby dostosować się do zmian w języku

Wypróbuj online!

Wyjaśnienie

+       % 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 bajtów

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

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

Przykład użycia:

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

Jak to działa:

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 bajtów

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 bajtów

Wypróbuj online!

Gra w golfa:

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

Nie golfowany:

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)

Aby go użyć, dodaj f=przed wierszem powyżej i nazwij go tak:

f(4, 5)

Wynik:

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