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

Правила

• Ви можете використовувати один і той же символ кілька разів в одному (і лише одному) фрагменті.
• Ці фрагменти повинні бути об'єднані в порядку їх подання , не пропускаючи жодного.
• Ви повинні написати щонайменше два фрагменти.
• Усі фрагменти повинні бути однаковою мовою.
• Пам’ятайте: фрагменти не повинні бути повноцінними програмами або функціями, а також не повинні функціонувати самостійно. -1є дійсним фрагментом на Java, напр
• Усі результуючі конкатенації повинні виводити відповідне значення K.
• Переможець - людина з найвищим N значенням. Автоматичний вимикач - найкоротша загальна довжина програми в байтах.

Приклад

Нехай ваші фрагменти були AD, xc, 123, і ;l. Потім:

• AD повинні виробляти 1
• ADxc повинні виробляти 2
• ADxc123 повинні виробляти 3
• і ADxc123;lповинні виробляти 4.

Ця програма мала б оцінку 4 .

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

Це дуже схоже на відповідь @ WheatWizard's 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-й фрагмент: _

Решта фрагментів - це 50105 окремих символів Unicode, які 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щоб увімкнути пастку обробника на об'єкт і отримати доступ до імені властивості як рядка, повертаючи ідентифікатор length / 2як його значення.

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

Ідентифікатори в JavaScript

У специфікації ECMAScript а 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()тест на перевірку дійсних символів, перебираючи натомість усі точки коду 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>

Під час виконання stat -f%z answer.jsвиходить кількість байтів 612802, але ми віднімаємо 13 байт для console.log(та )завершення фактичного подання.

Кодування

Джерело зберігається як utf-8, що відображається у величезному кількості байтів відповіді. Це робиться тому, що Node.js може запускати лише вихідні файли, закодовані у utf-8.

JavaScript внутрішньо зберігає рядки з кодуванням utf-16, тому рядок "довжина символів", повернутий у JavaScript, насправді становить лише половину кількості байтів рядка, закодованого у utf-16.

Пітон 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 bytes.)

Ви можете отримати дуже великий бал, зловживаючи довжиною рядка, як зазвичай: почніть з (як вказує @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рядок, який є одним, тому що є лише одна струна. Спробуйте в Інтернеті!

Snippet 2: *2виводить, 2оскільки ми беремо 1попередній фрагмент і множимо його на два. Спробуйте в Інтернеті!

Фрагмент 3: +!""виводиться 3, додаючи булеве значення, а не порожній рядок. Це неявно перекидає порожню рядок $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-char фрагменти:

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

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

Після того як ви додасте всі ці фрагменти, ви можете додати 2-знаковий фрагмент ”‘.

+1 завдяки Деннісу .

Спробуйте в Інтернеті!

Ленгуага , 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 .

BASIC (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 (ось так довгий один рядок відображається в Spectrum, тому якщо ви хочете перевірити код, це допоможе вам побачити, що ви правильно ввели його):

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

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

Klein 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 - це просто додавання наповнювача (листи не роблять нічого в Клейні, тому я використовував їх як наповнювач) до коду, щоб розтягнути обмежувальне поле. Це змушує ip пройти інший шлях через більш ранні частини коду через унікальну топологію Клейна.

Я буду робити повне пояснення пізніше, але наразі тут простіша для розуміння версія програми з усіма літерами, заміненими на .s.

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

Спробуйте в Інтернеті!

> <> , Оцінка: Нескінченність 1,112,064-6 = 1,112,058

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

"l4-n;

Цей фрагмент видає кількість символів після; плюс один. Це може бути розширено до нескінченної дуже великої кількості фрагментів одного символу кожен. Швидкий google каже мені, що є 1112,064 можливих символів Unicode, мінус 6, які я вже використав.

Спробуйте це в Інтернеті

R , оцінка: 79

Кредит на Perl відповідь Шона на вдиху; це зловживає деякими химерностями перекладача R.

Перший фрагмент:

nchar(scan(,""))
a

наступні фрагменти - це символи у:

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

Спробуйте в Інтернеті!

scanФункція зчитує дані з файлу , ""який по замовчуванням stdin().

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

Коли R читає скрипт з файлу, файл - це «консоль»: це традиційне використання для введення даних в рядку (див. Приклад «Вступ до R»).

Отже, наступні дані стають файлом. Це може бути тривіально розширено і може працювати з декількома різними кодуваннями.

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

Зверніть увагу, що це шістнадцяткові коди фактичних байтів, розділені пробілами, оскільки туди \x00включений нульовий байт ( ).

Початковий фрагмент:

6C 22 00

Наступні 1-char фрагменти:

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: amodulo-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 досить близький до змішаного. Я впевнений, що існує багато подібних (і, ймовірно, коротших) способів досягти цього в постійному струмі, цей вид просто став на місце. Зауважте, що cygwin обробляє AF, змішаний з 0-9, відмінним від більшості версій постійного струму, 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

Далі всі чіткі символи unicode, дозволені в ідентифікаторах, обчислені 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. Але він також додає число до yзмінної 8. Фрагмент 8 потім виводить значення y.
• Фрагмент 12 бере 11 із попереднього фрагмента і додає o(попередньо підкреслений до 1). Знімок 13 приймає цей результат і віднімає v(попередньо підкресливши до -1).
• Фрагмент 16 виводить 1без нового рядка ( Ok=kде k=kобчислюється до стандартного значення 1), а потім автодруків 6.

Інші цікаві речі:

• Snippet 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 фрагменти онлайн!

За допомогою цієї методики можливо більше фрагментів .