输入：

• 整数，它保证为。$n$$\ge3$
• 整数，它是。$d$$[-1,0,1]$

输出：

大小为的道路，如果，则为西北方向；如果，则为北方向；如果则为东北方向。道路将始终为三处宽（如果包括外部边界，则通常为五处）。此外，底部将有一条道路分隔线，此后向上交替显示。$n$$d=-1$$d=0$$d=1$

一些例子：

输入： 输出：$n=7, d=1$

      / / /
     /   /
    / / /
   /   /
  / / /
 /   /
/ / /

输入： 输出：$n=4, d=-1$

\   \
 \ \ \
  \   \
   \ \ \

挑战规则：

• 只要可以在屏幕上的某处打印所需的道路，任何数量的前导/尾随空格和/或换行符都是可以接受的。
• 除了选项您还可以使用选项或。另外，您可以选择三个选项中的哪个映射到三个方向中的哪个。（如果挑战说明中分别使用的选项不同于，请务必提及您使用了哪些选项！）$[-1,0,1]$$[0,1,2]$$[1,2,3]$$[-1,0,1]$[north-west, north, north-east]
• 任何合理的输出格式都是可以接受的。当然，最常见的做法是将其打印到STDOUT，但也可以将其作为字符串或2D字符列表返回。

一般规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
• 标准规则适用于具有默认I / O规则的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法以及返回类型的完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接（即TIO）。
• 另外，强烈建议为您的答案添加说明。

测试用例：

上面的两个示例，以及：

输入：$n=10, d=0$
输出：

|   |
| | |
|   |
| | |
|   |
| | |
|   |
| | |
|   |
| | |

画布，23 22 字节

B}⁴H‟ｍ↶⁷？／|∙/╋］＼|∙\╋］｝

在这里尝试！

使用方向输入0、1和2。

说明：

...‟    push "--¶¶- ¶¶--"
    m   mold the horizontal length to the 1st input - a horizontal road
     ↶  rotate counter-clockwise - so the separator is on the bottom
        also replaces the dashes with bars

⁷?     ]     ]}  switch over the 2nd input:
                 default case (input 2):
  /                pad with spaces to a "/" diagonal
   |∙/╋            replace "|" with "/"
                 case 0:
        \          pad with spaces to a "\" diagonal
         |∙\╋      replace "|" with ""

case 1 is empty, but because of a bug, the trailing "}" is still required

Python 2中，79个 78 73 72字节

n,d=input()
c='|\/'[d]
i=n
while i:print' '*(n-i*d)+c,i%2*c or' ',c;i-=1

在线尝试！

需要[1,0,-1]对[north-west, north, north-east]

_{-1字节，感谢尼尔}

Python 2，66字节

n,d=input()
s=' '+'|\/'[d]
for c in(s*n)[n:]:print' '*n+s,c+s;n+=d

在线尝试！

用途d=-1为NE，d=0为N，和d=1为NW。利用允许的前导空格。道路底部有分隔线的规则使正确设置奇偶校验变得很棘手。这是通过将空间和道路特征之间(s*n)[n:]的2n交替的后半部分进行切片来实现的。

1. Python 3.5，122 120字节

脚本有两个参数：n，d。

d：0、1、2-> \ | /

tio.run

import sys;(n,d)=[*map(int,sys.argv[1:3])];c="\\|/"[d]
for i in range(n):j=n+~i;print(" "*(i,0,j)[d],c,c*(j%2<1)or" ",c)

输出：

$ ./script.py 6 2
      /   /
     / / /
    /   /
   / / /
  /   /
 / / /
$ ./script.py 6 1
 |   |
 | | |
 |   |
 | | |
 |   |
 | | |
$ ./script.py 6 0
 \   \
  \ \ \
   \   \
    \ \ \
     \   \
      \ \ \

说明

# parse input params
(n,d)=[*map(int,sys.argv[1:3])]

# select char for "road"
c="\\|/"[d]

# loop n-times
for i in range(n):

    # complement (how many lines to end)
    j=n+~i

    # print
    #   space i or 0 or j times
    #   road, center of road if j is even else space, road
    print(" "*(i,0,j)[d], c, c*(j%2<1) or " ", c)

编辑：-2字节感谢凯文·克鲁伊森

PowerShell，88 82 80 74 71字节

^{-8字节归功于Mazzy，
-6字节归功于AdmBorkBork，而Mazzy
-3字节归功于AdmBorkBork}

param($n,$d)$n..1|%{' '*($_,($n-$_))[$d]+($y='/\|'[$d])," $y"[$_%2],$y}

在线尝试！

对NW，NE，N使用[0,1,2]。d两次用作列表索引，首先获取间距方法（使用2返回0时从列表中删除，然后绘制线条时使用哪个字符。将一个列表附加到构建道路的空格字符串（当这样添加时，在成员之间本来就有空格）。还可以基于模数学在开放车道或破折号之间交换。

C（gcc），100 90字节

f(a,b,c,d){for(c=a,d="\\|/"[b+1];c--;)printf("%*c %c %c\n",b>0?c+1:b?a-c:0,d,c%2?32:d,d);}

在线尝试！

写得好的版本

木炭，33 29 23字节

↷ＮＮη⊘⊕ηＵＥ¹¦¹Ｆ⟦²±²⟧«Ｊι⁰η

在线尝试！链接是详细版本的代码。现在，所有潜在的木炭错误似乎都已修复，我可以公布最佳代码。说明：

↶Ｎ

根据第一个输入逆时针旋转光标方向，以使1变为东北，2变为北，3变为西北。

Ｎη

输入道路长度。

⊘⊕ηＵＥ¹¦¹

打印道路长度的一半，然后将其拉伸以形成道路分隔符。

Ｆ⟦²±²⟧«Ｊι⁰η

打印路边。

@KevinCruijssen随后提交了该问题的较硬版本，此版本已删除，但具有足够代表的用户可以在此处看到：（硬）代码之路我在此答案中使用的拉伸技巧不适用于该问题，所以我改为编写了以下47个 45字节程序：

Ｆ³«Ｊ×ι⊘⊕θ⁰≔…⟦¹ ⟧⊕﹪ι²ιＦη«↶§κ⁰Ｆ⊖§κ¹§ιⅉＰ§ιⅉ↑↷§κ⁰

在线尝试！链接是详细版本的代码。说明：

Ｆ³«

在侧面和隔板上循环。

Ｊ×ι⊘⊕θ⁰

跳到一侧的起点。

≔…⟦¹ ⟧⊕﹪ι²ι

制作一个包含a 1和一个空格的数组，但是如果要绘制边而不是分隔符，请再次删除该空格。

Ｆη«

绕过每个路段。

↶§κ⁰

相应地旋转光标方向。

Ｆ⊖§κ¹

比路段的长度短一圈...

§ιⅉ

...并打印数组的交替元素。通过使用光标的Y坐标循环索引到数组中来实现交替。

Ｐ§ιⅉ

打印此路段的最后一行，但不要移动光标...

↑

...，以便可以将光标向上移动以准备下一节。

↷§κ⁰

向后旋转光标方向，为下一节做好准备。

Kotlin，96 92字节

{n,d->val c="\\|/"[d];(0..n-1).map{println(" ".repeat(n-it*(d-1))+ "$c ${" $c"[it%2]} $c")}}

接受[0，1，2]而不是[-1，0，1]

它的工作方式与其他语言的解决方案类似，但是不幸的是Kotlin并没有真正在这种语言中大放异彩。

val c=“\\|/“; 通过利用Kotlin将字符串像一个字符数组一样对待的事实来检索要在道路建设中使用的字符（应该，看一下Java）

在线尝试！

TSQL代码，171个 117字节

我意识到这可以写成更短的代码。

DECLARE @n INT=7,@d INT=0

,@ INT=0a:PRINT
space(@n-@*@d)+stuff(replicate(substring('\|/',@d+2,1)+' ',3),3,@%2,space(@%2))SET
@+=1IF @n>@ GOTO a

TSQL查询，137个字节

USE master
DECLARE @n INT=6,@ INT=-1

SELECT space(@n-y*@)+z+iif(y%2=1,z,'  ')+z 
FROM(SELECT top(@n)row_number()over(order
by @)y,' '+substring('\|/',@+2,1)z FROM spt_values)x

如果您的数据库已经是master，则不需要USE master。但是，某些用户具有不同的默认数据库。

试用时的脚本略有不同。我不得不将ascii-32替换为ascii-160，未显示空格。

试试看

进行了一些调整，意识到我可以替换

按1/0订购

与

由@订购

JavaScript（ES8）， 90 87  85字节

(direction)(length)$0$$1$$2$

d=>g=(n,w=n)=>n?(c='/|\\'[d]).padStart([n--,,w-n][d])+` ${n&1?' ':c} ${c}
`+g(n,w):''

在线尝试！

JavaScript（ES6），90个字节

此函数用更多的数学.padStart()方法而不是方法逐个字符地绘制输出字符。

(direction)(length)$1$$2$$3$

d=>n=>(g=x=>y?` /|\\
`[x+5?17+y%2*4>>--x+5-[,n+1-y,n,y][d]&1&&d:(x=n,y--,4)]+g(x):'')(y=n)

在线尝试！

果冻， 31  30 字节

⁶ẋẋƤḂ};€ị“\/|”ẋ3KƊ}Ṛ⁹¡⁶-2¦€ÐeṚ

双向链接，在左侧接受长度，在右侧接受取反方向*，这将产生二维字符数组。
*[north-west, north, north-east]=[1, 0, -1]

在线尝试！（页脚调用链接，与换行符连接并打印结果）

怎么样？

⁶ẋẋƤḂ};€ị“\/|”ẋ3KƊ}Ṛ⁹¡⁶-2¦€ÐeṚ - Link: integer, L; integer, D
⁶                              - space character
 ẋ                             - repeat L times
     }                         - using the right argument (D):
    Ḃ                          -   mod 2 (0 if D = 0, 1 otherwise ...A would work too)
   Ƥ                           - for each prefix (of the list of spaces):
  ẋ                            -   repeat (D mod 2 times)
                  }            - using the right argument (D):
                 Ɗ             -   last three links as a monad:
        ị“\/|”                 -     index into "\/|" (1-indexed & modular)
              ẋ3               -     repeat three times - e.g. "\\\"
                K              -     join with spaces          "\ \ \"
      ;€                       - concatenate €ach (altered prefix with that list)
                     ¡         - repeat action...
                    ⁹          - ...number of times: right argument (-1 repeats 0 times)
                   Ṛ           - ...action: reverse (i.e. reverse if north-west)
                           Ðe  - for even indexes:
                         ¦€    -   sparse application for €ach...
                       -2      -   ...to indices: [-2] (the middle of the road)
                      ⁶        -   ...action: a space character
                             Ṛ - reverse

Python 2，127字节

n,d=input()
c='|/\\'[d]
for i in range(n):t=0if d==0else(i if d<0else n-i);print(' '*t+'{} {} {}'.format(c,' 'if i%2==0else c,c))

在线尝试！

前两行来自@TFeld。

Python 2，93字节

n,d=input();p=''
while n:g='|/\\'[d];n-=1;print['',' '*n,p][d]+g+' %s '%(g,' ')[n%2]+g;p+=' '

在线尝试！

J，64字节

' \|/'{~(_2&|*[:i.[*1 _1{~3=])|."_1((5+[){."1(5,~[)|.@$]*#:@689)

在线尝试！

• 1西北
• 2北
• 3东北

稍后将尝试打高尔夫球

C＃（Visual C＃中交互式编译器），129个 107 103 93字节

a=>b=>{for(char i=a,W="/|\\"[b+1];i>0;)Write("{0,"+(a-i*b+5)+"} {1} {0}\n",W,--i%2<1?W:' ');}

东北-1，西北1，北部0

在线尝试！

红色，157字节

func[s d][p: pick"\|/"d set[a b]reduce pick[[4 1]0[5 + s -1]]d 
repeat n s[print pad/left form reduce pick[[p" "p][p p p]]odd?(n + pick[1 0]odd? s)a: a + b]]

在线尝试！

• 1西北
• 2北
• 3东北

Japt，53个字节

W="|/\\"gV;Æ"{W} {YÉ %2?W:' } {W}"ùVÄ?V?Y+5:5:U-Y+4Ãw

在线尝试！

迅速4.2，112 108个字节

^{-4个字节归功于Sriotchilism O'Zaic}

let c=["\\","|","/"][d];(0..<n).map{print((0..<n-$0*(d-1)).map{_ in" "}.joined()+c+" \($0%2==0 ?c:" ") "+c)}

[0,1,2]，而不是[-1,0,1]。

在线尝试！

说明

let c=["\\","|","/"][d]

确定要使用的路牌。（我敢打赌，可以通过某种方式将其缩短）

(0..<n).map{

遍及街道的整个长度。

(0..<n-$0*(d-1)).map{_ in" "}.joined()

在街道前面添加空间。

\($0%2==0 ?c:" ")"

在每隔一行添加中间符号。

我的第一个☝️，我对任何优化建议感到满意。从该线程中学到的最多：在Swift中打高尔夫球的技巧。

Perl 6，66个字节

->\n,\d{{(' 'x--$ *d%-+^n~(' ',<\ | />[d+1])[1,(n+$++)%2,1])xx n}}

在线尝试！

返回行列表。

说明

->\n,\d{                                                         }  # Block taking n, d
        {                                                       }   # Reset $ variables
         (                                                 )xx n    # Repeat n times
          ' 'x  # Space times
              --$ *d  # (-1,-2,-3,...) if d=1
                      # (0,0,0,...) if d=0
                      # (1,2,3,...) if d=-1
                    %-+^n  # modulo -~n = n+1
                         ~  # Concat
                          (' ',<\ | />[d+1])  # Space or line
                                            [1,(n+$++)%2,1]  # Alternate middle char

红宝石，90字节

n,a=*$*.map{|i|-i.to_i}
c='|\/'[a]
n.upto(-1){|i|puts' '*(i*a-n)+c+' '+[' ',c][i%2]+' '+c}

在线尝试！

更新：谢谢凯文（Kevin），他指出我的原始提交的内容是缺少道路边缘和标记之间的空间（即3宽度的道路，而不是5宽度的道路）。 c+' '+...+' '+c。

方向信息： -1, 0, 1映射到{ north-west, north, north-east }

参数：读取命令行参数，例如 4 -1（四行路，向西北倾斜）。

附加说明：这已在Ruby v2.6.1上进行了本地测试，并且“ 在线试用”似乎使用了Ruby v2.5.3。我没有理由认为它不适用于所有其他Ruby版本。

Java（JDK），116字节

d->n->{for(int c="\\|/".charAt(d),i=n;i-->0;)System.out.printf("%"+(d<1?n-i:d>1?i+1:1)+"c%2c %c%n",c,i%2<1?c:32,c);}

在线尝试！

注意到d为一体0，1或2。

Japt -R，40个字节

Æ=Vg"|\\/";²i1S+iX%2?S:U)iSp[TZÊ-YY]gVÃw

在线尝试！

说明：

Æ=Vg"|\\/";²i1S+iX%2?S:U)iSp[TZÊ-YY]gVÃw
                                            // U = road size
                                            // V = direction
Æ                                     Ã     // Loop X through [0...U]
 =        ;                                 //   Set U to:
    "|\\/"                                  //       "|\/"
  Vg                                        //            [V]
           ²                                //  Double U
            i1          )                   //  Insert at index 1:
              S+                            //    " " +
                 X%2?S:U                    //         X%2?" ":U
                i                           //                  + " "
                         i                  //  Insert at index 0:
                          Sp                //    " " repeated this many times:
                            [TZÊ-YY]        //      [0,U.length - X,X]
                                    gV      //                        [V]
                                        w   // Reverse output

Stax，23 个字节

ù╒←∩♂2Ωⁿ¡├∩22♀Ç○=÷â╧δÖ↑

运行并调试

输入是两个由空格分隔的整数。
首先是d。-1指定东北。北方为0。1代表西北。第二个参数是n。这两个值将从输入中隐式解析，并放在输入堆栈的n顶部。另外，d可以从stax的x由于它是第一个隐式解析的值，因此寄存器。

例如，输入“ 1 7”

            Main stack      Explanation
            ----------      -----------
;           [7]             peek from input stack
m                           map over integers [1..n] using the rest of the program
                            output each produced value implicitly
  ;         [1 7]           peek from input stack
  +         [8]             add
  .*"       [8 [42 34]]     2 character string literal with codepoints 42 and 34
  @         [42]            get the element at the specified modular index (8)
  0         [42 0]          literal zero
  "|\/"x@   [42 0 92]       get codepoint from string literal at input d (from x register)
  \         [42 [0 92]]     make pair
  :B        ['\ \ \ ']      encode in custom base; it's binary with custom codepoints
  _x*       ['\ \ \ ' 1]    (loop variable) * (input d)
  ;^        ['\ \ \ ' 1 8]  peek from input stack and increment
  %         ['\ \ \ ' 1]    modulus
  6+        ['\ \ \ ' 7]    add 6
  )         [' \ \ \ ']     left-pad to length

运行这个

perl -M5.010 -Mfeature =签名，97个字节

sub f($n,$d){$x=qw[| / \\][$d];say" "x($d<1?$_*-$d:$n-$_),$x,$",($n-$_)%2?$":$x,$",$x for 1..$n;}