Вызов

Напишите кратчайший фрагмент кода из возможных, чтобы при объединении N его копий количество выводимых символов составляло N ² . N будет положительным целым числом.

Например, если фрагмент был soln();, то при запуске soln();будет напечатано ровно 1 символ, а при запуске soln();soln();будет напечатано ровно 4 символа, а при запуске soln();soln();soln();будет напечатано ровно 9 символов и т. Д.

Любые символы могут быть в выводе, если общее количество символов является правильным. Чтобы избежать путаницы между операционными системами, \r\nпереводы строки считаются одним символом.

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

Вывод может идти в стандартный вывод или файл или подобную альтернативу. Там нет ввода.

Комментарии в коде в порядке, как и в середине исполнения.

В программе могут быть любые символы. Самая короткая подача в байтах побеждает.

TECO, 4 байта

V1\V

Vпечатает содержимое текущей строки в текстовом буфере 1\вставляет строковое представление числа 1 в текущей позиции.

Таким образом, на N- й итерации программы первая Vвыдаст N - 1 копию символа 1, затем добавит еще одну 1к тексту, а затем выведет N 1 s.

Brainfuck, 17 16 байтов

[>+>-..+<<-]-.>+

Вы можете проверить это здесь . Просто используйте тот факт, что .n2+2n+1=(n+1)2

Brainfuck, 11

Я увидел первый ответ Brainfuck и подумал, что это слишком долго :)

[.<]>[.>]+.

Вывод может быть легче увидеть, если вы замените плюс на гораздо больше плюсов.

На N-й итерации каждый цикл выводит N - 1 копию символа со значением ASCII 1, а затем еще одну с +..

Python 2, 22

a='';print a;a+='xx';a

Печатает пустую строку, затем два x, затем xчетыре и так далее. С новой строки после каждой строки, это выходит на n*nсимволы.

Один экземпляр: "\n"(1 символ)
Два экземпляра: "\nxx\n"(4 знака)
Три экземпляра: "\nxx\nxxxx\n"(9 символов)

Чтобы предотвратить aповторную инициализацию исходной переменной при каждом запуске, я заканчиваю код символом a ;a, который сам по себе доброкачественный, но в сочетании со следующим циклом создает козла отпущения, aaкоторый будет назначен вместо этого. Этот трюк не мой; Я видел это в предыдущем ответе. Я был бы признателен, если бы кто-то мог указать мне, чтобы я мог отдать должное.

CJam, 6 байтов

LLS+:L

Использует тот факт, что .n2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 байт

Я уверен, что есть очень короткий и хитрый способ решить эту проблему в ///, но я не смог найти ничего, кроме «простого» способа:

1/1\//112\///2\//1\//

Это основано на подходе печати последовательных нечетных чисел. Фрагмент состоит из 1напечатанного в начале символа и двух замен, которые добавляют еще две 1буквы к первой части каждой последующей копии фрагмента. Давайте пройдем через это для N = 3. Следующее должно быть прочитано группами из 3 или более строк: 1. текущий код, 2. обработанный токен (ы), 3. (и последующий) комментарий, что делает вышеуказанный токен.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

Интересно, что это работает так же хорошо, если мы переместим 1до конца:

/1\//112\///2\//1\//1

> <> , 14 байт

1:na*a*';'10p!

Использует идею «сумма последовательных нечетных целых чисел, начиная с 1». Он начинается с 1 и умножается на 100 каждый раз, постепенно увеличивая длину вывода с шагом 2.

Например, добавление 5 копий дает

1100100001000000100000000

Я проверил, отправив вывод в файл, и не увидел завершающий перевод строки.

Сломать

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 байтов

],)_S*a*~

Это печатает N ² пробелов, где Nколичество копий кода.

Расширение кода :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

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

Python 2, 20 байт

g=0
print'g'*g;g+=2#

Java - 91 байт

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

Это решение эквивалентно другому в Python. Это конечно не победит, но это было весело :)

Perl, 14 байт

print;s//__/;

Это должно быть запущено с помощью -lкомандного переключателя Perl , который вызывает printдобавление новых строк.

Он печатает переменную по умолчанию $_, а затем добавляет два подчеркивания через подстановку.

Пример:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 символов

Оба предыдущих решений Brainfuck были waaay слишком долго (16 и 11 символов) , поэтому здесь более короткий:

+[.->+<]>+

В n-ом блоке он печатает 2*n-1символы (с кодовыми точками от 2*n-1до 1)

Прелюдия , 18 12 байт

^1+(9!1-)#2+

Это печатает N ² вкладок. Предполагается, что он соответствует стандартному интерпретатору, который печатает символы вместо цифр, поэтому, если вы используете интерпретатор Python, вам необходимо установить NUMERIC_OUTPUTего False.

Идея состоит в том, чтобы просто использовать вершину стека (которая изначально равна 0) 2(N-1)и распечатать 2N-1вкладки, а затем увеличить вершину стека на 2. Следовательно, каждое повторение печатает следующее нечетное количество вкладок.

Java - 59/44 (в зависимости от требований)

static String n="1";
static{System.out.print(n);n+="11";}//

По-видимому, мы можем предположить, что код выполняется в классе.

Если это может пойти внутри основного метода:

String n="1";
System.out.print(n);n+="11";//

C 87 байтов

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

Это использует два магических макроса. __COUNTER__это макрос, который раскрывается до 0первого использования, 1второго и т. д. Это расширение компилятора, но доступно по крайней мере как в gcc, clang, так и в Visual Studio. __FILE__это имя исходного файла. Включение файла в C / C ++ - это то же самое, что вставка его непосредственно в исходный код, поэтому использовать его было немного сложно.

Было бы все еще возможно использовать эту технику без __COUNTER__. В этом случае стандартная защита от использования кода дважды может использоваться для #ifоператора и __LINE__может использоваться для подсчета необходимого количества символов.

Дьялог АПЛ, 20 19 байт

Решение на основе матрицы.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Попробуй это здесь . Возвращает строку повторений . Объяснение взрывом для :N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

СТАТА 20

di _n($a)
gl a=$a+2

Есть завершающая новая строка, чтобы убедиться, что оператор display (di) работает. Сначала отобразите текущее число в $ a новых строк (и еще одно из значений по умолчанию для отображения). Затем добавьте 2 к $ a.

Использует метод четных чисел (то есть нечетные числа приближаются к минус 1) с дополнительной новой строкой каждый раз.

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Обратите внимание на пробел, чтобы убедиться, что условие if каждый раз проверяется должным образом.

Использует подход нечетных чисел. Не уверен, есть ли новая строка в операторах выбора.

Не уверен, если есть более короткий способ создать таблицу, если она не существует.

PostScript, 35 символов

count dup 2 mul 1 add string print

Каждый проход «пропускает» одну вещь в стек, поэтому countкаждый раз увеличивается на 1. Тогда он использует трюк суммы нечетных чисел.

Все байты выводятся, \000потому что это начальное значение строк.

Хаскелл, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

объяснение

Оператор apply $действует так, как будто вы помещаете круглые скобки вокруг остальной части строки (есть исключения из этого, но в этом случае это работает). aputStrявляется функцией, которая принимает строку в формате «abc ...», где «abc» - квадратный корень длины строки, включая abc. Он проанализирует строку как целое число и вернет строку, начинающуюся с abc + 1 и имеющую эту длину в квадрате. Из-за $оператора это будет вызываться рекурсивно в «1» N раз.

Pyth, 8 байт

*d*2Z~Z1

Это зависит от того факта, что N ² равно сумме Nнечетных чисел. Теперь Pyth автоматически печатает новую строку, так что я должен просто напечатать Z * 2символы в каждом коде , где Zидет от 0к N - 1.

Расширение кода :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

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

Golflua, 23 байта

X=2+(X|-2)w(S.t("&",X))

выводит комбинацию &и \nсимволов.

Эквивалентный код Lua

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Каждый раз, когда выполняется фрагмент кода, он выводит на 2 символа больше, чем в прошлый раз, начиная с 1 символа. printФункция добавляет символ новой строки, так что я инициализировать X до 0 вместо 1.

ActionScript - 27/26 байт

var n=""
trace(n);n+="11"//

или

var n=1
trace(n);n+="11"//

Как это работает:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

Это просто комментирует первую строку. Примечание: traceдобавляет новую строку. Или, может быть, все IDE, которые я использую, делают это автоматически.

GML, 27

a=''show_message(a)a+='xx'a