挑战：

输入：正整数 $n$

输出：

在 $[1,n]$ 范围内创建一个列表，并将其连接到一个字符串（即 $n=13$ 将是字符串12345678910111213）。

现在，根据输入整数，使用以下字符串的四个方向之一，使用此字符串的前缀或后缀输出三角形：

如果，将其输出为三角形◣ $n\equiv 0\pmod 4$
如果，将其输出为三角形◤ $n\equiv 1\pmod 4$
如果，将其输出为三角形◥ $n\equiv 2\pmod 4$
如果，将其输出为三角形◢ $n\equiv 3\pmod 4$

例：

输入： $n=13$

因为，所以形状为◤。这里是三个可能的有效输出： $13\equiv 1\pmod 4$

12345678910111213    11111111111111111    12345678910111213
1234567891011121     2222222222222222     2345678910111213
123456789101112      333333333333333      345678910111213
12345678910111       44444444444444       45678910111213
1234567891011        5555555555555        5678910111213
123456789101         666666666666         678910111213
12345678910          77777777777          78910111213
1234567891           8888888888           8910111213
123456789            999999999            910111213
12345678             11111111             10111213
1234567              0000000              0111213
123456               111111               111213
12345                11111                11213
1234                 1111                 1213
123                  222                  213
12                   11                   13
1                    3                    3

挑战规则：

正如您在上面的三个有效输出中所看到的，只有正确的形状和以正确的顺序使用所有数字很重要。除此之外，您可以自由使用前缀或后缀；反转/反射；对角印刷允许每种形状有六个可能的输出中的任何一个（请参见下面的测试案例，以查看基于该形状的所有有效输出）。这允许具有内置旋转功能的语言使用它，但是没有旋转功能的语言也可以使用另一种方法，即使用从上到下的正确大小的前缀，或者对两个形状使用前缀，而对其他两个形状使用后缀。为您的语言选择最合适的输出选项是高尔夫过程的一部分。:)
输入保证为正整数。对于我们仅输出。 $n=1$ 1
只要在屏幕上的某处打印正确的三角形（没有垂直或水平定界符！），就可以使用任何数量的前导/后跟换行符/空格。

一般规则：

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

测试用例：

输入：所有可能的有效输出： $n=5$

12345    54321    12345    54321    11111    55555
1234     5432     2345     4321     2222     4444
123      543      345      321      333      333
12       54       45       21       44       22
1        5        5        1        5        1

输入：所有可能的输出： $n=6$

123456    654321    123456    654321    111111    666666
 12345     65432     23456     54321     22222     55555
  1234      6543      3456      4321      3333      4444
   123       654       456       321       444       333
    12        65        56        21        55        22
     1         6         6         1         6         1

输入：所有可能的输出： $n=7$

      1          1          7          7          7          1
     12         21         67         76         66         22
    123        321        567        765        555        333
   1234       4321       4567       7654       4444       4444
  12345      54321      34567      76543      33333      55555
 123456     654321     234567     765432     222222     666666
1234567    7654321    1234567    7654321    1111111    7777777

输入：所有可能的输出： $n=8$

1           1           8           8           8           1
12          21          78          87          77          22
123         321         678         876         666         333
1234        4321        5678        8765        5555        4444
12345       54321       45678       87654       44444       55555
123456      654321      345678      876543      333333      666666
1234567     7654321     2345678     8765432     2222222     7777777
12345678    87654321    12345678    87654321    11111111    88888888

输入：仅可能的输出： $n=1$

输入：所有可能的输出： $n=2$

12    21    12    21    11    22
 1     2     2     1     2     1

— 凯文·克鲁伊森
source

我们可以将其他值用于不同的三角形，例如1表示◤等吗？

— 无知

@EmbodimentofIgnorance不幸的例子，因为这就是规范所说的。我想您想问一下，只要我们保持一致，我们是否可以更改这四种安排的顺序（我认为那不是）。

— 暴民埃里克

1

如果为n==13，最上面的行可以是'33333333333333333'（或等效地'31211101987654321'）吗？

— Chas Brown

@EmbodimentofIgnorance对不起，但在这种情况下我拒绝。形状及其对应的形状mod 4是应对这一挑战的严格对。因此，您可能无法在四种mod 4情况下切换四种形状。但是，好问题仍然存在。

— 凯文·克鲁伊森

@ChasBrown是的，两个都很好。对于，我仅给出了三个可能的示例，但是所有六个选项（如测试用例）都是有效的输出。

n = 13

$n=13$

n = 5

$n=5$

— 凯文·克鲁伊森

9

JavaScript（ES6）， 93 89字节

返回字符矩阵。

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((d,y,a)=>a.map(_=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

在线尝试！

备用图案（相同大小）：

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((_,y,a)=>a.map(d=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

在线尝试！

已评论

n =>                 // n = input
  [...               // split the result of ...
    ( g = n =>       //   ... a call to the recursive function g, taking n
      n ?            //     if n is not equal to 0:
        g(n - 1)     //       append the result of a recursive call with n - 1
        + n          //       append n
      :              //     else:
        ''           //       stop recursion and return an empty string
    )(n)             //   initial call to g
  ].map((d, y, a) => // for each digit d at position y in this array a[]:
    a.map(_ =>       //   for each character in a[]:
      y -            //     we test either y < 0 if (n AND 2) is not set
      (n & 2)        //     or -y < 0 (i.e. y > 0) if (n AND 2) is set
      * y-- < 0      //     and we decrement y afterwards
      ?              //     if the above condition is met:
        ' '          //       append a space
      :              //     else:
        d            //       append d
    )                //   end of inner map()
  )                  // end of outer map()
  .sort(_ => -n % 2) // reverse the rows if n is odd

形状摘要

以下是每个的基本形状（由嵌套map循环生成）和最终形状（在之后sort）的： $n\bmod 4$

 n mod 4  | 0     | 1     | 2     | 3
----------+-------+-------+-------+-------
 n & 2    | 0     | 0     | 2     | 2
----------+-------+-------+-------+-------
 test     | y < 0 | y < 0 | y > 0 | y > 0
----------+-------+-------+-------+-------
 base     | #.... | #.... | ##### | #####
 shape    | ##... | ##... | .#### | .####
          | ###.. | ###.. | ..### | ..###
          | ####. | ####. | ...## | ...##
          | ##### | ##### | ....# | ....#
----------+-------+-------+-------+-------
 n % 2    | 0     | 1     | 0     | 1
----------+-------+-------+-------+-------
 reverse? | no    | yes   | no    | yes
----------+-------+-------+-------+-------
 final    | #.... | ##### | ##### | ....#
 shape    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

— Arnauld
source

1

感谢您的详细解释。

— 周江

9

Python 2，94个字节

n=0;s=''
exec"n+=1;s+=`n`;"*input()
K=k=len(s)
while k:k-=1;print s[k^n/-2%-2:].rjust(n%4/2*K)

在线尝试！

— 异或
source

7

Japt，8字节

返回行数组。

õ ¬å+ zU

试试吧

由于Kevin，节省了2个字节。

õ ¬å+ zU     :Implicit input of integer U
õ            :Range [1,U]
  ¬          :Join to a string
   å+        :Cumulatively reduce by concatenation
      zU     :Rotate clockwise by 90 degrees U times

— 毛茸茸
source

1

有ú必要吗？看来这隐式旋转了吗？

— Kevin Cruijssen

@KevinCruijssen，嗯...是的。我总是忘记这一点；很少使用z。

— 长毛

1

好吧，我一点都不了解Japt。只是好奇没有填充的情况下输出是什么样子，并看到它的工作

— 原理

4

画布，8 字节

ŗ］∑［］⁸［↷

在这里尝试！

— 宰马
source

4

Perl 6，94个字节

{[o](|(&reverse xx$_/2+.5),|(*>>.flip xx$_/2+1))([\~](my@a=[~](1..$_).comb)>>.fmt("%{+@a}s"))}

在线尝试！

带有一个数字并返回行列表的匿名代码块。

— 乔·金
source

3

木炭，17字节

Ｎθ≔⭆θ⊕ιηＧLＬηη⟲⊗θ‖

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

Ｎθ

输入n。

≔⭆θ⊕ιη

通过串联号码创建一个字符串1来n。

ＧLＬηη

用字符串填充该长度的三角形。

⟲⊗θ

逆时针旋转三角形n*90度。

‖

反射所有内容，从而最终形成一个顺时针旋转n*90角度的三角形。

— 尼尔
source

3

C＃（Visual C＃交互式编译器），128字节

n=>{var s="";int i=0,j,p;for(;i<n;s+=++i);for(p=j=s.Length;;)Write("{0,"+(n%4>1?p:0)+"}\n",new string(s[--j],-~n%4>1?j+1:p-j));}

在线尝试！

— 无知的体现
source

3

Ruby，95 82 79字节

->n{r=(0...z=/$/=~s=[*1..n]*'').map{|i|" "*n[1]*i+s[0,z-i]};-n&2>0?r:r.reverse}

在线尝试！

G B保存了3个字节。

— 基里尔
source

3

[R ，152个 139 137 134字节

function(n,N=nchar(s<-Reduce(paste0,1:n,'')),A=!n%%4%%3)for(i in 1:N)cat(rep('',(M=c(N-i+1,i))[1+!A]*(n%%4>1)),substr(s,1,M[1+A]),'
')

展开代码：

function(n){
  s = Reduce(paste0,1:n,'')      # concat the digits from 1 to n into a string s

  N = nchar(s)                   # store the length of s

  A = !n%%4%%3                   # A = TRUE if n MOD 4 == 1 or 2 

  for(i in 1:N){                 # for 1 to N (length of s)

    M = c(N-i+1,i)               # store N-i+1 and i into a vector

    nSpaces = M[1+!A]*(n%%4>1)   # if n MOD 4 == 1 or 2 then nSpaces = i else nSpaces = N-i+1, 
                                 # but if n MOD 4 == 0 or 1, then force nSpaces = 0

    nDigits = M[1+A]             # if n MOD 4 == 1 or 2 then nDigits = N-i+1 else nDigits = i

    prfx = rep('',)              # create a character vector repeating '' nSpaces times

    sufx = substr(s,1,M[1+A])    # substring s by taking the first nDigits characters

    cat(pr,su,'\n')              # print prfx and sufx using space as separator for the values 
                                 # contatenation (cat function default) and append a newline
  }

在线尝试！

— 数字化
source

……显然，这不是我打高尔夫球的一天。

— 朱塞佩

@朱塞佩：啊哈去过那里...然后你通常会让我失望：P

— digEmAll

2

APL + WIN，45个字节

提示输入整数

m←⊃(⍳⍴s)↑¨⊂s←(⍕⍳n←⎕)~' '⋄⍎(' ⊖⍉⌽'[1+4|n]),'m'

在线尝试！由Dyalog Classic提供

— 格雷厄姆
source

2

PowerShell，108字节

param($n)0..($y=($x=-join(1..$n)).length-1)|%{' '*(0,0,$_,($z=$y-$_))[$n%4]+-join$x[0..($_,$z,$z,$_)[$n%4]]}

在线尝试！

边缘有点粗糙但是可以用。将数字1连接n到一个字符串中，然后从0迭代到该字符串1的长度。每次，它使用列表索引交换到用于分割新字符串的正确间距方法和数字范围。

— 维斯卡
source

2

果冻，12字节

D€Ẏ;\z⁶U$⁸¡Y

在线尝试！

— 暴民埃里克
source

2

05AB1E（旧版），14 12 10字节

由于某些原因，使用传统版本作为重写非常慢。

感谢Kevin Cruijssen节省了2个字节

LSηsFRζ}J»

在线尝试！

说明

L           # push range [1 ... input]
 S          # split to list of individual digits
  η         # calculate prefixes
   sF  }    # input times do:
     R      # reverse list
      ζ     # and transpose it
        J   # join to list of strings
         »  # and join on newlines

— 艾米尼亚
source

由于隐式变平，您可以保存更改LJη€S为的2个字节。LSηS

— 凯文·克鲁伊森

@KevinCruijssen：哦，是的，谢谢！我忘记了这一点。我尝试€S了效果不佳的方法；）

— Emigna

2

Stax，10 个字节

Ç√çZ╟84Γó║

运行并调试

— 递归的
source

2

PowerShell中，105个 101 95字节

-4个字节，感谢Arnauld的Sort技巧。

param($n)($x=1..$n-join'')|% t*y|%{($s+="$_")}|sort -d:($n%4-in1,2)|% *ft($x.Length*($n%4-ge2))

在线尝试！

少打高尔夫球：

param($n)
$x=1..$n-join''
$x|% toCharArray |% {
    ($s+="$_")
} | sort -Descending:($n%4-in1,2) |% PadLeft ($x.Length*($n%4-ge2))

— 疯狂的
source

2

[R ，175个 172 154字节

function(n)write(c(" ",0:9)[1+(x=utf8ToInt(Reduce(paste0,1:n,""))-47)*!upper.tri(diag(y<-sum(x|1)))["if"(n%%4>1,1:y,y:1),"if"(!n%%4%%3,y:1,1:y)]],1,y,,"")

在线尝试！

可怕的在线混乱！

通过更改旋转条件来获得-3字节

-17个字节要感谢digEmAll的建议，而打高尔夫球之后还要再提供一个字节

— 朱塞佩
source

我喜欢这种upper.triangle方法，可以将其缩短为155个字节 ……也许甚至更多，我确定我缺少明显的东西……

— digEmAll

@digEmAll啊，有很多改进，但仍然很长：-（

— Giuseppe

1

Wolfram语言（Mathematica），137个字节

(t=Table[Table[" ",If[(m=#~Mod~4)>1,Tr[1^s]-k,0]]<>ToString/@s[[;;k]],{k,Length[s=Join@@IntegerDigits/@Range@#]}];If[0<m<3,Reverse@t,t])&

在线尝试！

— J42161217
source

1

Python 2，116字节

n=input()
s=''.join(map(str,range(1,n+1)));L=len(s)
p=-~n/2%2;i=~-L*p+1
exec'print s[:i].rjust(n/2%2*L);i+=1-2*p;'*L

在线尝试！

— 查斯·布朗
source

1

红色，155字节

func[n][b: copy""repeat i n[append b i]repeat i l:
length? b[t:[l - i + 1]set[k m]pick[i t[l t][l i]]n % 4 + 1
print pad/left copy/part b do do m do do k]]

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

1

perl 5，117字节

$p=$_++&2?'/ ':'$/';$s='(.*\d.\n)';$r=$_--&2?$s.'\K$':"^(?=$s)";$_=(join"",1..$_).$/;1while s,$r,'$1=~s/\d'."$p/r",ee

蒂奥

— 纳韦尔·福耶勒（Nahuel Fouilleul）
source

1

PHP，116 111 109字节

for($m=$l=strlen($s=join(range(1,$n=$argn)));$l--;)printf('%'.($n&2?$m:-$l).'.'.($n-1&2?$m-$l:$l+1)."s
",$s);

在线尝试！

使用的php -nF输入运行STDIN。

$ echo 6|php -nF t.php

— 640KB
source

1

的Java（JDK），247个 209 188 186 160 148字节的

i->{String s="";int l=0,w;for(;l<i;s+=++l);for(w=s.length(),l=0;l<w;)System.out.printf("%"+(1>i%4/2?1:w)+"s\n",s.substring(0,1>~-i%4/2?w-l++:++l));}

在线尝试！

-38 bytes感谢@KevinCruijssen
-21 bytes通过printf处理填充。
-2 bytes通过在替换之前执行子字符串，使我们可以l在一个位置而不是两个位置增加。
-26 bytes-通过printf进行填充，不再需要充满空格的字符串，并且显然可以以较短的方式生成数字字符串。
-12 bytes通过不搞乱单个数字而不是打印我们已经拥有的可完全维护的数字字符串的子字符串。

不打高尔夫球

input->{
    // Lambda expression with target type of IntConsumer
    String allDigits = "";
    int lineLength, line = 0;

    // Collect a list of all digits in order.
    for (;line < input; allDigits += ++line) {}

    // Save the max length of a line, and create a string of that many spaces.
    for (lineLength=allDigits.length(), line=0; line < lineLength;) {
        System.out.printf(   "%" // construct a format string to handle the padding
                           + (   1 > input%4/2
                               ? 1 // No padding
                               : w // Yes padding
                             )
                           + "s\n"
                         , allDigits.substring( 0
                                              ,   1 > (i-1)%4/2
                                                ? w - l++
                                                : ++l
                                              ) // A string containing only the digit we want.
                         );
    }
}

— 萨拉·J
source

1

好答案。不过，还有很多事情需要打高尔夫：for(可以删除球后的空间。new String(new char[w=s.length()]).replace('\0',' ')可以" ".repeat(w=s.length())使用Java 11+。您可以删除三元检查周围的括号。1>(i-1)%4/2可以1>~-i%4/2。w-1-l++可以w+~l++。而且您不必在字节数中计算尾随的分号。全部加起来变成209个字节。

— 凯文·克鲁伊森

数字三角形

挑战：

挑战规则：

一般规则：

测试用例：

JavaScript（ES6）， 93 89字节

已评论

形状摘要

Python 2，94个字节

Japt，8字节

画布，8 字节

Perl 6，94个字节

木炭，17字节

C＃（Visual C＃交互式编译器），128字节

Ruby，95 82 79字节

[R ，152个 139 137 134字节

APL + WIN，45个字节

PowerShell，108字节

果冻，12字节

05AB1E（旧版），14 12 10字节

Stax，10 个字节

PowerShell中，105个 101 95字节

[R ，175个 172 154字节

Wolfram语言（Mathematica），137个字节

Python 2，116字节

红色，155字节

perl 5，117字节

PHP，116 111 109字节

的Java（JDK） ，247个 209 188 186 160 148字节的

不打高尔夫球

的Java（JDK），247个 209 188 186 160 148字节的