Ecrivez un programme ou une fonction qui prend un entier non négatif N à partir de stdin ou comme argument de fonction. Il doit imprimer ou renvoyer une chaîne d'un carré ASCII-art creux dont les côtés sont chacun constitués de N copies du nombre N.

Plus précisément:

Si N est 0, aucune copie de N n'est utilisée, il ne devrait donc y avoir aucune sortie (ou seulement un retour à la ligne simple).

Si N est 1, la sortie est:

1

Si N est 2:

22
22

Si N est 3:

333
3 3
333

Si N est 4:

4444
4  4
4  4
4444

Si N est 5:

55555
5   5
5   5
5   5
55555

Le modèle continue pour à 6travers 9.

Si N est 10, la sortie est:

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

Notez que ce n'est pas réellement carré. Il a 10 rangées de hauteur mais 20 colonnes de largeur car il 10comporte deux caractères. Ceci est destiné. Le fait est que chaque côté du "carré" contient N copies de N. Ainsi, toutes les entrées au 9- delà seront techniquement des rectangles ASCII.

Par exemple, si N est 23, le résultat est:

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

Voici les pastebin des sorties nécessaires pour 99, 100, 111et 123(ils peuvent sembler mal dans un navigateur , mais dans un éditeur de texte ils semblent corrects). Le résultat pour 1000Pastebin est trop grand, mais il aurait 1000 lignes et 4000 colonnes. Les nombres de 4 chiffres ou plus doivent fonctionner comme des nombres plus petits.

Détails:

• N doit être écrit dans la représentation du nombre décimal habituel, sans +signe ni autre non-chiffre.
• La zone creuse ne doit être remplie que d'espaces.
• Aucune ligne ne doit avoir d'espaces de début ou de fin.
• Une seule nouvelle ligne après la dernière ligne des carrés est éventuellement autorisée.
• Les langues écrites après la création de ce défi sont les bienvenues, elles ne sont tout simplement pas éligibles pour gagner .
• Le code le plus court en octets gagne!

Jolf, 31 27 25 23 octets

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

Ceci est codé dans le codage ISO-8859-7 et contient des données non imprimables, voici donc un hexdump:

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

Essayez ce violon en ligne ou vérifiez tous les cas de test en même temps (utilisez le bouton d'exécution complète) .

Cela se termine avec une erreur pour n = 0, autorisée par défaut.

Merci à Conor pour avoir joué au golf à 4 6! octets. _{^{inb4 barré quatre ressemble encore à quatre commentaires}}

Explication

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

Shrriped , 317 octets

Pendant que je pose la question, je peux aussi montrer mon nouveau langage "puriste".

@ 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

^{(fonctionne définitivement dans v1.0.0 )}

Il n'y a pas d'opération mathématique intégrée dans Shtriped sauf incrémenter et décrémenter. Il n'y a pas non plus de bouclage ni de condition, donc tout doit être construit à partir de zéro dans chaque programme.

C'est ce que mon programme fait, par exemple , @est essentiellement une boucle, +est une fonction d'addition, }est >=. La sortie réelle n’est produite que dans les 8 dernières lignes du programme.

Il n'y a pas non plus de ficelle dans Shtriped. Vous pouvez entrer et imprimer des chaînes, mais elles sont toutes représentées de manière interne en tant qu'entiers de précision arbitraire qui ne peuvent être incrémentés et décrémentés. Il n’ya donc pas de moyen facile d’obtenir la longueur de la chaîne 10pour remplir le centre carré avec la bonne quantité d’espace. J'ai dû bricoler ensemble la fonction ~qui calcule efficacement floor(log10(N)) + 1pour trouver la longueur de N en décimal.

Cela pourrait probablement être joué un peu plus en réorganisant où et comment les variables utilisées, mais pas tant que ça . Il n'y a pas moyen de contourner les limites inhérentes à Shtriped. (De toute façon, ça n'a jamais été une langue de golf.)

Code commenté (une barre oblique inverse est un commentaire):

@ 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

Sérieusement, 32 31 30 29 octets

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

Essayez-le en ligne!

Explication:

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

Sauvegardé a4 octets grâce à @ user81655

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

Prend une chaîne, pas un nombre pour la saisie.

Essayez-le en ligne (tous les navigateurs fonctionnent)

MATL , 34 29 26 octets

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

Cela fonctionne avec la version actuelle (13.0.0) du langage / compilateur

Essayez-le en ligne!

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

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

Sortie:

666666 
6    6 
6    6  
6    6  
6    6 
666666 

LiveDemo

Entrez la taille souhaitée et cliquez Run querypour obtenir une représentation textuelle.

Veuillez noter que cette démo n'affiche pas les polices à largeur fixe . Donc 7est plus épais que 1.

MODIFIER:

Si nous traitons l'entrée en tant que chaîne:

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 octets

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

Il s'agit d'une fonction anonyme qui accepte un entier et imprime le rectangle ASCII sur STDOUT. Pour l'appeler, assignez-le à une variable.

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

Essayez-le en ligne

Ruby, 100 octets

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

Dommage que je n'ai même pas réussi à battre JS. Toute aide supplémentaire au golf serait appréciée.

Voici une version plus ou moins non-golfée:

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 octets

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

L'explication vient peut-être demain.

Essayez-le en ligne ici.

C ++ 14, 156 caractères

Je pensais que c'était une solution plutôt cool, bien que je ne puisse évidemment pas battre la plupart des autres entrées ici.

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

Et comme toujours, appeler la fonction use [](string t) { ... }("10");

TSQL, 112 104 octets

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 octets

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

Essayez-le ici!

Explication

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 octets

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

Assez simple. Le premier argument de la ligne de commande est considéré comme le nombre. Placez le script dans un fichier et exécutez-le perl file.pl 1.

Perl, 62 60 58 + 2 = 60 octets

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

Nécessite des -nlEdrapeaux:

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

Avec des espaces ajoutés:

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

R, 90 octets

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

Cela crée une matrice de x*xtaille puis se remplit d'espaces de taille nchar(x). Si xplus petit que 2, alors rien n'est rempli.

Pyth - 26 octets

K*QQjbm++Q**lQ;ttQQttQK

Essayez-le en ligne ici .

Pip -l , 21 octets

Utilise des fonctionnalités linguistiques plus récentes que la question, autorisée par la stratégie en vigueur; si le libellé de la question est interprété de manière à outrepasser ladite politique, voir la réponse à 25 octets ci-dessous.

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

Essayez-le en ligne!

Merci à Luis Mendo réponse de MATL pour l' (a+1)%n<2astuce.

Explication

Yqlit une ligne de stdin et la glisse dans y. Ensuite:

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

Réponse originale de 2016, 25 octets (plus -ldrapeau):

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

Changelog:

• MCa été ajouté plus récemment; à l'époque, j'ai utilisé MMCG(carte-carte + grille de coordonnées).
• Il y avait un bogue dans l'interprète actuel qui empêchait l'utilisation ++sur des listes, donc je devais faire ++*(appliquer ++à chaque élément) à la place.
• Map a été étendu: <string1> M <string2>retourne maintenant une liste de len(<string2>)copies de <string1>; à l'époque, j'ai utilisé sX#y, espace de répétition de chaîne par len(y).

Pyth, 37 à 30 octets

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

Essayez ici.

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

Rétine , 90

Encore une fois, je suis sûr que les experts vont jouer au golf:

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

;
¶

Essayez-le en ligne.

Gelée, 28 octets

Grr, je ne peux pas dire si Jelly est mauvaise à cordes, ou si je suis mauvaise à Jelly.

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

Essayez-le en ligne.

Pyke , 33 octets (non compétitif)

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

Explication:

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

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

Merci à @ MartinBüttner pour cette suggestion ff. C'est a+[0X(]&assez louche, mais bon.

Essayez-le en ligne!

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 caractères

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

Haskell, 78 octets

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

Exemple d'utilisation:

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

La fonction >>est pratique: <list> >> <string>fait des length <list>copies <string>, par exemple, les lignes du haut et du bas x=10sont [1..10] >> "10"-> "10101010101010101010".

Perl, 72 octets

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

S'appuie sur les fonctionnalités modernes de Perl:

dire 'quelque chose'

est automatiquement disponible depuis Perl 5.10 (utilisez simplement la version 5.1 ou ultérieure).

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

accepte avec plaisir de travailler sur un rvalue (un str_expr pas nécessairement réduit à une variable scalaire) pour donner un r esult (le « r option » à la fin de l'expression régulière) sans altérer la str_expr initiale.

PHP, 151 octets

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

Désordre absolu, besoin de plus de temps pour optimiser. s(Number)vous donne la sortie.

Java 8, 280 octets

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

C'est seulement environ 10 fois plus long que les réponses les plus courtes, ce qui est vraiment bon pour Java!

Exemple d'exécution:

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

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 / expliqué:

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.

Comme il s’agit de ma première réponse code-golf , des critiques constructives et / ou des suggestions seraient utiles!

Rouille, 141 137 octets

A abusé de certains éléments de formatage, sinon cela aurait été beaucoup plus long.

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

Déballé:

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

Lien de terrain de jeu

Powershell, 98 96 95 83 82 75 octets

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

Script de test non expliqué et expliqué:

$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

Sortie:

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