Thử thách

Viết đoạn mã ngắn nhất có thể sao cho, khi N bản sao của nó được nối với nhau, số lượng ký tự đầu ra là N ² . N sẽ là một số nguyên dương.

Ví dụ: nếu đoạn mã là soln();, thì chạy soln();sẽ in chính xác 1 ký tự và chạy soln();soln();sẽ in chính xác 4 ký tự và chạy soln();soln();soln();sẽ in chính xác 9 ký tự, v.v.

Bất kỳ ký tự nào cũng có thể ở đầu ra miễn là tổng số ký tự là chính xác. Để tránh nhầm lẫn giữa các hệ điều hành, các \r\ndòng mới được tính là một ký tự.

Các chương trình không được đọc nguồn của riêng họ hoặc đọc kích thước tệp của họ hoặc sử dụng các sơ hở khác. Hãy đối xử với này giống như một nghiêm ngặt Quine thách thức.

Đầu ra có thể đi đến thiết bị xuất chuẩn hoặc một tập tin hoặc một sự thay thế tương tự. Không có đầu vào.

Nhận xét trong mã là tốt, như đang thoát khỏi thực thi giữa.

Bất kỳ nhân vật có thể có trong chương trình. Đệ trình ngắn nhất tính bằng byte thắng.

TECO, 4 byte

V1\V

Vin nội dung của dòng hiện tại trong bộ đệm văn bản. 1\chèn đại diện chuỗi của số 1 ở vị trí hiện tại.

Vì vậy, trong lần lặp thứ N của chương trình, lần đầu tiên Vsẽ xuất ra N - 1 bản sao của ký tự 1, sau đó thêm một bản khác 1vào văn bản, sau đó xuất N 1 s.

Brainfuck, 17 16 byte

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

Bạn có thể kiểm tra nó ở đây . Chỉ cần sử dụng thực tế rằng .n2+2n+1=(n+1)2

Brainfuck, 11

Tôi đã thấy câu trả lời đầu tiên của Brainfuck và nghĩ rằng nó quá dài :)

[.<]>[.>]+.

Đầu ra có thể dễ dàng hơn để xem nếu bạn thay thế dấu cộng bằng nhiều điểm cộng hơn.

Trên lần lặp thứ N, mỗi vòng lặp xuất ra N - 1 bản sao của ký tự có giá trị ASCII 1, và sau đó thêm một lần nữa với +..

Con trăn 2, 22

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

In chuỗi trống, sau đó hai x, rồi xbốn và cứ thế. Với dòng mới sau mỗi chuỗi, điều này đi ra các n*nký tự.

Một bản sao: "\n"(1 char)
Hai bản sao: "\nxx\n"(4 ký tự)
Ba bản sao: "\nxx\nxxxx\n"(9 ký tự)

Để ngăn biến ban đầu akhông được khởi tạo lại mỗi lần chạy, tôi tự kết thúc mã bằng a ;a, lành tính, nhưng kết hợp với vòng lặp tiếp theo để tạo ra vật tế thần aađược chỉ định thay thế. Thủ thuật này không phải của tôi; Tôi đã nhìn thấy nó trong một câu trả lời trước đó. Tôi đánh giá cao nếu ai đó có thể chỉ cho tôi để tôi có thể cung cấp tín dụng.

CJam, 6 byte

LLS+:L

Sử dụng thực tế rằng .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

Tôi chắc chắn có một cách thực sự ngắn và xoắn để giải quyết vấn đề này trong /// nhưng tôi không thể tìm thấy bất cứ điều gì, ngoài cách "đơn giản" này:

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

Điều này dựa trên cách tiếp cận in số lẻ liên tiếp. Đoạn mã bao gồm một 1phần đầu được in và hai phần thay thế thêm hai phần nữa 1vào phần đầu tiên của mỗi bản sao liên tiếp của đoạn trích. Chúng ta hãy đi qua điều này cho N = 3. Các phần sau nên được đọc theo nhóm từ 3 dòng trở lên: 1. mã hiện tại, 2. mã thông báo đã xử lý, 3. (và sau) một nhận xét về mã thông báo trên làm gì.

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

Thật thú vị, nó cũng hoạt động tốt nếu chúng ta di chuyển 1đến cùng:

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

> <> , 14 byte

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

Sử dụng ý tưởng "tổng các số nguyên lẻ liên tiếp bắt đầu từ 1". Nó bắt đầu với 1 và nhân nó lên 100 mỗi lần, tăng dần độ dài của đầu ra theo mức tăng của 2.

Ví dụ: nối thêm 5 bản sao

1100100001000000100000000

Tôi đã kiểm tra bằng cách dẫn đầu ra vào một tệp và không thấy một dòng mới nào.

Phá vỡ

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*~

Điều này in N ² khoảng trắng trong đó Nlà số lượng bản sao của mã.

Mã mở rộng :

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

Dùng thử trực tuyến tại đây

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

Giải pháp này tương đương với giải pháp khác trong Python. Nó chắc chắn sẽ không thắng, nhưng nó rất vui :)

Perl, 14 byte

print;s//__/;

Điều này cần phải được chạy với -lchuyển đổi lệnh của Perl , điều này gây ra printcác đường nối mới.

Nó in biến mặc định $_, sau đó thêm hai dấu gạch dưới thông qua thay thế.

Thí dụ:

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

__
____
______

Brainfuck, 10 ký tự

Cả hai giải pháp Brainfuck trước đây đều là waaay quá dài (16 và 11 ký tự) vì vậy đây là một giải pháp ngắn hơn:

+[.->+<]>+

Trong nkhối -th, nó in ra các 2*n-1ký tự (với các điểm mã từ 2*n-1đến 1)

Mở đầu , 18 12 byte

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

Điều này in N ² tab. Nó giả sử một trình thông dịch tuân thủ tiêu chuẩn in các ký tự thay vì số, vì vậy nếu bạn sử dụng trình thông dịch Python, bạn sẽ cần phải đặt NUMERIC_OUTPUTthành False.

Ý tưởng chỉ đơn giản là sử dụng đỉnh của ngăn xếp (ban đầu là 0) 2(N-1)và in 2N-1các tab, sau đó tăng đỉnh của ngăn xếp lên 2. Do đó, mỗi lần lặp lại sẽ in số lượng tab lẻ tiếp theo.

Java - 59/44 (tùy theo yêu cầu)

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

Rõ ràng chúng ta được phép giả sử mã chạy trong một lớp.

Nếu nó có thể đi vào bên trong một phương thức chính:

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

Điều này sử dụng hai macro ma thuật. __COUNTER__là một macro mở rộng đến 0lần đầu tiên được sử dụng, 1lần thứ hai, v.v. Nó là một phần mở rộng trình biên dịch, nhưng ít nhất có sẵn trong cả gcc, clang và Visual Studio. __FILE__là tên của tệp nguồn. Bao gồm một tệp trong C / C ++ theo nghĩa đen giống như dán nó trực tiếp vào mã nguồn của bạn, vì vậy việc sử dụng một chút khó khăn.

Vẫn có thể sử dụng kỹ thuật này mà không cần __COUNTER__. Trong trường hợp đó, bộ bảo vệ tiêu chuẩn chống lại việc sử dụng mã hai lần có thể được sử dụng cho #ifcâu lệnh và __LINE__có thể được sử dụng để đếm số lượng ký tự cần thiết.

APL Dyalog, 20 19 byte

Một giải pháp dựa trên ma trận.

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

Hãy thử nó ở đây . Trả về một chuỗi lặp lại của . Giải thích bằng vụ nổ cho :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'.

SỐ 20

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

Có một dòng mới để đảm bảo rằng câu lệnh (di) hiển thị hoạt động. Đầu tiên hiển thị số hiện tại bằng $ một dòng mới (và một bổ sung từ mặc định của màn hình). Sau đó thêm 2 đến $ a.

Sử dụng cách tiếp cận số chẵn (tức là cách tiếp cận số lẻ trừ 1) với một dòng mới thêm mỗi lần.

T-SQL 117

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

Lưu ý không gian dấu để đảm bảo rằng điều kiện if được kiểm tra đúng cách mỗi lần.

Sử dụng cách tiếp cận số lẻ. Không chắc chắn nếu có một dòng mới trên các tuyên bố chọn.

Không chắc chắn nếu có một cách ngắn hơn để tạo bảng nếu nó không tồn tại.

PostScript, 35 ký tự

count dup 2 mul 1 add string print

Mỗi lượt "rò rỉ" một thứ trên stack, countcứ thế tăng lên 1 lần. Sau đó, nó sử dụng tổng số lừa số lẻ.

Đầu ra byte là tất cả \000vì đó là giá trị ban đầu của chuỗi.

Haskell, 72

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

Giải trình

Toán tử áp dụng $hoạt động như thể bạn đặt dấu ngoặc đơn xung quanh phần còn lại của dòng (có trường hợp ngoại lệ cho trường hợp này, nhưng nó hoạt động trong trường hợp này). aputStrlà một hàm lấy một chuỗi có định dạng "abc ...", trong đó "abc" là căn bậc hai của độ dài của chuỗi, bao gồm abc. Nó sẽ phân tích chuỗi dưới dạng một số nguyên và trả về một chuỗi bắt đầu bằng abc + 1 và có độ dài đó bình phương. Do $toán tử, điều này sẽ được gọi đệ quy trên "1" N lần.

Bình thường, 8 byte

*d*2Z~Z1

Điều này phụ thuộc vào thực tế là N ² bằng tổng các Nsố lẻ. Bây giờ Pyth tự động in một dòng mới, vì vậy tôi chỉ cần in các Z * 2ký tự trong mỗi mã Zđi từ đâu 0đến N - 1.

Mở rộng mã :

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

Dùng thử trực tuyến tại đây

Golflua, 23 byte

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

xuất ra một sự kết hợp &và các \nký tự.

Mã Lua tương đương

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

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

Mỗi lần đoạn mã chạy, nó tạo ra thêm 2 ký tự đầu ra so với lần trước, bắt đầu bằng 1 ký tự. Các printchức năng gắn thêm một dòng mới, vì vậy tôi khởi X 0 thay vì 1.

ActionScript - 27/26 byte

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

hoặc là

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

Làm thế nào nó hoạt động:

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

Nó chỉ đơn giản là nhận xét ra dòng đầu tiên. Lưu ý: tracethêm một dòng mới. Hoặc có thể tất cả các IDE tôi sử dụng đều tự động làm điều đó.

GML, 27

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