Meydan okuma:

Giriş: n pozitif bir tamsayı$n$

Çıktı:

$[1,n]$ aralığında bir liste oluşturun ve onu bir dizeye birleştirin (yani, $n=13$ dize olur 12345678910111213).

Şimdi bu dizgenin öneklerini veya soneklerini kullanarak, giriş tamsayısına göre aşağıdaki dört yönden birinde bir üçgen çıkarıyoruz:

• Eğer $n\equiv 0\pmod 4$ , bunu shape üçgen şeklinde çıkar.
• Eğer $n\equiv 1\pmod 4$ , shape üçgen şeklinde çıkar
• Eğer $n\equiv 2\pmod 4$ , üçgen şeklinde çıkış olarak ◥
• Eğer $n\equiv 3\pmod 4$ , shape üçgen şeklinde çıkar

Örnek:

Giriş: $n=13$

Çünkü $13\equiv 1\pmod 4$ , şekil ◤ olacaktır. İşte üç olası geçerli çıktı:

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

Meydan okuma kuralları:

• Yukarıdaki üç geçerli çıktıda görebileceğiniz gibi, yalnızca doğru şekil ve tüm basamakları doğru sırayla kullanmak önemlidir. Bunun dışında önek veya sonek kullanmakta özgürsünüz; geri / yansıtır; çapraz baskı; vb. Her bir şekil için olası altı çıktıdan herhangi birine izin verilir ( şekle dayalı tüm geçerli çıktıları görmek için aşağıdaki test durumuna bakın ). Bu, döndürme yapılarına sahip dillerin onu kullanmasına izin verir, ancak dili olmayanlar, ön ekleri doğru boyutta yukarıdan aşağıya doğru kullanma ya da iki şekil için ön ekleri kullanma, ancak diğer iki şekil için son ekleri kullanma seçeneğine de sahip olabilir. . Diliniz için en uygun çıktı seçeneklerini seçmek golf sürecinin bir parçasıdır. :)
• Giriş pozitif bir tamsayıdır. İçin biz sadece çıkış .$n=1$1
• Ekranda bir yere doğru üçgeni (dikey veya yatay sınırlayıcılar olmadan!) Yazdırdığı sürece, her türlü satır başı / son satırları / boşlukları kullanılabilir.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Giriş: Mümkün olan tüm geçerli çıkışlar:$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

Giriş: Tüm olası çıkışlar:$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

Giriş: Tüm olası çıkışlar:$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

Giriş: Tüm olası çıkışlar:$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

Giriş: Sadece mümkün çıkış:$n=1$

1

Giriş: Tüm olası çıkışlar:$n=2$

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

JavaScript (ES6),  93  89 bayt

Bir karakter matrisi döndürür.

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

Çevrimiçi deneyin!

Alternatif desen (aynı boyutta):

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

Çevrimiçi deneyin!

Yorumlananlar

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

Şekil özeti

mapsort$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 bayt

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)

Çevrimiçi deneyin!

Japt , 8 bayt

Satır dizisini döndürür.

õ ¬å+ zU

Dene

Kevin sayesinde 2 bayt kurtardı .

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

Tuval , 8 bayt

ŗ］∑［］⁸［↷

Burada dene!

Perl 6 , 94 bayt

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

Çevrimiçi deneyin!

Sayı alan ve satır listesini döndüren adsız kod bloğu.

Kömür , 17 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｎθ

Giriş n.

≔⭆θ⊕ιη

Sayıları birleştirerek bir dize oluşturun 1için n.

ＧLＬηη

Bu uzunluktaki bir üçgeni dize ile doldurun.

⟲⊗θ

Üçgeni saat yönünün tersine n*90derece derece döndürün.

‖

Her şeyi yansıtın, böylece saat yönünde döndürülen bir üçgenle n*90bitirin.

C # (Visual C # Etkileşimli Derleyici) , 128 bayt

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

Çevrimiçi deneyin!

Ruby , 95 82 79 bayt

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

Çevrimiçi deneyin!

G B. tarafından kaydedilen 3 bayt

R , 152 139 137 134 bayt

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

Kontrolsüz kod:

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
  }

Çevrimiçi deneyin!

APL + WIN, 45 bayt

Tamsayı için sor

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

Çevrimiçi deneyin! Dyalog Classic'in İzniyle

PowerShell , 108 bayt

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

Çevrimiçi deneyin!

Kenarlarda biraz pürüzlü ama işe yarıyor. Rakam 1'i nbir dizgiye ekler, ardından 0'dan bu dizge-1'in uzunluğuna çıkar. Her seferinde, yeni dizgimizi dilimlemek için kullanılan doğru aralık yöntemine ve sayı aralığına geçmek için liste indekslemeyi kullanır.

Jöle , 12 bayt

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

Çevrimiçi deneyin!

05AB1E (eski) , 14 12 10 bayt

Eski veryonun tekrar yazma olarak kullanılması, bazı sebeplerden dolayı bu konuda oldukça yavaştır.

Kevin Cruijssen sayesinde 2 bayt kaydedildi

LSηsFRζ}J»

Çevrimiçi deneyin!

açıklama

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 bayt

Ç√çZ╟84Γó║

Koş ve hata ayıkla

PowerShell , 105 101 95 bayt

-4 bayt Sort ile numara için Arnauld teşekkürler .

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

Çevrimiçi deneyin!

Daha az golf oynadı:

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 bayt

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

Çevrimiçi deneyin!

Korkunç bir çizgi karışıklığı!

Dönme koşulunu değiştirerek -3 bayt

DigEmAll'in önerisi sayesinde -17 bayt ve daha sonra golf oynadıktan sonra başka bir bayt

Wolfram Dili (Mathematica) , 137 bayt

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

Çevrimiçi deneyin!

Python 2 , 116 bayt

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

Çevrimiçi deneyin!

Kırmızı , 155 bayt

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

Çevrimiçi deneyin!

perl 5, 117 bayt

$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 bayt

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

Çevrimiçi deneyin!

php -nFGirişi ile çalıştırın STDIN.

$ echo 6|php -nF t.php

123456
 12345
  1234
   123
    12
     1

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

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

Çevrimiçi deneyin!

-38 bytes @KevinCruijssen için teşekkürler
-21 bytes vererek printfdolgu işlemek.
-2 bytesdeğiştirmeden önce alt dizeyi yaparak, liki yerine tek bir konumda artmamıza izin verin .
-26 bytes- printfDolgu yapılırken, boşluklarla dolu olan dize artık gerekli değildi ve rakam dizeleri görünüşte daha kısa bir şekilde oluşturulabilirdi.
-12 bytesZaten sahip olduğumuz mükemmel hizmete sahip rakam dizisinin alt dizelerini yazdırmak yerine tek bir rakam ile uğraşmayarak.

Ungolfed

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