到达矩形相对角的最佳解决方案

13

您的工作是编写一个程序，以找到从矩形的左下角到相对的右上角所需的最佳移动次数。

您的程序将接受输入作为有序对(width, height)。这些将是您将使用的矩形的尺寸。您的程序将创建解决方案的ASCII艺术形式（.用于空正方形和#部分解决方案，X用于起始正方形），并计算到达端点所需的移动次数。不允许对角移动。如果有多种解决方案，请选择一种解决方案。

以字节为单位的最短程序获胜。

例

输入： (4, 5)

输出：

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

移动次数：7

code-golf  ascii-art  grid  counting 
— ericw31415
source
那么输出中是否还应包含#in“最佳解决方案”中的数量（这是从不向左或向下移动的任何解决方案）？
— Martin Ender
12
关于“很抱歉，这是我的第一个代码高尔夫球问题，所以我不太擅长制作这些。” 让我推荐一个沙盒，您可以在其中发布挑战想法并获得反馈，然后再将其发布到主要项目上。欢迎来到PPCG！:)
— Martin Ender
@MartinBüttner是的，移动计数本质上是，#因为向左或向下移动是不合逻辑的。
— ericw31415 '16
可以用空格分隔每个字符吗？
— 蓝色
1
我们是否必须输出移动计数和ASCII艺术？输出应如何精确显示？
— 詹姆斯

Answers:

0

05AB1E，27 24字节

码：

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

说明：

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

在线尝试！。使用CP-1252编码。

— 阿德南
source
字节和字符有什么区别？
— Leaky Nun
2
@KennyLau我忘了提起我的帖子了……05AB1E使用CP-1252编码，此处代码中使用的每个字符均为1个字节。
— 阿德南
3

视网膜，54 53字节

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

以换行符分隔输入并输出解决方案网格，然后输出移动计数。

在线尝试！

说明

\d+
$*.

将两个整数都变成那么多.s，即将它们转换为一元。

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

.通过匹配每个.一元高度并捕获宽度的一元表示，可以构建s 的网格。该S激活分离模式，它返回拍摄串，并|\D和_一起确保一切从字符串中删除。

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

这会将每行的最后一个字符以及整个最后一行变成#s。

:m-1=`^#
X

这使用了大量的选项，仅将#最后一行的第一行转换为X（由于宽度为1的输入，我们需要确保仅最后一行受到影响）。m激活多行模式，使之^匹配行的开头。-1=告诉Retina仅在最后一场比赛中执行替换。最后，:关闭默认的静音模式，以便将网格打印到STDOUT作为中间结果。

#

最后，我们简单地计算#字符串中的数字，该数字与移动数相对应。

— 马丁·恩德
source
也许应该将内置对象添加到视网膜以转换为一元。
— Cyoce '16
3

Pyke，26个字节

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

在这里尝试

或是非竞争性的34个位元组，加上带ast的Apply节点

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

在这里尝试！

或30个字节（如果允许空格作为填充）

jUa]Dm!X|RZjht]q+".#X"R@)Pjmts
— 蓝色
source
为什么不具有竞争力？
— Leaky Nun
3
我改变了语言的挑战公布后
— 蓝
@muddyfish当您单击此处尝试时发生内部服务器错误
— Insane
@Insane修复了该错误（希望如此），只要日期改变，内部的时间测试就会失败。
— 2016年
2

Pyth，32 29 24字节

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

在线尝试！

输入样例：

(4, 5)

样本输出：

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

怎么运行的：

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

先前尝试：

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

在线尝试！

输入样例：

(4, 5)

样本输出：

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

怎么运行的：

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
— 漏尼姑
source
@MartinBüttner也许您可以帮我打高尔夫球吗？
— Leaky Nun
@KennyLau我不认识Pyth ...
— Martin Ender
@MartinBüttner击败Pyth真是令人尴尬，对
— Leaky Nun
您可以将前两个分配与结合使用AtMQ。这会将两个值分配给G和H。
— 雅库布
1

Ruby，48个字节

这是一个匿名函数，根据此meta post的要求，除非问题指出“完整程序”，否则该函数是可以接受的。我通常不会对此之以鼻，但是问题很简单，并且做一个程序会大大提高分数。

输入是两个参数。返回值是一个包含ASCII美术字串和#路径中数字的数组。

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

在测试程序中

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

puts f[4,5]

输出量

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

它只是一串由w-1点组成的h-1行，后跟a #和换行符。我#在末尾放置了一个#\n字符，以便对#换行符和换行符都使用单个文字（代码包含实际的换行符，而不是转义序列。）然后，最后一行X后面是w-1 #。

在ASCII art生成期间减小w和h的值变短了，因此最终的计算很简单w+h。

— Level River St
source
1

JavaScript（ES6），60个字节

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

用法

f(4)(5)

7
...#
...#
...#
...#
X###
— 用户名
source
1

MATL，28 26 25字节

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

编辑（2016年6月10日）：下面的链接包含一个修改（5L由代替IL）以适应语言的更改

在线尝试！

说明

+       % 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
— 路易斯·门多
source
0

Scala，118个字节

(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 "#"
— corvus_192
source
0

Haskell，64个字节

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

用法示例：

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

怎么运行的：

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
— 妮米
source
0

Java，137132字节

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;}
— 漏尼姑
source
Java并非完全是个玩笑……
— ericw31415 '16
S + =不是s = S +的会为你节省几个字节
— 蓝
0

Lua，81个字节

在线尝试！

打高尔夫球：

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

取消高尔夫：

w,h=4,5
print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))
print(w+h-2)
— 漏尼姑
source
0

Python，48岁。

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

要使用它，请f=在上面的行之前添加并按如下方式调用它：

f(4, 5)

结果：

...#
...#
...#
...#
X###
— q
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.