stdin에서 음이 아닌 정수 N을 받거나 함수 인수로 사용하는 프로그램이나 함수를 작성하십시오. 면이 각각 숫자 N의 N 복사본으로 만들어진 빈 ASCII 아트 사각형의 문자열을 인쇄하거나 반환해야합니다.

구체적으로 :

N이 0인 경우 N 사본이 사용되지 않으므로 출력이 없어야합니다 (또는 단일 후행 줄 바꿈).

N이 1인 경우 출력은 다음과 같습니다.

1

N이 2:

22
22

N이 3:

333
3 3
333

N이 4:

4444
4  4
4  4
4444

N이 5:

55555
5   5
5   5
5   5
55555

패턴은를 6통해 계속 됩니다 9.

N이 10인 경우 출력은 다음과 같습니다.

10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010

이것은 실제로 사각형이 아닙니다. 길이는 2 행이므로 키는 10 행이지만 20 열 10입니다. 이것은 의도 된 것입니다. 요점은 "사각형"의 각면에 N의 N 개 사본이 포함되어 있다는 것 입니다. 따라서 모든 입력 9은 기술적으로 ASCII 사각형이됩니다.

예를 들어 N이 23인 경우 출력은 다음과 같습니다.

2323232323232323232323232323232323232323232323
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
23                                          23
2323232323232323232323232323232323232323232323

여기에 필요한 출력의 Pastebins이다 99, 100,은 111, 그리고 123(그들은 브라우저에서 잘못된 보일 수 있지만, 텍스트 편집기에서이 올바른지 살펴 보겠습니다). 1000Pastebin 의 출력 은 크지 만 1000 개의 행과 4000 개의 열이 있습니다. 4 자리 이상의 숫자는 작은 숫자처럼 작동해야합니다.

세부:

• N은 +부호 나 다른 숫자가 아닌 일반적인 10 진수로 작성해야합니다 .
• 빈 공간은 공간으로 만 채워 져야합니다.
• 줄에 선행 또는 후행 공백이 없어야합니다.
• 사각형의 마지막 줄 다음에 하나의 줄 바꿈이 선택적으로 허용됩니다.
• 이 도전 후에 작성된 언어는 환영합니다. 단지 이길 수는 없습니다 .
• 바이트 단위의 가장 짧은 코드가 이깁니다!

줄프, 31 27 25 23 바이트

?=1i1ρρ,aii+*3έέi*li

이것은 ISO-8859-7 인코딩으로 인코딩되고 인쇄 할 수없는 파일을 포함하므로 다음은 16 진 덤프입니다.

0000000: 3f3d 3169 31f1 f12c 6169 692b 2a33 dd05  ?=1i1..,aii+*3..
0000010: dd69 052a 056c 69                        .i.*.li

이 바이올린을 온라인으로 시도 하거나 모든 테스트 사례를 한 번에 확인하십시오 (전체 실행 버튼 사용) .

n = 0에 대한 오류와 함께 종료 되며 기본적으로 허용됩니다.

4 6 오프 골프에 대해 Conor에게 큰 감사를드립니다 ! 바이트. _{^{inb4는 여전히 4 개의 주석처럼 보입니다.}}

설명

?=1i1ρρ,aii+*3έ\x05έi\x05*\x05li

?=1i1                             if input is 1 return 1, otherwise...
       ,aii+*3έ\x05               draw an input x input hollow box of tabs
      ρ            έi             replace all tabs with input
     ρ               \x05*\x05li  replace all spaces with spaces * length of input

스트립 됨 , 317 바이트

질문을하면서 새로운 "순수한"언어를 과시 할 수 있습니다.

@ f x
 d x
 f
 @ f x
+ x y
 +
  i x
 @ + y
 h x
} x y
 e 1
 i 1
 d y
 d 1
 d x
 } x y
e 0
e 2
i 2
i 2
e 6
+ 2 2 6
+ 2 6 6
e T
+ 2 2 T
+ 6 T T
e N
t N
e P
+ T 0 P
e L
i L
*
 e x
 *
  + P x x
 @ * T
 h x
~
 } N P 0
 d 0
 i L
 * P
 ~
~
#
 p N
-
 s 6
_
 @ - L
$
 #
 @ _ n
 #
 s 2
@ # N
e n
+ N 0 n
d n
d n
s 2
@ $ n
@ # N

^{( v1.0.0 에서 확실히 작동합니다 )}

증가 및 감소를 제외하고 Shtriped에는 수학 연산이 내장되어 있지 않습니다. 루핑이나 조건부도 없으므로 모든 프로그램에서 처음부터이 모든 것들을 구축해야합니다.

즉 예를 들어, 내 프로그램이 무엇이다 @, 루프 본질적이며 +, 부가 기능입니다 }입니다 >=. 실제 출력은 프로그램의 마지막 8 줄에서만 생성됩니다.

Shtriped에는 문자열이 없습니다. 문자열을 가져오고 인쇄 할 수 있지만 모두 내부적으로 증분 및 감소 만 가능한 임의의 정밀 정수로 표시됩니다. 따라서 10정사각형 중심을 적절한 양의 공간으로 채울 문자열의 길이를 얻는 쉬운 방법은 없습니다 . N의 길이를 십진수로 찾기 위해 ~효과적으로 계산 하는 함수 를 함께 묶어야했습니다 floor(log10(N)) + 1.

이것은 어디에서, 어떤 변수가 사용되는지를 재정 의하여 조금 더 골프를 칠 수는 있지만 그 이상은 아닙니다 . Shtriped의 고유 한 한계를 극복 할 수는 없습니다. (어쨌든 골프 언어가 아니 었습니다.)

주석 처리 된 코드 (백 슬래시는 주석입니다) :

@ f x \ function that calls f() x times, returns 0
 d x
 f
 @ f x
+ x y \ returns x + y
 +
  i x
 @ + y
 h x
} x y \ returns 1 if x >= y, else 0
 e 1
 i 1
 d y
 d 1
 d x
 } x y

\ declare and set up variables for the numbers 0, 2, 6, 10
e 0 \ 0 is used to help copy values via +
e 2 \ 2 is used for printing newlines
i 2
i 2
e 6 \ 6 is used for printing spaces
+ 2 2 6
+ 2 6 6
e T \ 10 is used for finding the string length of N
+ 2 2 T
+ 6 T T

e N \ declare N
t N \ and set it to what the user inputs

\ all the code from here to the last ~ is for finding the length of N as a string

e P \ P is the current power of 10 (10, 100, 1000...), starting with 10
+ T 0 P
e L \ L will be the length of N in decimal digits
i L

* \ function that returns P times 10 by adding P to itself 10 times
 e x
 *
  + P x x
 @ * T
 h x

~ \ function that increments L and multiplies P by 10 until N < P, at which point L will be the string length of N
 } N P 0 \ the 0 variable can be used as a dummy now since we don't need it anymore
 d 0
 i L
 * P \ multiply P by 10 to 
 ~
~

\ helper functions for displaying the output
# \ simply prints N as a decimal integer
 p N
- \ prints a single space
 s 6
_ \ prints L spaces (L = digit length of N)
 @ - L
$ \ prints one of the central N-2 lines of the square
 #
 @ _ n
 #
 s 2

\ finally, call these functions to display the output
@ # N \ print N copies of N (top line of square)
e n \ declare n and set it to N - 2
+ N 0 n
d n
d n \ if N was 0 or 1 the program will end here, having printed nothing if 0 or just the top line if 1
s 2 \ print a newline
@ $ n \ print the central line of the square N-2 times
@ # N \ print N copies of N (bottom line of square)

\ the output always prints without a trailing newline

진심으로, 32 31 30 29 bytes

╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(

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

설명:

╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(
╩                              push each input to its own register
                                 (we'll call register 0 "n")
 ╜                             push n to the stack
  ó                            terminate if 0
   $╝                          push str(n) to register 1
                                 (we'll call register 1 "s")
     ╜Dbu╜╛*n                  make min(2,n) copies of s*n (the top and bottom)
                                 (this avoids an extra copy if n is 1)
             ╜¬;               push n-2 twice
                ╛l*' *         push (n-2)*len(s) spaces
                      ╛+╛@+    put s on the front and end of the string (a middle piece)
                           n   push (n-2) total copies of the middle piece
                            (  bring the top piece to the top

자바 스크립트 (ES6), 73 82 78 바이트

@ user81655 덕분에 a4 바이트 절약

n=>(a=n[r='repeat'](n),n<2?a:a+`
${n+' '[r](n.length*(n-2))+n}`[r](n-2)+`
`+a)

입력 할 숫자가 아닌 문자열을받습니다.

온라인으로 사용해보십시오 (모든 브라우저에서 작동)

MATL , 34 29 26 바이트

:G\2<t!+gQ"@!2GVYX1GVnZ"YX

언어 / 컴파일러의 현재 릴리스 (13.0.0) 에서 작동합니다.

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

:            % array [1,2,...,N], where N is input, taken implicitly
G\           % modulo N. Gives [1,2,...,N-1,0]
2<           % smaller than 2? Gives [1,0,...,0,1]
t!           % duplicate, transpose
+            % addition with broadcast. Gives 2D array with nonzeros in the border 
             % and zeros in the interior
gQ           % convert to logical, add 1: twos in the border, ones in the interior
"            % for each column of that array (note the array is a symmetric matrix,
             % so columns and rows are the same)
  @!         %   push column. Transpose into a row        
  2GVYX      %   replace twos by the string representation of N, via regexp
  1GVnZ"YX   %   replace ones by as many spaces as length of that string, via regexp
             % end for each, implicitly
             % display stack contents, implicitly

T-SQL / SQL 서버 2012+, 167 161 바이트

DECLARE @ INT = 6;

SELECT IIF(u IN(1,s),REPLICATE(s,s),CONCAT(s,REPLICATE(' ',s-2*LEN(s)),s))
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v

산출:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

원하는 크기를 입력하고 클릭 Run query하여 텍스트 표현을 얻으십시오.

이 데모에는 고정 폭 글꼴이 표시되지 않습니다 . 그래서 7보다 두꺼운입니다 1.

편집하다:

입력을 문자열로 취급하면 :

DECLARE @ VARCHAR(10) = '7';

SELECT IIF(u IN(1,s),REPLICATE(s,s),s+REPLICATE(' ',s-2*LEN(s))+s)
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s+0)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v

LiveDemo2

줄리아, 78 바이트

n->(s="$n";(p=println)(s^n);[p(s*" "^(n-2)endof(s)*s)for i=2:n-1];n>1&&p(s^n))

이것은 정수를 허용하고 ASCII 사각형을 STDOUT에 인쇄하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

언 골프 드 :

function f(n)
    # Save a string version of n
    s = "$n"

    # Print the top line
    println(s^n)

    # Print each middle line
    [println(s * " "^(n-2)endof(s) * s) for i = 2:n-1]

    # Print the last line if there is one
    n > 1 && println(s^n)
end

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

루비, 100 바이트

->n{s="";n.times{|i|s+=(i<1||i>n-2?"#{n}"*n :"#{n}#{' '*[(n-2)*n.to_s.size,0].max}#{n}")+$/};puts s}

JS를 이길 수조차 없었습니다. 골프를 치는 데 도움이되는 추가 도움을 주시면 감사하겠습니다.

언 골프 버전은 다음과 같습니다.

def f(n)
    n.times{|num|
        if num == 0 || num == n-1
            s += "#{n}" * n
        else
            s += "#{n}"+" "*[(n-2)*n.to_s.length,0].max+"#{n}"
        end
        s += "\n"
    }
    puts s
end

레티 나, 76 바이트

.+
$0$*n$0
n(?=n*(\d+))|.
$1_
\d+_
$_¶
T`d` `(?<=¶.*_.*).(?=.*_\d.*¶\d)
\`_
[empty line]

내일 올지도 모른다.

여기에서 온라인으로 사용해보십시오.

C ++ 14, 156 자

분명히 다른 솔루션을 이길 수는 없지만 꽤 멋진 솔루션이라고 생각했습니다.

#define f for(i=0;i++<n;c<<t);
[](string t){auto&c=cout;int n=stoi(t),i;f c<<'\n';for(i=0;++i<n-1;c<<t,c.width(~-n*size(t)+1),c.fill(0),c<<t+'\n');if(n-1)f}

언 골프 드 :

#define f for ( i = 0; i++ < n; c << t ); // print top/bot row
[](string t) {
  auto& c = cout;
  int n = stoi(t), i;
  f // print first row
  c << '\n'; // kind of annoying but no way to get rid of (yes I tried
             // c << '\n'+t instead of c << t+'\n')
  for ( i = 0; ++i < n - 1; ) {
    c << t; // output the number
    // then we we get the width of necessary spaces
    c.width(~-n*size(t)+1); // Equivalent to (n-1)*size(t) + 1, but we save
                            // two bytes since ~- takes precedence over
                            // multiplication
    c.fill(0); // fill with spaces, ' ' == 0
    c << t+'\n';
   }
   if ( n-1 ) f // This if statement is dissapointing 
}

항상 그렇듯이 함수 사용을 호출하려면 [](string t) { ... }("10");

TSQL, 112 104 바이트

DECLARE @ varchar(10)='12'

PRINT REPLICATE(@,@)+ISNULL('
'+REPLICATE(@+ISNULL(SPACE((@-2)*len(@))+@,'')+'
',@-2)+REPLICATE(@,@),'')

1. generating first line
2. adding hollow lines + line breaks
3. adding last line(when needed)

Minkolang 0.15 , 57 바이트

nd?.d1-2&N.$z01FlOz2-[lz6Z" "I2-z2-*Dz6Z$O]01F.
z[z6Z]$Of

여기 사용해보십시오!

설명

n                Read number from input
 d?.             Stop if n=0, continue otherwise
    d1-2&N.      Print 1 and stop if n=1, continue otherwise
           $z    Store top of stack in register (z, which is n)

01F                                   Gosub to second line
   lO                                 Print newline
     z2-                              Push value from register and subtract 2
        [                             Pop k and run body of for loop k times
                                      (Does not run if k <= 0)
         l                            Push a newline
          z6Z                         Push z and convert to string
             " "                      Push a space
                I2-                   Push length of stack minus 2
                   z2-                Push z minus 2
                      *               Pop b,a and push a,b
                       D              Pop k and duplicate top of stack k times
                        z6Z           Push z and convert to string
                           $O         Output whole stack as characters
                             ]        Close for loop
                              01F.    Gosub to second line and stop after returning.


z[   ]       For loop that runs z times
  z6Z        Push z and convert to string
      $O     Output whole stack as characters
        f    Return to position called from

펄, 79 76 74 바이트

$_=$.=pop;s/./ /g;print$.x$.,$/,($.,$_ x($.-2),$.,$/)x($.-2),$.>1?$.x$.:''

꽤 직설적 인. 첫 번째 명령 줄 인수는 숫자로 사용됩니다. 스크립트를 파일에 넣고로 실행하십시오 perl file.pl 1.

펄, 62 60 58 + 2 = 60 바이트

for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}

-nlE플래그 필요 :

$ perl -nlE'for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}' <<< 5
55555
5   5
5   5
5   5
55555

공백이 추가 된 경우 :

for$.(1..$_) {
  say(
    $. > 1 & $. < $_
      ? $_ . $"x(length$_*($_-2)) . $_
      : $_ x $_
  )
}

R, 90 바이트

x=scan();m=matrix(x,x,x);k=2:(x-1)*(x>2);m[k,k]=format("",w=nchar(x));write(m,"",n=x,s="")

x*x크기 의 행렬을 만든 다음 size의 공백으로 채 웁니다 nchar(x). 경우 x보다 작은 2, 다음 아무것도 채워지지되고있다.

Pyth-26 바이트

K*QQjbm++Q**lQ;ttQQttQK

여기에서 온라인으로 사용해보십시오 .

핍 -l , 21 바이트

현재 정책에 따라 허용되는 질문보다 새로운 언어 기능을 사용합니다. 질문 문구가 해당 정책을 무시하도록 해석되는 경우 아래 25 바이트 답변을 참조하십시오.

Yq{MN++g%y>1?sMyy}MCy

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

트릭에 대한 Luis Mendo의 MATL 덕분에 (a+1)%n<2.

설명

Yqstdin에서 줄을 읽고 들어갑니다 y. 그때:

{              }MCy  Map this function to each coordinate pair in a y-by-y grid
                     (Inside the function, the list of both coords is g)
   ++g                Increment both coordinates
      %y              Take them mod y
 MN     >1?           Test whether the min of the resulting list is 2 or greater
           sMy         If so, it's in the center; use len(y) spaces
              y        If not, it's an edge; use the number y
                     Print result with newlines between rows (implicit, -l flag)

원래 2016 답변, 25 바이트 (플러스 -l플래그) :

Yq{MN++*a%y<2?ysX#y}MMCGy

변경 로그:

• MC더 최근에 추가되었습니다; 당시에는 MMCG(지도 맵 + 좌표 그리드)를 사용했습니다.
• 현재 인터프리터 ++에 목록에서 사용하지 못하게하는 버그가 있었으므로 대신 각 요소에 ++*적용 ++해야했습니다.
• MAP는 확장 된 지금 <string1> M <string2>의 목록 반환 len(<string2>)의 사본 <string1>; 당시에는 sX#y문자열 반복 공간을로 사용했습니다 len(y).

Pyth, 37 30 바이트

J*K`QQI>Q1JV-Q2++Q*d-lJ*2lKQ;J

여기에서 시도하십시오.

J*K`QQ                          set K to repr(input); that is, stringified
                                  set J to K repeated (input) times
      I>Q1                  ;   if input is greater than 1...
          J                     output J (stringified input times input)
           V-Q2                 do this (input - 2) times...
               ++               output the following on one line:
                 Q              the input number
                  *d-lJ*2lK     n spaces, where n = len(J) - 2*len(K)
                           Q    the input number again
                            ;   break out of everything
                             J  output J (str(input)*input) one last time,
                                  regardless of whether input > 1

망막 , 90

다시 말하지만, 나는 이것이 전문가들에 의해 크게 골프화 될 것이라고 확신합니다.

.+
$&$&$*:$&$*;
+`(\d+:):
$1$1
+`([\d+:]+;);
$1$1
T`d` `(?<=;\d+:)[^;]+(?=:\d+:;\d)
:

;
¶

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

젤리, 28 바이트

Grr, Jelly가 줄에 나쁜지 또는 Jelly에 나쁜지를 알 수 없습니다.

ŒṘ©L⁶xWẋWẋ$®W¤1¦€U'Z$$4¡j⁷ȯ⁷

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

파이크 , 33 바이트 (비경쟁)

QD`i*Djli2*lR-k*iRi]3J"bR+2Q-*jR+

설명:

                                  - autoassign Q = eval_or_not(input())
QD`i*                             - Get the input multiplied by itself
Q                                 - [Q]
 D                                - [Q, Q]
  `                               - [repr(Q), Q]
   i                              - i = stack[0]
    *                             - [stack[0]*stack[1]]

     Djli2*lR-                    - Get number of spaces
     D                            - [^,^]
      j                           - j = stack[0]
       l                          - len(stack[0])
        i2*                       - i*2
           l                      - len(stack[0])
            R                     - rotate_2()
             -                    - stack[0]-stack[1]

              k*iRi               - Get middle line
              k*                  - " "*^
                iRi               - [i,^,i]

                   ]3J"bR+        - Join middle line together
                   ]3             - list(stack[:3])
                     J"           - "".join(stack[0])
                       bR+        - ^+"\n"

                          2Q-     - Get middle lines
                          2Q-*    - Q-2

                              jR+ - Add end line
                              jR+ - ^+j

CJam, 27 바이트

ri:X,_ff{a+[0X(]&XXs,S*?}N*

제안 해 주신 @ MartinBüttner에게 감사합니다 ff. 그것은 a+[0X(]&꽤 비린내가있다. 그러나 오 잘.

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

ri:X              Read input integer and save as variable X
,_                Range, i.e. [0 1 ... X-1] and make a copy
ff{...}           Map with extra parameter, twice. This is like doing a Cartesian product
                  between two 1D arrays, but we get a nice X by X array at the end

                  For each coordinate pair,
a+                Put the two coordinates into an array
[0X(]&            Set intersection with the array [0 X-1]
X                 Push X
Xs,S*             Push a number of spaces equal to the length of X
?                 Ternary: choose one of the previous two depending on the set intersection

N*                Join X by X array with newlines

파이썬 2, 70 자

def p(i):
 k=`i`;j=i-2;h=k*i;print h+'\n'+(k+' '*j*len(k)+k+'\n')*j+h

하스켈, 78 바이트

i x=unlines$take x$1#s:3#[s++(3#s>>" ")++s]++[1#s]where s=show x;z#s=[z..x]>>s

사용 예 :

*Main> putStr $ i 4
4444
4  4
4  4
4444

이 기능은 >>유용 : <list> >> <string>수 length <list>의 사본 <string>을 위해, 예를 들어, 상단과 하단 라인 x=10입니다 [1..10] >> "10"-> "10101010101010101010".

펄, 72 바이트

$_=($.=pop)-2;say for($.x$.,($..($.x$_)=~s/./ /rg.$.)x$_,$.x$.)[0..$.-1]

현대적인 Perl 기능에 의존합니다 :

'무언가' 라고 말하다

Perl 5.10부터 자동으로 사용 가능합니다 (v5.10 이상 사용).

str_expr = ~ s /.../.../ r

행복하게 양보하기를 rvalue (반드시 스칼라 변수로 감소 아닌 str_expr)에서 작동하도록 허용 r에 esult합니다 ( ' R 초기 str_expr을 변경하지 않고 정규 표현식의 끝에'옵션을).

PHP, 151 바이트

function s($n){for($r=0;$r<$n;$r++){for($c=0;$c<$n;$c++){if($r*$c&&$r!=$n-1&&$c!=$n-1){for($d=0;$d<=log10($n);$d++){echo' ';}}else{echo$n;}}echo"\n";}}

절대 혼란, 최적화하는 데 더 많은 시간이 필요합니다. s(Number)당신에게 출력을 제공합니다.

자바 8, 280 바이트

interface A{static<T>void p(T o){System.out.print(o);}static void main(String[]a){long n=new Long(a[0]),l=a[0].length();for(long i=0;i<n;i++,p(a[0]));p("\n"+(n>1?a[0]:""));for(long j=2;j<n;j++,p(a[0])){for(long i=l*2;i<n*l;i++,p(' '));p(a[0]+"\n");}for(long i=1;i<n;i++)p(a[0]);}}

가장 짧은 답변보다 약 10 배 밖에 걸리지 않으므로 Java에 정말 좋습니다!

예제 실행 :

$ java A 10
10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010

파이썬 3, 108 96 148 바이트

a=input()
b=c=int(a)-2 if a!="1" else 0
print(a*int(a))
while b:print(a+" "*int(len(a))*c+a);b-=1
if a!="1":print(a*int(a))

언 골프 / 설명 :

number = input() # Gets a number as input
iterator = var = int(number) - 2 if number != "1" else 0 # Assigns two variables, one of them an iterator, to the number minus 2 (the amount of middle rows in the square) if the number isn't 1. If it is, it sets the vars to 0 so the while doesn't trigger.
print(number * int(number)) # Prints the top row of the square.
while iterator != 0: # Loops for the middle rows
    print(number + " " * int(len(number)) * var + number) # Prints the number, then as many spaces as needed, and the number.
    iterator -= 1 # De-increments the iterator.
if number != 1: # Makes sure the number isn't 1, because 1 should return 1.
    print(a * int(a)) # Same as the first row, it prints the bottom row.

이것이 첫 번째 코드 골프 답변이므로 일부 건설적인 비판 및 / 또는 제안이 도움이 될 것입니다!

녹 141 137 바이트

몇 가지 서식 지정 항목을 남용했습니다. 그렇지 않으면 훨씬 길어졌습니다.

|i|{let f=||{for _ in 0..i{print!("{}",i)}println!("")};f();if i>1{for _ in 0..i-2{println!("{}{0:1$}",i,i.to_string().len()*(i-1))}f()}}

포장 풀기 :

|i| {
    let f = || {
        for _ in 0..i {
            print!("{}",i)
        }
        println!("")
    };

    f();

    if i>1 {
        for _ in 0..i-2 {
            println!("{}{0:1$}",i,i.to_string().len()*(i-1))
        }
        f()
    }
}

운동장 링크

Powershell, 98 96 95 83 82 75 바이트

param($n)($l="$n"*$n)
if(($m=$n-2)-ge0){,"$n$(' '*"$n".Length*$m)$n"*$m
$l}

Ungolfed 및 설명 테스트 스크립트 :

$f = {

    param($n)
    ($l="$n"*$n)                #   let $l is a string contains N only and return this value as a first line
    $m=$n-2
    if($m-ge0){                 # if(N>1)
        $s=' '*"$n".Length*$m   #   let $s is spaces inside repeated (length of string represented of n * m)
        ,"$n$s$n"*$m            #   return $m strings contains: N, spaces and N
        $l                      #   retrun the first line again
    }

}

&$f 1
&$f 2
&$f 3
&$f 4
&$f 10

산출:

1
22
22
333
3 3
333
4444
4  4
4  4
4444
10101010101010101010
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10                10
10101010101010101010