Negatif olmayan bir tamsayıda N alanını stdin'den veya işlev argümanından alan bir program veya işlev yazın. Her biri N sayısının N kopyası ile yapılmış olan içi boş bir ASCII-art karesinin bir dizisini yazdırmalı veya iade etmelidir.

özellikle:

N ise 0, N'nin hiçbir kopyası kullanılmaz, bu nedenle çıktı olmamalıdır (veya yalnızca sondaki bir satırsonu).

N ise 1, çıktı:

1

N ise 2:

22
22

N ise 3:

333
3 3
333

N ise 4:

4444
4  4
4  4
4444

N ise 5:

55555
5   5
5   5
5   5
55555

Desen, 6içinden devam eder 9.

N ise 10, çıktı:

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

Bunun aslında kare olmadığına dikkat edin. 10 satır uzunluğunda ancak 20 sütun genişliğinde çünkü 10iki karakter uzunluğunda. Bu amaçlanmıştır. Mesele şu ki, "karenin" her bir tarafı N'nin N kopyasını içerir. Bu nedenle tüm girdiler 9teknik olarak ASCII dikdörtgenleri olacaktır.

Örneğin, N ise 23, çıktı:

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

İşte için gerekli çıktıların Pastebins olan 99, 100, 111ve 123(onlar bir tarayıcıda yanlış görünebilir ama bir metin editörü onlar doğru bakacağız). Bunun için çıktı 1000Pastebin için daha büyük, ancak 1000 satır ve 4000 sütun olacaktı. 4 veya daha fazla rakam içeren sayılar, daha küçük sayılar gibi çalışmalıdır.

Detaylar:

• N, normal ondalık sayı göstergesinde, +işaretsiz veya rakamsız bir şekilde yazılmalıdır .
• İçi boş alan sadece boşluklarla doldurulmalıdır.
• Hiçbir çizginin önde veya arkada boşluk olmaması gerekir.
• Karelerin son satırından sonra tek bir yeni satıra isteğe bağlı olarak izin verilir.
• Bu meydan okuma yapıldıktan sonra yazılan diller açıktır, sadece kazanmaya uygun değildir .
• Bayt cinsinden en kısa kod kazanır!

Jolf, 31 27 25 23 bayt

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

Bu, ISO-8859-7 kodlamasında kodlanmıştır ve yazdırılamaz içerir, bu yüzden burada bir hexdump:

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

Bu kemanı çevrimiçi deneyin veya tüm test durumlarını bir kerede doğrulayın (tüm çalıştır düğmesini kullanın) .

Bu, varsayılan olarak izin verilen n = 0 hatasıyla çıkar .

Conor'a 4 6 golf oynadığı için teşekkür ederiz ! bayt. _{^{inb4 dört çarpı hala dört yorum gibi görünüyor}}

açıklama

?=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

Gezindi , 317 bayt

Soruyu yaparken, yeni "saf" dilimi gösterebilirim.

@ 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

^{(kesinlikle v1.0.0'da çalışır )}

Shtriped'de yerleşik olarak artırma ve azaltma dışında bir matematik işlemi yoktur. Ayrıca ilmek ya da şartlanma yoktur, bu nedenle bunların hepsinin her programda sıfırdan oluşturulması gerekir.

Yani örneğin benim program yaptığı da budur @, döngü aslında bir olduğunu +, ilave bir işlevdir }olduğunu >=. Gerçek çıktı sadece programın son 8 satırında üretilir.

Shtriped'de de hiçbir dize yok. Dizeleri alabilir ve yazdırabilirsiniz, ancak hepsi dahili olarak yalnızca artırılıp azaltılabilen keyfi kesin tamsayılar olarak temsil edilir. Dolayısıyla 10, kare merkezinde doğru boşluklarla doldurmak için dize uzunluğunu almanın kolay bir yolu yoktur . Onda N uzunluğunu bulmak için ~etkili bir şekilde hesaplayan fonksiyonu bir araya getirmek zorunda kaldım floor(log10(N)) + 1.

Bu, muhtemelen hangi değişkenlerin nerede ve nasıl kullanıldığını yeniden düzenleyerek biraz daha fazla golf oynayabilir, ancak o kadar fazla değil . Shtriped'in içsel kısıtlamaları aşmanın yolu yok. (Zaten hiç bir golf dili olmak istememişti.)

Yorumlanan kod (ters eğik çizgi yorumdur):

@ 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

Cidden, 32 31 30 29 bayt

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

Çevrimiçi deneyin!

Açıklama:

╩╜ó$╝╜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

JavaScript (ES6), 73 82 78 bayt

@ User81655 sayesinde kaydedilmiş a4 bayt

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

Girdi için sayı değil dize alır.

Çevrimiçi deneyin (tüm tarayıcılar çalışır)

MATL , 34 29 26 bayt

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

Bu , dilin / derleyicinin geçerli sürümüyle (13.0.0) çalışır

Çevrimiçi deneyin!

:            % 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 Server 2012+, 167 161 bayt

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

Çıktı:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

İstediğiniz boyutu girin ve Run querymetin gösterimini almak için tıklayın .

Lütfen bu demonun sabit genişlikte font göstermediğini unutmayın . Yani 7daha kalın 1.

DÜZENLE:

Girdiyi string olarak ele alırsak:

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

Julia, 78 bayt

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

Bu bir tamsayıyı kabul eden ve ASCII dikdörtgenini STDOUT'a basan anonim bir işlevdir. Aramak için değişkene atayın.

Ungolfed:

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

Çevrimiçi deneyin

Ruby, 100 bayt

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

Çok kötü, JS'yi bile yenemedim. Onu aşağı golf herhangi bir başka yardımına minnettar olurum.

İşte daha fazla veya daha az ungolfed versiyonu:

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

Retina, 76 bayt

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

Açıklama belki yarın gelir.

Burada çevrimiçi deneyin.

C ++ 14, 156 karakter

Açıkçası buradaki diğer girişlerin çoğunu geçememekle birlikte oldukça havalı bir çözüm olduğunu düşündüm.

#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}

Ungolfed:

#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 
}

Ve her zamanki gibi, işlev kullanımını çağırmak için [](string t) { ... }("10");

TSQL, 112 104 bayt

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 bayt

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

Burada dene!

açıklama

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

Perl, 79 76 74 bayt

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

Oldukça basit. İlk komut satırı argümanı sayı olarak alınmıştır. Komut dosyasını bir dosyaya yerleştirin ve ile çalıştırın perl file.pl 1.

Perl, 62 60 58 + 2 = 60 bayt

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

-nlEBayraklar gerektirir :

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

Boşluk eklenmiş olarak:

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

R, 90 bayt

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

Bu, bir x*xboyut matrisi oluşturur ve daha sonra boyut boşluklarıyla doldurulur nchar(x). Eğer xdaha küçük 2'ye sonra hiçbir şey dolduruluyor.

Pyth - 26 bayt

K*QQjbm++Q**lQ;ttQQttQK

Burada çevrimiçi deneyin .

Pip -l , 21 bayt

Mevcut politikaya göre izin verilen, sorudan daha yeni olan dil özelliklerini kullanır; Sorunun ifadesi söz konusu politikayı geçersiz kılacak şekilde yorumlanırsa, aşağıdaki 25-byte cevabına bakınız.

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

Çevrimiçi deneyin!

Luis Mendo en sayesinde Matl cevap için (a+1)%n<2hile.

açıklama

Yqstdin'den bir satır okur ve içine sokar y. Sonra:

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

Orijinal 2016 cevabı, 25 bayt (artı -lbayrağı):

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

Değişiklikler:

• MCdaha yakın zamanda eklendi; O zaman kullandım MMCG(harita-harita + koordinat ızgarası).
• Geçerli yorumlayıcıda ++listelerde kullanılmasını engelleyen bir hata vardı, bu yüzden yapmak zorunda kaldım ++*( ++her öğeye uygulamak ).
• Map uzatıldı: şimdi kopyalarının <string1> M <string2>bir listesini döndürüyor ; O sırada dize tekrarlayan boşluk kullandım .len(<string2>)<string1>sX#ylen(y)

Pyth, 37 30 bayt

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

Burada dene.

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

Retina , 90

Yine de bunun uzmanlar tarafından çok iyi golf oynayacağına eminim:

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

;
¶

Çevrimiçi deneyin.

Jöle, 28 bayt

Grr, Jelly'in iplerde kötü olup olmadığını ya da Jelly'de kötü olup olmadığımı söyleyemem.

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

Çevrimiçi deneyin.

Pyke , 33 bayt (rekabetçi olmayan)

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

Açıklama:

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

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

Önerdiğiniz için @ MartinBüttner teşekkür ederiz ff. a+[0X(]&Oh iyi ama oldukça şüpheli.

Çevrimiçi deneyin!

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

Python 2, 70 karakter

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

Haskell, 78 bayt

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

Kullanım örneği:

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

Fonksiyon >>işe yarar: <list> >> <string>yapar length <list>kopyalarını <string>için, örneğin üst ve alt çizgileri x=10vardır [1..10] >> "10"-> "10101010101010101010".

Perl, 72 bayt

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

Modern Perl özelliklerine güvenir:

'bir şey söyle '

Perl 5.10'dan beri otomatik olarak kullanılabilir (v5.10 veya üstünü kullanın).

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

mutlu bir vermek üzere bir rvalue (zorunlu olarak bir skaler düşük olmayan bir str_expr) üzerinde çalışmak için kabul R esult ( ' r ilk str_expr değiştirmeden düzenli ifade sonunda' seçeneği).

PHP, 151 bayt

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

Mutlak karışıklık, optimize etmek için daha fazla zamana ihtiyacınız var. s(Number)size çıktıyı verir.

Java 8, 280 bayt

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

Java için gerçekten iyi olan en kısa cevapların sadece 10 katıdır!

Örnek çalışma:

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

Python 3, 108 96 148 bayt

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

Ungolfed / açıkladı:

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.

Bu benim ilk kod-golf cevabım olduğundan, bazı yapıcı eleştiriler ve / veya öneriler size yardımcı olacaktır!

Rust, 141 137 bayt

Bazı biçimlendirme şeylerini kötüye kullandım, aksi takdirde bu çok daha uzun olurdu.

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

ambalajsız:

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

Bahçesi Bağlantı

Powershell, 98 96 95 83 82 75 bayt

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

Ungolfed ve test senaryosunu açıkladı:

$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

Çıktı:

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