六角形三角形！

20

您的任务：制作一个边长为的六边形三角形n，其中n正整数或0。

首先，让我定义一个六边形：

 / \
|   |
 \ /

（惊人的ASCII艺术，对吗？）

六边形可以通过共享边链接在一起：

 / \ / \
|   |   |
 \ / \ /

   / \  
  |   |
 / \ /
|   |
 \ /

六角形三角形如下：

   / \
  |   |
 / \ / \
|   |   |
 \ / \ /

该六边形三角形的边长为2--制作一侧需要六边形。边长为1的六边形三角形仅是一个六边形，边长为0的六边形为空。

更正式地说，六边形三角形是由六边形连接在一起的三角形。顶部六角形在底部两个侧面链接到其下方的两个。左下角的三角形链接到其右侧和右上角的三角形，右下角的三角形链接到其左侧和左上角的三角形。边角之间有六边形，它们的相对侧相连，数量为n-2。三角形未填充。

更多示例：

Side length 3:
     / \
    |   |
   / \ / \
  |   |   |
 / \ / \ / \
|   |   |   |
 \ / \ / \ /

Side length 4:
       / \
      |   |
     / \ / \
    |   |   |
   / \ / \ / \
  |   |   |   |
 / \ / \ / \ / \
|   |   |   |   |
 \ / \ / \ / \ /
(This triangle isn't really filled, the borders make it look like there is a hexagon in the middle, but there is not.)

Side length 5:
         / \
        |   |
       / \ / \
      |   |   |
     / \ / \ / \
    |   |   |   |
   / \ /     \ / \
  |   |       |   |
 / \ / \ / \ / \ / \
|   |   |   |   |   |
 \ / \ / \ / \ / \ /

Side length 6:
           / \
          |   |
         / \ / \
        |   |   |
       / \ / \ / \
      |   |   |   |
     / \ /     \ / \
    |   |       |   |
   / \ /         \ / \
  |   |           |   |
 / \ / \ / \ / \ / \ / \
|   |   |   |   |   |   |
 \ / \ / \ / \ / \ / \ /
code-golf  ascii-art  geometry  hexagonal-grid 
— 小马同志
source
22
如果没有对此的十六进制答案，我将对@MartinEnder失去信心。
— caird coinheringaahing
@Soyoucanreplytomeincomments让我们说，如果我可以在这里关注用户，他们就会在列表中。
— phyrfox
1
@phyrfox 可以的。
— 丹尼斯，
2
我希望在木炭中看到一个简短的答案。我自己做，但是我必须先学习它，对不起，我想看电影。
— 尼尔，
3
@Neil，您不学习全新的编程语言是可以原谅的。但这是您的第一个警告！
— caird coinheringaahing

Answers:

11

木炭，62 43 39字节

ＮβＦ³«Ｆ⁻β‹ι²« / \¶|   |¶ \ /Ｍײι↑¿⁻¹ιＭ⁶←

在线尝试！编辑：由于@ ASCII-only而节省了一些字节（不确定确切多少，因为我还保存了另外6 10个字节，但随后需要在错误修正上花费4个字节）。现在使用嵌套循环，这应该一直是这样。

— 尼尔
source
45个字节：（Ａ / \¶| |¶ \ /αＮβＦβ«α←←»Ｆβ«α↖↖Ｍ⁶←»Ｆβ«αＭ⁴↑←←顺便说»一下，木炭最后会自动完成所有需要的操作）
— （仅ASCII
仅限@ASCII，可悲的是，我似乎再也找不到了炭笔文档，所以我不知道您的代码做什么。
— 尼尔
命令是在wiki 这里，基本上Assign(hexagon_with_space_to_left, a);InputNumber(b);for(b){Print(a);Move(:Left);Move(:Left);}for(b){Print(a);Move(:UpLeft);Move(:UpLeft);Move(6, :Left);}for(b){Print(a);Move(4, :Up);Move(:Left);Move(:Left);}，每一个for循环绘制一面
— ASCII-仅
您正在做什么，但字符串已保存为变量
— 仅使用ASCII
仅限@ASCII通过反转绘图方向，我可以再节省2个字节。（另外，让我感到有点失望的是，绘制六边形的最佳方法是字符串文字，但至少这使重复变得容易。）
— Neil
7

Python 2中，184个 177 174 164字节

n=input();p='|   |';e=' \\ /'
for i in range(n):k=' '*(4*i-5);w='  '*~(i-n);print w+[' / \\'*-~i+'\n'+w+p[:4]*i+p,' /'+e+k[3:]+e+' \\\n'+w+p+k+p][2<i<n-1]
print e*n

在线尝试！

-7个字节归功于ØrjanJohansen

— 数学迷
source
您缺少|顶部三行和底部六边形行中最右边的。
— 与Orjan约翰森
p[:4]*(i+2)而不是p[:4]*(i+1)解决它。
— 与Orjan约翰森
您只b在一个地方使用，因此将其与您的~把戏结合起来可以w=' '*2*~(i-n)减少7个字节。
— 与Orjan约翰森
@ØrjanJohansen谢谢，代码经历了很多重构，我忘了更改这些内容
— 数学迷
6

JavaScript（ES6），243个字节

f=n=>(n=n*2-2,a=[...Array(n+3)].map(_=>Array(n*2+5).fill` `),g=(y,x)=>(a[y+1][x]=a[y+1][x+4]=`|`,a[y][x+1]=a[y+2][x+3]=`/`,a[y][x+3]=a[y+2][x+1]=`\\`),[...Array(n+!n)].map((_,i)=>i%2||(g(n,i*2),g(i,i=n-i),g(i,n+i))),a.map(a=>a.join``).join`
`)
<input type=number oninput=o.textContent=f(this.value)><pre id=o>
展开摘要

— 尼尔
source
4

JavaScript（ES6），133 129 128 126字节

用两个字符逐个构建输出字符 for循环。

n=>{for(s='',y=n*2,n*=4;~y--;s+=`
`)for(x=n;~x--;)s+=' \\ /|'[x>y-2&x<n-y&(k=x+y&3,x>n-y-6|x<y+4|y<2)?y&1?k:k+1&4:0];return s}

怎么运行的

在外循环中，y从n * 2-1迭代到-1。在内部循环中，x从n * 4-1迭代到-1。我们设置k =（x + y）＆3，这是用于生成六边形的基础图案。

以下是n = 4的结果网格：

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 6 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 5 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 4 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
 3 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2
 2 |  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1
 1 |  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0
 0 |  3  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3
-1 |  2  1  0  3  2  1  0  3  2  1  0  3  2  1  0  3  2

在偶数行上，当k = 3时，单元格用竖线字符填充，否则用空格填充。竖线是我们参考字符串中的第5个字符" \ /|"，因此正确的索引由（k + 1）＆4给出。

在奇数行上，每个单元格都直接用参考字符串中的相应字符填充：

  • k = 0 →空间
  • k = 1 →“ \”
  • k = 2 →空间
  • k = 3 →“ /”

下面是我们的更新示例（用点替换空格）：

     15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 -1
   +---------------------------------------------------
 7 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 6 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 5 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 4 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
 3 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .
 2 |  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .
 1 |  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .
 0 |  |  .  .  .  |  .  .  .  |  .  .  .  |  .  .  .  |
-1 |  .  \  .  /  .  \  .  /  .  \  .  /  .  \  .  /  .

在以下公式中，为便于阅读，我们定义N = n * 4（尽管在代码中使用了相同的变量）。

通过测试获得三角形形状：

  • x> y-2 →移除右上角
  • AND x <N-y →删除左角

然后通过测试删除内部部分：

  • x> N-y-6 →仅保留左边缘
  • 或x <y + 4 →仅保留右边缘
  • 或y <2 →仅保留底边

演示版

显示代码段

— Arnauld
source
有[x>y-2&x<n-y&(x>n-y-6|x<y+4|y<2)&&y&1?x+y&3:x-~y&4]工作吗？
— 尼尔，
@Neil Hmm，我不这么认为。我们需要在三元表达式周围加上括号，并且(x+y+1)&4与相同(((x+y)&3)+1)&4。
— Arnauld
不，当然不是。我在想什么...
— Neil
3

果冻， 62  61 字节

当前包含六个六位。

_‘<×⁸>6
Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥
ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y

在线尝试！

怎么样？

_‘<×⁸>6 - Link 1, should we eat the praline? row number, triangle size
_       - row number minus triangle size
 ‘      - plus one
  <     - less than triangle size? (1 if one of the last rows else 0)
   ×⁸   - multiply by row number   (row number or 0)
     >6 - greater than 6?          (row number if between row 6 and last two rows)

Rµ‘⁾| ẋ⁾/\ẋ⁸¤ż;/K€µ⁶ðMṀ_6r6ẋð¦"Jç¥ - Link 2, build a solid triangle: triangle size
                                              (except the very bottom row)
R                                  - range: [1,2,...,size]
 µ                                 - monadic chain separation, call that r
  ‘                                - increment: [2,3,...,size+1]
   ⁾| <space                       - literal "| "
      ẋ                            - repeat: ["| | ","| | | ",...]
            ¤                      - nilad followed by link(s) as a nilad:
       ⁾/\                         -   literal "/\"
           ⁸                       -   link's left argument, r
          ẋ                        -   repeat (vectorises): ["/\","/\/\",...]
             ż                     - zip the two repeated lists together: [["/\","| | "],["/\/\","| | | "],...]
              ;/                   - reduce by concatenation: ["/\","| | ","/\/\","| | | ",...]
                K€                 - join with spaces for €ach: ["/ \","|   |  ","/ \ / \","|   |   |  ",...]
                  µ                - monadic chain separation call that s
                                 ¥ - last two links a a dyad:
                               J   -   range(length(s))  
                                ç  -   call the last (1) link as a dyad (left = result of J, right = size)
                              "    - zip with: (call those d)
                    ð       ð¦     -   apply to indexes:
                   ⁶               -   a literal space character
                     M             -     indexes of maximal elements in an element of s (a row)
                      Ṁ            -     maximum (this is the rightmost non-space index, MṀ working like length ignoring trailing spaces)
                       _6          -     subtract 6  (6 indexes back from the right)
                         r6        -     range from there to 6, i.e [l-6,l-7,...,6]
                           ẋ       -     repeat d times (1 or 0), thus applying to the middle rows but not the bottom and top ones.

ḤḶUẋ@€⁶;"ǵ-ịṙ6ṭ⁸Y - Main link: triangle size
Ḥ                  - double(size)
 Ḷ                 - unlength: [0,1,2,...,double(size)-1]
  U                - upend: [double(size)-1,...,2,1,0]
      ⁶            - literal space character
   ẋ@€             - repeat for €ach with reversed arguments ["  ...  ",...,"  "," ",""]
         Ç         - call the last link (2) as a monad(size)
       ;"          - zip with concatenation (zips the leading spaces with the solid triangle body)
          µ        - monadic chain separation, call that t
           -ị      - index -1 (last but one row of t)
             ṙ6    - rotate left by 6 (any number congruent to 2 mod 4 would do)
               ṭ⁸  - tack to t (add this new row on)
                 Y - join all the rows by new lines
                   - implicit print
— 乔纳森·艾伦
source
存在丢失>的解释（<space）
— 罗马格拉夫
@RomanGräf，谢谢，我编辑了说明！如果您的意思不仅仅是“ ẋ说明中的空格未对齐”，请告诉我。
— 乔纳森·艾伦，
1

Mathematica，155个字节

""<>Table[If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]],{j,(d=2#)+1},{i,4#+1}]~Riffle~"\n"&

用\n换行符替换。

更具可读性：

"" <> Table[
    If[i+j < d || i-j > d+1 || 
      i+j > d+5 && i-j < d-3 && j < d-1, " ", 
     Switch[Mod[i+d+{j,-j}, 4], {1, 3}, "/", {3, 1}, 
      "\\", {1, 1}, "|", _, " "]], {j, (d=2#)+1}, {i, 4#+1}]~
   Riffle~"\n" &

创建一个字符数组，水平方向从i到1到4 n +1 索引i，垂直方向从1到2 n +1 索引j。首先，填充一个六边形网格：Switch[Mod[i+d+{j,-j},4],{1,3},"/",{3,1},"\\",{1,1},"|",_," "]

 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ / 
  |   |   |   |  
 / \ / \ / \ / \ 
|   |   |   |   |
 \ / \ / \ / \ /

然后If[i+j<d||i-j>d+1||i+j>d+5&&i-j<d-3&&j<d-1," ",...]将其替换" "为未填充三角形的外部。

— 不是树
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.