这只是一个错误

76

受到@Carcigenicate的Clojure回答中的错误输出启发，以回答 “ 打印此钻石”挑战。

打印此确切的文本：

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

（从两个方向的中间向外，每个数字比前一行多一个空格。）

挑战规则：

  • 将没有输入（或空的未使用输入）。
  • 尾随空格是可选的。
  • 一条尾随的换行符是可选的。
  • 不允许前导空格或换行符。
  • 不允许返回字符串数组。您应该输出文本，或者具有返回正确结果的单个字符串的函数。

通用规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。您的来电。
  • 默认漏洞是禁止的。
  • 如果可能的话，请添加一个带有测试代码的链接。
  • 另外，如有必要，请添加说明。
code-golf  ascii-art  number  kolmogorov-complexity 
— 凯文·克鲁伊森
source
是否输出字符串数组（每行1个字符串）？
— 毛茸茸的
@Shaggy抱歉，在这种情况下，它应该返回带有换行符的单个字符串，或者输出结果。我已将此规则添加到挑战中。
— 凯文·克鲁伊森
凯文，别担心。只是着胳膊看看我是否可以自己节省几个字节。
— 毛茸茸的
3
@蓬松的呵呵。除了保存那几个字节的目的之外，在代码高尔夫球挑战中我们还必须问什么其他原因？;）
— Kevin Cruijssen
8
哈，太棒了。我想知道为什么这个答案突然引起如此多的关注。谢谢！
— Carcigenicate

Answers:

7

SOGL V0.12，12个字节

9{SUē↕∑}¹№╬«

在这里尝试！ 说明：

9{     }      9 times do
  SU            push "1234567890"
    ē           push e, predefined with the input, which defaults to 0, and then increase it
     ↕          get that many spaces
      ∑         join the string of digits with those spaces
        ¹     collect the results in an array
         №    reverse the array vertically
          ή  palindromize vertically with 1 overlap
— 宰马
source
哦，很好，这比接受的答案还要短。嗯，在答案被接受后的几个月内，对较短答案的政策是什么？现在是否可以获得支票（对我认为当前接受的答案有点不公平），还是我应该做其他事情？好的答案无论如何！向我+1。
— 凯文·克鲁伊森
@KevinCruijssen通常，最佳实践是更新已接受的答案，但是由于它使用了几个新功能，因此我想有两种选择的理由-您可以选择。
— dzaima
62

Python 2中，59个57 56 55字节

i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17

在线尝试！

@Leaky Nun帮助了很多高尔夫运动，@ Praind建议了一种保存1字节的方法，我以前曾想过，但是却忘记了编辑，@ CotyJohnathanSaxman建议更改循环。

说明

  • i=8-将值分配8给名为的变量i。

  • exec"..."*17-执行该代码块（...）17次。

  • print(...) -输出结果。

  • ' '*abs(i)-创建一个带有重复空格的字符串|i|。

  • .join('1234567890')-用交织上面创建的字符串1234567890，以便|i|在数字之间插入空格。

  • i-=1-递减i，并执行17次，达到-8它，在的帮助下创建重复的模式abs()。

— Xcoder先生
source
5
— Leaky Nun
23
这个农场比任何高尔夫语言恕我直言的25字节都要令人印象深刻。
— Jylo
4
@Jylo谢谢，但是25个字节的解决方案令人印象深刻，因为它们显示了作者所做的大量高尔夫工作。您首先应该知道其来源中每个角色的含义，然后您将了解他们打高尔夫球的方式多么漂亮。
— Xcoder先生17年
2
@JasonChen不，Python不允许该语法，因为它特定于类C语言。
— Xcoder先生17年
5
可能的启发：exec 甚至可以不占用55个字节。使用类似的方法将Python 3压缩到57个字节。没有看到任何明显的方法来缩短它的长度（通过省略）exec，但是我认为这是一种可能。
— ShadowRanger
32

Vim，35个字节：

i1234567890<esc>qqYP:s/\d/& /g
YGp{q7@q

说明：

i1234567890<esc>    " insert '1234567890'
qq                  " Record the following into register 'q'
  Y                 "   Yank a line
   P                "   Paste it above us
    :s/\d/& /g      "   Put a space after each number
Y                   "   Yank this line
 G                  "   Move the end of the buffer
  p                 "   Paste the line
   {                "   Move the beginning of the buffer
    q               " Stop recording
     7@q            " Call macro 'q' 7 times
— DJMcMayhem
source
6
我什至不在乎这不是赢家，它很漂亮。
— MrDuk '17
@MrDuk谢谢！我很高兴您喜欢它：)
— DJMcMayhem
21

05AB1E， 14  13字节

17F9ÝÀN8αð×ý,

在线尝试！

说明

17F            # for N in [0 ... 16] do
   9Ý          # push [0 ... 9]
     À         # rotate left
      N8α      # compute the absolute difference between N and 8
         ð×    # push that many spaces
           ý   # merge the list of digits with the space string as separator
            ,  # print
— 艾米尼亚
source
1
嗯...如果您不需要...，您可能已经击败了SOGL s...将一个字符串与一个列表或一个字符串与列表连接是否有意义？我会建议对Adnan进行改进。哦，还有.∊对û»。
— 暴民埃里克'17
@EriktheOutgolfer：或者，我可以切换方法并保存我需要的1个字节：）
— Emigna
对不起，已经投票了。
— 暴民埃里克（Erik the Outgolfer）'17年
3
这意味着我会再次投票……
— 暴民埃里克（Erik the Outgolfer）
4
8F9ÝÀNð×ý}».∊我确实做了一个飞船的花胶！我对建议进行12字节的编辑感到非常兴奋。
— 魔术章鱼缸
20

C64 ASM，358个字节（102个字节，使用basicstub编译）

由于明显的限制，这是我能得到的最接近的值：

C64

jsr $E544
lda #9
sta $FD
nl1: jsr dl
jsr il
dec $FD
bne nl1
inc $FD
nl2: ldy $FD
cpy #9
bne nt1
bl: jmp bl
nt1: iny
sty $FD
jsr dl
jsr il
jmp nl2
dl: clc
ldx #$31
ldy #0
lp: txa
sm: sta $0400, y
inx
cpx #$31
bne c1
rts
c1: cpx #$3A
bne nt2
ldx #$30
clc
nt2: tya
adc $FD
cmp #40
bcc c2
rts
c2: tay
jmp lp
il: lda sm+1
adc #39
bcc nc
inc sm+2
nc: sta sm+1
rts

（可能会进行很多优化）

— 木偶3
source
欢迎来到PPCG！请使用代码标签发布漂亮。我编辑了你的帖子。更改应用后，你可以看到，通过点击编辑有什么改变
— ЕвгенийНовиков
我刚刚检查了一下，它甚至不适合80列的PET，因为第一行和最后一行需要82列。
— Shaun Bebbers
17

TSQL，220个 148字节的

ZLK发布的改进：

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+'
'FROM sys.objects PRINT @

输出：

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
— 扬·德罗森（Jan Drozen）
source
DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+' 'FROM sys.objects PRINT @
— ZLK
用和替换sys.objects为sysobjects1object_id`，id我在sys模式中寻找较短的表，但没有什么短的列如此短sysobjects
— Jaloopa
您还可以通过将内部CAST（带有POWER(10)）更改为VARCHAR
— Jaloopa
实际上，请避免使用LOG10和替换所有东西REPLICATE：DECLARE @o VARCHAR(MAX)=''SELECT TOP 17 @o+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',replicate(' ',LOG10(POWER(10,ABS(ROW_NUMBER()OVER(ORDER BY id)-9)+1)/10)))+' 'FROM sysobjects PRINT @o
— Jaloopa
您可以将变量名称更改为仅@剃除3个字符。
— 桥
14

APL（Dyalog），22字节

↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D

在线尝试！

⎕D 数字从零到九

1⌽ 向右旋转一步（结束时置零）

⊂ 封闭（视为单位）

(… )↑¨¨ 对于每个数字，请从每个字母中提取那么多字符：

 ⍳17 一到十七

 ¯9+ 减去九

 | 找出绝对值

 1+ 加一

∊¨ 分别招募（拼合）

↑ 将一层深度更改为等级（matrify）

— 亚当
source
3
在像这样的紧凑语言中，认真地需要两个字节加一个吗？
— aschepler
3
@aschepler是的。APL不是一种高尔夫语言，并且没有增量原语。J可以，但是需要两个字节；>:。
— ADAM
4
APL is not a golfing language…… ↑⊃¨,/¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕Dಠ_ಠ–
— 亚历山大
1
@Alexander感谢您再次关注此话题。我可以打3个字节。
— 2015年
12

Java 11（JDK），98个字节

o->{for(int i=-9;++i<9;)System.out.println("".join(" ".repeat(i<0?-i:i),"1234567890".split("")));}

在线尝试！

  • 通过切换到现在具有native的JDK 11，可以减少-14个字节String::repeat。

上一个答案（Java（OpenJDK 8）），113112字节

o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}

在线尝试！

说明

我基本上在构造以下String17次（N是变量，而不是实际值）：

"1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n"

这是所有期望的数字，%1$Ns其中where N是每个数字之间的空格数。

%1$Ns基本上意味着“采用第一个参数并将其填充到长度至少为N”。此外，%1$0s不支持这样一个特殊的情况下%1$s被用于制成0。

最后，我使用一个参数""格式化该字符串：因此，格式化程序将始终重复使用相同的空字符串，并根据需要在其中填充空格。

节省

  • 1个字节，感谢Kevin Cruijssen
— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
2
好答案！顺便说一句，我明确地在未使用的空参数允许的挑战所提到的，这样你就可以替换()->使用o->，以节省一个字节。：）
— 凯文·克鲁伊森
你可以做o的int，并用它在你的循环？for(o=-9;++o<9;)
— 年
2
@Winter否，因为质询提示“ 未使用 ”，并且即使不使用该值也将使用参数变量。
— 奥利维尔·格雷瓜尔
@OlivierGrégoire它链接到此代码codegolf.meta.stackexchange.com/questions/12681/…，并且该帖子仅说应为空（整数为0）。
— 年
@Indeed确实如此，但是挑战本身说“未使用”。挑战中的特定裁定推翻了违约。
— 奥利维尔·格雷戈尔
11

Japt -R，19 18 16 14 13字节

Aõ%A
£qYçÃÔÅê

测试或在线尝试

说明

A             :10
 õ           :Range [1,10]
  %A         :Modulo each by 10
\n           :Assign to variable U
£            :Map each element at 0-based index Y
 q           :  Join U with
  Yç         :   Space repeated Y times
    Ã        :End map
     Ô       :Reverse
      Å      :Slice off first element
       ê     :Mirror
             :Implicitly join with newlines and output
— 毛茸茸
source
2
真好 我的16字节解决方案是9ÆAõ%A qXîÃw ê ·
— ETHproductions'Jul 3'3
8

JavaScript（ES2017），83 73 72 68字节

感谢Shaggy保存10个字节。感谢Craig保存1个字节。感谢弧节省了4个字节。

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))


for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

console.log(a);
.as-console-wrapper { max-height: 100% !important; top: 0; }
.as-console-row:after { display: none !important; }
展开摘要

— 杜沙尔
source
通过使用polyfill保存1个字节Math.abs。我还对a列表进行了硬编码，但这是优先选择……a=[...Array(10).keys()];for(i=-8;i<9;i++)console.log(a.join(' '.repeat(i<0?-i:i)))
— Thomas W
1
使用[..."1234567890"].join("".padEnd(i<0?-i:i))
— Shaggy'17
@粗野的谢谢。节省了10个字节。:)
— Tushar
1
@ThomasW：[...Array(10).keys]将0作为第一个元素，而不是最后一个。
— 毛茸茸的
1
您可以使用将结果存储在字符串中而不是使用日志记录的方法来保存字节：for(i=-8,s="";i<9;i++)s+=[..."1234567890"].join("".padEnd(i<0?-i:i))+`X`，其中X是实际的换行符
— Craig Ayre
7

Brachylog，30 29 28字节

Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ

在线尝试！

多亏Leaky Nun节省了一个字节。

说明

Ị↺                               The string "1234567890"
  {               }ᶠ⁹            Find the first 9 outputs of:
   ∧≜                              Take an integer
       ;Ṣj₍                        Juxtapose " " that number of times
           g;?↔z                   Zip that string of spaces with "1234567890"
                cc                 Concatenate twice into one string
                    ↔            Reverse the resuling list
                     ;XcP↔P      Palindromize the list (concatenate X to it into the list P,
                                   P reversed is still P)
                           ẉᵐ    Map writeln
— 致命
source
2
— Leaky Nun
@LeakyNun我被困在大型“打印此确切的文本”上，却没有读到我们可能会有尾随线……
— Fatalize
4
— Leaky Nun
1
@LeakyNun为什么不发布自己的答案？
— 致命
7

木炭，18字节

Ｆ⁹⪫⁺…Ｉ¹:⟦0¶⟧× ι‖Ｂ↑

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

Ｆ⁹      Repeat 9 times (i = loop variable)
  ⪫       Join
   ⁺       Concatentate
    …Ｉ¹:    All the characters from str(1) below ":" (i.e. to "9") as a list
    ⟦0¶⟧    A list whose element is the string "0\n"
   × ι     With i spaces
‖Ｂ↑     Reflect everything upwards but without duplicating the top line

注意：Cast(1)占用相同数量的字节，因为"1"在":"此之前需要一个分隔符（实际上，副声音分隔符无法插入）。

— 尼尔
source
7

R，108个字节

for(i in abs(-8:8))cat(paste0(el(strsplit("1234567890","")),paste(rep(" ",i),collapse=""),collapse=""),"\n")

只是粘贴和折叠琴弦。

在线尝试！

编辑：感谢Challenger5指出了一个问题。立即修复。

编辑2：由于有弹力球，节省了一个字节。

— 宝宝
source
欢迎光临本站！:)
— DJMcMayhem
2
这看起来不太正确-中线根本不应该有任何空格。
— 硕果累累
@ Challenger5你是对的！通过使用paste0而不是paste必须添加一个字节来修复它：(
— Probel
1
使用el：el(strsplit("1234567890",""))而不是strsplit("1234567890","")[[1]]
— bouncyball
您可以paste通过使用sep参数to来摆脱其中的一条语句，cat并多做一些操作以使其达到70字节
— Giuseppe
7

Python 3中，58个 57 54字节

i=8
while i+9:print(*'1234567890',sep=' '*abs(i));i-=1

在线尝试！

（感谢@flornquake最后三个字节;我完全忘了使用sep，以节省对.join）

— 暗影游侠
source
1
54个字节：while i+9:print(*'1234567890',sep=' '*abs(i));i-=1
— flornquake
6

Java的8，235个 234 206 163字节

interface A{static void main(String[]a){for(int i=-8;i<9;i++){String s="";for(int j=1,k;j<10;j++){s+=j;for(k=0;k<(i>0?i:-i);k++)s+=" ";}System.out.println(s+0);}}}

更新：-28字节感谢Leaky Nun！
更新2：-43字节再次感谢Leaky Nun！

松散

interface A {
    static void main(String[] a) {
        for (int i = -8; i < 9; i++) {
            String s = "";
            for (int j = 1, k; j < 10; j++) {
                s += j;
                for (k = 0; k < (i > 0 ? i : -i); k++)
                    s += " ";
            }
            System.out.println(s + 0);
        }
    }
}

在线尝试

编辑：之前的代码是错误的！打高尔夫球时犯了一个错误，现在应该可以正常工作了！

— 亚历克斯·费雷蒂
source
4
欢迎来到PPCG！阅读Java 技巧和<所有语言>技巧可能很有趣。:)您可以打高尔夫的某些事情是删除public，并摆脱了一些不必要的空间。还有很多需要改进的地方，但我建议您通读提示，并了解可以改进的地方。再次欢迎您，并祝您逗留愉快！:)
— Kevin Cruijssen'7
2
嗯，您确定输入的代码正确吗？当我将您的代码复制粘贴到TryItOnline时，它不会提供正确的输出。
— 凯文·克鲁伊森
1
噢，该死，打高尔夫球的代码时我做错了！我会解决这个问题！
— Alex Ferretti
1
— 漏嫩
1
— Leaky Nun
6

外壳，21字节

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9

这是一个完整的程序，可以打印到STDOUT。 在线尝试！ 有很多尾随空格。

说明

Husk仍然缺少许多重要的东西，例如两个参数的范围函数，因此此解决方案的某些部分有些笨拙。

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
              ṁs`:0ḣ9  This part evaluates to the string "1234567890".
                   ḣ9   Range from 1 to 9.
                `:0     Append 0.
              ṁs        Convert each number to string and concatenate.
     §+↔tḣR8'          This part evaluates to a list like ["  "," ",""," ","  "]
                       but with 17 elements instead of 5.
          R8'           A string of 8 spaces.
         ḣ              Take prefixes.
     §+                 Concatenate
       ↔                the reversal and
        t               tail of the prefix list, palindromizing it.
  Ṫ                    Take outer product of the two lists
   `:                  with respect to flipped prepeding.
                       This prepends each digit to each string of spaces.
mΣ                     Map concatenation over the results, computing the rows.
                       Implicitly join with newlines and print.
— 兹加布
source
您可以替换ṁs`:0ḣ9为uṁsḣ10以更少的字节生成字符串“ 1234567890”！
— Sophia Lechner
6

T-SQL 145个152字节

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @

更新为使用：

  • master..spt_values生成数字（WHERE type = 'P'，这些数字始终是连续的，从0开始）
  • @ZLK的TOP 17想法
  • 打印（遵守规则-没有字符串列表）
  • @JanDrozen的好主意是在字符串中包含回车符（我认为这只是一个字节-Windows CRLF是什么？）
  • @Bridge仅将@用作变量名的想法-所有这些技巧!!

结果：

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

（感谢@JanDrozen的REPLACE想法）

— 逆向工程师
source
这是一个很好的答案！欢迎来到该网站：)
— DJMcMayhem
谢谢。我看到我们中的一些人在这里发明了自己的语言：）
— 逆向工程师
1
此答案与另一个答案之间的最佳组合是最佳的：例如SELECT TOP 17REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))FROM sys.objects（假设您不需要打印）。
— ZLK
啊哈@ZLK-一些不错的技巧-TOP 17，RANK OVER和sys.objects-谢谢！
— 反向工程师
6

Clojure，126个 99字节

-27解决了一些愚蠢的错误。a不需要外部使用，因此我完全可以摆脱，a只写apply str一次。这也使我可以将函数宏用于主函数，从而节省了一些字节。我还内联了，Math/abs而不是重新绑定n-spaces。

基本上是@ Mr.Xcoder的Python想法的Clojure端口。回想起来，我本来应该使用abs/ range方法来进行钻石挑战，但是那时我可能没有产生错误的输出！

很简单 用取决于当前行的多个空格连接数字字符串。

#(doseq[n(range -8 9)](println(clojure.string/join(apply str(repeat (Math/abs n)\ ))"1234567890")))
(defn bugged []
  (doseq [n-spaces (range -8 9)]
    (println
        (clojure.string/join
          ; "String multiplication"
          (apply str
                 (repeat (Math/abs n-spaces) \space))
          "1234567890"))))
— 致癌物质
source
5

Mathematica，92个字节

Column@Join[Reverse@(s=Row/@Table[Riffle[Range@10~Mod~10,""<>Table[" ",i]],{i,0,8}]),Rest@s]

在线尝试

使用ctrl-v复制/粘贴代码，
按shift + enter运行

— J42161217
source
您能否添加一个TryItOnline链接？
— 凯文·克鲁伊森
@KevinCruijssen Mathematica不是免费的语言，并且Mathics似乎不起作用。
— Leaky Nun
@LeakyNun好的，谢谢。我有时会看到MartinEnder发布TIO链接，但这些确实是Mathics链接。
— 凯文·克鲁伊森'17
1
@Kevin Cruijssen是的，当然，我添加了说明链接
— J42161217 '17
5

C，97字节

i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}

您的编译器可能会对此代码抱怨很多。我发出了4种不同类型的7条警告。以后可能会改进代码。

在线尝试！

— 汤姆森
source
5

C（gcc），76个字节

f(x,y){for(y=-9;++y<9;puts(""))for(x=10;x++;printf("%-*d",abs(y)+1,x%=10));}

在线尝试！

它输出一些尾随空格，应该可以。

它使用左对齐的动态长度字段来打印数字，这就是格式字符串%-*d的用途。

内部循环具有一些有趣的初始化（从10开始； 10的任何倍数都可以）来“简化”其终止条件。

— 阿纳托利格
source
4

木炭，21 20 19 18字节

Ｆ⁹«Ｆ…¹χ⁺κ… ι0⸿»‖Ｂ↑

在线尝试！

链接到详细版本。基本上，我创建图形的下部，然后将文本向上反射。

— 查理
source
1
当我看到问题时，虽然我会先在木炭中尝试一下，然后再看答案。我从一个21字节的答案开始，但打到20字节……令人毛骨悚然！
— 尼尔
@Neil :-D好，现在是19个字节！
— 查理
是的，我才发现自己打高尔夫球。我也正在调查Ｅ…⁹⪫Ｅ…·¹χＩ﹪κχ× ι‖Ｂ↑（也为19个字节），但是解释器似乎并不喜欢它（我自己看不出问题出在哪里）。
— 尼尔
哦，Range有两个论点，愚蠢的我。
— 尼尔
1
原来Map是鲱鱼，所以我现在发布了18字节的答案。
— 尼尔，2017年
4

CJam，21个字节

A,(+aH*ee{:\8-zS**n}/

在线尝试！

说明

A,     e# Get [0 1 2 ... 9].
(+     e# Rotate the 0 to the end.
aH*    e# Wrap in an array and repeat 17 times.
ee     e# Enumerate. This pairs each copy of the array with its index in
       e# the list.
{      e# For each [index array] pair...
  :\   e#   Unwrap the pair and swap its order.
  8-z  e#   Get the absolute difference of the index from 8.
  S*   e#   Get a string of that many spaces.
  *    e#   Riffle the list of digits with the string of spaces.
  n    e#   Print it with a trailing linefeed.
}/
— 马丁·恩德
source
1
替代解决方案（也为21个字节）：9{S*A,(+\*}%_W%);\+N*
— Esolanging Fruit
4

批次，163字节

@set s=1 2 3 4 5 6 7 8 9 0
@set t=         
@for %%l in (9 7)do @for /l %%i in (1,1,%%l)do @call:%%l
:7
@set t=  %t%
:9
@set t=%t:~1%
@call echo %%s: =%t%%%

注意：第一行以9个空格结束。说明：使用广告素材行号！第一个循环需要运行9次并每次删除一个空格，而第二个循环则需要运行8次并每次添加一个空格。前者是通过运行7次并掉落第8次来实现的，而后者是通过添加两个空格并掉回以再次删除其中一个来实现的。

— 尼尔
source
4

SOGL V0.12，14个字节

ā9{SUčf@*∑Κ}╬Æ

在这里尝试！

说明：

ā               push an empty array
 9{        }    9 times do
   SU             push "1234567890"
     č            chop into characters
      f@*         get current iteration (0-based) amount of spaces
         ∑        join with that
          Κ       prepend this to the array
            Β  palindromize vertically with 1 overlap
— 宰马
source
4

PowerShell，30字节

8..0+1..8|%{1..9+0-join' '*$_}

在线尝试！

构造一个范围，8,7,6...2,1,0,1,2...8然后遍历每个数字。在循环内部，我们构造了一个1..9级联的范围，0然后-join将该范围内的数字以及适当的空格数进行了级联。每个字符串都留在管道上，并且在程序完成时隐式输出。

— AdmBorkBork
source
1
好答案！Powershell突然感觉更像高尔夫球了：)
— Xcoder先生17年
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.