Thử thách:

Đầu vào: Một số nguyên dương $n$

Đầu ra:

Tạo một danh sách trong phạm vi $[1,n]$ và nối nó lại với nhau thành một chuỗi (tức là $n=13$ sẽ là chuỗi 12345678910111213).

Bây giờ chúng ta xuất ra một tam giác bằng cách sử dụng các tiền tố hoặc hậu tố của chuỗi này, theo một trong bốn định hướng sau dựa trên số nguyên đầu vào:

• Nếu , hãy xuất nó theo hình tam giác$n\equiv 0\pmod 4$
• Nếu , hãy xuất nó theo hình tam giác$n\equiv 1\pmod 4$
• Nếu , hãy xuất nó theo hình tam giác$n\equiv 2\pmod 4$
• Nếu , hãy xuất nó theo hình tam giác$n\equiv 3\pmod 4$

Thí dụ:

Đầu vào:$n=13$

Vì , hình dạng sẽ là. Dưới đây là ba kết quả đầu ra hợp lệ:$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

Quy tắc thử thách:

• Như bạn có thể thấy ở ba đầu ra hợp lệ ở trên, chỉ có hình dạng chính xác và sử dụng tất cả các chữ số theo đúng thứ tự là quan trọng. Ngoài ra, bạn có thể tự do sử dụng tiền tố hoặc hậu tố; đảo ngược / phản ánh; in chéo; v.v ... Bất kỳ sáu đầu ra có thể cho mỗi hình dạng đều được cho phép (xem trường hợp thử nghiệm bên dưới để xem tất cả các đầu ra hợp lệ dựa trên hình dạng). Điều này cho phép các ngôn ngữ có nội dung xoay vòng sử dụng nó, nhưng những ngôn ngữ không có thể sử dụng một cách tiếp cận khác là sử dụng các tiền tố theo kích thước chính xác từ trên xuống dưới hoặc sử dụng tiền tố cho hai trong số các hình dạng nhưng hậu tố cho hai hình dạng khác . Chọn các tùy chọn đầu ra phù hợp nhất cho ngôn ngữ của bạn là một phần của quy trình chơi gôn. :)
• Đầu vào được đảm bảo là một số nguyên dương. Với chúng tôi chỉ đơn giản là đầu ra .$n=1$1
• Bất kỳ số lượng dòng / dòng mới hàng đầu / dấu vết nào đều được cho phép, miễn là nó in đúng hình tam giác (không có dấu phân cách dọc hoặc ngang!) Ở đâu đó trên màn hình.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

Đầu vào: Tất cả các đầu ra hợp lệ có thể:$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

Đầu vào: Tất cả các đầu ra có thể:$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

Đầu vào: Tất cả các đầu ra có thể:$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

Đầu vào: Tất cả các đầu ra có thể:$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

Đầu vào: Chỉ đầu ra có thể:$n=1$

1

Đầu vào: Tất cả các đầu ra có thể:$n=2$

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

JavaScript (ES6),  93  89 byte

Trả về một ma trận các ký tự.

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

Hãy thử trực tuyến!

Mẫu thay thế (cùng kích thước):

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

Hãy thử trực tuyến!

Đã bình luận

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

Tóm tắt hình dạng

Dưới đây là tóm tắt về hình dạng cơ sở (được tạo bởi các mapvòng lặp lồng nhau ) và hình dạng cuối cùng (sau sort) cho mỗi :$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    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

Python 2 , 94 byte

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)

Hãy thử trực tuyến!

Japt , 8 byte

Trả về một mảng các dòng.

õ ¬å+ zU

Thử nó

Lưu được 2 byte nhờ Kevin .

õ ¬å+ 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

Canvas , 8 byte

ŗ］∑［］⁸［↷

Hãy thử nó ở đây!

Perl 6 , 94 byte

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

Hãy thử trực tuyến!

Khối mã ẩn danh lấy một số và trả về một danh sách các dòng.

Than , 17 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Đầu vào n.

≔⭆θ⊕ιη

Tạo một chuỗi bằng cách nối các số 1thành n.

ＧLＬηη

Điền vào một hình tam giác có độ dài đó bằng chuỗi.

⟲⊗θ

Xoay tam giác ngược chiều kim đồng hồ theo n*90độ.

‖

Phản ánh tất cả mọi thứ, do đó kết thúc bằng một hình tam giác được xoay theo chiều kim đồng hồ theo n*90độ.

C # (Trình biên dịch tương tác Visual C #) , 128 byte

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));}

Hãy thử trực tuyến!

Ruby , 95 82 79 byte

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

Hãy thử trực tuyến!

3 byte được lưu bởi G B.

R , 152 139 137 134 byte

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]),'
')

Mã chưa được kiểm soát:

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
  }

Hãy thử trực tuyến!

APL + THẮNG, 45 byte

Lời nhắc cho số nguyên

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

PowerShell , 108 byte

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

Hãy thử trực tuyến!

Một chút thô xung quanh các cạnh nhưng hoạt động. Nối các chữ số 1 nthành một chuỗi sau đó lặp từ 0 đến độ dài của chuỗi đó-1. Mỗi lần, nó sử dụng lập chỉ mục danh sách để hoán đổi sang phương thức khoảng cách chính xác và phạm vi số được sử dụng để cắt chuỗi mới của chúng tôi.

Thạch , 12 byte

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

Hãy thử trực tuyến!

05AB1E (di sản) , 14 12 10 byte

Sử dụng các verion kế thừa như viết lại là rất chậm về điều này vì một số lý do.

Đã lưu 2 byte nhờ Kevin Cruijssen

LSηsFRζ}J»

Hãy thử trực tuyến!

Giải trình

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

Stax , 10 byte

Ç√çZ╟84Γó║

Chạy và gỡ lỗi nó

PowerShell , 105 101 95 byte

-4 byte cảm ơn Arnauld cho thủ thuật với Sắp xếp .

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

Hãy thử trực tuyến!

Ít chơi gôn hơn:

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

R , 175 172 154 byte

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,,"")

Hãy thử trực tuyến!

Một mớ hỗn độn kinh khủng!

-3 byte bằng cách thay đổi điều kiện xoay

-17 byte nhờ vào gợi ý của digEmAll và một byte khác sau khi chơi gôn thêm

Ngôn ngữ Wolfram (Mathicala) , 137 byte

(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])&

Hãy thử trực tuyến!

Python 2 , 116 byte

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

Hãy thử trực tuyến!

Màu đỏ , 155 byte

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]]

Hãy thử trực tuyến!

perl 5, 117 byte

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

TIO

PHP ,116 111 109 byte

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);

Hãy thử trực tuyến!

Chạy với php -nFđầu vào từ STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

Java (JDK) , 247 209 188 186 160 148 byte

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));}

Hãy thử trực tuyến!

-38 bytescảm ơn @KevinCruijssen
-21 bytesbằng cách printfxử lý phần đệm.
-2 bytesbằng cách thực hiện chuỗi con trước khi thay thế, cho phép chúng tôi tăng lở một vị trí chứ không phải hai.
-26 bytes- với printfviệc thực hiện phần đệm, chuỗi đầy khoảng trắng không còn cần thiết nữa và chuỗi số có thể được tạo theo cách ngắn hơn rõ ràng.
-12 bytesbằng cách không gây rối với các chữ số đơn thay vì in các chuỗi con của chuỗi chữ số hoàn toàn có thể phục vụ mà chúng ta đã có.

Bị đánh cắp

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.
                         );
    }
}