Ваша задача состоит в том, чтобы написать N фрагменты кода таким образом, что, когда вы сцепить первый K ≥ 1 вместе, они производят число K . Чем выше N , тем лучше. В этом и заключается подвох: вы не можете использовать какой-либо символ более одного раза в своих фрагментах.

правила

• Вы можете использовать один и тот же символ несколько раз в одном (и только одном) фрагменте.
• Эти фрагменты должны быть объединены в том порядке, в котором они представлены , без пропуска.
• Вы должны написать как минимум два фрагмента.
• Все фрагменты должны быть на одном языке.
• Помните: фрагменты не должны быть полными программами или функциями, и при этом они не должны функционировать самостоятельно. -1допустимый фрагмент в Java, например
• Все полученные конкатенации должны выводить соответствующее значение K.
• Победителем становится человек с наибольшим значением N. Tie-breaker - самая короткая общая длина программы в байтах.

пример

Пусть ваши фрагменты были AD, xc, 123, и ;l. Затем:

• AD должен производить 1
• ADxc должен производить 2
• ADxc123 должен производить 3
• и ADxc123;lдолжен производить 4.

Эта программа будет иметь 4 балла .

Python 3 , 1 112 056 фрагментов, 4 383 854 байта

Это очень похоже на ответ @ WheatWizard на Python 2 . Я начал работать над этим незадолго до того, как он был опубликован, но для выяснения причуд Python относительно символов, отличных от ASCII, и длинных строк потребовалось некоторое время. Я обнаружил, что Python читает строки по 8191 байт за раз, и когда эти 8191 байт содержат только часть многобайтового символа, Python генерирует ошибку SyntaxError .

Первый фрагмент использует кодировку из Наименьших (различных) символов для полноты Тьюринга .

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

Это чудовище просто строит следующую строку и выполняет ее.

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

Следующие фрагменты имеют длину всего один символ. Следующие три символа \n, \rи #. Все остальные символы Unicode (кроме суррогатов) следуют в определенном порядке, поэтому они выровнены по границе 8191 байт.

Следующий скрипт генерирует соответствующие программы для ввода k между 1 и 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 фрагмент

Первый фрагмент:

use utf8; print length A

От 2 до 26 фрагментов: BчерезZ

Фрагменты от 27 до 46: aсквозные z, исключая символы длины

От 47 до 56 фрагментов: 0через9

57-й фрагмент: _

Остальные фрагменты представляют собой 50,105 отдельных символов Юникода, которые Perl считает символами «слова», исключая 14 различных символов слова в исходном фрагменте в любом порядке.

Что ж, это была хорошая мысль, но оказалось, что после определенной длины Perl выдает ошибку «слишком длинный идентификатор». Это самая длинная комбинированная программа, которую я смог заставить Perl переварить:

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

Страница руководства perldiag гласит: «Будущие версии Perl, вероятно, устранят эти произвольные ограничения», но мой Perl 5.18 этого не сделал.

Объяснение:

В нестрогом режиме Perl 5 интерпретирует строки в кавычках без кавычек как «голые слова», по сути, автоматически цитируя их для вас. Их обычно лучше избегать, но они обязательно помогут здесь!

Python 2 , оценка 32

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

При последующих фрагментах B, C, D, ... Y, Z, u, v, w, x, y, z.

По иронии судьбы Python 3 поддерживает идентификаторы Unicode, что позволило бы нам очень глупо использовать этот трюк, но printбез скобок это невозможно . Я мог бы втиснуть цифры и в идентификатор, но я не думаю, что такой подход очень интересен, чтобы выжать из него больше.

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

Python 2 , оценка 18, меньше чит-у

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

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

JavaScript (ES6, V8 6.x), 52 50298 119526 119638 119683 128781 фрагмент, 88 149147 575179 575631 576121 612789 байт

Ниже приведен фрагмент стека, который генерирует полную программу, оценивает ее и создает ссылку для загрузки файла. Этот фрагмент будет продолжать генерировать лучшие ответы, так как более поздние версии Unicode поддерживаются более новыми версиями JavaScript, которые добавляют новые допустимые идентификаторы к языку.

Использование только ASCII

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

объяснение

При этом используется метод метапрограммирования, Proxyпозволяющий включить обработчик get для объекта и получить доступ к имени свойства в виде строки, возвращая идентификатор в length / 2качестве значения.

С первым фрагментом, начинающимся как new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, каждый добавленный дополнительный фрагмент увеличивает строку lengthидентификатора, 2проверяя его до .repeat()соответствующей кодовой точки дважды для 2-байтовых символов utf-16 и один раз для 4-байтовых символов utf-16.

Идентификаторы в JavaScript

В спецификации ECMAScript an IdentifierNameопределяется следующей грамматикой:

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”

Генерация ответа

Изначально используя свойство Unicode "ID_Continue", я написал скрипт Node.js, который генерирует полный ответ. Теперь это всего лишь сценарий на стороне клиента, который использует наивный eval()для проверки допустимых символов, вместо этого перебирая все кодовые точки Юникода:

// 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>

Выполнение stat -f%z answer.jsдает число байтов 612802, но мы вычитаем 13 байтов для фактического представления console.log(и )переноса.

кодирование

Источник хранится в формате utf-8, что отражается в огромном количестве байтов ответа. Это сделано потому, что Node.js может запускать только исходные файлы, закодированные в utf-8.

JavaScript внутренне хранит строки с кодировкой utf-16, поэтому строка «длина символа», возвращаемая в JavaScript, на самом деле составляет лишь половину количества байтов строки, закодированной в utf-16.

Python 2 , оценка 6 10

^{+3 благодаря pizzapants184
+1 благодаря WheatWizard}

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

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

TI-Basic (серия 83, версия ОС 1.15 или выше), оценка: 17 18 19 24

(Tiebreaker: 53 байта.)

Вы можете получить очень большую оценку, используя обычную длину строки: начните с (как указывает @Scrooble) и продолжайте добавлять фрагменты с одним токеном до конца. TI-Basic имеет более 700 из них, так что на самом деле работает довольно хорошо. Но вот другой подход: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

Обратите внимание , что TI-Basic является лексемы, так (например) e^(команда не использует какой - либо из символов e, ^, (.

Полагается на недокументированную особенность sub(команды: помимо поиска подстрок, ее также можно использовать для деления числа на 100.

Это работает , если он работает на свежий калькулятор, который позволяет нам предположить , что X, Y, Zравны нулю, что оконные переменные устанавливаются в стандартные значения, что калькулятор в радианах режиме, и что rand«s первые три выхода составит около 0.943, 0.908, 0.146.

PowerShell , 25 байт, оценка 5

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

Фрагмент 1: ' '.countвыводы 1. Это делается путем взятия .countстроки, которая равна единице, потому что есть только одна строка. Попробуйте онлайн!

Фрагмент 2: *2выходные данные, 2потому что мы берем 1предыдущий фрагмент и умножаем его на два. Попробуйте онлайн!

Фрагмент 3: +!""вывод 3, добавив логическое значение not пустой строки. Это неявно приводит к пустой строке $true, которая снова неявно приводится к 1, поэтому мы добавляем одну Попробовать онлайн!

Фрагмент 4: -(-1)результаты 4путем простого вычитания отрицательного значения Попробуйте онлайн!

Фрагмент 5: |%{5}вывод 5, перенося предыдущий номер в цикл, и каждая итерация этого цикла (только один, потому что есть только один входной номер) выводит 5 Попробуйте онлайн!

Спасибо Яну за альтернативный способ придумать 4и хитроумный способ придумать 5.

C, 10 фрагментов, 45 байтов

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

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

MATL , оценка 8 15, 64 123 байта

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

• Получил 12 с помощью Луиса Мендо! Использование 11,23ZPбыло его идеей, наряду с изменением3 с Iдля сниппета 7.
• Получил 15 с большей помощью от Луиса. OO...N&была его идея.

Еще не все. Я не знаю функции MATL наизусть, поэтому мне приходилось переходить туда-сюда в документации ... :)

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

V , оценка 10

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

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

Желе , 253 байта, оценка 250

L}“L

Последующие фрагменты из 1 символа:

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

Примечание: ¶также может быть заменено на \n, это тот же байт в кодовой странице Jelly.

После добавления всех этих фрагментов вы можете добавить фрагмент из 2 символов ”‘.

+1 спасибо Деннису .

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

Lenguage , 1 112 064 фрагментов

П - ^й фрагмент состоит из 2 -х ^3n-1 повторений п - ^го не-суррогатного характера Unicode, вплоть до и включая 1 112 064 ^{- й} и последний не-суррогатной характер текущего стандарта Unicode.

Вывод в унарном виде (с использованием нулевого байта в качестве цифры) для простоты. Десятичная дробь возможна, но это сделает программы еще длиннее. С помощью унарного мы можем протестировать первые программы.

Для n = 1 мы получаем 4 повторения U + 0000 . Это эквивалентно программе brainfuck ., которая печатает один нулевой байт.

Для n = 2 мы получаем 32 повторения U + 0001 , всего 36 символов. Это эквивалентно программе brainfuck .., которая печатает два нулевых байта.

Для n = 3 мы получаем 256 повторений U + 0002 , в общей сложности 292 символа. Это эквивалентно программе Brainfuck... , которая печатает три нулевых байта.

И так далее, до n = 1 112 064 .

Бейсик (ZX Spectrum), оценка 244 (новая оценка 247) [это обман?]

Фрагмент 1:

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

Фрагмент 2: :

Фрагмент 3: REM

Фрагменты кода 4-244: фрагменты из одного символа, в которых используются все символы, не входящие в фрагменты 1, 2 и 3.

объяснение

Символы

На Спектруме PRINTстоит один символ (код 245). Сниппета 1 использует 11 различных символов: 2, 3, 5, 6, +, -, *, (, ), PRINTи PEEKчто вы видите , как пробелы являются частью символов PRINTиPEEK , таким образом , само пространство не используется. Я решил дать номер строки 2356, потому что это единственные цифры в коде.

Символы 13 и 14 не допускаются. Это означает, что для фрагментов 2-244 осталось 243 символа, начиная с кода :и REMизбегая кода, который может привести к ошибке или сделать что-то еще.

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

Вот почему я не уверен, что этот ответ от книги.

23635 - это ячейка памяти для 16-битной системной переменной PROG, хранящаяся как LH. (Значение обычно составляет 23755. Но если не считать неправильный результат, если это не так, использование этого числа напрямую, даже если это укорачивает код, обойдется мне в дополнительные цифры.) Значение PROG - это место в памяти где хранится сама программа. Первые два байта - это номер строки, хранящийся как HL, следующие два байта - это длина строки, хранящаяся как LH. Вот как программа ищет длину собственной строки, поэтому необходимо вычесть что-то подходящее

Сохранение персонажей

Учитывая то, как хранятся числа, строка могла бы заканчиваться на -114, чтобы фрагмент 1 выдавал 1. Но я не хотел использовать дополнительные цифры, поэтому вместо этого я убрал два двузначных числа, которые затем пришлось сложить до 122; 56 и 66 сделали хорошо.

Код немного некрасив, со всеми вложенными и вычисленными значениями PROG ( PEEK 23635+256*PEEK 23636) дважды. Но если я сохраню его, а затем использую сохраненное значение, это будет стоить дополнительных символов / фрагментов - строка может начинаться как

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

который будет использовать 4 дополнительных символов: LET, p, =и :.

Может быть, я спроектирую это так, чтобы все числа рассчитывались из чисел, которые используют только 1 цифру, и получают 3 фрагмента.

РЕДАКТИРОВАТЬ:

Вот новый фрагмент 1 (именно так длинная отдельная строка отображается на Спектруме в виде переноса, поэтому, если вы захотите проверить код, это поможет вам убедиться, что вы набрали его правильно):

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

Я мог бы получить другой фрагмент, избегая +и просто обойтись -. Я не собираюсь пробовать это, это было достаточно тяжелым испытанием.

Кляйн 011 , 9 фрагментов

Фрагмент 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

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

Фрагмент 2

2((2|bbb0b2bbbb4bbbbbbbb

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

Фрагмент 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

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

Фрагмент 4

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

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

Фрагмент 5

ee

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

Фрагмент 6

fff

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

Фрагмент 7

ggggg

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

Фрагмент 8

hh

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

Фрагмент 9

iiiii

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

объяснение

Это было действительно забавное испытание для Кляйна. Уникальная топология Кляйна позволяет сделать много интересного. Как вы могли заметить, ответы 5-9 - это просто добавление заполнителя (буквы в Klein ничего не делают, поэтому я использовал их в качестве наполнителя) в коде, чтобы растянуть ограничивающую рамку. Это заставляет ip идти другим путем через более ранние части кода из-за уникальной топологии Klein.

Я собираюсь сделать полное объяснение позже, но сейчас здесь более простая для понимания версия программы со всеми буквами, замененными на .s.

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

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

> <> , Счет: Бесконечность 1,112,064-6 = 1,112,058

Фрагмент 1 (6 байт)

"l4-n;

Этот фрагмент выводит количество символов после; плюс один. Это может быть расширено до бесконечности большого количества фрагментов по одному символу каждый. Быстрый Google говорит мне, что есть 1 112 064 возможных символов Unicode, минус 6 я уже использовал.

Попробуйте It Интернет

R , оценка: 79

Благодарю Perl от Sean за вдохновение; это нарушает некоторые особенности интерпретатора R.

Первый фрагмент:

nchar(scan(,""))
a

последующие фрагменты - это символы в:

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

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

scanФункция считывает данные из файла , ""который по умолчанию stdin().

Документы для stdin()указывают, что:

Когда R читает скрипт из файла, файл является «консолью»: это традиционное использование, чтобы разрешить встроенные данные (см. «Введение в R» для примера).

Следовательно, последующие данные становятся файлом. Это может быть тривиально расширено и может работать с несколькими различными кодировками.

Пайк , 256 байт, оценка 254

Обратите внимание, что это шестнадцатеричные коды фактических байтов, разделенных пробелами, поскольку там \x00включен нулевой byte ( ).

Начальный фрагмент:

6C 22 00

Последующие фрагменты из 1 символа:

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

Попробуй это здесь!

Java 8, 7 фрагментов (19 байт)

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

Просто для начала продолжим работать над этим.

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

Объяснение:

Приоритет выполнения, возможно, становится понятнее, когда я добавляю круглые скобки:

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

• a*b: Умножить aнаb
• ~a: -a-1
• a>b?x:y: if(a>b){ x }else{ y }
• a|b: Побитовое ИЛИ aсb
• a^b: Побитовый XOR aсb
• a%b: по aмодулюb

Python 2 , 110 фрагментов

Вот полный фрагмент:

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

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

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

Первый фрагмент

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

И затем следующие 109 фрагментов являются следующими 109 байтами.

Это довольно "обманчиво", как говорит Линн. Первый фрагмент открывает файл и вычитает 44 из его длины, затем каждый другой фрагмент добавляет 1 к длине файла без изменения логики программы в целом. таким образом увеличивая результат вывода на 1.

dc , оценка 13, 58 байт

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

Попробуйте онлайн! (Обратите внимание, версия TIO добавляетf после каждого фрагмента для печати весь стек, показывая, что каждый фрагмент оставляет только одно значение в стеке; также я забыл начальный пробел в последнем фрагменте, который функционально не имеет значения, когда они разбитый на разрывы строк, но он учитывает использование моего персонажа)

Каждая дополнительная конкатенация фрагментов оставляет желаемое значение и только желаемое значение в стеке. После того, как я набрал 12, у меня не хватило способов съесть стек. Я пытался использовать математические операции на ранних этапах, так как они поглощают стек, и по мере того, как мы увеличиваем число, становится сложнее управлять этим способом. Когда все сказано и сделано, у меня остается только цифра 0, с которой можно играть, и очень мало способов выталкивания стеков, поэтому я думаю, что 13 довольно близко к максимальному значению. Я уверен, что есть много схожих (и, вероятно, более коротких) способов сделать это в DC, это только отчасти стало на свои места. Обратите внимание, что Cygwin обрабатывает AF, смешанный с 0-9, в отличие от большинства версий DC, 44C4r/CC 4//работает для последнего фрагмента в Cygwin.

Pyth , 124 фрагмента

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

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

Непечатаемые символы, которые экранируются тремя печатными символами ( x..). Первый фрагмент имеет длину три байта, после чего каждый фрагмент увеличивается в длину на один.

Битник , 22 байта, оценка 20

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

Предполагая, что слово «фрагмент» позволяет поместить значение в стек.

Октава, Оценка 86

nnz n

С последующим:

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

Это использует тот факт, что Octave обрабатывает все после имени функции как строковый ввод. Такnnz n возвращает количество ненулевых элементов в строке 'n'. Мы добираемся до 86, добавляя другие печатные символы ASCII. ',"%#не работает

APL (Дьялог) , оценка 12

+1 оценка благодаря @dzaima

Фрагменты с первого по третий:

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

Тогда каждый из 234567890 .

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

Юлия 0,6, 111217

Следующий скрипт создает полную программу:

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

объяснение

Макрос

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

за которыми следуют все различные символы Юникода, разрешенные в идентификаторах, вычисленные с помощью isidentifier. Некоторые диакритические знаки запутались, поэтому я их убрал.

TeX, оценка 61 (возможно 190)

Первый фрагмент:

\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 фрагментов: в любом порядке, каждый из которых содержит один символ из

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

Объяснение: \lenкоторое вызывается в конце, преобразует управляющую последовательность в строку, каждый символ (включая \) является одним символьным токеном этой строки; затем \glenжетон сожрал \, затем \tlenсчитает оставшиеся жетоны. Поэтому он выводит длину этой последовательности управления (не включая\ ).

Символы из других фрагментов расширяют последовательность управления, которая изначально является простой \t. Многосимвольная управляющая последовательность должна состоять только из букв, но все они считаются буквами, потому что им был присвоен код категории 11 (с использованием кодов ASCII, чтобы сами символы не появлялись в первом фрагменте).

Я решил использовать восьмеричные коды для некоторых символов, которые стоили мне один символ, 'но сохранили мне две цифры, 8 и 9, поэтому я получил один фрагмент. Возможно, мог бы получить еще пару, если бы я не нуждался \expandafter.

Выход

Возможное изменение: обертывание \number\count1в \message{}поэтому выход не переходит в .dviвыходной , но вместо того, чтобы вывести консоль и .log. Это не стоит никаких дополнительных писем.

190

К сожалению, TeX работает с ASCII, а не с Unicode (или делает это сейчас?), Но мое решение может быть расширено, чтобы включить еще 129 односимвольных фрагментов, содержащих символы с кодами 127-255. Может быть, даже некоторые символы до 32. Символ 32 (пробел) не работал, в противном случае я бы также поместил его во фрагмент - он не понадобился в первом фрагменте. Конечно, каждый из этих дополнительных символов должен был бы быть \catcodeзаключен в букву в первом фрагменте.

Пип, 57 байт, оценка = 16

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

Обратите внимание, что <tab>представляет собой буквенный символ табуляции (ASCII 9). Попробуйте онлайн!

Каждый фрагмент представляет собой полную программу, которая выводит желаемое число. Большинство из них работают по принципу, согласно которому последнее выражение в программе Pip автоматически печатается: например, во фрагменте 5 вычисляется предыдущий код, но важна только часть 5. Исключениями являются:

• Фрагмент 3 работает нормально в отдельности как RT9(квадратный корень из 9), но после фрагмента 2 он фактически анализируется как 2RT9(2-й корень из 9) - что, конечно, равносильно тому же.
• Фрагмент 6 получает восьмой символ (0-индексированный) из e ^ 3, который равен 6. Но он также возвращает число 8 в yпеременную. Затем фрагмент 8 выводит значение y.
• Фрагмент 12 берет 11 из предыдущего фрагмента и добавляет o( предварительно инициализированный в 1). Фрагмент 13 берет этот результат и вычитает v(предварительно инициализирован до -1).
• Фрагмент 16 выводится 1без новой строки ( Ok=kгде k=kзначение по умолчанию равно 1), а затем автоматически печатается 6.

Другие интересные вещи:

• Фрагмент 14 использует операции регулярного выражения для извлечения 14из значения pi.
• Фрагмент 15 преобразует строку "F"из шестнадцатеричной.

Zsh , оценка> 50 000 (1 112 046?), 16 + Σ (длины кодовой точки UTF-8)

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

Zsh по умолчанию обрабатывает многобайтовые кодировки. Базовый фрагмент содержит 18 уникальных персонажей, всего 34. Любая другая кодовая точка (кроме нулевого байта) может быть добавлена ​​к этому. Когда я пишу это, мой скрипт проверяет их на кодовой точке ~ 50 000, общий размер файла 150 КБ, примерно 30 фрагментов в секунду. Запустите мой полный тестовый скрипт самостоятельно здесь. Вы можете настроить его так, чтобы он начинался с более поздних кодов.

Попробуйте первые 2000 фрагментов онлайн!

Больше фрагментов возможно с использованием этой техники .