Scrivi un programma o una funzione che accetta un numero intero non negativo N da stdin o come argomento di funzione. Deve stampare o restituire una stringa di un quadrato vuoto di arte ASCII i cui lati sono fatti ciascuno con N copie del numero N.

In particolare:

Se N è 0, non vengono utilizzate copie di N, quindi non dovrebbe esserci output (o solo una nuova riga finale).

Se N è 1, l'output è:

1

Se N è 2:

22
22

Se N è 3:

333
3 3
333

Se N è 4:

4444
4  4
4  4
4444

Se N è 5:

55555
5   5
5   5
5   5
55555

Il modello continua per 6attraverso 9.

Se N è 10, l'output è:

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

Si noti che questo non è in realtà quadrato. È alto 10 file ma largo 20 colonne perché 10è lungo due caratteri. Questo è previsto. Il punto è che ogni lato del "quadrato" contiene N copie di N. Quindi tutti gli input oltre 9saranno tecnicamente rettangoli ASCII.

Ad esempio, se N è 23, l'output è:

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

Qui ci sono Pastebins delle uscite necessarie per 99, 100, 111, e 123(se possono sembrare sbagliato in un browser, ma in un editor di testo che li guardino corretto). L'output per 1000è troppo grande per Pastebin ma avrebbe 1000 righe e 4000 colonne. I numeri con 4 o più cifre devono funzionare come numeri più piccoli.

Dettagli:

• N deve essere scritto nella solita rappresentazione del numero decimale, senza +segno o altre non cifre.
• L'area vuota deve essere riempita solo di spazi.
• Nessuna linea dovrebbe avere spazi iniziali o finali.
• È facoltativamente consentita una nuova riga dopo l'ultima riga dei quadrati.
• Le lingue scritte dopo la presentazione di questa sfida sono benvenute, ma non sono idonee a vincere .
• Vince il codice più breve in byte!

Jolf, 31 27 25 23 byte

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

Questo è codificato nella codifica ISO-8859-7 e contiene non stampabili, quindi ecco un hexdump:

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

Prova questo violino online o verifica tutti i casi di test contemporaneamente (usa il pulsante di esecuzione completa) .

Questo si chiude con un errore per n = 0, che è consentito per impostazione predefinita.

Grazie infinite a Conor per il golf off 4 6! byte. _{^{inb4 barrato quattro sembra ancora un commento di quattro}}

Spiegazione

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

Shtriped , 317 byte

Mentre faccio la domanda, posso mostrare il mio nuovo linguaggio "purista".

@ 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

^{(sicuramente funziona in v1.0.0 )}

Non ci sono operazioni matematiche integrate in Shtriped tranne l'incremento e il decremento. Non ci sono inoltre loop o condizionali, quindi tutte queste cose devono essere costruite da zero in ogni programma.

Questo è ciò che fa il mio programma, ad esempio @è essenzialmente un ciclo for, +è una funzione di aggiunta, lo }è >=. L'output effettivo viene prodotto solo nelle ultime 8 righe del programma.

Non ci sono stringhe neanche in Shtriped. È possibile accettare e stampare stringhe, ma sono tutte rappresentate internamente come interi di precisione arbitrari che possono essere solo incrementati e decrementati. Quindi non c'è modo semplice di ottenere la lunghezza della stringa 10per riempire il centro quadrato con la giusta quantità di spazi. Ho dovuto mettere insieme la funzione ~che calcola efficacemente floor(log10(N)) + 1per trovare la lunghezza di N in decimale.

Questo potrebbe probabilmente essere giocato a golf un po 'più riorganizzando dove e come, che vengono utilizzate variabili, ma non che molto di più. Non è possibile aggirare i limiti intrinseci di Shtriped. (Non è mai stato pensato per essere un linguaggio da golf.)

Codice commentato (una barra rovesciata è un commento):

@ 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

Scherzi a parte, 32 31 30 29 byte

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

Provalo online!

Spiegazione:

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

A4 byte salvati grazie a @ user81655

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

Accetta una stringa, non un numero per l'input.

Provalo online (tutti i browser funzionano)

MATL , 34 29 26 byte

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

Funziona con la versione corrente (13.0.0) del linguaggio / compilatore

Provalo online!

:            % 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 byte

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

Produzione:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

Immettere la dimensione desiderata e fare clic Run queryper ottenere la rappresentazione del testo.

Nota che questa demo non mostra caratteri a larghezza fissa . Quindi 7è più spesso di 1.

MODIFICARE:

Se trattiamo l'input come stringa:

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 byte

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

Questa è una funzione anonima che accetta un numero intero e stampa il rettangolo ASCII su STDOUT. Per chiamarlo, assegnarlo a una variabile.

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

Provalo online

Rubino, 100 byte

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

Peccato che non riuscissi nemmeno a battere JS. Ogni ulteriore aiuto per giocare a golf sarebbe apprezzato.

Ecco una versione più o meno ungolfed:

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 byte

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

La spiegazione forse arriva domani.

Provalo online qui.

C ++ 14, 156 caratteri

Ho pensato che fosse una soluzione davvero interessante, anche se ovviamente non posso battere la maggior parte delle altre voci qui.

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

E come sempre, per chiamare la funzione utilizzare [](string t) { ... }("10");

TSQL, 112 104 byte

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 byte

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

Provalo qui!

Spiegazione

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 byte

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

Abbastanza diretto. Il primo argomento della riga di comando viene preso come numero. Inserire lo script in un file ed eseguirlo con perl file.pl 1.

Perl, 62 60 58 + 2 = 60 byte

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

Richiede -nlEbandiere:

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

Con spazi aggiunti:

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

R, 90 byte

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

Questo crea una matrice di x*xdimensioni e quindi si riempie di spazi di dimensioni nchar(x). Se xinferiore a 2, non viene riempito nulla.

Pyth - 26 byte

K*QQjbm++Q**lQ;ttQQttQK

Provalo online qui .

Pip -l , 21 byte

Utilizza funzionalità linguistiche più recenti rispetto alla domanda, consentita dalla politica corrente; se la formulazione della domanda viene interpretata per sovrascrivere tale politica, vedere la risposta a 25 byte di seguito.

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

Provalo online!

Grazie alla risposta MATL di Luis Mendo per il (a+1)%n<2trucco.

Spiegazione

Yqlegge una riga da stdin e la trascina dentro y. Poi:

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

Risposta originale 2016, 25 byte (più -lbandiera):

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

changelog:

• MCè stato aggiunto più di recente; al momento, ho usato MMCG(map-map + coordinate-grid).
• Nell'interprete corrente c'era un bug che impediva l'uso ++nelle liste, quindi dovevo fare ++*(applicare ++a ciascun elemento).
• Map è stato esteso: ora <string1> M <string2>restituisce un elenco di len(<string2>)copie di <string1>; all'epoca utilizzavo lo sX#yspazio ripetitivo di stringa di len(y).

Pyth, 37 30 byte

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

Provalo qui.

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

Ancora una volta, sono abbastanza sicuro che questo sarà molto golfabile dagli esperti:

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

;
¶

Provalo online.

Gelatina, 28 byte

Grr, non so dire se Jelly sia cattiva nelle corde o se io sia cattiva con Jelly.

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

Provalo online.

Pyke , 33 byte (non competitivo)

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

Spiegazione:

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

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

Grazie a @ MartinBüttner per avermi suggerito ff. Il a+[0X(]&è abbastanza pesce, ma vabbè.

Provalo online!

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 caratteri

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

Haskell, 78 byte

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

Esempio di utilizzo:

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

La funzione >>è utile: <list> >> <string>crea length <list>copie di <string>, ad esempio, le linee superiore e inferiore per x=10sono [1..10] >> "10"-> "10101010101010101010".

Perl, 72 byte

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

Si affida alle moderne funzionalità Perl:

di 'qualcosa'

è automaticamente disponibile da Perl 5.10 (utilizzare semplicemente v5.10 o successive).

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

accetta felicemente al lavoro su un rvalue (a str_expr non necessariamente ridotta ad una variabile scalare) per fornire una r isultato (il ' r opzione' alla fine della regex) senza alterare la str_expr iniziale.

PHP, 151 byte

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

Pasticcio assoluto, ho bisogno di più tempo per ottimizzare. s(Number)ti dà l'output.

Java 8, 280 byte

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

Sono solo circa 10 volte più lunghe delle risposte più brevi, il che è davvero buono per Java!

Esempio di esecuzione:

$ 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 byte

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 / ha spiegato:

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.

Dato che questa è la mia prima risposta in codice golf , alcune critiche costruttive e / o suggerimenti sarebbero utili!

Ruggine, 141 137 byte

Ho abusato di alcune cose di formattazione, altrimenti sarebbe stato molto più lungo.

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

Unpacked:

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

Link al parco giochi

Powershell, 98 96 95 83 82 75 byte

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

Script di prova non risolto e spiegato:

$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

Produzione:

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