이 질문은 내 사무실에서 바이러스처럼 확산되었습니다. 매우 다양한 접근 방식이 있습니다.

다음을 인쇄하십시오.

        1
       121
      12321
     1234321
    123454321
   12345654321
  1234567654321
 123456787654321
12345678987654321
 123456787654321
  1234567654321
   12345654321
    123454321
     1234321
      12321
       121
        1

문자 수가 적을수록 좋은 점수를받습니다.

J, 29 26 24 23 22 21 자

,.(0&<#":)"+9-+/~|i:8

트릭을 위한 FUZxxl 덕분에 "+(나는 이전에 사용한 적이 없다고 생각합니다 u"v).

설명

                  i:8  "steps" vector: _8 _7 _6 ... _1 0 1 ... 7 8
                 |     magnitude
              +/~      outer product using +
            9-         inverts the diamond so that 9 is in the center
  (      )"+           for each digit:
      #                  copy
   0&<                   if positive then 1 else 0
       ":                copies of the string representation of the digit
                         (in other words: filter out the strictly positive
                          digits, implicitly padding with spaces)
,.                     ravel each item of the result of the above
                       (necessary because the result after `#` turns each
                        scalar digit into a vector string)

APL ( 33 31)

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽¨⍴∘(1↓⎕D)¨⍳9

숫자를 구분하는 공백이 허용되면 (Mathematica 항목에서와 같이) 28 26 으로 단축 될 수 있습니다 .

A⍪1↓⊖A←A,0 1↓⌽A←⌽↑⌽∘⍕∘⍳¨⍳9

설명:

• (긴 프로그램 :)
• ⍳9: 1에서 9까지의 숫자 목록
• 1↓⎕D: ⎕D는 문자열 '0123456789'이며 1↓첫 번째 요소를 제거합니다.
• ⍴∘(1↓⎕D)¨⍳9:의 각 요소 N에 ⍳9대해에서 첫 번째 N 요소를 가져옵니다 1↓⎕D. [ "1", "12", "123", ... "123456789"] 목록을 문자열로 제공합니다.

• ⌽¨:이 목록의 각 요소를 반대로 바꿉니다. [ "1", "21", "321"...]

• (짧은 프로그램 :)

• ⍳¨⍳9: N에 대한 1부터 N까지의 목록 [1..9]. 그러면 [[1], [1,2], [1,2,3] ... [1,2,3,4,5,6,7,8,9]]가 숫자로 표시됩니다.
• ⌽∘⍕∘: 이러한 각 목록의 문자열 표현의 반대입니다. [ "1", "2 1"...]
• (지금부터 동일)
• A←⌽↑: 목록의 목록에서 행렬을 만들고 오른쪽에 공백을 채워 넣은 다음 그 반대로합니다. 이것은 다이아몬드의 상한 사분면을 제공합니다. A에 저장됩니다.
• A←A,0 1↑⌽A: A, A의 첫 번째 열에서 오른쪽에 연결된 첫 번째 열. 사각형의 위쪽 절반이 나타납니다. 그런 다음 A에 다시 저장됩니다.
• A⍪1↓⊖A: ⊖Ais 세로로 미러링되고 (하반신 제공) 하반신 1↓의 맨 위 행을 제거하고 상단의 맨 A⍪위입니다 1↓⊖A.

Clojure의, 191 179 바이트

#(loop[[r & s](range 18)h 1](print(apply str(repeat(if(< r 8)(- 8 r)(- r 8))\ )))(doseq[m(concat(range 1 h)(range h 0 -1))](print m))(println)(if s(recur s((if(< r 8)inc dec)h))))

outer doseq를 a 로 변경하여 -12 바이트로 loop, atom(yay)를 제거 할 수있었습니다 .

이중 "for-loop". 외부 루프 ( loop내부 루프 (하면서), 각 행으로 진행한다 doseq)의 범위에있는 행의 각 숫자를 넘어 (concat (range 1 n) (range n 0 -1)), n행의 최대 수이다.

(defn diamond []
  (let [spaces #(apply str (repeat % " "))] ; Shortcut function that produces % many spaces
    (loop [[row-n & r-rows] (range 18) ; Deconstruct the row number from the range
           high-n 1] ; Keep track of the highest number that should appear in the row
      (let [top? (< row-n 8) ; Are we on the top of the diamond?
            f (if top? inc dec) ; Decided if we should increment or decrement
            n-spaces (if top? (- 8 row-n) (- row-n 8))] ; Calculate how many prefix-spaces to print
        (print (spaces n-spaces)) ; Print prefix-spaces
        (doseq [m (concat (range 1 high-n) (range high-n 0 -1))] ; Loop over the row of numbers
          (print m)) ; Print the number
        (println)

        (if r-rows
          (recur r-rows (f high-n)))))))

첫 번째 시도에서 논리의 버그로 인해 (실수로 각 숫자 사이에 접두사 공백을 삽입하는 경우) 다음과 같은 결과를 얻었습니다.

1
1       2       1
1      2      3      2      1
1     2     3     4     3     2     1
1    2    3    4    5    4    3    2    1
1   2   3   4   5   6   5   4   3   2   1
1  2  3  4  5  6  7  6  5  4  3  2  1
1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
12345678987654321
1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1
1  2  3  4  5  6  7  8  9  8  7  6  5  4  3  2  1
1   2   3   4   5   6   7   8   7   6   5   4   3   2   1
1    2    3    4    5    6    7    6    5    4    3    2    1
1     2     3     4     5     6     5     4     3     2     1
1      2      3      4      5      4      3      2      1
1       2       3       4       3       2       1
1        2        3        2        1
1         2         1

명백한 버그를 무시해도 문제는 없지만 멋져 보였습니다.

매스 매 티카 83 49 43 54 51

Print@@#&/@(Sum[k~DiamondMatrix~17,{k,0,8}]/.0->" ")

Kelly Lowder 덕분에 3 바이트가 절약되었습니다.

분석

코드의 주요 부분은 WolframAlpha에서Sum[DiamondMatrix[k, 17], {k, 0, 8}] 확인할 수 있습니다 .

다음은 접근 방식의 기본 논리를 소규모로 보여줍니다.

a = 0~DiamondMatrix~5;
b = 1~DiamondMatrix~5;
c = 2~DiamondMatrix~5;
d = a + b + c;
e = d /. 0 -> "";
Grid /@ {a, b, c, d, e}

파이썬 2, 72 69 67 61

영리하지 않다 :

s=str(111111111**2)
for i in map(int,s):print'%8s'%s[:i-1]+s[-i:]

C, 79 자

v;main(i){for(;i<307;putchar(i++%18?v>8?32:57-v:10))v=abs(i%18-9)+abs(i/18-8);}

파이썬 2, 60 59

for n in`111111111**2`:print`int('1'*int(n))**2`.center(17)

백틱과 남용을 남용합니다.

GolfScript, 33 31 30 자

다른 GolfScript 솔루션

17,{8-abs." "*10@-,1>.-1%1>n}%

다른 문자 를 위해 @PeterTaylor 에게 감사합니다 .

Previos 버전 :

17,{8-abs" "*9,{)+}/9<.-1%1>+}%n*

( 온라인으로 실행 )

17,{8-abs" "*9,{)+}/9<.-1%1>n}%

매스 매 티카 55 50 45 41 38

(10^{9-Abs@Range[-8,8]}-1)^2/81//Grid

Grid[(10^Array[{9}-Abs[#-9]&,17]-1)^2/81]

자바 스크립트, 114

Codegolf에 대한 첫 출품!

for(l=n=1;l<18;n-=2*(++l>9)-1,console.log(s+z)){for(x=n,s="";x<9;x++)z=s+=" ";for(x=v=1;x<2*n;v-=2*(++x>n)-1)s+=v}

이것이 더 짧아 질 수 있다면 의견을 주시기 바랍니다 :)

PHP, 92 90 자

<?for($a=-8;$a<9;$a++){for($b=-8;$b<9;){$c=abs($a)+abs($b++);echo$c>8?" ":9-$c;}echo"\n";}

중심으로부터 위치의 맨해튼 거리를 계산하고 인쇄합니다. 1보다 작 으면 공백을 인쇄합니다.

익명 사용자가 다음과 같은 개선 (84 자)을 제안했습니다.

<?for($a=-8;$a<9;$a++,print~õ)for($b=-8;$b<9;print$c>8?~ß:9-$c)$c=abs($a)+abs($b++);

일반적인 Lisp, 113 자

(defun x(n)(if(= n 0)1(+(expt 10 n)(x(1- n)))))(dotimes(n 17)(format t"~17:@<~d~>~%"(expt(x(- 8(abs(- n 8))))2)))

먼저 다이아몬드의 요소가 다음과 같이 표현 될 수 있음을 알았습니다.

  1   =   1 ^ 2
 121  =  11 ^ 2
12321 = 111 ^ 2

기타

x재귀 적으로 제곱 된 밑 (1, 11, 111 등)을 계산 한 다음 중앙에 인쇄합니다 format. 숫자를 가장 높은 항으로 올리고 다시 내리 (- 8 (abs (- n 8)))려면 두 번째 루프를 피하는 데 사용 했습니다.

숯 (비경쟁), 13 바이트

언어가 질문보다 훨씬 더 새롭기 때문에 경쟁하지 않습니다.

Ｆ⁹«ＧX⁻⁹ιＩ⁺ι¹→

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

어떻게?

서로 위에 9 개의 연속적으로 작은 동심원 숫자 다이아몬드를 그립니다.

Ｆ⁹«   Loop ι from 0 to 8:
ＧX     Draw a (filled) polygon with four equilateral diagonal sides
⁻⁹ι      of length 9-ι
Ｉ⁺ι¹    using str(ι+1) as the character
→       Move right one space before drawing the next one

자바 스크립트, 81

for(i=9;--i+9;console.log(s))for(j=9;j;s=j--^9?k>0?k+s+k:" "+s:k+"")k=i<0?j+i:j-i

PowerShell (2 옵션) : 92 84 45 바이트

1..8+9..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}
1..9+8..1|%{' '*(9-$_)+[int64]($x='1'*$_)*$x}

1 ^ 2,11 ^ 2,111 ^ 2를 사용하는 힌트 를 얻은 Strigoides 에게 감사드립니다 .

다음과 같은 방법으로 일부 캐릭터를 면도했습니다.

• 제거 $w.
• $x처음 사용하는 대신 정의를 중첩했습니다 .
• Rynant의 솔루션 에서 힌트를 얻었습니다 .
  • 정수 배열을 +대신 ,사용하여 배열 주위의 괄호를 제거하고 루프의 중첩 계층을 제거 할 수 있습니다.
  • 9-$_더 복잡한 수학 및 객체 방법 대신 필요한 공간의 길이를 계산하는 데 사용 됩니다. 이것은 또한의 필요성을 제거했다 $y.

설명:

1..8+9..1또는 1..9+8..11에서 9까지 오름차순으로 1에서 내림차순으로 정수 배열을 생성합니다.

|%{... 내장 별칭을 통해 }정수 배열을 ForEach-Object루프 로 파이프합니다 %.

' '*(9-$_)+ 9에서 현재 정수를 뺀 다음이 줄의 출력 시작 부분에 많은 공간의 문자열을 만듭니다.

[int64]($x='1'*$_)*$x현재 정수가 크면 s $x문자열로 정의합니다 1. 그런 다음 int64로 변환되고 ( E 표기법을 사용하지 않고 111111111 ² 를 올바르게 출력해야 함 ) 제곱됩니다.

Vim, 62 39 38 키 입력

많은 바이트를 절약 한 @DJMcMayhem에게 감사합니다!

나의 첫번째 Vim 답변, 너무 신나!

i12345678987654321<ESC>qqYP9|xxI <ESC>YGpHq7@q

녹음을 통해 숫자를 쓰려고했지만 훨씬 길다

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

설명:

i123 ... 321<ESC>                   Write this in insert mode and enter normal mode
qq                                  Start recording into register q
  YP                                Yank this entire line and Paste above
    9|                              Go to the 9th column
      xx                            Delete character under cursor twice
        I <ESC>                     Go to the beginning of the line and insert a space and enter normal mode
               Y                    Yank this entire line
                G                   Go to the last line
                 p                  Paste in the line below
                  H                 Go to the first line
                   q                End recording
                    7@q             Repeat this 7 times

편집하다:

H대신 gg1 바이트를 사용 하고 저장했습니다.

APL (Dyalog Classic) , 20 19 바이트

(⍉⊢⍪1↓⊖)⍣2⌽↑,⍨\1↓⎕d

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

⎕d 자릿수 '0123456789'

1↓첫 번째 드롭 ( '0')

,⍨\ 교체 된 catenate 스캔, 즉 반전 된 접두사 '1' '21' '321' ... '987654321'

↑ 공백으로 채워진 행렬로 혼합하십시오.

1
21
321
...
987654321

⌽ 행렬을 가로로 뒤집다

(... )⍣2이 작업을 두 번 수행하십시오.

⍉⊢⍪1↓⊖⍉행렬 자체 의 조옮김 ( )은 첫 번째 행 ( ) 없이 수직 반전 된 행렬 ( ) 과 ⊢수직으로 연결 ( )⍪⊖1↓

R, 71 자

기록을 위해 :

s=c(1:9,8:1);for(i in s)cat(rep(" ",9-i),s[0:i],s[(i-1):0],"\n",sep="")

k ( 64 50 자)

-1'(::;1_|:)@\:((|!9)#'" "),'$i*i:"J"$(1+!9)#'"1";

오래된 방법 :

-1',/(::;1_|:)@\:((|!9)#\:" "),',/'+(::;1_'|:')@\:i#\:,/$i:1+!9;

CJam, 31 27 바이트

CJam은이 도전보다 훨씬 새로운 것이므로이 답변을 수락 할 수 없습니다. 그러나 이것은 토요일 저녁의 작은 도전이었습니다. ;)

8S*9,:)+9*9/2%{_W%1>+z}2*N*

여기에서 테스트하십시오.

아이디어는 왼쪽 위 사분면을 먼저 형성하는 것입니다. 작동 방식은 다음과 같습니다.

먼저을 " 123456789"사용하여 문자열을 형성하십시오 8S*9,:)+. 이 문자열의 길이는 17 자입니다. 이제 문자열을 9 번 반복 한 다음을 사용하여 길이가 9 인 하위 문자열로 분할합니다 9/. 9와 17 사이의 불일치는 다른 모든 행을 한 문자 왼쪽으로 오프셋합니다. 각 부분 문자열을 자체 줄에 인쇄하면 다음과 같은 결과가 나타납니다.

        1
23456789 
       12
3456789  
      123
456789   
     1234
56789    
    12345
6789     
   123456
789      
  1234567
89       
 12345678
9        
123456789

따라서 우리가 다른 행을 모두 삭제하면 (편리하게 작동하여 2%) 원하는대로 하나의 사분면을 얻습니다.

        1
       12
      123
     1234
    12345
   123456
  1234567
 12345678
123456789

마지막으로 두 번 미러링하여 두 미러링 작업이 다른 축을 따라 이동하도록 그리드를 바꿉니다. 미러링 자체는 단지

_      "Duplicate all rows.";
 W%    "Reverse their order.";
   1>  "Discard the first row (the centre row).";
     + "Add the other rows.";

마지막으로 모든 줄을 개행과 함께 연결 N*합니다.

GolfScript, 36 자

이것이 코드 골프 과제 라고 가정하면 기본 GolfScript 솔루션은 다음과 같습니다.

9,.);\-1%+:a{a{1$+7-.0>\" "if}%\;n}%

루비, 76 자

def f(a)a+a.reverse[1..-1]end;puts f [*1..9].map{|i|f([*1..i]*'').center 17}

개선을 환영합니다. :)

Befunge-93 , 155 자

9:v:<,+55<v5*88<v-\9:$_68v
> v>     ^>3p2vpv  -1<!  *
, 1^  2p45*3+9<4:    ,:  +
g -^_75g94+4pg7^!    +^ ,<
1 : ^ `0    :-1$_:68*^$
^1_$:55+\-0\>:#$1-#$:_^

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

확실히 더 골프를 칠 수는 있지만 내 첫 번째 Funge 프로그램이며 이미 머리가 아파요. 그래도 재미 있었어

자바 스크립트, 170 바이트

내 첫 번째 코드 골프 :)

골프

a="";function b(c){a+=" ".repeat(10-c);for(i=1;i<c;i++)a+=i;for(i=2;i<c;i++)a+=c-i;a+="\n";}for(i=2;i<11;i++)b(i);for(i=9;i>1;i--)b(i);document.write("<pre>"+a+"</pre>");

언 골프

var str = "";
function row(line) {
    str += " ".repeat(10 - line);
    for (var i = 1; i < line; i++) {
        str += i;
    }
    for (var i = 2; i < line; i++) {
        str += line - i;
    }
    str += "\n";
}
for (var line = 2; line < 11; line++) {
    row(line);
}
for (var line = 9; line > 1; line--) {
    row(line);
}
document.write("<pre>" + str + "</pre>");

펄 56 54 자

-p스위치에 1 개의 문자를 추가했습니다 .

시퀀스를 생성하기 위해 제곱 된 반발을 사용합니다.

s//12345678987654321/;s|(.)|$/.$"x(9-$1).(1x$1)**2|eg

펄, 43 + 1

에 -E필요한 +1 추가say

say$"x(9-$_).(1x$_)**2for 1..9,reverse 1..8

편집 : 조금 단축

파이썬, 65

for i in map(int,str(int('1'*9)**2)):print' '*(9-i),int('1'*i)**2

그루비 77 75

i=(-8..9);i.each{a->i.each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}

구 버전:

(-8..9).each{a->(-8..9).each{c=a.abs()+it.abs();print c>8?' ':9-c};println""}

스칼라-86 자

val a="543210/.-./012345";for(i<-a){for(j<-a;k=99-i-j)print(if(k<1)" "else k);println}

자바 스크립트, 137

재귀와 함께 :

function p(l,n,s){for(i=l;i;s+=" ",i--);for(i=1;i<=n;s+=i++);for(i-=2;i>0;s+=i--);return(s+="\n")+(l?p(l-1,n+1,"")+s:"")}alert(p(8,1,""))

CG에 처음 :)

또는 118

111111111**2더 높은 정밀도로 실행되는 JS 구현을 찾을 수 있다면 .
(여기 : 12345678987654320).

a="1",o="\n";for(i=0;i<9;i++,o+="         ".substr(i)+a*a+"\n",a+="1");for(i=8;i;i--)o+=o.split("\n")[i]+"\n";alert(o)