画一个大的ASCII X

20

问题

受先前挑战做类似事情的启发

给定正整数输入，n输出将遵循以下模式：

输入n=1：

* *
 *
* *

输入n=2：

**  **
 ****
  **
 ****
**  **

输入n=3：

***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***

等等...

它具有以下属性：

n*2+1 行高

n除了合并时，“手臂”很宽

中心线很n宽

如果n中心上方和下方的线是否n*2宽

如果n是奇数，则中心上方和下方的n*2-1线宽

规则

  • 尾随换行符被接受
  • 适用标准漏洞
  • 最短字节获胜
  • 输出可以打印出来或一个字符串或字符串数​​组

编辑

  • n=0 不需要处理
  • 允许尾随空格
code-golf  string  ascii-art 
— LiefdeWen
source
2
它是好，如果输出具有1替代*和0替代空间？
— JungHwan Min
我们的模式可以索引为0吗？
— Leaky Nun
@JungHwanMin我会允许的，但如果您投票最多，那么您就不会获胜。
— LiefdeWen
@LeakyNun 0索引很好
— LiefdeWen

Answers:

9

木炭，13 12 字节

感谢@ErikTheOutgolfer一个字节

ＦＮ«ＰX⁺*×*Ｉθ→

在线尝试！

这是我有史以来第一个使用木炭的方法，我很确定它的高尔夫球性能不尽人意，但是我认为我会从某个地方开始。

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one
— nmjcman101
source
— 暴民埃里克（Erik the Outgolfer）'17年
@EriktheOutgolfer我知道必须有一种方法！谢谢！
— nmjcman101
是的，它实际上看起来像是打高尔夫球一样。
— 暴民埃里克（Erik the Outgolfer）'17年
@EriktheOutgolfer无论如何你都
— 没来过
1
@thomasrutter Charcoal具有自己的自定义代码页，具有256个字节，其中每个字符均为1个字节。因此，它不是用ASCII编码的，其中某些字符确实是多个字节。nmjcman101 +1 btw。昨天也在尝试我的第一个木炭答案，但在下班回家之前的几分钟内，它并没有真正解决。所以你击败了我。我确实从您的回答中学到了一些东西，所以谢谢。
— 凯文·克鲁伊森
13

MATL，16字节

EQXyG:Y+tP+g42*c

在线尝试！

说明

以输入2为例。堆栈内容如下所示。

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']
— 路易斯·门多
source
你比我快...
— Leaky Nun
@LeakyNun很少:-)
— Luis
我希望Jelly具有2D卷积...我必须在每行中附加0，然后应用矢量化总和...
— Leaky Nun
1
@LeakyNun你知道他们对卷积怎么说……
— Luis
1
@LuisMendo在我心中，您是使用卷积的赢家，带回了如此美好的回忆。
— LiefdeWen
9

果冻，15字节

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

在线尝试！

— 暴民埃里克
source
非常好。比我少8个字节。
— Leaky Nun
@LeakyNun直截了当的方法很有帮助。
— 暴民埃里克（Erik the Outgolfer）
一个非常好的方法
— Jonathan Allan
@JonathanAllan是的，特别是tfw，您学习»vectorizes的方法
— Outgolfer的Erik
1
我真的很喜欢您的用户名！但我希望您改用“ vi”或“ vim”，所以您可以选择“ Erik the vi King” ...（这里是Monty Python迷...）
— Olivier Dulac
4

V，18 17字节

感谢@DJMcMayhem的输入技巧，节省了一个字节。

Àé*ÄJÀälÀñ2ÙÀl2x>

在线尝试！

说明

Àé*ÄJÀäl

这插入 [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

缓冲区从中循环的每次迭代

|**   ***

至

***   ***
 |** ***
***   ***

哪里|是光标用*其下

— nmjcman101
source
哇。你waaay outgolfed我。做得好！一些提示：您可以Àé*ÄJÀäl代替Àá*Àá Àá*，可以做<M-c>，即ã（mnemonic：center）移至行的中间，比行短一字节Àl。在线尝试！
— DJMcMayhem
@DJMcMayhem我想在许多不同的地方与您交谈。我会窃取我认为的第一个建议，但会<M-c>中断更高的数字
— nmjcman101
3

05AB1E，18个字节

Å4bS{I·ƒDÂ~„ *èJ,À

在线尝试！

说明

范例 n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left
— 艾米尼亚
source
3

V，23个字节

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

在线尝试！

十六进制转储：

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

无论出于何种原因，在V语言中，这一挑战比上一个挑战要困难得多。由于我们一般的方法是n倍，因此在此处无法生成'x'，因此我们将构造X的顶部，将其复制并翻转，然后将两个部分连接在一起。

说明：

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

在循环的最后进行缩进，使我们能够利用隐式结尾。这也方便地创建n + 1行，恰好是“ X”的上半部分。假设输入为4。此时，缓冲区如下所示：

****    ****
 ****  ****
  ********
   ******
    ****

我们在最后一行。因此，我们：

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process
— DJMcMayhem
source
我也ãxx刚开始做这件事，但我认为它会中断，例如n = 8？
— nmjcman101
@ nmjcman101啊，你是对的。如果您这样做ãl，或者在居中之前先缩进就可以了，但这实际上并没有节省任何字节。我不明白为什么它适用于较小的数字。
— DJMcMayhem
3

C＃，139130115字节

通过创建字符串并调用-1字节WriteLine，从而保存对新行的检查。
-6个字节感谢Kevin和他的高手高尔夫技术！
-2通过替换字节n*3-n用n*2。
凯文（Kevin）友好地向我指出了-15个字节：我可以返回字符串而不是打印它，从而将调用保存到System.Console.WriteLine()。还有其他一些提示...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

在线尝试！

取消高尔夫：

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

它只是沿着打印大X所需的空间的行和列进行迭代，并根据条件打印a '*'或a ' '。

— 查理
source
1
+1！打高尔夫球的一些小东西。在这种情况下，所有&&可以&并且||可以是|。for(int j=0;可以是for(int j=0,i;然后可以删除int 在前面的i在内部循环。此外，在第一次更改&和之后|，您还可以删除i++for循环内部的内容，并将其更改i==n*3-1?...为i++==n*3-1?...。
— 凯文·克鲁伊森 Kevin Cruijssen）
@KevinCruijssen非常感谢！我更改了内部循环，现在创建了一个字符串，以便可以调用WriteLine，只保存了1个字节。因此，现在我不确定如何处理您的最后建议。
— 查理
1
顺便说一句，为什么System.Console.WriteLine？返回字符串：n=>{string s="";for(int i,j=0;j<n*2+1;j++,s+="\n")for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>n*2-j-1?'*':' ';return s;}较短[ 120个字节 ]（并且通过将所有内容放入for循环中也消除了括号。这是一个TIO链接，以显示其工作原理。此外，请随意添加此字符串（或您自己的字符串）
— TIO-
1
@KevinCruijssen我不知道TIO可以处理C＃代码！我WriteLine在代码中添加了代码，因为OP要求输出大X，而不仅仅是返回它，所以我认为X的输出（通过调用WriteLine方法）应该是代码的一部分。但是，我仍然不习惯于代码高尔夫球规则，并且我不知道编写代码时可以获得哪些许可。我刚刚看到这里的其他一些答案在代码中打印X，而另一些答案在页脚中打印。在这种情况下有效的方法是什么？
— 查理
1
除非另有说明，否则通常默认情况下通常允许返回字符串以及使用函数而不是程序。另外，在该问题中，其状态为“ 输出可能已打印输出或字符串或字符串数​​组 ”，因此允许返回字符串。:)哦，还有您可以打高尔夫球的最后一件事：j<n*2+1可以j<=n*2。我还用相同的字节数为您的答案创建了一个Java 8端口，这当然给您带来了惊人的答案。
— Kevin Cruijssen
3

Haskell，88 87 86字节

-1感谢@Laikoni 

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

在线尝试！

— 酒标
source
1
zipWith max m(reverse m)可以缩短为zipWith max(reverse m)m。这与相同zipWith max=<<reverse$m，然后m可以内联：在线尝试！
— Laikoni
2

MATLAB，153126字节（17.6％↓）

感谢@LuisMendo的注释，函数disp()可以输出不带单引号的字符，因此我可以防止使用fprintfwith formats并省略一些字节。此外，他的评论提醒我，我需要使用char(32)一个空格而不是char(0)（null）。 

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

在线尝试！

MATLAB，153个字节

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

结果示例：n = 10

**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********
— 秦国阳
source
2

Python 2中，93个 90 89 83字节

-3个字节，感谢Leaky Nun
-1个字节，感谢Zachary T
-6个字节，感谢xnor 

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[在线尝试！] [TIO-j3xwsktf]

以'*** 'for 开头的字符串开始n=3，适用map/max于在*每个位置上选择空格，然后添加空格并从字符串中删除最后一个字符，然后再次执行所有操作。

— 竿
source
— Leaky Nun
您不能替换n*2*' '为n*' '吗？
— 扎卡里
该map(max可直接没有完成zip。另外，n*2+1是n-~n。
— xnor
1

Haskell，70个字节

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

在线尝试！

输出字符串列表。

对于行r，列的每个位置c，使用一个公式确定它是否落在两个对角线带之一内*。

— 异或
source
1

使用Javascript（ES2017），155个 157字节

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

返回字符串数组。我对数组执行操作，然后对其进行镜像。可以像其他答案一样使用矩阵对它进行优化，但我想保持独特。

编辑：正如Neil所指出的那样，对于的偶数值n，中心线并不n宽，因此我在对列进行切片时添加了一个模数以检测偶数/奇数。

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

不打高尔夫球

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

象限

n=5
   *****
  ***** 
 *****  
*****   
****    
***

水平镜像

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****

垂直镜像

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****
— 安德烈·沃基
source
甚至会产生错误的输出n-中心线不n宽。
— 尼尔
0

Mathematica，148个字节

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&
— J42161217
source
0

R，102字节

码：

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

测试：

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********
— 朱里奥
source
0

CJam，24个字节

{:T2*){S*T'**+}%_W%..e>}

这是一个从堆栈中获取数字并将行列表输出到堆栈的块。

说明：

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End
— 硕果累累
source
0

Python 2，110个字节

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

该程序将每行分成4个部分，第一个空格，第一个星星，第二个空格，然后第二个星星。对于X的每个水平线，它计算该线的4个部分中的每个部分需要多少个星星或空格，然后构造并打印该字符串。

— 雅各布洛
source
0

视网膜，144字节

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

在线尝试！说明：

.+
 $&$* $&$* $&

在输入值之前添加2n + 1个空格（每个输出行一个空格）。

$`#$'¶

用a替换每个空格#并收集结果。这给出了一条#s 的对角线，在两侧填充了空格，输入值带有后缀。

¶\d+$

删除原始输入值，因为现在每行都有一个副本。

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

建立两条n *s的对角线，并将分隔符列n包裹在一对#s中。

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

在*s靠近中间的那些线上，将两半交换。这给出了类似的外观> | | <。

+` (# +#)
$1

将| |s移到最左端，看起来>> > <很像。

+` #...
#

对于#s 之间的每个空格，删除以下三个字符。该加入> <到X。

##

删除现在不必要#的。

— 尼尔
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.