에서 도청 출력에서 영감을 @Carcigenicate 의 Clojure의 응답 에 대한 인쇄이 다이아몬드 도전.

이 정확한 텍스트를 인쇄하십시오 :

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(중간에서 바깥 방향으로, 각 자릿수는 이전 행보다 하나 이상의 공백으로 분리됩니다.)

도전 규칙 :

• 입력이 없거나 비어있는 입력이 없습니다 .
• 후행 공백은 선택 사항입니다.
• 단일 후행 줄 바꿈은 선택 사항입니다.
• 선행 공백이나 줄 바꾸기는 허용되지 않습니다.
• 문자열 배열을 반환하는 것은 허용되지 않습니다. 텍스트를 출력하거나 올바른 결과를 가진 단일 문자열을 반환하는 함수가 있어야합니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

SOGL V0.12 , 12 바이트

9{SUē↕∑}¹№╬«

여기 사용해보십시오! 설명:

9{     }      9 times do
  SU            push "1234567890"
    ē           push e, predefined with the input, which defaults to 0, and then increase it
     ↕          get that many spaces
      ∑         join the string of digits with those spaces
        ¹     collect the results in an array
         №    reverse the array vertically
          ή  palindromize vertically with 1 overlap

파이썬 2 , 59 57 56 55 바이트

i=8;exec"print(' '*abs(i)).join('1234567890');i-=1;"*17

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

@Leaky Nun은이 일을 많이 도와주었습니다. @Praind 1 바이트를 절약 할 수있는 방법을 제안했는데 이전에 생각했지만 편집을 잊어 버렸습니다.

설명

• i=8- 8라는 변수에 값 을 할당합니다 i.

• exec"..."*17-해당 코드 블록 ( ...)을 17 번 실행하십시오.

• print(...) -결과를 출력합니다.

• ' '*abs(i)-공백이 반복되는 문자열을 만듭니다 |i|.

• .join('1234567890')-위에 만든 문자열을 숫자 사이에 공백이 삽입 1234567890되도록 인터리브하십시오 |i|.

• i-=1-감소 i하고 17 회 실행하여 도달하여 도달 -8하여 반복적 인 패턴을 만듭니다 abs().

Vim, 35 바이트 :

i1234567890<esc>qqYP:s/\d/& /g
YGp{q7@q

설명:

i1234567890<esc>    " insert '1234567890'
qq                  " Record the following into register 'q'
  Y                 "   Yank a line
   P                "   Paste it above us
    :s/\d/& /g      "   Put a space after each number
Y                   "   Yank this line
 G                  "   Move the end of the buffer
  p                 "   Paste the line
   {                "   Move the beginning of the buffer
    q               " Stop recording
     7@q            " Call macro 'q' 7 times

05AB1E ,  14  13 바이트

17F9ÝÀN8αð×ý,

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

설명

17F            # for N in [0 ... 16] do
   9Ý          # push [0 ... 9]
     À         # rotate left
      N8α      # compute the absolute difference between N and 8
         ð×    # push that many spaces
           ý   # merge the list of digits with the space string as separator
            ,  # print

C64 ASM, 358 바이트 (기본 바이트로 컴파일 된 102 바이트)

이것은 명백한 한계로 인해 얻을 수있는 가장 가까운 것입니다.

jsr $E544
lda #9
sta $FD
nl1: jsr dl
jsr il
dec $FD
bne nl1
inc $FD
nl2: ldy $FD
cpy #9
bne nt1
bl: jmp bl
nt1: iny
sty $FD
jsr dl
jsr il
jmp nl2
dl: clc
ldx #$31
ldy #0
lp: txa
sm: sta $0400, y
inx
cpx #$31
bne c1
rts
c1: cpx #$3A
bne nt2
ldx #$30
clc
nt2: tya
adc $FD
cmp #40
bcc c2
rts
c2: tay
jmp lp
il: lda sm+1
adc #39
bcc nc
inc sm+2
nc: sta sm+1
rts

(아마도 약간 최적화되었을 수 있습니다)

TSQL, 220 148 바이트

ZLK의 개선 사항 :

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1@2@3@4@5@6@7@8@9@0','@',SPACE(ABS(9-RANK()OVER(ORDER BY object_id))))+'
'FROM sys.objects PRINT @

산출:

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

APL (Dyalog) , 22 바이트

↑∊¨(1+|¯9+⍳17)↑¨¨⊂1⌽⎕D

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

⎕D D 0에서 아홉 igits

1⌽ 한 단계 오른쪽으로 회전 (끝에 0을 넣음)

⊂ 동봉 (단위로 취급)

(... )↑¨¨ 에 대한 각 이 숫자에서 많은 문자를 가지고 각 글자를 :

 ⍳17 1에서 17

 ¯9+ 구를 빼다

 | 절대 값을 찾으십시오

 1+ 하나 추가

∊¨ 각각 입대 (평평하게하다)

↑ 깊이의 한 층을 계급 수준으로 변경 (매립)

하스켈 , 58 55 바이트

unlines["1234567890">>=(:(' '<$[1..abs n]))|n<-[-8..8]]

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

이것은 기본적으로 @nimi의 솔루션입니다 :)

Java 11 (JDK) , 98 바이트

o->{for(int i=-9;++i<9;)System.out.println("".join(" ".repeat(i<0?-i:i),"1234567890".split("")));}

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

• 이제 기본을 가지고 JDK (11)로 전환하여 -14 바이트 String::repeat.

이전 대답은 ( 자바 (오픈 JDK 8) ), (113) 112 바이트

o->{for(int i=-9;++i<9;)System.out.printf("".join("%1$"+(i<0?-i:i>0?i:"")+"s","1234567890".split(""))+"%n","");}

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

설명

나는 기본적으로 다음과 같은 String17 번 구성하고 있습니다 ( N실제 값이 아닌 변수입니다).

"1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n"

각 숫자 사이의 공백 수는 %1$Ns어디 에서 합쳐 지는지 예상되는 모든 N숫자입니다.

%1$Ns기본적으로 "첫 번째 인수를 취하고 길이가 최소가 될 때까지 채 웁니다 N"를 의미합니다. 또한 %1$0s지원되지 않으므로에 대한 특별한 경우 %1$s가 0있습니다.

마지막으로 단일 인수를 사용하여 해당 문자열을 ""서식 인쇄합니다 . 포맷터는 항상 같은 빈 문자열을 재사용하여 필요에 따라 공백으로 채 웁니다.

저장

• Kevin Cruijssen 덕분에 1 바이트

Japt -R , 19 18 16 14 13 바이트

Aõ%A
£qYçÃÔÅê

그것을 시험 하거나 온라인으로 시도하십시오

설명

A             :10
 õ           :Range [1,10]
  %A         :Modulo each by 10
\n           :Assign to variable U
£            :Map each element at 0-based index Y
 q           :  Join U with
  Yç         :   Space repeated Y times
    Ã        :End map
     Ô       :Reverse
      Å      :Slice off first element
       ê     :Mirror
             :Implicitly join with newlines and output

자바 스크립트 (ES2017), 83 73 72 68 바이트

10 바이트를 절약 해 주셔서 감사합니다. Shaggy 1 바이트를 절약 해 준 Craig 에게 감사합니다 . 감사합니다 호 4 바이트를 저장합니다.

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

for(i=-9,a="";i++<8;)a+=[...`1234567890
`].join("".padEnd(i<0?-i:i))

console.log(a);

.as-console-wrapper { max-height: 100% !important; top: 0; }
.as-console-row:after { display: none !important; }

Brachylog , 30 29 28 바이트

Ị↺{∧≜;Ṣj₍g;?↔zcc}ᶠ⁹↔;XcP↔Pẉᵐ

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

Leaky Nun 덕분에 1 바이트를 절약했습니다 .

설명

Ị↺                               The string "1234567890"
  {               }ᶠ⁹            Find the first 9 outputs of:
   ∧≜                              Take an integer
       ;Ṣj₍                        Juxtapose " " that number of times
           g;?↔z                   Zip that string of spaces with "1234567890"
                cc                 Concatenate twice into one string
                    ↔            Reverse the resuling list
                     ;XcP↔P      Palindromize the list (concatenate X to it into the list P,
                                   P reversed is still P)
                           ẉᵐ    Map writeln

숯 , 18 바이트

Ｆ⁹⪫⁺…Ｉ¹:⟦0¶⟧× ι‖Ｂ↑

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

Ｆ⁹      Repeat 9 times (i = loop variable)
  ⪫       Join
   ⁺       Concatentate
    …Ｉ¹:    All the characters from str(1) below ":" (i.e. to "9") as a list
    ⟦0¶⟧    A list whose element is the string "0\n"
   × ι     With i spaces
‖Ｂ↑     Reflect everything upwards but without duplicating the top line

참고 : 전에 구분 기호가 필요 Cast(1)하기 때문에 동일한 수의 바이트 를 사용합니다."1"":"

R , 108 바이트

for(i in abs(-8:8))cat(paste0(el(strsplit("1234567890","")),paste(rep(" ",i),collapse=""),collapse=""),"\n")

문자열을 붙여 넣고 접는 것입니다.

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

편집 : 문제를 지적한 Challenger5에 감사드립니다. 지금 고쳤습니다.

편집 2 : bouncyball 덕분에 바이트를 저장했습니다.

파이썬 3 , 58 57 54 바이트

i=8
while i+9:print(*'1234567890',sep=' '*abs(i));i-=1

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

(마지막 3 바이트 동안 @flornquake 덕분에; 나는 sepvs를 저장하는 것을 완전히 잊어 버렸습니다. .join)

Pyth , 14 13 바이트

Mnemonic 덕분에 1 바이트.

V17j*da8NeMST

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

자바 (8) 235 234 206 163 바이트

interface A{static void main(String[]a){for(int i=-8;i<9;i++){String s="";for(int j=1,k;j<10;j++){s+=j;for(k=0;k<(i>0?i:-i);k++)s+=" ";}System.out.println(s+0);}}}

업데이트 : Leaky Nun 덕분에 -28 바이트!
업데이트 2 : Leaky Nun 덕분에 -43 바이트!

언 골프 :

interface A {
    static void main(String[] a) {
        for (int i = -8; i < 9; i++) {
            String s = "";
            for (int j = 1, k; j < 10; j++) {
                s += j;
                for (k = 0; k < (i > 0 ? i : -i); k++)
                    s += " ";
            }
            System.out.println(s + 0);
        }
    }
}

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

편집 : 이전 코드가 잘못되었습니다! 코드를 골프를 타는 동안 실수를 했으므로 이제 의도 한대로 작동해야합니다!

껍질 , 21 바이트

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9

이것은 STDOUT으로 인쇄하는 전체 프로그램입니다. 온라인으로 사용해보십시오! 후행 공간이 많이 있습니다.

설명

Husk에는 여전히 2 개의 인수 범위 함수와 같은 필수 요소가 많이 없기 때문에이 솔루션의 일부는 약간 해킹 적입니다.

mΣṪ`:§+↔tḣR8' ṁs`:0ḣ9
              ṁs`:0ḣ9  This part evaluates to the string "1234567890".
                   ḣ9   Range from 1 to 9.
                `:0     Append 0.
              ṁs        Convert each number to string and concatenate.
     §+↔tḣR8'          This part evaluates to a list like ["  "," ",""," ","  "]
                       but with 17 elements instead of 5.
          R8'           A string of 8 spaces.
         ḣ              Take prefixes.
     §+                 Concatenate
       ↔                the reversal and
        t               tail of the prefix list, palindromizing it.
  Ṫ                    Take outer product of the two lists
   `:                  with respect to flipped prepeding.
                       This prepends each digit to each string of spaces.
mΣ                     Map concatenation over the results, computing the rows.
                       Implicitly join with newlines and print.

T-SQL 145 152 바이트

DECLARE @ VARCHAR(MAX)=''SELECT TOP 17@+=REPLACE('1x2x3x4x5x6x7x8x9x0','x',SPACE(ABS(number-8)))+'
'FROM master..spt_values WHERE type='P'PRINT @

사용하도록 업데이트 되었습니다 :

• master..spt_values숫자를 생성하려면 ( WHERE type = 'P'0부터 시작하여 항상 연속적 임)
• @ZLK의 TOP 17아이디어
• 인쇄 (규칙 준수-문자열 목록 없음)
• @JanDrozen의 문자열에 캐리지 리턴을 포함시키는 훌륭한 아이디어 (1 바이트로 계산했습니다-Windows CRLF 무엇?)
• 변수 이름에 @를 사용하는 @Bridge의 아이디어-이 모든 트릭!

결과 :

1        2        3        4        5        6        7        8        9        0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0

(교체 아이디어에 대한 @JanDrozen에게 감사드립니다)

클로저, 126 99 바이트

벙어리 실수 몇 가지를 수정하여 -27. 외부 사용은 a필요하지 않았으므로 a완전히 제거 하고 apply str한 번만 쓸 수있었습니다 . 또한 메인 함수에 함수 매크로를 사용하여 바이트를 절약했습니다. 또한 Math/abs리 바인딩 대신 호출을 인라인했습니다 n-spaces.

기본적으로 @ Mr.Xcoder의 Python 아이디어의 Clojure 포트. 돌이켜 보면 원래 다이아몬드 챌린지에 abs/ range메소드를 사용해야 했지만 버그가있는 출력을 생성하지 않았을 수 있습니다!

꽤 간단합니다. 현재 행에 따라 여러 개의 공백으로 숫자 문자열을 조인합니다.

#(doseq[n(range -8 9)](println(clojure.string/join(apply str(repeat (Math/abs n)\ ))"1234567890")))

(defn bugged []
  (doseq [n-spaces (range -8 9)]
    (println
        (clojure.string/join
          ; "String multiplication"
          (apply str
                 (repeat (Math/abs n-spaces) \space))
          "1234567890"))))

젤리 , 15 바이트

8ŒRA⁶ẋØDṙ1¤jЀY

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

Mathematica, 92 바이트

Column@Join[Reverse@(s=Row/@Table[Riffle[Range@10~Mod~10,""<>Table[" ",i]],{i,0,8}]),Rest@s]

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

ctrl-v
를 사용 하여 코드 복사 / 붙여 넣기 Shift + Enter를 눌러 실행

C, 97 바이트

i=-9;main(j){for(;++i<9;putchar(10))for(j=0;++j<11;printf("        "+8-abs(i)))putchar(48+j%10);}

컴파일러는 아마도이 코드에 대해 많은 불만을 제기 할 것입니다 . 광산은 4 가지 유형의 7 가지 경고를 던졌습니다. 나중에 코드를 개선 할 수 있습니다.

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

C (gcc) , 76 바이트

f(x,y){for(y=-9;++y<9;puts(""))for(x=10;x++;printf("%-*d",abs(y)+1,x%=10));}

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

후행 공백을 출력하며 이는 정상입니다.

동적 길이의 왼쪽 정렬 필드를 사용하여 숫자를 인쇄합니다. 이것이 형식 문자열 %-*d입니다.

내부 루프는 종료 조건을 "단순화"하기 위해 재미있는 초기화 (10에서 시작, 10의 배수는 양호)가 있습니다.

숯 , 21 20 19 18 바이트

Ｆ⁹«Ｆ…¹χ⁺κ… ι0⸿»‖Ｂ↑

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

자세한 버전으로 연결합니다 . 기본적으로 나는 그림의 아래쪽 부분을 만든 다음 텍스트를 반영합니다.

CJam , 21 바이트

A,(+aH*ee{:\8-zS**n}/

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

설명

A,     e# Get [0 1 2 ... 9].
(+     e# Rotate the 0 to the end.
aH*    e# Wrap in an array and repeat 17 times.
ee     e# Enumerate. This pairs each copy of the array with its index in
       e# the list.
{      e# For each [index array] pair...
  :\   e#   Unwrap the pair and swap its order.
  8-z  e#   Get the absolute difference of the index from 8.
  S*   e#   Get a string of that many spaces.
  *    e#   Riffle the list of digits with the string of spaces.
  n    e#   Print it with a trailing linefeed.
}/

배치, 163 바이트

@set s=1 2 3 4 5 6 7 8 9 0
@set t=         
@for %%l in (9 7)do @for /l %%i in (1,1,%%l)do @call:%%l
:7
@set t=  %t%
:9
@set t=%t:~1%
@call echo %%s: =%t%%%

참고 : 첫 줄은 9 칸으로 끝납니다. 설명 : 크리에이티브 라인 번호 매기기를 사용합니다! 첫 번째 루프는 9 번 실행되고 매번 공백을 삭제해야하며, 두 번째 루프는 8 회 실행되고 매번 공백을 추가해야합니다. 전자는 7 회 실행하고 8 회 넘어져 달성되는 반면 후자는 2 개의 공백을 추가하고 넘어져서 그 중 하나를 다시 삭제함으로써 달성됩니다.

SOGL V0.12 , 14 바이트

ā9{SUčf@*∑Κ}╬Æ

여기 사용해보십시오!

설명:

ā               push an empty array
 9{        }    9 times do
   SU             push "1234567890"
     č            chop into characters
      f@*         get current iteration (0-based) amount of spaces
         ∑        join with that
          Κ       prepend this to the array
            Β  palindromize vertically with 1 overlap

PHP , 69 바이트

for(;$i<17;)echo join(str_pad("",abs($i++-8)),range(1,9)+[9=>0]),"
";

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

PowerShell , 30 바이트

8..0+1..8|%{1..9+0-join' '*$_}

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

8,7,6...2,1,0,1,2...8그런 다음 범위를 구성하여 각 숫자를 반복합니다. 내부 루프는 우리의 다양한 구성 1..9으로 연결된를 0다음 -join공간의 해당 번호와 함께 범위의 숫자. 각 문자열은 파이프 라인에 남아 있으며 프로그램 완료시 출력이 내재됩니다.