Thách thức của bạn là viết N đoạn mã như vậy mà, khi bạn nối đầu tiên K ≥ 1 với nhau, họ sản xuất số K . N càng cao thì càng tốt. Đây là một nhược điểm: bạn không được sử dụng bất kỳ ký tự nào nhiều lần trên các đoạn của mình.

Quy tắc

• Bạn có thể sử dụng cùng một ký tự nhiều lần trong một (và chỉ một) đoạn trích.
• Các đoạn này phải được nối theo thứ tự chúng được trình bày , mà không bỏ qua bất kỳ.
• Bạn phải viết ít nhất hai đoạn.
• Tất cả các đoạn phải ở cùng một ngôn ngữ.
• Hãy nhớ rằng: đoạn mã không phải là chương trình hoặc chức năng đầy đủ, cũng không phải tự hoạt động. -1là một đoạn mã hợp lệ trong Java, vd
• Tất cả các kết quả kết quả phải xuất giá trị K tương ứng .
• Người chiến thắng là người có giá trị N cao nhất . Tie-breaker là chiều dài chương trình tổng thể ngắn nhất tính bằng byte.

Thí dụ

Giả sử đoạn của bạn là AD, xc, 123, và ;l. Sau đó:

• AD nên sản xuất 1
• ADxc nên sản xuất 2
• ADxc123 nên sản xuất 3
• và ADxc123;lnên sản xuất 4.

Chương trình này sẽ có điểm 4 .

Đoạn mã Python 3 , 1 112 056, 4 383 854 byte

Điều này rất giống với câu trả lời Python 2 của @ WheatWizard . Tôi đã bắt đầu làm việc này ngay trước khi nó được đăng, nhưng việc phân loại các câu đố của Python liên quan đến các ký tự không phải ASCII và các dòng dài mất một thời gian. Tôi phát hiện ra rằng Python đọc các dòng 8191 byte cùng một lúc và khi 8191 byte đó chỉ chứa một phần của một ký tự nhiều byte, Python sẽ ném SyntaxError .

Đoạn mã đầu tiên sử dụng mã hóa từ các ký tự Fewest (riêng biệt) cho Turing Hoàn thiện .

exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))

Sự quái dị này chỉ đơn giản là xây dựng chuỗi sau đây và thực hiện nó.

print(len(open(__file__).read())-1260)

Các đoạn sau đây đều dài chính xác một ký tự. Ba ký tự tiếp theo là \n, \r, và #. Tất cả các ký tự Unicode còn lại (trừ người thay thế) tuân theo một thứ tự cụ thể, vì vậy chúng phù hợp với ranh giới 8191 byte.

Kịch bản sau đây tạo các chương trình thích hợp cho đầu vào k trong khoảng từ 1 đến 1112056 .

j = 4
s = "exec('%c'%(111+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(111+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(111)+'%c'%(111+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+11)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1+1)+'%c'%(111+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1+1)+'%c'%(11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+11+11+11+11+11+1)+'%c'%(11+11+11+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1+1)+'%c'%(11+11+11+11+1)+'%c'%(11+11+11+11+1+1+1+1+1)+'%c'%(11+11+11+11+1+1+1+1+1+1)+'%c'%(11+11+11+11+11)+'%c'%(11+11+11+11+1+1+1+1)+'%c'%(11+11+11+1+1+1+1+1+1+1++++++++++1))"
l = 1
c = \
        [
                None,
                [n for n in range(0x80) if chr(n) not in "\n\r#%'()+1cex"],
                [*range(0x80, 0x800)],
                [*range(0x800, 0xd800), *range(0xe000, 0x10000)],
                [*range(0x10000, 0x110000)]
        ]

k = int(input())
assert k in range(1, 1112057)
s += '\n\r#'[:k - 1]
k -= 4

while j:
                while k > 0 and c[j] and l + j < 8191:
                        s += chr(c[j].pop())
                        l += j
                        k -= 1
                if k < 1:
                        print(end = s)
                        break
                elif c[j] == []:
                        j -= 1
                else:
                        s += chr(c[8191 - l].pop())
                        print(end = s)
                        k -= 1
                        s = ''
                        l = 0

Perl 5, 50.091 151 đoạn

Đoạn đầu tiên:

use utf8; print length A

Đoạn 2 đến 26: Bthông quaZ

Đoạn trích thứ 27 đến 46: athông qua z, ngoại trừ các ký tự có "độ dài"

Đoạn thứ 47 đến 56: 0thông qua9

Đoạn thứ 57: _

Các đoạn mã còn lại là 50.105 ký tự Unicode riêng lẻ mà Perl coi là các ký tự "từ", ngoại trừ 14 ký tự từ riêng biệt trong đoạn mã ban đầu, theo bất kỳ thứ tự nào.

Vâng, đó là một suy nghĩ tốt, nhưng hóa ra sau một thời gian nhất định Perl cung cấp cho bạn một lỗi "định danh quá dài". Đây là chương trình kết hợp dài nhất mà tôi có thể khiến Perl tiêu hóa:

use utf8; print length A012345679BCDEFGHIJKLMNOPQRSTUVWXYZ_abcdjkmoqsvwxyzĀāĂ㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĦħĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľĿŀŁłŃńŅņŇňʼnŊŋŌōŎŏŐőŒœŔŕŖŗŘřŚśŜŝŞşŠšŢţ

Trang hướng dẫn sử dụng perldiag cho biết "Các phiên bản tương lai của Perl có khả năng loại bỏ các giới hạn tùy ý này" nhưng Perl 5.18 của tôi đã không làm như vậy.

Giải trình:

Trong chế độ không nghiêm ngặt, Perl 5 diễn giải các chuỗi ký tự từ không được trích dẫn là "barewords", về cơ bản trích dẫn chúng cho bạn. Họ thường tránh tốt nhất, nhưng họ chắc chắn giúp đỡ ở đây!

Con trăn 2 , điểm 32

for r in range(32):locals()[''.join(map(chr,range(65,66+r)[:26]+range(117,92+r)))]=r+1
print A

Với đoạn tiếp theo B, C, D, ... Y, Z, u, v, w, x, y,z .

Trong một tình huống trớ trêu kịch tính, Python 3 hỗ trợ các định danh Unicode, điều này sẽ cho phép chúng ta rất ngớ ngẩn với thủ thuật này - nhưng nó không thể không printcó dấu ngoặc đơn. Tôi cũng có thể nhồi nhét các chữ số vào mã định danh, nhưng tôi không nghĩ cách tiếp cận này rất thú vị để vắt kiệt hơn.

Hãy thử trực tuyến!

Python 2 , điểm 18, ít gian lận-y

print 0x10-1&0x1
print 0x10-1&0x12
print 0x10-1&0x123
print 0x10-1&0x1234
print 0x10-1&0x12345
print 0x10-1&0x123456
print 0x10-1&0x1234567
print 0x10-1&0x12345678
print 0x10-1&0x123456789
print 0x10-1&0x123456789A
print 0x10-1&0x123456789Ab
print 0x10-1&0x123456789Abc
print 0x10-1&0x123456789Abcd
print 0x10-1&0x123456789AbcdE
print 0x10-1&0x123456789AbcdEf
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]
print 0x10-1&0x123456789AbcdEf^((()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==())+(()==()))|[[[]]>[]][[]>[]]<<False**False

Hãy thử trực tuyến!

JavaScript (ES6, V8 6.x), 52 50298 119526 119638 119683 128781 đoạn, 88 149147 575179 575631 576121 612789 byte

Xa hơn bên dưới là Stack Snippet tạo chương trình đầy đủ, đánh giá nó và tạo liên kết tải xuống cho tệp. Đoạn mã đó sẽ tiếp tục tạo ra các câu trả lời tốt hơn vì các phiên bản Unicode sau này được hỗ trợ bởi các phiên bản JavaScript mới hơn, bổ sung các định danh hợp lệ mới cho ngôn ngữ.

Chỉ sử dụng ASCII

console.log(new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn$$00112233445566778899AABBCCDDEEFFGGHHIIJJKKLLMMNNOOQQRRSSTTUUVVWWXXYYZZ__aabbccddffiijjkkmmppqqssuuvvzz)

Giải trình

Điều này sử dụng kỹ thuật siêu lập trình Proxyđể kích hoạt bẫy xử lý trên đối tượng và truy cập tên thuộc tính dưới dạng chuỗi, trả về mã định danhlength / 2 là giá trị của nó.

Với đoạn mã đầu tiên bắt đầu là new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, mỗi đoạn mã bổ sung được thêm vào sẽ tăng chuỗi lengthcủa mã định danh bằng 2cách đảm bảo .repeat()điểm mã tương ứng hai lần cho 2 byte utf-16 ký tự và một lần cho 4 byte utf-16 ký tự.

Mã định danh trong JavaScript

Trong Đặc tả ECMAScript , một IdentifierNameđược xác định với ngữ pháp sau:

IdentifierName::
  IdentifierStart
  IdentifierName IdentifierPart

IdentifierStart::
  UnicodeIDStart
  $
  _
  \UnicodeEscapeSequence

IdentifierPart::
  UnicodeIDContinue
  $
  _
  \UnicodeEscapeSequence
  <ZWNJ>
  <ZWJ>

UnicodeIDStart::
  any Unicode code point with the Unicode property “ID_Start”

UnicodeIDContinue::
  any Unicode code point with the Unicode property “ID_Continue”

Tạo câu trả lời

Ban đầu sử dụng thuộc tính Unicode "ID_Continue", tôi đã viết một tập lệnh Node.js để tạo câu trả lời đầy đủ. Bây giờ, nó chỉ là một tập lệnh phía máy khách sử dụng một ngây thơ eval()để kiểm tra các ký tự hợp lệ, lặp đi lặp lại qua tất cả các điểm mã unicode:

// first snippet
let answer = 'new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn'

const used = Array.from(
  answer,
  c => c.codePointAt(0)
).sort(
  (a, b) => a - b
)

// create a O(1) lookup table for used characters in first snippet
const usedSet = Array.from(
  { length: Math.max(...used) + 1 }
)

for (const codePoint of used) {
  usedSet[codePoint] = true
}

// equal to 1 for first snippet
let snippets = eval(answer)
let identifier = ''

for (let codePoint = 0, length = 0x110000; codePoint < length; codePoint++) {
  const character = String.fromCodePoint(codePoint)

  // if unused
  if (usedSet[codePoint] === undefined) {
    // if valid `IdentifierPart`
    try {
      eval(`{let _${character}$}`)
    } catch (error) {
      // console.log(character)
      continue
    }

    // repeat so that `snippet.length === 2`
    identifier += character.repeat(2 / character.length)
    snippets++
  }
}

// number of snippets generated
console.log(`snippets: ${snippets}`)

const program = `console.log(${answer + identifier})`

// output of program to validate with
eval(program)

// download link to check number of bytes used
dl.href = URL.createObjectURL(new Blob([program], { type: 'text/javascript' }))

<a id=dl download=answer.js>Click to Download</a>

Chạy stat -f%z answer.jsmang lại số byte là 612802, nhưng chúng tôi trừ 13 byte cho console.log(và) gói thực tế.

Mã hóa

Nguồn được lưu trữ dưới dạng utf-8, được phản ánh trong số byte khổng lồ của câu trả lời. Điều này được thực hiện vì Node.js chỉ có thể chạy các tệp nguồn được mã hóa trong utf-8.

JavaScript lưu trữ bên trong các chuỗi với mã hóa utf-16, do đó, "độ dài ký tự" được trả về trong JavaScript thực tế chỉ bằng một nửa số byte của chuỗi được mã hóa trong utf-16.

Con trăn 2 , điểm 6 10

^{+3 nhờ pizzapants184
+1 nhờ WheatWizard}

4/4
*2
-~0
+1
|5
^3
&776%6
and 8
if[]else[9][9>9]
.__xor__((""=="").__xor__((""=="")<<(""=="")))

Hãy thử trực tuyến!

TI-Basic (sê-ri 83, phiên bản HĐH 1.15 trở lên), điểm: 17 18 19 24

(Tiebreaker: 53 byte.)

Bạn có thể nhận được số điểm rất lớn bằng cách lạm dụng độ dài chuỗi như bình thường: bắt đầu bằng (như @Scrooble chỉ ra) và tiếp tục thêm các đoạn mã thông báo duy nhất vào cuối. TI-Basic có hơn 700 trong số đó, do đó thực sự hoạt động khá tốt. Nhưng đây là một cách tiếp cận khác:length("A length("length(

int(log(11
2
3
4
5
6
7
8
9
0
Xmax
Ymax
nMax
abs(Xmin
Ymin
ππ
eee
³
²
₁₀^(₁₀^(X
+e^(⁻e^(Y))))
/√(sub(Z!
°
randrandrand

Lưu ý rằng TI-Basic được tokenized, vì vậy (ví dụ) các e^(lệnh không sử dụng bất kỳ ký tự e, ^,( .

Dựa vào một tính năng không có giấy tờ của sub( lệnh: ngoài việc tìm các chuỗi con, nó cũng có thể được sử dụng để chia một số cho 100.

Công trình này nếu nó đang chạy trên một máy tính mới, cho phép chúng tôi cho rằng X, Y, Ztất cả đều bằng không, mà các biến cửa sổ được thiết lập để các giá trị tiêu chuẩn của họ, mà máy tính đang ở chế độ radian, và rằng rand's ba đầu ra đầu tiên sẽ là về 0.943, 0.908, 0.146.

PowerShell , 25 byte, Điểm 5

' '.count*2+!""-(-1)|%{5}

Đoạn 1: ' '.countđầu ra 1. Nó thực hiện điều này bằng cách lấy .countchuỗi, là một chuỗi vì chỉ có một chuỗi. Hãy thử trực tuyến!

Đoạn 2: *2kết quả đầu ra 2vì chúng tôi lấy 1đoạn trích từ đoạn trước và nhân nó với hai Thử trực tuyến!

Đoạn 3: +!""xuất ra 3bằng cách thêm Boolean - không phải của chuỗi rỗng. Điều này ngầm định đưa chuỗi rỗng vào $true, một lần nữa được truyền ngầm 1, vì vậy chúng tôi đang thêm một chuỗi Hãy thử trực tuyến!

Đoạn 4: -(-1)kết quả đầu ra 4bằng cách trừ đi phần phủ định Hãy thử trực tuyến!

Đoạn 5: |%{5}đầu ra 5bằng cách lấy số trước vào một vòng lặp và mỗi lần lặp của vòng lặp đó (chỉ một, vì chỉ có một số đầu vào) đầu ra 5 Hãy thử trực tuyến!

Cảm ơn Jan cho một phương tiện thay thế sắp tới 4và một cách thức xảo quyệt 5.

C, 10 đoạn, 45 byte

sizeof(char)              // sizeof(char) = 1
<<9/9                     // Multiply by two.
|1                        // 2 or 1 = 3
,4                        // Discard previous expression, return 4.
+!!8                      // Add one.
^3                        // 5 xor 3 = 6
&66                       // 3 and 66 = 2, 5 xor 2 = 7 (& has higher precedence)
??'0xF                    // Trigraph for '^'. 7 xor 15 = 8
-~-2                      // ~-2 = 1, 7 xor 14 = 9
*57%5                     // 1*57%5 = 2, 7 xor 13 = 10

Hãy thử trực tuyến!

MATL , Điểm 8 15, 64 123 byte

rg             % 1 Random number, make boolean (1)
Q              % 2 Increment
Yq             % 3 Nth prime
a,E]           % 4 any (convert to boolean 1. Do twice: Multiply by 2
T+             % 5 Add True
F~_-           % 6 Subtract negative (not(false)) = 6-(-1)
:sI/           % 7 Range 1:6, sum (21), divide by 3
A8*            % 8 All elements (True). Multiply by 8
d9             % 9 Clear stack, push 9
x10            % 10 Clear stack, push 10
WBPf           % 11 Raise 2^10. Convert to binary [1 0 ... 0], flip [0 0 ... 1]. Find
23ZP           % 12 Push 23, and calculate the distance between 11 and 23
yyyyyyyyyyyyyyyyyyyyyyyyhhhhhhhhhhhhhhhhhhhhhhhhz  % 13. Duplicate and count elements
tttttttttttttvvvvvvvvvvvn  % 14 Duplicate and count elements
OOOOOOOOOOOOOON&           % 15 Add bunch of zeros, output size of stack

• Đến 12 với sự giúp đỡ từ Luis Mendo! Sử dụng 11,23ZPlà ý tưởng của anh ấy, cùng với việc thay đổi 3với Iđoạn 7.
• Đến 15 với sự giúp đỡ nhiều hơn từ Luis. OO...N&là ý tưởng của anh ấy.

Nhiều hơn nữa Tôi không biết các hàm MATL bằng trái tim, vì vậy tôi phải quay đi quay lại và quay lại trong tài liệu ... :)

Hãy thử trực tuyến!

V , điểm 10

é1
<C-a>
r3
DÉ4
ñóä/5ñ
ddá6
xÁ7
C8<esc>
R9<C-c>
ø.<cr>ÎA0

Hãy thử trực tuyến!

Jelly , 253 byte, điểm 250

L}“L

Đoạn trích 1-char sau đó:

¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż

Lưu ý: ¶cũng có thể được thay thế bởi \n, chúng là cùng một byte trong bảng mã của Jelly.

Sau khi bạn nối thêm tất cả các đoạn đó, bạn có thể nối thêm đoạn mã 2 char ”‘.

+1 cảm ơn Dennis .

Hãy thử trực tuyến!

Lenguage , 1 112 064 đoạn

Các n ^th đoạn gồm 2 ^3n-1 lần lặp lại của n ^th ký tự Unicode không thay thế, lên đến và bao gồm cả 1 112 064 ^thứ và cuối cùng nhân vật không thay thế các tiêu chuẩn Unicode hiện hành.

Đầu ra là đơn nhất (sử dụng byte null dưới dạng chữ số) để đơn giản. Thập phân là có thể, nhưng nó sẽ làm cho các chương trình dài hơn. Với unary, chúng tôi có thể thử nghiệm các chương trình đầu tiên.

Với n = 1 , chúng ta nhận được 4 lần lặp lại U + 0000 . Điều này tương đương với chương trình brainfuck ., in một byte null.

Với n = 2 , chúng tôi nhận được 32 lần lặp lại U + 0001 , với tổng số 36 ký tự. Điều này tương đương với chương trình brainfuck .., in hai byte null.

Với n = 3 , chúng tôi nhận được 256 lần lặp lại U + 0002 , với tổng số 292 ký tự. Điều này tương đương với chương trình brainfuck... , in ba byte null.

Và cứ thế, lên tới n = 1 112 064 .

BASIC (ZX Spectrum), điểm số 244 (điểm mới 247) [đây có phải là gian lận không?]

Đoạn 1:

2356 PRINT PEEK (PEEK 23635+256*PEEK 23636+2)+256*PEEK (PEEK 23635+256*PEEK 23636+3)-56-66

Đoạn 2: :

Đoạn 3: REM

Đoạn trích 4-244: Đoạn mã một ký tự, sử dụng tất cả các ký tự không có trong đoạn 1, 2 và 3.

Giải trình

Nhân vật

Trên Spectrum, PRINTlà một ký tự đơn (mã 245). Đoạn 1 sử dụng 11 nhân vật khác nhau: 2, 3, 5, 6, +, -, *, (, ), PRINTvà PEEKNhững gì bạn thấy là không gian là một phần của nhân vật PRINTvàPEEK , do đó không gian riêng của mình đã không được sử dụng. Tôi quyết định đưa ra số dòng 2356 vì đây là những chữ số duy nhất có trong mã.

Nhân vật 13 và 14 không được phép. Điều đó có nghĩa là có 243 ký tự còn lại cho đoạn trích 2-244, bắt đầu bằng :và REMđể tránh mã gây ra lỗi hoặc làm bất cứ điều gì khác.

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

Đây là lý do tại sao tôi không chắc câu trả lời này là của cuốn sách.

23635 là vị trí bộ nhớ cho PROG biến hệ thống 16 bit, được lưu dưới dạng LH. (Giá trị thường là 23755. Nhưng ngoài kết quả sai nếu không xảy ra trường hợp này, sử dụng trực tiếp số này, mặc dù nó sẽ rút ngắn mã, sẽ khiến tôi mất thêm ký tự chữ số.) Giá trị của PROG là vị trí bộ nhớ nơi chương trình được lưu trữ. Hai byte đầu tiên là số dòng được lưu dưới dạng HL, hai byte sau là độ dài của dòng được lưu dưới dạng LH. Đó là cách chương trình tìm kiếm độ dài của dòng riêng của nó, vì vậy cần phải trừ đi một số thứ thích hợp

Lưu nhân vật

Xem xét cách các số được lưu trữ, dòng có thể đã kết thúc bằng -114 để đoạn 1 tạo ra 1. Nhưng tôi không muốn sử dụng các chữ số phụ, vì vậy tôi đã lấy đi hai số có 2 chữ số, sau đó phải cộng lại đến 122; 56 và 66 đã làm tốt.

Mã này hơi xấu với tất cả các giá trị lồng và tính toán của PROG ( PEEK 23635+256*PEEK 23636) hai lần. Nhưng nếu tôi lưu trữ nó và sau đó sử dụng giá trị được lưu trữ, nó sẽ tốn thêm các ký tự / đoạn trích - dòng có thể bắt đầu như

2356 LET p=PEEK 23635+256*PEEK 23636: PRINT PEEK (s+2)...

mà sẽ sử dụng 4 ký tự bổ sung: LET, p, =và :.

Có lẽ tôi sẽ thiết kế điều này để tất cả các số được tính từ các số chỉ sử dụng 1 chữ số và nhận được 3 đoạn.

CHỈNH SỬA:

Đây là đoạn 1 mới (đó là cách một dòng đơn dài được hiển thị trên Spectrum, vì vậy nếu bạn muốn kiểm tra mã, điều đó sẽ giúp bạn thấy rằng bạn đã nhập chính xác):

1111 PRINT +PEEK (PEEK (11111+11
111+1111+(1+1+1)*(111-11)+1+1)+(
111+111+11+11+11+1)*PEEK (11111+
11111+1111+(1+1+1)*(111+1-11))+1
+1)+(111+111+11+11+11+1)*PEEK (P
EEK (11111+11111+1111+(1+1+1)*(1
11-11)+1+1)+(111+111+11+11+11+1)
*PEEK (11111+11111+1111+(1+1+1)*
(111+1-11))+1+1+1)-111-111-111-1
11-111-111

Tôi có thể có được một đoạn khác bằng cách tránh +và chỉ cần thực hiện với -. Tôi sẽ không thử nó, điều này là đủ thử thách.

Klein 011 , 9 đoạn

Đoạn 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Hãy thử trực tuyến!

Đoạn 2

2((2|bbb0b2bbbb4bbbbbbbb

Hãy thử trực tuyến!

Đoạn 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Hãy thử trực tuyến!

Đoạn 4

ddddddddddddddddddddddd>$d:d:++-$:+:+++$:?:-$-+++

Hãy thử trực tuyến!

Đoạn 5

ee

Hãy thử trực tuyến!

Đoạn 6

fff

Hãy thử trực tuyến!

Đoạn 7

ggggg

Hãy thử trực tuyến!

Đoạn 8

hh

Hãy thử trực tuyến!

Đoạn 9

iiiii

Hãy thử trực tuyến!

Giải trình

Đây là một thử thách thực sự thú vị cho Klein. Cấu trúc liên kết độc đáo của Klein cho phép thực hiện rất nhiều công cụ thú vị. Như bạn có thể nhận thấy câu trả lời 5-9 chỉ là thêm filler (các chữ cái không làm gì trong Klein nên tôi đã sử dụng chúng làm filler) vào mã để kéo dài hộp giới hạn. Điều này khiến ip có một đường dẫn khác thông qua các phần trước của mã do cấu trúc liên kết duy nhất của Klein.

Tôi sẽ giải thích đầy đủ sau, nhưng bây giờ đây là phiên bản dễ hiểu hơn của chương trình với tất cả các chữ cái được thay thế bằng .s.

!@1!...................../.2((2|...0.2....4........
.\*3.....................\.........3.6....9
.\.......................>$.:.:++-$:+:+++$:?:-$-+++.................

Hãy thử trực tuyến!

> <> , Điểm: Vô cực 1,112,064-6 = 1,112,058

Đoạn 1 (6 byte)

"l4-n;

Đoạn mã này xuất ra số lượng ký tự sau; cộng với một. Điều này có thể được mở rộng đến vô hạn số lượng rất lớn các đoạn của một nhân vật từng. Một google nhanh chóng cho tôi biết có 1.112.064 ký tự Unicode có thể, trừ 6 ký tự tôi đã sử dụng.

Hãy thử Nó trực tuyến

R , điểm: 79

Tín dụng cho câu trả lời Perl của Sean cho cảm hứng; điều này lạm dụng một số quirks của trình thông dịch R.

Đoạn đầu tiên:

nchar(scan(,""))
a

đoạn trích tiếp theo là các ký tự trong:

bdefgijklmopqtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@$%^&*_+|\[]{}:?><;

Hãy thử trực tuyến!

Các scanchức năng đọc dữ liệu từ file"" mặc định là stdin().

Các tài liệu cho stdin() biết rằng:

Khi R đang đọc một tập lệnh từ một tập tin, tập tin là 'bàn điều khiển': đây là cách sử dụng truyền thống để cho phép dữ liệu nội tuyến (xem phần Giới thiệu về R 'để biết ví dụ).

Do đó, dữ liệu tiếp theo trở thành tập tin. Điều này có thể được mở rộng tầm thường và có thể hoạt động với nhiều bảng mã khác nhau.

Pyke , 256 byte, điểm số 254

Xin lưu ý rằng đây là các mã hex của các byte thực tế, được phân tách bằng khoảng trắng, vì có byte null (\x00 ) được bao gồm.

Đoạn trích bắt đầu:

6C 22 00

Đoạn trích 1-char sau đó:

01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF

Hãy thử nó ở đây!

Đoạn mã Java 8, 7 (19 byte)

1
*2
-~0
>4?4:4
|5
^3
7%7

Chỉ cần một sự khởi đầu, sẽ tiếp tục làm việc trên nó.

Hãy thử nó ở đây.

Giải trình:

Ưu tiên thực thi có lẽ được làm rõ hơn khi tôi thêm dấu ngoặc đơn:

((1*2)-~0)>4?4:4|(5^(37%7))

• a*b: Nhân avớib
• ~a: -a-1
• a>b?x:y: if(a>b){ x }else{ y }
• a|b: Bitwise-HOẶC avớib
• a^b: Bitwise-XOR avớib
• a%b: amodulo-b

Đoạn mã Python 2 , 110

Đây là đoạn hoàn chỉnh:

print((((len(open(__file__).read())-44.))))

#	 !"$%&'*+,/012356789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`bcghjkmqsuvwxyz{|}~

Hãy thử trực tuyến!

Đoạn đầu tiên là

print((((len(open(__file__).read())-44.))))

Và sau đó 109 đoạn tiếp theo là 109 byte tiếp theo.

Điều này khá "gian lận" như Lynn nói. Đoạn mã đầu tiên mở tệp và trừ 44 từ độ dài của nó, sau đó mỗi đoạn mã khác thêm 1 vào chiều dài của tệp mà không thay đổi toàn bộ logic của chương trình. do đó làm tăng kết quả của đầu ra thêm 1.

dc , điểm 13, 58 byte

I3%                   #I is the default input radix, 10, mod 3 yields 1
1+                    #Add one
2^2^2^Z               #2^8=256, Z pushes the number of digits to the stack
6*v                   #Square root of 18 = ~4.24, at precision 0 we get 4
c5                    #Start getting lazy, clear the stack and push 5
_F-E-                 #Subtract negative 15, then subtract 14
ss7                   #Lazy, 'drop' the value by storing it, push 7
SS8                   #Lazy, 'drop' the value by storing it, push 8
d::9                  #Lazy, 'drop' the value by storing it, push 9
;;kA                  #Recall element 9 from nonexistant array ; which is zero, set precision, push A (10)
iB                    #Set input radix to 10, push B (11)
oD                    #Set output radix to 11, push D (13, or 12 in base 11)
 4CCCCCCr/4C/CC/4/    #We have division and the digits 4 and C left, this might not be the optimal way to get us to 13 but it does the job

Hãy thử trực tuyến! (Lưu ý, phiên bản TIO thêm mộtf sau mỗi đoạn mã để in toàn bộ ngăn xếp, cho thấy rằng mỗi đoạn mã chỉ để lại một giá trị duy nhất trên ngăn xếp; tôi cũng quên khoảng trống hàng đầu trên đoạn mã cuối cùng không quan trọng về chức năng khi chúng bị phá vỡ bởi các ngắt dòng nhưng không được tính vào cách sử dụng ký tự của tôi)

Mỗi phép nối đoạn bổ sung để lại giá trị mong muốn và chỉ giá trị mong muốn trên ngăn xếp. Sau khi đánh 12, tôi đã hết cách để ăn stack. Tôi đã cố gắng sử dụng các phép toán từ sớm vì chúng đã ngấu nghiến ngăn xếp và khi chúng tôi có được số lượng lớn hơn, việc quản lý theo cách đó trở nên khó khăn hơn. Khi tất cả được nói và thực hiện, tôi chỉ còn lại chữ số 0 để chơi và rất ít trong cách xếp chồng lên nhau, vì vậy tôi nghĩ rằng 13 là khá gần với tối đa. Tôi chắc chắn có nhiều cách tương tự (và có thể ngắn hơn) để thực hiện điều này trong dc, đây chỉ là loại rơi vào vị trí. Lưu ý rằng cygwin xử lý AF được trộn với 0-9 khác với hầu hết các phiên bản dc, 44C4r/CC 4//hoạt động cho đoạn mã cuối cùng trong cygwin.

Pyth , 124 đoạn

l"x00x01x03x04x05x06x07x08
x0bx0c
x0ex0fx10x11x12x13x14x15x16x17x18x19x1ax1bx1cx1dx1ex1f !#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkmnopqrstuvwxyz{|}~x7f

Hãy thử trực tuyến!

Các ký tự không thể in được thoát bằng ba ký tự có thể in ( x..). Đoạn mã đầu tiên dài ba byte, mỗi đoạn mã sau đó tăng dần theo chiều dài.

Beatnik , 22 byte, điểm 20

K A
E
I
L
N
O
R
S
T
U
a
e
i
l
n
o
r
s
t
u

Giả sử từ "đoạn trích" cho phép bạn đẩy giá trị lên ngăn xếp.

Octave, Điểm 86

nnz n

Theo dõi bởi:

!$&()*+./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstuvwxy{|}~

Điều này khai thác thực tế rằng Octave xử lý mọi thứ sau một tên hàm làm đầu vào chuỗi. Vì vậy, nnz ntrả về số lượng phần tử khác không trong chuỗi 'n'. Chúng tôi nhận được 86 bằng cách thêm các ký tự ASCII có thể in khác. ',"%#không hoạt động.

APL (Dyalog) , điểm 12

+1 điểm nhờ @dzaima

Đoạn đầu tiên đến đoạn thứ ba:

(~⍴⍬)
+≢'a'
,⍕1

Sau đó, mỗi 234567890 .

Hãy thử trực tuyến!

Julia 0,6, 111217

Kịch bản sau đây tạo chương trình đầy đủ:

A = "macro length(a);length(string(a))end;@length a"
B0 = join(([Char(x) for x in Iterators.flatten((0x000001:0x00d7ff, 0x00e000:0x10ffff)) if Base.isvalid(Char(x)) && Char(x) ∉ A && Base.isidentifier("a$(Char(x))") ]));
B = normalize_string(B0, stripmark=true, decompose=true);
B = join(unique(b for b in B))
while (n = search(B, '·')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end
while (n = search(B, '`')) > 0
    B = B[1:prevind(B,n)]*B[nextind(B,n):end]
end

open("concount.jl", "w") do f
    write(f, A)
    write(f, B)
end

Giải trình

Vĩ mô

 macro length(a);length(string(a))
 end
 @length a

theo sau là tất cả các ký tự unicode riêng biệt được phép trong mã định danh, được tính toán với isidentifier. Một số dấu phụ ghi lộn xộn đếm nên tôi loại bỏ chúng.

TeX, điểm 61 (có thể 190)

Đoạn đầu tiên:

\def\len#1{\expandafter\glen\string#1=}
\def\glen#1{\tlen}
\def\tlen#1{\if#1=\let\tlen\end\number\count1\else\advance\count1by1\fi\tlen}
\count1=-1
\catcode33=11
\catcode34=11
\catcode36=11
\catcode37=11
\catcode'46=11
\catcode40=11
\catcode41=11
\catcode42=11
\catcode43=11
\catcode44=11
\catcode45=11
\catcode46=11
\catcode47=11
\catcode56=11
\catcode57=11
\catcode'72=11
\catcode'73=11
\catcode60=11
\catcode62=11
\catcode63=11
\catcode64=11
\catcode'133=11
\catcode'135=11
\catcode'136=11
\catcode'137=11
\catcode'140=11
\catcode124=11
\catcode126=11
\len\t

60 đoạn khác: theo bất kỳ thứ tự nào, mỗi đoạn chứa một ký tự trong số

!"$%&()*+,-./:;<>?@[]^_`|~89ABCDEFGHIJKLMNOPQRSTUVWXYZhjkqwz

Giải thích : \len, được gọi ở cuối, chuyển đổi một chuỗi điều khiển thành một chuỗi, mỗi ký tự (bao gồm \) là một mã thông báo ký tự của chuỗi đó; sau đó \glenngấu nghiến mã thông báo \, sau đó \tlenđếm số mã thông báo còn lại. Do đó, nó đưa ra độ dài của chuỗi điều khiển đó (không bao gồm \).

Các ký tự từ các đoạn khác mở rộng chuỗi điều khiển ban đầu chỉ là \t . Một chuỗi điều khiển đa ký tự chỉ được tạo thành các chữ cái, nhưng tất cả chúng đều được tính là các chữ cái vì tất cả chúng đều được gán mã danh mục 11 (sử dụng mã ASCII để các ký tự không xuất hiện trong đoạn mã đầu tiên).

Tôi quyết định sử dụng mã bát phân cho một số ký tự có giá một ký hiệu, ' nhưng đã lưu cho tôi hai chữ số 8 và 9, vì vậy tôi đã có được một đoạn. Có thể tôi đã kiếm được nhiều hơn nếu tôi không cần \expandafter.

Đầu ra

Thay đổi có thể có: bọc \number\count1vào \message{}để đầu ra không đi vào.dvi đầu ra mà thay vào đó là đầu ra của bàn điều khiển và .log. Nó không tốn bất kỳ chữ cái thêm.

190

Thật không may, TeX hoạt động với ASCII chứ không phải Unicode (hoặc hiện tại?), Nhưng giải pháp của tôi có thể được mở rộng để bao gồm thêm 129 đoạn mã ký tự đơn có chứa các ký tự có mã 127-255. Thậm chí có thể một số nhân vật trước 32. Nhân vật 32 (không gian) không hoạt động, nếu không tôi cũng sẽ đưa nó vào một đoạn trích - không cần nó trong đoạn trích đầu tiên. Tất nhiên, mỗi ký tự bổ sung này sẽ phải được viết \catcodethành một chữ cái trong đoạn trích đầu tiên.

Pip, 57 byte, điểm = 16

!u
2
RT9
#m
5
(EX3Y8)
7
y
A'<tab>
t
11
+o
-v
PI@`\...`@`..$`
"F"FB:4*4
Ok=k6

Lưu ý rằng <tab>đại diện cho một ký tự tab theo nghĩa đen (ASCII 9). Hãy thử trực tuyến!

Mỗi đoạn mã là một chương trình đầy đủ tạo ra số lượng mong muốn. Hầu hết chúng hoạt động theo nguyên tắc biểu thức cuối cùng trong chương trình Pip được tự động in: ví dụ, trong đoạn 5, đoạn mã trước được ước tính, nhưng phần duy nhất quan trọng là5 . Ngoại lệ cho điều này là:

• Đoạn 3 hoạt động tốt trong sự cô lập như RT9(căn bậc hai của 9), nhưng đến sau đoạn 2, nó thực sự phân tích thành2RT9 (gốc thứ 2 của 9) - tất nhiên, tương đương với điều tương tự.
• Đoạn 6 có ký tự thứ 8 (0 chỉ mục) của e ^ 3, xảy ra là 6. Nhưng nó cũng đưa số 8 vào ybiến. Đoạn 8 sau đó xuất giá trị củay .
• Đoạn trích 12 lấy số 11 từ đoạn trước và thêm o(được khởi tạo trước thành 1). Đoạn 13 lấy kết quả đó và trừv (được khởi tạo thành -1).
• Đoạn trích 16 xuất ra 1mà không có dòng mới ( Ok=ktrong đó k=kđánh giá giá trị trung thực mặc định là 1) và sau đó tự động in 6.

Những thứ thú vị khác:

• Đoạn 14 sử dụng các thao tác regex để giải nén 14 từ giá trị của pi.
• Đoạn 15 chuyển đổi chuỗi "F"từ thập lục phân.

Zsh , điểm> 50 000 (1 112 046?), 16 + (độ dài mã hóa UTF-8) byte

exec echo   $((${#:-$(<$0)}-33))
#

Zsh xử lý mã hóa đa bào theo mặc định. Đoạn mã cơ sở có 18 ký tự duy nhất, tổng cộng 34. Mọi mã khác (lưu cho byte null) có thể được thêm vào này. Khi tôi viết bài này, tập lệnh của tôi kiểm tra các tập lệnh này trên codepoint ~ 50 000, tổng kích thước tệp 150K, với tốc độ khoảng 30 đoạn / giây. Chạy kịch bản thử nghiệm đầy đủ của tôi ở đây. Bạn có thể muốn điều chỉnh nó để bắt đầu tại một số điểm mã sau này.

Hãy thử 2000 đoạn đầu tiên trực tuyến!

Nhiều đoạn trích có thể bằng cách sử dụng kỹ thuật này .