도전:

입력 : 양의 정수$n$

산출:

범위의 목록을 작성하고 이를 문자열로 결합하십시오 (즉, 은 문자열이됩니다 ).$[1,n]$$n=13$12345678910111213

이제이 정수의 접두사 또는 접미사를 사용하여 입력 정수에 따라 다음 4 가지 방향 중 하나를 사용하여 삼각형을 출력합니다.

• 만약 $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

도전 규칙 :

• 위의 세 가지 유효한 출력에서 ​​볼 수 있듯이 올바른 모양 만 올바른 순서 로 모든 숫자를 사용하는 것이 중요합니다. 그 외에도 접두사 또는 접미사를 자유롭게 사용할 수 있습니다. 반전 / 반영; 대각선 인쇄; 등. 각 모양에 대해 가능한 6 가지 출력 중 하나가 허용됩니다 ( 모양에 따라 유효한 모든 출력 을 보려면 아래 테스트 사례 참조 ). 이를 통해 회전 내장 언어가있는 언어에서이를 사용할 수 있지만,없는 언어의 경우 접두사를 위에서 아래로 올바른 크기로 사용하거나 두 가지 도형에 접두사를 사용하고 다른 두 가지 도형에 접미사를 사용하는 대체 방법을 사용할 수도 있습니다. . 귀하의 언어에 가장 적합한 출력 옵션을 선택하는 것은 골프 과정의 일부입니다. :)
• 입력은 양의 정수 여야합니다. 들면 우리는 단순히 출력 .$n=1$1
• 화면의 어딘가에 올바른 삼각형 (수직 또는 수평 구분 기호없이)을 인쇄하는 한 선행 / 후행 줄 바꿈 / 공백이 허용됩니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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$

1

입력 : 가능한 모든 출력 :$n=2$

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

자바 스크립트 (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    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

파이썬 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)

온라인으로 사용해보십시오!

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

캔버스 , 8 바이트

ŗ］∑［］⁸［↷

여기 사용해보십시오!

펄 6 , 94 바이트

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

온라인으로 사용해보십시오!

숫자를 가져와 줄 목록을 반환하는 익명 코드 블록입니다.

숯 , 17 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｎθ

입력 n.

≔⭆θ⊕ιη

에 숫자 1를 연결하여 문자열을 만듭니다 n.

ＧLＬηη

해당 길이의 삼각형을 문자열로 채 웁니다.

⟲⊗θ

삼각형을 시계 반대 방향으로 n*90도 단위로 회전시킵니다 .

‖

시계 방향으로 n*90도 회전하는 삼각형으로 끝나는 모든 것을 반영하십시오 .

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

온라인으로 사용해보십시오!

루비 , 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 바이트를 절약했습니다.

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
  }

온라인으로 사용해보십시오!

APL + WIN, 45 바이트

정수에 대한 프롬프트

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

온라인으로 사용해보십시오! Dyalog Classic 제공

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의 길이까지 반복합니다. 매번 목록 인덱싱을 사용하여 새 문자열을 슬라이스하는 데 사용되는 올바른 간격 방법 및 숫자 범위로 바꿉니다.

젤리 , 12 바이트

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

온라인으로 사용해보십시오!

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

Stax , 10 바이트

Ç√çZ╟84Γó║

실행 및 디버깅

PowerShell을 , 105 (101) 95 바이트

-4 감사가에 대한 Arnauld 바이트 정렬과 트릭 .

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

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 바이트

digEmAll 의 제안 덕분에 -17 바이트 , 골프 후의 다른 바이트

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

온라인으로 사용해보십시오!

파이썬 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

온라인으로 사용해보십시오!

빨강 , 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]]

온라인으로 사용해보십시오!

펄 5, 117 바이트

$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 바이트

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

123456
 12345
  1234
   123
    12
     1

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