Tantangan

Menulis potongan terpendek kode mungkin seperti itu, ketika N salinan itu adalah concatenated bersama-sama, jumlah output karakter adalah N ² . N akan menjadi bilangan bulat positif.

Misalnya jika snipet itu soln();, maka menjalankan soln();akan mencetak tepat 1 karakter, dan menjalankan soln();soln();akan mencetak tepat 4 karakter, dan menjalankan soln();soln();soln();akan mencetak tepat 9 karakter, dll.

Setiap karakter mungkin ada dalam output selama jumlah karakter sudah benar. Untuk menghindari kebingungan lintas-OS, \r\nbaris baru dihitung sebagai satu karakter.

Program mungkin tidak membaca sumbernya sendiri atau membaca ukuran file mereka atau menggunakan celah lain semacam itu. Perlakukan ini seperti tantangan quine yang ketat .

Outputnya mungkin pergi ke stdout atau file atau alternatif serupa. Tidak ada input.

Komentar dalam kode baik-baik saja, seperti yang keluar pertengahan eksekusi.

Setiap karakter mungkin ada di program. Pengajuan terpendek dalam byte menang.

TECO, 4 byte

V1\V

Vmencetak isi dari baris saat ini di buffer teks. 1\memasukkan representasi string dari angka 1 pada posisi saat ini.

Jadi pada N th iterasi dari program, yang pertama Vakan menampilkan N - 1 salinan karakter 1, kemudian tambahkan lagi 1ke teks, maka output N 1 s.

Brainfuck, 17 16 byte

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

Anda bisa mengujinya di sini . Gunakan saja fakta itu .n2+2n+1=(n+1)2

Brainfuck, 11

Saya melihat jawaban Brainfuck pertama dan berpikir itu terlalu lama :)

[.<]>[.>]+.

Outputnya mungkin lebih mudah dilihat jika Anda mengganti plus dengan lebih banyak plus.

Pada iterasi ke-N, setiap loop menghasilkan N-1 salinan karakter dengan nilai ASCII 1, dan kemudian satu lagi dengan +..

Python 2, 22

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

Mencetak string kosong, lalu dua x, lalu xempat dan seterusnya. Dengan baris baru setelah setiap string, ini keluar ke n*nkarakter.

Satu salinan: "\n"(1 karakter)
Dua salinan: "\nxx\n"(4 karakter)
Tiga salinan: "\nxx\nxxxx\n"(9 karakter)

Untuk menghentikan variabel awal agar tidak diinisialisasi aulang setiap kali dijalankan, saya mengakhiri kode dengan a ;a, yang jinak sendiri, tetapi dikombinasikan dengan loop berikutnya untuk membuat kambing hitam aauntuk ditugaskan sebagai gantinya. Trik ini bukan milikku; Saya melihatnya di jawaban sebelumnya. Saya akan menghargai jika seseorang bisa menunjuk saya sehingga saya bisa memberikan pujian.

CJam, 6 byte

LLS+:L

Menggunakan fakta itu .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 byte

Saya yakin ada cara yang sangat pendek dan memutar untuk menyelesaikan ini di /// tapi saya tidak bisa menemukan apa pun, di luar cara "langsung":

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

Ini didasarkan pada pendekatan pencetakan nomor ganjil berturut-turut. Cuplikan terdiri dari a 1di awal yang dicetak, dan dua penggantian yang menambahkan dua 1s ke bagian pertama dari setiap salinan cuplikan secara berturut-turut. Mari kita bahas ini N = 3. Berikut ini harus dibaca dalam kelompok 3 atau lebih baris: 1. kode saat ini, 2. token yang diproses, 3. (dan berikut) komentar apa yang dilakukan token di atas.

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

Menariknya, ini bekerja dengan baik jika kita memindahkannya 1sampai akhir:

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

> <> , 14 byte

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

Menggunakan "jumlah bilangan bulat aneh berurutan mulai dari ide 1". Dimulai dengan 1 dan mengalikannya dengan 100 setiap kali, meningkatkan panjang output secara progresif dengan peningkatan 2.

Misalnya, menambahkan 5 salinan memberi

1100100001000000100000000

Saya menguji dengan mem-piping output ke file, dan tidak melihat baris baru.

Kerusakan

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 byte

],)_S*a*~

Ini mencetak N ² spasi di mana Njumlah salinan kode.

Ekspansi kode :

],            "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";

Cobalah online di sini

Python 2, 20 byte

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

Java - 91 byte

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

Solusi ini setara dengan yang lain ini di Python. Itu pasti tidak akan menang, tapi itu menyenangkan :)

Perl, 14 byte

print;s//__/;

Ini perlu dijalankan dengan -lsaklar perintah Perl , yang menyebabkan printuntuk menambahkan baris baru.

Ini mencetak variabel default $_, kemudian menambahkan dua garis bawah melalui substitusi.

Contoh:

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

__
____
______

Brainfuck, 10 karakter

Kedua solusi Brainfuck sebelumnya adalah waaay terlalu lama (16 dan 11 karakter) jadi di sini adalah lebih pendek:

+[.->+<]>+

Di nblok -th ia mencetak 2*n-1karakter (dengan codepoint dari 2*n-1ke 1)

Prelude , 18 12 byte

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

Ini cetakan N ² tab. Ini mengasumsikan juru bahasa yang memenuhi standar yang mencetak karakter alih-alih angka, jadi jika Anda menggunakan juru bahasa Python Anda harus mengatur NUMERIC_OUTPUTuntuk False.

Idenya adalah hanya menggunakan bagian atas tumpukan (yang awalnya 0) sebagai 2(N-1), dan mencetak 2N-1tab, kemudian menambah bagian atas tumpukan dengan 2. Oleh karena itu setiap pengulangan mencetak jumlah ganjil berikutnya dari tab.

Java - 59/44 (tergantung kebutuhan)

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

Tampaknya kami diizinkan untuk menganggap kode berjalan di kelas.

Jika bisa masuk ke dalam metode utama:

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

C, 87 byte

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

Ini menggunakan dua makro ajaib. __COUNTER__adalah makro yang diperluas untuk 0pertama kali digunakan, 1yang kedua, dll. Ini adalah ekstensi kompiler, tetapi tersedia di gcc, dentang, dan Visual Studio setidaknya. __FILE__adalah nama file sumber. Menyertakan file dalam C / C ++ secara harfiah sama dengan menempelkannya langsung ke kode sumber Anda, jadi agak sulit untuk memanfaatkannya.

Masih mungkin untuk menggunakan teknik ini tanpa __COUNTER__. Dalam hal itu, penjaga standar terhadap penggunaan kode dua kali dapat digunakan untuk #ifpernyataan, dan __LINE__dapat digunakan untuk menghitung jumlah karakter yang dibutuhkan.

Dyalog APL, 20 19 byte

Solusi berbasis matriks.

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

Coba di sini . Mengembalikan serangkaian pengulangan . Penjelasan oleh ledakan untuk :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'.

STATA 20

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

Ada garis baru di belakang untuk memastikan bahwa pernyataan tampilan (di) berfungsi. Pertama-tama tampilkan nomor saat ini dalam $ a baris baru (dan satu tambahan dari tampilan default). Kemudian tambahkan 2 menjadi $ a.

Menggunakan pendekatan bilangan genap (yaitu pendekatan bilangan ganjil minus 1) dengan baris baru ekstra setiap waktu.

T-SQL 117

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

Perhatikan ruang trailing untuk memastikan bahwa jika kondisi diperiksa dengan benar setiap waktu.

Menggunakan pendekatan angka ganjil. Tidak yakin apakah ada baris baru pada pernyataan pilih.

Tidak yakin apakah ada cara yang lebih pendek untuk membuat tabel jika tidak ada.

PostScript, 35 karakter

count dup 2 mul 1 add string print

Setiap pass "bocor" satu hal di stack, jadi countnaik 1 setiap kali. Kemudian hanya menggunakan jumlah trik angka ganjil.

Output byte semua \000karena itulah nilai awal string.

Haskell, 72

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

Penjelasan

Operator yang berlaku $bertindak seolah-olah Anda menempatkan tanda kurung di sekeliling sisa baris (ada pengecualian untuk ini, tetapi berfungsi dalam hal ini). aputStradalah fungsi yang mengambil string dengan format "abc ...", di mana "abc" adalah akar kuadrat dari panjang string, termasuk abc. Ini akan mengurai string sebagai integer, dan mengembalikan string yang dimulai dengan abc + 1 dan memiliki panjang kuadrat itu. Karena $operator, ini akan dipanggil secara rekursif pada "1" N kali.

Pyth, 8 byte

*d*2Z~Z1

Ini bergantung pada fakta bahwa N ² sama dengan jumlah Nbilangan ganjil. Sekarang Pyth otomatis mencetak baris baru, jadi saya harus mencetak Z * 2karakter di setiap kode dari mana Zpergi 0ke N - 1.

Ekspansi Kode :

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

Cobalah online di sini

Golflua, 23 byte

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

menghasilkan kombinasi &dan \nkarakter.

Kode Lua Setara

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

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

Setiap kali snipet kode berjalan, ia menghasilkan 2 karakter lebih banyak keluaran daripada yang terakhir, dimulai dengan 1 karakter. The printFungsi menambahkan baris baru, jadi saya menginisialisasi X untuk 0 bukan 1.

ActionScript - 27/26 byte

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

atau

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

Bagaimana itu bekerja:

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

Itu hanya komentar dari baris pertama. Catatan: tracemenambahkan baris baru. Atau mungkin semua IDE yang saya gunakan melakukannya secara otomatis.

GML, 27

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