Tantangan:

Input: Bilangan bulat positif$n$

Keluaran:

Buat daftar dalam rentang , dan gabungkan bersama menjadi sebuah string (yaitu akan menjadi string ).$[1,n]$$n=13$12345678910111213

Sekarang kita menghasilkan sebuah segitiga menggunakan awalan atau akhiran dari string ini, dalam salah satu dari empat orientasi berikut berdasarkan pada integer input:

• Jika $n\equiv 0\pmod 4$ , output dalam bentuk segitiga ◣
• Jika $n\equiv 1\pmod 4$ , output dalam bentuk segitiga ◤
• Jika $n\equiv 2\pmod 4$ , output dalam bentuk segitiga ◥
• Jika $n\equiv 3\pmod 4$ , output dalam bentuk segitiga ◢

Contoh:

Input: $n=13$

Karena $13\equiv 1\pmod 4$ , bentuknya akan ◤. Berikut tiga kemungkinan hasil yang valid:

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

Aturan tantangan:

• Seperti yang Anda lihat pada tiga output yang valid di atas, hanya bentuk yang benar dan menggunakan semua digit dalam urutan yang benar adalah penting. Selain itu, Anda bebas menggunakan awalan atau sufiks; membalikkan / mencerminkan; pencetakan diagonal; dll. Salah satu dari enam kemungkinan output untuk setiap bentuk diperbolehkan (lihat test case di bawah ini untuk melihat semua output yang valid berdasarkan bentuk). Ini memungkinkan bahasa dengan builtin rotasi untuk menggunakannya, tetapi mereka yang tidak dapat juga menggunakan pendekatan alternatif menggunakan awalan dalam ukuran yang benar dari atas ke bawah, atau menggunakan awalan untuk dua bentuk tetapi sufiks untuk dua bentuk lainnya . Memilih opsi keluaran yang paling tepat untuk bahasa Anda adalah bagian dari proses bermain golf. :)
• Input dijamin bilangan bulat positif. Untuk kita cukup output .$n=1$1
• Sejumlah baris / spasi terdepan / tertinggal diperbolehkan, asalkan mencetak segitiga yang benar (tanpa pembatas vertikal maupun horizontal!) Di suatu tempat di layar.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O standar , sehingga Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

Input: Semua kemungkinan hasil valid:$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

Input: Semua output yang mungkin:$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

Input: Semua output yang mungkin:$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

Input: Semua output yang mungkin:$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

Input: Hanya keluaran yang mungkin:$n=1$

1

Input: Semua output yang mungkin:$n=2$

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

JavaScript (ES6),  93  89 byte

Mengembalikan matriks karakter.

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

Cobalah online!

Pola alternatif (ukuran yang sama):

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

Cobalah online!

Berkomentar

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

Ringkasan bentuk

Berikut ini adalah ringkasan dari bentuk dasar (dihasilkan oleh bersarang maploop) dan bentuk akhir (setelah sort) untuk setiap $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)

Cobalah online!

Japt , 8 byte

Mengembalikan array garis.

õ ¬å+ zU

Cobalah

Disimpan 2 byte berkat 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

Kanvas , 8 byte

ŗ］∑［］⁸［↷

Coba di sini!

Perl 6 , 94 byte

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

Cobalah online!

Blok kode anonim yang mengambil nomor dan mengembalikan daftar baris.

Arang , 17 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

Masukan n.

≔⭆θ⊕ιη

Buat string dengan menggabungkan angka 1ke n.

ＧLＬηη

Isi segitiga dengan panjang itu dengan tali.

⟲⊗θ

Putar segitiga berlawanan arah jarum jam oleh n*90derajat.

‖

Refleksikan semuanya, dengan demikian berakhir dengan segitiga yang diputar searah jarum jam dengan n*90derajat.

C # (Visual C # Interactive Compiler) , 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));}

Cobalah online!

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}

Cobalah online!

3 byte disimpan oleh 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]),'
')

Kode terbuka:

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
  }

Cobalah online!

APL + WIN, 45 byte

Anjuran untuk bilangan bulat

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

Cobalah online! Atas perkenan 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]]}

Cobalah online!

Agak kasar di tepinya tetapi bekerja. Bergabung dengan angka 1 nmenjadi string kemudian beralih dari 0 ke panjang string-1 itu. Setiap kali, ia menggunakan pengindeksan daftar untuk bertukar ke metode spasi yang benar dan rentang nomor yang digunakan untuk mengiris string baru kami.

Jelly , 12 byte

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

Cobalah online!

05AB1E (warisan) , 14 12 10 byte

Menggunakan versi lawas sebagai penulisan ulang sangat lambat untuk beberapa alasan.

Disimpan 2 byte berkat Kevin Cruijssen

LSηsFRζ}J»

Cobalah online!

Penjelasan

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Γó║

Jalankan dan debug itu

PowerShell , 105 101 95 byte

-4 byte, terima kasih Arnauld untuk triknya dengan Sortir .

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

Cobalah online!

Kurang bermain golf:

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

Cobalah online!

Kekacauan in-line yang mengerikan!

-3 byte dengan mengubah kondisi rotasi

-17 byte berkat saran digEmAll , dan byte lain setelah bermain golf lebih lanjut

Bahasa Wolfram (Mathematica) , 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])&

Cobalah online!

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

Cobalah online!

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

Cobalah online!

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

Cobalah online!

Jalankan dengan php -nFinput dari STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

Java (JDK) , 247 209 188 186 160 160 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));}

Cobalah online!

-38 bytesterima kasih kepada @KevinCruijssen
-21 bytesdengan membiarkan printfpegangan bantalannya.
-2 bytesdengan melakukan substring sebelum mengganti, memungkinkan kami menambah lsatu lokasi daripada dua.
-26 bytes- dengan printfmelakukan padding, string yang penuh dengan ruang tidak lagi diperlukan, dan string digit dapat dihasilkan dengan cara yang lebih pendek.
-12 bytesdengan tidak mengotak-atik dengan satu digit alih-alih mencetak substring dari string digit sempurna yang telah kita miliki.

Tidak disatukan

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