Công việc của bạn là viết một chương trình tìm ra số lần di chuyển tối ưu để đi từ góc dưới bên trái của hình chữ nhật sang góc trên bên phải đối diện trực tiếp.

Chương trình của bạn sẽ chấp nhận đầu vào như một cặp theo thứ tự (width, height). Đây sẽ là kích thước của hình chữ nhật bạn sẽ làm việc với. Chương trình của bạn sẽ tạo ra một nghệ thuật ASCII của giải pháp (sử dụng .cho hình vuông trống và #một phần của giải pháp, Xđể bắt đầu hình vuông) và đếm số lần di chuyển cần thiết để đạt đến điểm cuối. Di chuyển chéo không được phép. Nếu có nhiều giải pháp, chọn một để đầu ra.

Chương trình ngắn nhất tính bằng byte thắng.

Thí dụ

Đầu vào: (4, 5)

Đầu ra:

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

Số lượng di chuyển: 7

05AB1E , 27 24 byte

Mã số:

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

Giải trình:

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

Hãy thử trực tuyến! . Sử dụng mã hóa CP-1252 .

Võng mạc , 54 53 byte

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

Đưa đầu vào được phân tách bằng nguồn cấp dữ liệu và xuất lưới giải pháp theo sau là số lần di chuyển.

Hãy thử trực tuyến!

Giải trình

\d+
$*.

Biến cả hai số nguyên thành nhiều .s, tức là chuyển đổi chúng thành unary.

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

Điều này xây dựng một lưới .s, bằng cách khớp từng .chiều cao đơn nguyên và nắm bắt đại diện đơn nguyên của chiều rộng. Các Skích hoạt chế độ phân chia mà trả về chuỗi bắt, và |\Dvà _cùng nhau đảm bảo rằng mọi thứ khác được lấy ra từ các chuỗi.

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

Điều này biến ký tự cuối cùng của mỗi dòng cũng như toàn bộ dòng cuối cùng thành #s.

:m-1=`^#
X

Điều này sử dụng rất nhiều tùy chọn để chỉ chuyển đổi hàng đầu tiên #trên hàng cuối cùng sang X(chúng tôi cần đảm bảo rằng chỉ hàng cuối cùng bị ảnh hưởng vì đầu vào chiều rộng-1). mkích hoạt chế độ đa dòng ^phù hợp với phần đầu của dòng. -1=nói với Retina chỉ thực hiện thay thế vào trận đấu cuối cùng. Cuối cùng, :tắt chế độ im lặng mặc định sao cho lưới được in thành STDOUT làm kết quả trung gian.

#

Cuối cùng, chúng ta chỉ cần đếm số #trong chuỗi, tương ứng với số lần di chuyển.

Pyke, 26 byte

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

Hãy thử nó ở đây

Hoặc 34 byte không cạnh tranh, thêm nút áp dụng với ast)

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

Hãy thử nó ở đây!

Hoặc 30 byte nếu không gian được phép dưới dạng phần đệm

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

Bình thường, 32 29 24 byte

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

Hãy thử trực tuyến!

Đầu vào mẫu:

(4, 5)

Đầu ra mẫu:

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

Làm thế nào nó hoạt động:

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

Lần thử trước:

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

Hãy thử trực tuyến!

Đầu vào mẫu:

(4, 5)

Đầu ra mẫu:

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

Làm thế nào nó hoạt động:

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 byte

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

Lấy đầu vào ở dạng width heightvà xuất số đếm di chuyển trên dòng đầu tiên, theo sau là lưới giải pháp.

Kiểm tra nó ở đây.

Điều này cũng hoạt động cho cùng một số byte:

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

Ruby, 48 byte

Đây là một chức năng ẩn danh, theo bài đăng meta này có thể chấp nhận được trừ khi câu hỏi nêu rõ "chương trình đầy đủ". Tôi thường không phải là người phạm tội về vấn đề này nhưng vấn đề rất đơn giản và thực hiện một chương trình sẽ làm tăng đáng kể% điểm số.

Đầu vào là hai đối số. Giá trị trả về là một mảng chứa chuỗi nghệ thuật ASCII và số lượng #trong đường dẫn.

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

Trong chương trình thử nghiệm

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

puts f[4,5]

Đầu ra

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

Nó chỉ là một chuỗi gồm h-1 hàng chấm w-1, theo sau là một #dòng mới. Tôi đặt #ở cuối để sử dụng một #\nchữ duy nhất cho cả hai #và dòng mới (mã chứa một dòng mới thực sự chứ không phải là một chuỗi thoát.) Hàng cuối cùng sau đó là dòng Xtiếp theo của w-1 #.

Nó ngắn hơn để giảm các giá trị của w và h trong quá trình tạo nghệ thuật ASCII, do đó việc tính toán cuối cùng chỉ đơn giản là w+h.

JavaScript (ES6), 60 byte

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

Sử dụng

f(4)(5)

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

MATL , 28 26 25 byte

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

EDIT (ngày 10 tháng 6 năm 2016): liên kết bên dưới bao gồm sửa đổi ( 5Lđược thay thế bằng IL) để thích ứng với các thay đổi trong ngôn ngữ

Hãy thử trực tuyến!

Giải trình

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

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

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

Ví dụ sử dụng:

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

Làm thế nào nó hoạt động:

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 byte

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 byte

Hãy thử trực tuyến!

Chơi gôn

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

Ung dung:

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

Con trăn, 48.

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

Để sử dụng nó, hãy thêm f=trước dòng trên và gọi nó như thế này:

f(4, 5)

Kết quả:

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