Напишите программу или функцию, которая принимает неотрицательное целое число N из стандартного ввода или в качестве аргумента функции. Он должен напечатать или вернуть строку полого квадрата ASCII-art, каждая сторона которого сделана с N копиями числа N.

В частности:

Если 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

Обратите внимание, что это на самом деле не квадрат. Это 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(они могут выглядеть неправильно в браузере , но в текстовом редакторе , они будут выглядеть правильно). Выходные данные для for 1000являются большими для Pastebin, но они будут иметь 1000 строк и 4000 столбцов. Числа с 4 или более цифрами должны работать так же, как меньшие числа.

Подробности:

• N должно быть записано в обычном представлении десятичного числа без +знака или других нецифровых чисел.
• Полость должна быть заполнена только пробелами.
• Ни в одной строке не должно быть начальных или конечных пробелов.
• Отдельная новая строка после последней строки квадратов может быть разрешена.
• Языки, написанные после выполнения этого задания, приветствуются, они просто не имеют права на победу .
• Самый короткий код в байтах побеждает!

Джольф, 31 27 25 23 байта

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

Это кодируется в кодировке ISO-8859-7 и содержит непечатаемые, поэтому вот hexdump:

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

Попробуйте эту скрипку онлайн или проверьте все тестовые случаи одновременно (используйте кнопку полного запуска) .

Это происходит с ошибкой для n = 0, которая разрешена по умолчанию.

Огромное спасибо Конору за игру в гольф 4 6! байт. _{^{Inb4 вычеркнул четыре все еще выглядит как четыре комментария}}

объяснение

?=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 строках программы.

В Штрипеде тоже нет струн. Вы можете принимать и распечатывать строки, но все они представляются внутри как целые числа произвольной точности, которые могут только увеличиваться и уменьшаться. Так что нет простого способа получить длину строки 10для заполнения квадратного центра нужным количеством пробелов. Мне пришлось собрать воедино функцию, ~которая эффективно вычисляет, floor(log10(N)) + 1чтобы найти длину N в десятичной дроби.

Это, вероятно , может быть golfed немного больше перестановки , где и как , которые используются переменные, но не , что намного больше. Нельзя обойти присущие Штрипеду ограничения. (Так или иначе, он никогда не был языком игры в гольф.)

Код с комментариями (обратный слеш - это комментарий):

@ 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 байт

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

JavaScript (ES6), 73 82 78 байт

Сохранено a4 байта благодаря @ user81655

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 Server 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. Чтобы вызвать его, присвойте его переменной.

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

Попробуйте онлайн

Рубин, 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}

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 
}

И, как всегда, для вызова функции использовать [](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)

Минколанг 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

Perl, 79 76 74 байта

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

Довольно просто. Первый аргумент командной строки принимается за число. Поместите скрипт в файл и запустите perl file.pl 1.

Perl 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размера и затем заполняет пробелы размера nchar(x). Если xменьше 2, то ничего не заполняется.

Pyth - 26 байт

K*QQjbm++Q**lQ;ttQQttQK

Попробуйте это онлайн здесь .

Пип -l , 21 байт

Использует языковые функции более новые, чем вопрос, который разрешен в соответствии с текущей политикой; если формулировка вопроса интерпретируется как переопределение указанной политики, см. 25-байтовый ответ ниже.

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

Попробуйте онлайн!

Благодаря ответу MATL Луиса Мендо на (a+1)%n<2хитрость.

объяснение

Yqчитает строку из стандартного ввода и вставляет ее в 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

Changelog:

• 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 байт

Грр, не могу сказать, плохо ли Джелли в струнах, или я плох в Джелли.

ŒṘ©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

Python 2, 70 символов

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

Haskell, 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".

Perl, 72 байта

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

Полагается на современные возможности Perl:

сказать "что-то"

автоматически доступен с Perl 5.10 (просто используйте v5.10 или новее).

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

с удовольствием принимает на работу на RValue (An str_expr не обязательно сводится к переменной скалярной) с получением г esult (далее « г опцию» в конце регулярного выражения) без изменения первоначального 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)дает вам выход.

Java 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

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

Ungolfed / объяснил:

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

Playground Link

Powershell, 98 96 95 83 82 75 байт

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

Разоблаченный и объясненный тестовый скрипт:

$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