Twoim wyzwaniem jest napisanie N fragmentów kodu tak, że kiedy pierwszy złączyć K ≥ 1 razem produkują numer K . Im wyższy N , tym lepiej. Oto haczyk: nie możesz użyć żadnej postaci więcej niż raz w swoich fragmentach.

Zasady

• Możesz użyć tego samego znaku wiele razy w jednym (i tylko jednym) fragmencie.
• Te fragmenty muszą być konkatenowane w kolejności, w jakiej są prezentowane , bez pomijania żadnych.
• Musisz napisać co najmniej dwa fragmenty.
• Wszystkie fragmenty muszą być w tym samym języku.
• Pamiętaj: fragmenty nie muszą być pełnymi programami ani funkcjami, ani nie muszą działać samodzielnie. -1jest poprawnym fragmentem kodu w Javie, np
• Wszystkie wynikowe konkatenacje muszą generować odpowiednią wartość K.
• Zwycięzcą zostaje osoba o najwyższej wartości N. Tie-breaker to najkrótsza całkowita długość programu w bajtach.

Przykład

Załóżmy, że fragmenty były AD, xc, 123, i ;l. Następnie:

• AD powinien produkować 1
• ADxc powinien produkować 2
• ADxc123 powinien produkować 3
• i ADxc123;lpowinien produkować 4.

Ten program uzyskałby wynik 4 .

Fragmenty w języku Python 3 , 1 112 056, 4 383 854 bajtów

Jest to bardzo podobne do odpowiedzi Python 2 na @ WheatWizard . Zacząłem nad tym pracować krótko przed opublikowaniem, ale uporządkowanie dziwactw Pythona dotyczących znaków spoza ASCII i długich linii zajęło trochę czasu. Odkryłem, że Python odczytuje wiersze 8191 bajtów naraz, a kiedy te 8191 bajtów zawierają tylko część znaku wielobajtowego, Python generuje błąd SyntaxError .

Pierwszy fragment korzysta z kodowania od najmniejszej liczby (odrębnych) znaków dla kompletności Turinga .

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

Ta potworność po prostu buduje następujący ciąg i wykonuje go.

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

Poniższe fragmenty mają długość dokładnie jednego znaku. Kolejne trzy znaki są \n, \ri #. Wszystkie pozostałe znaki Unicode (oprócz surogatów) następują w określonej kolejności, więc są wyrównane do granicy 8191 bajtów.

Poniższy skrypt generuje odpowiednie programy dla wejścia k od 1 do 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 fragmentów

Pierwszy fragment:

use utf8; print length A

Fragmenty od 2 do 26: BprzezZ

Fragmenty od 27 do 46: ado z, z wyłączeniem znaków w „długości”

Fragmenty od 47 do 56.: 0do9

57. fragment kodu: _

Pozostałe fragmenty to 50 105 pojedynczych znaków Unicode, które Perl uważa za znaki „słowne”, z wyłączeniem 14 odrębnych znaków słownych w początkowym fragmencie, w dowolnej kolejności.

Cóż, to była miła myśl, ale okazuje się, że po pewnej długości Perl podaje błąd „zbyt długi identyfikator”. To najdłuższy połączony program, który udało mi się przekonać Perla do strawienia:

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

Strona podręcznika perldiag mówi: „Przyszłe wersje Perla prawdopodobnie wyeliminują te arbitralne ograniczenia”, ale mój Perl 5.18 tego nie zrobił.

Wyjaśnienie:

W trybie innym niż ścisły Perl 5 interpretuje niecytowane ciągi znaków słownych jako „bez słów”, w zasadzie automatycznie je cytując. Zazwyczaj najlepiej ich unikać, ale z pewnością pomagają tutaj!

Python 2 , wynik 32

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

Z kolejnych fragmentów B, C, D, ... Y, Z, u, v, w, x, y, z.

W zdziwieniu dramatycznej ironii Python 3 obsługuje identyfikatory Unicode, co pozwoliłoby nam być bardzo głupim dzięki tej sztuczce - ale nie może się printbez nawiasów. Mógłbym również wcisnąć cyfry do identyfikatora, ale nie sądzę, że takie podejście jest fajnie wyciskać więcej.

Wypróbuj online!

Python 2 , wynik 18, mniej cheat-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

Wypróbuj online!

JavaScript (ES6, V8 6.x), 52 50298 119526 119638 119683 128781 fragmentów, 88 149147 575179 575631 576121 612789 bajtów

Dalej znajduje się urywek stosu, który generuje pełny program, ocenia go i tworzy łącze pobierania pliku. Ten fragment kodu będzie nadal generował lepsze odpowiedzi, ponieważ nowsze wersje Unicode są obsługiwane przez nowsze wersje JavaScript, które dodają nowe prawidłowe identyfikatory do języka.

Używanie tylko ASCII

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

Wyjaśnienie

Wykorzystuje to technikę metaprogramowania, Proxyaby włączyć pułapkę procedury obsługi get dla obiektu i uzyskać dostęp do nazwy właściwości jako łańcucha, zwracając identyfikator length / 2jako jego wartość.

Z pierwszym fragmentem rozpoczynającym się od new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, każdy dodatkowy dodany fragment zwiększa łańcuch lengthidentyfikatora, 2upewniając się, .repeat()że odpowiedni punkt kodowy dwukrotnie dla 2 bajtów utf-16 znaków i raz dla 4 bajtów utf-16 znaków.

Identyfikatory w JavaScript

W specyfikacji ECMAScript an IdentifierNamejest zdefiniowany za pomocą następującej gramatyki:

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”

Generowanie odpowiedzi

Początkowo za pomocą właściwości Unicode „ID_Continue” napisałem skrypt Node.js, który generuje pełną odpowiedź. Teraz jest to tylko skrypt po stronie klienta, który używa naiwnego eval()do testowania poprawnych znaków, iterując zamiast tego wszystkie punkty kodu 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>

Uruchomienie stat -f%z answer.jsdaje liczbę bajtów 612802, ale odejmujemy 13 bajtów dla console.log(i zawijamy )faktyczne przesłanie.

Kodowanie

Źródło jest przechowywane jako utf-8, co znajduje odzwierciedlenie w ogromnej liczbie bajtów odpowiedzi. Dzieje się tak, ponieważ Node.js może uruchamiać tylko pliki źródłowe zakodowane w utf-8.

JavaScript wewnętrznie przechowuje ciągi znaków z kodowaniem utf-16, więc ciąg znaków „długość znaku” zwracany w JavaScript jest tak naprawdę tylko połową liczby bajtów ciągu zakodowanego w utf-16.

Python 2 , wynik 6 10

^{+3 dzięki pizzapantom 184
+1 dzięki WheatWizard}

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

Wypróbuj online!

TI-Basic (seria 83, wersja OS 1.15 lub wyższa), wynik: 17 18 19 24

(Tiebreaker: 53 bajty.)

Możesz uzyskać bardzo duży wynik, jak zwykle wykorzystując długość łańcucha: zacznij od (jak wskazuje @Scrooble) i dodawaj fragmenty pojedynczego tokena do końca. TI-Basic ma ich ponad 700, więc właściwie działa całkiem dobrze. Ale oto inne podejście: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

Zauważ, że TI-Basic jest tokenized, więc (dla przykładu) e^(komenda nie używa żadnego z bohaterów e, ^, (.

Opiera się na nieudokumentowanej funkcji sub(polecenia: oprócz znajdowania podciągów można go również użyć do podzielenia liczby przez 100.

To działa, jeśli jest uruchomiony na świeżym, kalkulator, który pozwala nam przypuszczać, że X, Y, Zsą zerowe, że zmienne okna są ustawione do ich standardowych wartości, że kalkulator jest w trybie radian, i że rand„s pierwsze trzy wyjścia będzie o 0.943, 0.908, 0.146.

PowerShell , 25 bajtów, wynik 5

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

Snippet 1: ' '.countwyjścia 1. Robi to, biorąc .countciąg znaków, który jest jeden, ponieważ istnieje tylko jeden ciąg. Wypróbuj online!

Snippet 2: dane *2wyjściowe, 2ponieważ bierzemy 1poprzedni fragment i mnożymy go przez dwa Wypróbuj online!

Snippet 3: dane +!""wyjściowe 3przez dodanie logicznej nie-pustego łańcucha. To domyślnie rzutuje pusty ciąg znaków na $true, który ponownie jest domyślnie rzutowany 1, więc dodajemy jeden Wypróbuj online!

Snippet 4: dane -(-1)wyjściowe 4po prostu odejmując jeden ujemny Wypróbuj online!

Snippet 5: dane |%{5}wyjściowe 5poprzez pobranie poprzedniej liczby do pętli i każda iteracja tej pętli (tylko jedna, ponieważ jest tylko jedna liczba wejściowa)5 Wypróbuj online!

Dzięki Janowi za alternatywny sposób wymyślenia 4i sprytny sposób wymyślenia 5.

C, 10 fragmentów, 45 bajtów

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

Wypróbuj online!

MATL , wynik 8 15, 64 123 bajtów

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

• Dotarłem do 12 z pomocą Luisa Mendo! Używanie 11,23ZPbyło jego pomysłem, wraz ze zmianą3 się Ina fragmencie 7.
• Dostałem 15 z większą pomocą Luisa. OO...N&był jego pomysł.

Więcej w przyszłości.Nie znam na pamięć funkcji MATL, więc musiałem tam i z powrotem iz powrotem w dokumentacji ... :)

Wypróbuj online!

V , wynik 10

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

Wypróbuj online!

Galareta , 253 bajty, wynik 250

L}“L

Kolejne fragmenty 1-znakowe:

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

Uwaga: ¶ może być również zastąpiony przez \n, są one tym samym bajtem na stronie kodowej Jelly.

Po dołączeniu wszystkich tych fragmentów możesz dodać fragment 2-znakowy ”‘.

+1 dzięki Dennisowi .

Wypróbuj online!

Lenguage , 1 112 064 fragmentów

N ^p fragment składa się z 2 ^3n-1 powtórzeń n ^-tego nie zastępczego postaci UNICODE, włącznie z 1 112 064 ^TH , a ostatni nie zastępczym postać obecnego standardu Unicode.

Dla uproszczenia dane wyjściowe są jednostkowe (używając bajtu zerowego jako cyfry). Dziesiętny jest możliwy, ale spowoduje to, że programy będą jeszcze dłuższe. Za pomocą unary możemy przetestować pierwsze programy.

Dla n = 1 otrzymujemy 4 powtórzenia U + 0000 . Jest to ekwiwalent programu pieprzenia mózgów. , który drukuje jeden bajt zerowy.

Dla n = 2 otrzymujemy 32 powtórzenia U + 0001 , w sumie 36 znaków. Jest to ekwiwalent programu pieprzenia mózgów.. , który drukuje dwa bajty zerowe.

Dla n = 3 otrzymujemy 256 powtórzeń U + 0002 , w sumie 292 znaków. Jest to ekwiwalent programu pieprzenia mózgów... , który drukuje trzy bajty zerowe.

I tak dalej, do n = 1 112 064 .

BASIC (ZX Spectrum), wynik 244 (nowy wynik 247) [czy to oszustwo?]

Fragment 1:

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

Snippet 2: :

Fragment 3: REM

Fragmenty 4-244: Fragmenty jednoznakowe, wykorzystujące wszystkie znaki spoza fragmentów 1, 2 i 3.

Wyjaśnienie

Postacie

W Spectrum PRINTjest pojedynczy znak (kod 245). Fragment 1 wykorzystuje 11 różnych znaków: 2, 3, 5, 6, +, -, *, (, ), PRINTi PEEKco widzisz jako przestrzenie są częścią znaków PRINTiPEEK tak nie była używana sama przestrzeń. Postanowiłem podać numer linii 2356, ponieważ są to jedyne cyfry obecne w kodzie.

Znaki 13 i 14 są niedozwolone. Oznacza to, że dla fragmentów 2-244 pozostało 243 znaków, zaczynając od :i REMunikając kodu, który mógłby powodować błędy lub robić cokolwiek innego.

Jak to działa

Dlatego nie jestem pewien, czy ta odpowiedź pochodzi z książki.

23635 to miejsce w pamięci dla 16-bitowej zmiennej systemowej PROG, zapisanej jako LH. (Wartość wynosi zwykle 23755. Ale oprócz złego wyniku, jeśli tak się nie stanie, użycie tego numeru bezpośrednio, nawet jeśli skróciłoby kod, kosztowałoby mnie dodatkowe cyfry). Wartość PROG to lokalizacja pamięci gdzie sam program jest przechowywany. Pierwsze dwa bajty to numer linii przechowywany jako HL, kolejne dwa bajty to długość linii przechowywanej jako LH. W ten sposób program sprawdza długość własnej linii, więc należy odjąć coś odpowiedniego

Zapisywanie znaków

Biorąc pod uwagę sposób przechowywania liczb, linia mogła zakończyć się cyfrą -114, tak że fragment 1 wygenerowałby 1. Ale nie chciałem używać dodatkowych cyfr, więc zamiast tego zabrałem dwie 2-cyfrowe liczby, które następnie musiałem dodać do 122; 56 i 66 wypadły dobrze.

Kod jest nieco brzydki, ponieważ wszystkie zagnieżdżanie i obliczanie wartości PROG ( PEEK 23635+256*PEEK 23636) dwukrotnie. Ale gdybym go zapisał, a następnie użył przechowywanej wartości, kosztowałoby to dodatkowe znaki / fragmenty - wiersz mógłby zacząć się tak

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

który użyłby 4 dodatkowe znaki: LET, p, =i :.

Może to skonstruuję tak, aby wszystkie liczby były obliczane na podstawie liczb, które używają tylko 1 cyfry i uzyskują 3 fragmenty.

EDYTOWAĆ:

Oto nowy fragment 1 (w ten sposób wyświetlana jest długa pojedyncza linia w Spectrum, więc jeśli chcesz przetestować kod, pomoże ci to sprawdzić, czy wpisałeś go poprawnie):

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

Mógłbym zdobyć kolejny fragment, unikając +i po prostu się z tym pogodzić -. Nie zamierzam tego próbować, to wystarczyło na ciężką próbę.

Klein 011 , 9 urywków

Snippet 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Wypróbuj online!

Snippet 2

2((2|bbb0b2bbbb4bbbbbbbb

Wypróbuj online!

Snippet 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Wypróbuj online!

Snippet 4

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

Wypróbuj online!

Snippet 5

ee

Wypróbuj online!

Snippet 6

fff

Wypróbuj online!

Snippet 7

ggggg

Wypróbuj online!

Snippet 8

hh

Wypróbuj online!

Snippet 9

iiiii

Wypróbuj online!

Wyjaśnienie

To było naprawdę zabawne wyzwanie dla Kleina. Unikalna topologia Kleina pozwala na zrobienie wielu interesujących rzeczy. Jak można zauważyć, odpowiedzi 5-9 po prostu dodają wypełniacz (litery nie robią nic w Kleinie, więc użyłem ich jako wypełniacza) do kodu, aby rozciągnąć obwiednię. Powoduje to, że ip podąża inną ścieżką przez wcześniejsze części kodu ze względu na unikalną topologię Kleina.

Wyjaśnię później pełne wyjaśnienie, ale na razie jest to łatwiejsza do zrozumienia wersja programu, w której wszystkie litery zostały zastąpione literą .s.

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

Wypróbuj online!

> <> , Wynik: nieskończoność 112 064-6 = 1 112 058

Snippet 1 (6 bajtów)

"l4-n;

Ten fragment wyświetla liczbę znaków po; plus jeden. Można to rozszerzyć do nieskończonej ilości fragmentów jednej postaci. Szybkie google mówi mi, że istnieje 1 112 064 możliwych znaków Unicode, pomijając 6, których już użyłem.

Spróbuj It Online

R , wynik: 79

Podziękowania za inspirację dla Seela Perla ; narusza to niektóre dziwactwa interpretera R.

Pierwszy fragment:

nchar(scan(,""))
a

kolejne fragmenty to znaki w:

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

Wypróbuj online!

scanFunkcja odczytuje dane z pliku ""która domyślnie stdin().

Dokumenty stdin()wskazują, że:

Gdy R odczytuje skrypt z pliku, plik jest „konsolą”: jest to tradycyjne użycie, aby zezwolić na dane w linii (patrz przykład „Wprowadzenie do R”).

Dlatego kolejne dane stają się plikiem. Można to trywialnie rozszerzyć i może współpracować z wieloma różnymi kodowaniami.

Pyke , 256 bajtów, wynik 254

Należy pamiętać, że są to kody szesnastkowe rzeczywistych bajtów, oddzielone spacjami, ponieważ zawiera on bajt null ( \x00).

Początkowy fragment kodu:

6C 22 00

Kolejne fragmenty 1-znakowe:

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

Wypróbuj tutaj!

Fragmenty Java 8, 7 (19 bajtów)

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

Tylko początek, będę kontynuować prace nad tym.

Wypróbuj tutaj.

Wyjaśnienie:

Pierwszeństwo wykonania może być chyba jaśniejsze, gdy dodam nawias:

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

• a*b: Pomnóż aprzezb
• ~a: -a-1
• a>b?x:y: if(a>b){ x }else{ y }
• a|b: Bitowo-LUB azb
• a^b: Bitowy-XOR azb
• a%b: amodulo-b

Python 2Fragmenty w , 110

Oto pełny fragment kodu:

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

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

Wypróbuj online!

Pierwszy fragment to

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

A następnie kolejne 109 urywków to kolejne 109 bajtów.

To dość „oszukańcze”, jak to ujęła Lynn. Pierwszy fragment otwiera plik i odejmuje 44 od jego długości, a następnie każdy inny fragment dodaje 1 do długości pliku bez zmiany logiki programu jako całości. zwiększając w ten sposób wynik produkcji o 1.

dc , wynik 13, 58 bajtów

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

Wypróbuj online! (Uwaga, wersja TIO dodajef po każdym fragmencie, aby wydrukować cały stos, pokazując, że każdy fragment pozostawia tylko jedną wartość na stosie; zapomniałem również o wiodącym miejscu na ostatnim fragmencie, który nie ma znaczenia funkcjonalnego, gdy są w podziale według podziałów linii, ale nie wlicza się do użycia mojej postaci)

Każda dodatkowa konkatenacja fragmentu pozostawia żądaną wartość i tylko żądaną wartość na stosie. Po osiągnięciu 12, miałem dość sposobów na zjedzenie stosu. Próbowałem wcześnie korzystać z operacji matematycznych, ponieważ pochłaniają one stos, a gdy wchodzimy w większe liczby, trudniej jest nim zarządzać. Kiedy wszystko jest już powiedziane i zrobione, pozostała mi tylko cyfra 0 i bardzo mało przeszkadza w stosach, więc myślę, że 13 jest bardzo bliskie maksymalizacji. Jestem pewien, że istnieje wiele podobnych (i prawdopodobnie krótszych) sposobów na osiągnięcie tego w DC, ten rodzaj właśnie się sprawdził. Zauważ, że cygwin obsługuje AF zmieszany z 0-9 inaczej niż większość wersji dc, 44C4r/CC 4//działa na końcowy fragment w cygwin.

Pyth , 124 fragmenty

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

Wypróbuj online!

Znaki niedrukowalne uciekały przy użyciu trzech znaków drukowalnych ( x..). Pierwszy fragment ma długość trzech bajtów, a następnie każdy fragment rośnie o jeden.

Beatnik , 22 bajty, wynik 20

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

Zakładając, że słowo „snippet” pozwala na przesunięcie wartości na stosie.

Oktawa, wynik 86

nnz n

Śledzony przez:

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

Wykorzystuje to fakt, że Octave traktuje wszystko po nazwie funkcji jako ciąg wejściowy. nnz nZwraca więc liczbę niezerowych elementów w ciągu 'n'. Przechodzimy do 86, dodając inne drukowalne znaki ASCII. ',"%#nie działa

APL (Dyalog) , wynik 12

Wynik +1 dzięki @dzaima

Fragmenty od pierwszego do trzeciego:

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

Następnie każdy z nich 234567890 .

Wypróbuj online!

Julia 0.6, 111217

Poniższy skrypt tworzy pełny program:

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

Wyjaśnienie

Makro

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

po których następują wszystkie wyraźne znaki Unicode dozwolone w identyfikatorach, obliczone z isidentifier. Niektóre znaki diakrytyczne psują się, więc je usunąłem.

TeX, wynik 61 (ewentualnie 190)

Pierwszy fragment:

\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

Pozostałe 60 fragmentów: w dowolnej kolejności, z których każdy zawiera jeden znak z

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

Objaśnienie:, \lenktóry jest wywoływany na końcu, konwertuje sekwencję kontrolną na ciąg, każdy znak (w tym \) jest jednym znakiem tokena tego ciągu; następnie \glenpożera żeton \, a następnie \tlenliczy pozostałe żetony. W związku z tym wyprowadza długość tej sekwencji kontrolnej (bez uwzględnienia\ ).

Znaki z innych fragmentów rozszerzają sekwencję kontrolną, która początkowo jest sprawiedliwa \t . Wieloznakowa sekwencja kontrolna musi składać się wyłącznie z liter, ale wszystkie one liczą się jako litery, ponieważ wszystkie mają przypisany kod kategorii 11 (używając kodów ASCII, aby same znaki nie pojawiały się w pierwszym fragmencie).

Postanowiłem użyć kodów ósemkowych dla niektórych znaków, które kosztowały mnie jeden symbol, 'ale zapisałem mi dwie cyfry, 8 i 9, więc zyskałem jeden fragment kodu. Być może mógłbym zyskać jeszcze kilka, gdybym nie potrzebował \expandafter.

Wydajność

Możliwa zmiana: zawiń \number\count1w, \message{}aby dane wyjściowe nie trafiały do .dvidanych wyjściowych, ale do danych wyjściowych konsoli i .log. To nie kosztuje żadnych dodatkowych liter.

190

Niestety, TeX współpracuje z ASCII, a nie z Unicode (czy teraz?), Ale moje rozwiązanie mogłoby zostać rozszerzone o 129 dodatkowych fragmentów jednoznakowych zawierających znaki o kodach 127-255. Może nawet niektóre postacie przed 32. Postać 32 (spacja) nie działała, w przeciwnym razie umieściłbym ją również we fragmencie - nie potrzebowałem go w pierwszym fragmencie. Oczywiście, każdy z tych dodatkowych znaków musiałby zostać \catcodewpisany do litery w pierwszym fragmencie.

Pip, 57 bajtów, wynik = 16

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

Zauważ, że <tab>reprezentuje dosłowny znak tabulacji (ASCII 9). Wypróbuj online!

Każdy fragment jest pełnym programem, który wyświetla żądaną liczbę. Większość z nich działa na zasadzie, że ostatnie wyrażenie w programie Pip jest automatycznie drukowane: na przykład we fragmencie 5 poprzedni kod jest oceniany, ale liczy się tylko część 5. Wyjątkami są:

• Snippet 3 działa dobrze w oderwaniu jako RT9(pierwiastek kwadratowy z 9), ale po fragmencie 2 faktycznie analizuje jako 2RT9(2. pierwiastek z 9) - co oczywiście oznacza to samo.
• Snippet 6 otrzymuje ósmy znak (zindeksowany 0) e ^ 3, który przypadkowo ma wartość 6. Ale dodaje również liczbę 8 do yzmiennej. Snippet 8 następnie wyświetla wartość y.
• Fragment 12 bierze 11 z poprzedniego fragmentu i dodaje o(wstępnie zainicjalizowany do 1). Fragment 13 przyjmuje ten wynik i odejmuje v(wstępnie zainicjalizowany na -1).
• Snippet 16 wyświetla dane wyjściowe 1bez nowego wiersza ( Ok=k, gdzie k=kzwraca domyślną wartość prawdy wynoszącą 1), a następnie automatycznie drukuje 6.

Inne interesujące rzeczy:

• Fragment 14 używa operacji wyrażenia regularnego w celu wyodrębnienia 14wartości pi.
• Snippet 15 konwertuje ciąg "F"z szesnastkowego.

Zsh , wynik> 50 000 (1 112 046?), 16 + Σ (długości punktów kodowych UTF-8)

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

Zsh domyślnie obsługuje kodowanie wielobajtowe. Podstawowy fragment ma 18 unikalnych znaków, w sumie 34. Można do niego dodać każdy inny punkt kodowy (z wyjątkiem bajtu zerowego). Gdy to piszę, mój skrypt testuje je w punkcie kodowym ~ 50 000, całkowity rozmiar pliku 150 KB, przy szybkości około 30 fragmentów na sekundę. Uruchom tutaj mój pełny skrypt testowy. Możesz go dostosować, aby zaczynał od niektórych późniejszych punktów kodowych.

Wypróbuj pierwsze 2000 fragmentów online!

Przy użyciu tej techniki można uzyskać więcej fragmentów kodu .