La sfida è quella di scrivere N frammenti di codice in modo tale che, quando è concatenare il primo K ≥ 1 insieme, producono il numero K . Più alta è la N , meglio è. Ecco il trucco: non puoi usare nessun personaggio più di una volta nei tuoi frammenti.

Regole

• Puoi usare lo stesso personaggio più volte in uno (e solo uno) frammento.
• Questi frammenti devono essere concatenati nell'ordine in cui sono presentati , senza saltarne nessuno.
• Devi scrivere almeno due frammenti.
• Tutti gli snippet devono essere nella stessa lingua.
• Ricorda: i frammenti non devono essere programmi o funzioni completi, né devono funzionare da soli. -1è uno snippet valido in Java, ad es
• Tutte le concatenazioni risultanti devono generare il rispettivo valore K.
• Il vincitore è la persona con il valore N più alto. Il tie-breaker è la lunghezza complessiva del programma più breve in byte.

Esempio

Supponiamo che i tuoi frammenti erano AD, xc, 123, e ;l. Poi:

• AD dovrebbe produrre 1
• ADxc dovrebbe produrre 2
• ADxc123 dovrebbe produrre 3
• e ADxc123;ldovrebbe produrre 4.

Questo programma avrebbe un punteggio di 4 .

Python 3 , 1 112 056 frammenti, 4 383 854 byte

Questo è molto simile alla risposta Python 2 di @ WheatWizard . Ho iniziato a lavorarci su poco prima che fosse pubblicato, ma per risolvere le stranezze di Python riguardanti i caratteri non ASCII e le linee lunghe ci è voluto del tempo. Ho scoperto che Python legge le righe 8191 byte alla volta e quando quegli 8191 byte contengono solo una parte di un carattere multi-byte, Python genera un SyntaxError .

Il primo frammento utilizza una codifica da Pochi caratteri (distinti) per Turing Completezza .

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

Questa mostruosità costruisce semplicemente la seguente stringa e la esegue.

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

I seguenti frammenti sono tutti esattamente di un carattere. I tre caratteri successivi sono \n, \re #. Tutti i rimanenti caratteri Unicode (tranne i surrogati) seguono un ordine specifico, quindi si allineano al limite di 8191 byte.

Il seguente script genera i programmi appropriati per l'input k tra 1 e 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 frammenti

Primo frammento:

use utf8; print length A

Frammenti dal 2 ° al 26 °: BattraversoZ

Dal 27 ° al 46 ° snippet: athrough z, esclusi i caratteri in "lunghezza"

Frammenti dal 47 ° al 56 °: 0attraverso9

57 ° snippet: _

I frammenti rimanenti sono i 50.105 singoli caratteri Unicode che Perl considera caratteri "parola", esclusi i 14 caratteri parola distinti nello snippet iniziale, in qualsiasi ordine.

Bene, è stato un bel pensiero, ma si scopre che dopo una certa lunghezza Perl ti dà un errore "identificatore troppo lungo". Questo è il programma combinato più lungo che sono riuscito a far digerire Perl:

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

La pagina di manuale di perldiag dice "Le versioni future di Perl probabilmente elimineranno queste limitazioni arbitrarie", ma il mio Perl 5.18 non lo ha fatto.

Spiegazione:

In modalità non rigorosa, Perl 5 interpreta le stringhe di caratteri di parole non quotate come "bareword", essenzialmente citandole automaticamente. Di solito sono meglio evitare, ma sicuramente aiutano qui!

Python 2 , punteggio 32

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

Con frammenti successivi B, C, D, ... Y, Z, u, v, w, x, y, z.

In un tocco di ironia drammatica, Python 3 supporta gli identificatori Unicode, il che ci permetterebbe di diventare molto sciocchi con questo trucco - ma non può fare a printmeno delle parentesi. Potrei anche inserire cifre nell'identificatore, ma non penso che questo approccio sia molto divertente per spremere di più.

Provalo online!

Python 2 , punteggio 18, meno 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

Provalo online!

JavaScript (ES6, V8 6.x), 52 50298 119526 119.638 119.683 128.781 frammenti, 88 149.147 575.179 575.631 576.121 612.789 byte

Più sotto c'è uno snippet di stack che genera l'intero programma, lo valuta e crea un collegamento per il download del file. Lo snippet continuerà a generare risposte migliori poiché le versioni successive di Unicode sono supportate da versioni più recenti di JavaScript, che aggiungono nuovi identificatori validi alla lingua.

Utilizzando solo ASCII

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

Spiegazione

Questo utilizza la tecnica di metaprogrammazione Proxyper abilitare una trap di gestore get sull'oggetto e accedere al nome della proprietà come stringa, restituendo l'identificatore length / 2come valore.

Con il primo frammento che inizia come new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, ogni frammento aggiuntivo aggiunto incrementa la stringa lengthdell'identificatore 2assicurandosi che .repeat()il rispettivo punto di codice due volte per i caratteri utf-16 a 2 byte e una volta per i caratteri utf-16 a 4 byte.

Identificatori in JavaScript

Nella specifica ECMAScript , un IdentifierNameè definito con la seguente grammatica:

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”

Generare la risposta

Inizialmente usando la proprietà Unicode "ID_Continue", ho scritto uno script Node.js che genera la risposta completa. Ora è solo uno script sul lato client che utilizza un ingenuo eval()per testare caratteri validi, ripetendo invece tutti i punti di codice 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>

L'esecuzione stat -f%z answer.jsproduce un conteggio di byte di 612802, ma sottraggiamo 13 byte per console.log(e )completando l'invio effettivo.

Codifica

La sorgente è memorizzata come utf-8, che si riflette nell'enorme numero di byte della risposta. Questo perché Node.js può eseguire solo file sorgente codificati in utf-8.

JavaScript memorizza internamente stringhe con codifica utf-16, quindi la stringa "lunghezza carattere" restituita in JavaScript è in realtà solo la metà del numero di byte della stringa codificata in utf-16.

Python 2 , punteggio 6 10

^{+3 grazie a pizzapants184
+1 grazie a WheatWizard}

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

Provalo online!

TI-Basic (serie 83, versione OS 1.15 o successiva), punteggio: 17 18 19 24

(Tiebreaker: 53 byte.)

Puoi ottenere un punteggio molto grande abusando della lunghezza della stringa come al solito: inizia con (come sottolinea @Scrooble) e continua ad aggiungere frammenti di token singolo alla fine. TI-Basic ne ha oltre 700, quindi funziona davvero abbastanza bene. Ma ecco un altro approccio: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

Si noti che TI-Basic è tokenized, in modo (per esempio) il e^(comando non utilizza nessuno dei personaggi e, ^, (.

Si basa su una funzione non documentata del sub(comando: oltre a trovare sottostringhe, può anche essere usato per dividere un numero per 100.

Questo funziona se è in esecuzione su un calcolatore fresco, che ci fa supporre che X, Y, Zsono tutti a zero, che le variabili della finestra vengono impostate sui valori standard, che la calcolatrice è in modalità radianti, e che rand's prime tre uscite saranno circa 0.943, 0.908, 0.146.

PowerShell , 25 byte, punteggio 5

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

Snippet 1: ' '.countoutput 1. Lo fa prendendo il .countdi una stringa, che è uno perché c'è solo una stringa. Provalo online!

Snippet 2: *2output 2perché prendiamo il 1snippet dal precedente e lo moltiplichiamo per due Provalo online!

Snippet 3: +!""output 3aggiungendo il valore booleano-non di una stringa vuota. Questo lancia implicitamente la stringa vuota in $true, che è di nuovo implicitamente lanciata 1, quindi ne stiamo aggiungendo una Provala online!

Snippet 4: -(-1)output 4semplicemente sottraendo quello negativo Provalo online!

Snippet 5: |%{5}output 5portando il numero precedente in un loop e ogni iterazione di quel loop (solo uno, perché c'è solo un numero di input) output 5 Provalo online!

Grazie a Jan per un modo alternativo di inventare 4e un modo furbo di inventare 5.

C, 10 frammenti, 45 byte

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

Provalo online!

MATL , punteggio 8 15, 64 123 byte

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

• Sono arrivato a 12 con l'aiuto di Luis Mendo! Usare 11,23ZPera la sua idea, insieme a cambiare 3con Iper snippet 7.
• Sono arrivato a 15 con più aiuto da Luis. OO...N&era la sua idea.

E c'è dell'altro. Non conosco le funzioni MATL a memoria, quindi ho dovuto andare avanti e indietro avanti e indietro nella documentazione ... :)

Provalo online!

V , punteggio 10

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

Provalo online!

Gelatina , 253 byte, punteggio 250

L}“L

Snippet successivi di 1 carattere:

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

Nota: ¶possono anche essere sostituiti da \n, sono lo stesso byte nella tabella codici di Jelly.

Dopo aver aggiunto tutti questi frammenti, puoi quindi aggiungere lo snippet a 2 caratteri ”‘.

+1 grazie a Dennis .

Provalo online!

Lenguage , 1 112 064 frammenti

Il n ^° frammento costituito da 2 ^3n-1 ripetizioni del n ^° carattere non Unicode surrogato, fino ae compresa la 1 112 064 ^esimo e ultimo carattere non surrogato della corrente standard Unicode.

L'output è in unario (usando il byte null come cifra) per semplicità. Il decimale è possibile, ma renderà i programmi ancora più lunghi. Con unario possiamo testare i primi programmi.

Per n = 1 , otteniamo 4 ripetizioni di U + 0000 . Ciò equivale al programma brainfuck ., che stampa un byte null.

Per n = 2 , otteniamo 32 ripetizioni di U + 0001 , per un totale di 36 caratteri. Ciò equivale al programma brainfuck .., che stampa due byte null.

Per n = 3 , otteniamo 256 ripetizioni di U + 0002 , per un totale di 292 caratteri. Ciò equivale al programma brainfuck ..., che stampa tre byte null.

E così via, fino a n = 1 112 064 .

BASIC (ZX Spectrum), punteggio 244 (nuovo punteggio 247) [è questo imbroglio?]

Snippet 1:

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

Snippet 2: :

Snippet 3: REM

Snippet 4-244: snippet a carattere singolo, utilizzando tutti i caratteri non presenti nei frammenti 1, 2 e 3.

Spiegazione

Personaggi

Su Spectrum, PRINTè un singolo carattere (codice 245). Il frammento 1 utilizza 11 diversi personaggi: 2, 3, 5, 6, +, -, *, (, ), PRINTe PEEKQuello che si vede in quanto i posti sono una parte di personaggi PRINTe PEEK, quindi lo spazio in sé non è stata utilizzata. Ho deciso di dare il numero di riga 2356 perché queste sono le uniche cifre presenti nel codice.

I personaggi 13 e 14 non sono ammessi. Ciò significa che sono rimasti 243 caratteri per gli snippet 2-244, a partire da :e REMper evitare il codice che genererebbe errori o farebbe qualsiasi altra cosa.

Come funziona

Questo è il motivo per cui non sono sicuro che questa risposta sia contenuta nel libro.

23635 è la posizione di memoria per la variabile di sistema PROG a 16 bit, memorizzata come LH. (Il valore è di solito 23755. Ma a parte un risultato errato se non fosse il caso, l'uso diretto di questo numero, anche se accorcerebbe il codice, mi costerebbe caratteri extra). Il valore di PROG è la posizione della memoria dove è memorizzato il programma stesso. I primi due byte sono il numero di riga memorizzato come HL, i seguenti due byte sono la lunghezza della riga memorizzata come LH. Ecco come il programma cerca la lunghezza della propria linea, quindi è necessario sottrarre qualcosa di appropriato

Salvataggio di personaggi

Considerando come vengono memorizzati i numeri, la riga potrebbe essere terminata con -114 in modo che lo snippet 1 producesse 1. Ma non volevo usare cifre extra, quindi ho tolto due numeri a 2 cifre, che poi hanno dovuto sommare a 122; 56 e 66 hanno fatto bene.

Il codice è un po 'brutto con tutto l'annidamento e il calcolo del valore di PROG ( PEEK 23635+256*PEEK 23636) due volte. Ma se lo memorizzassi e quindi utilizzassi il valore memorizzato, costerebbe caratteri / frammenti aggiuntivi: la riga potrebbe iniziare in questo modo

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

che sarebbe utilizzare 4 caratteri aggiuntivi: LET, p, =e :.

Forse lo ingegnerò in modo che tutti i numeri vengano calcolati da numeri che usano solo 1 cifra e ottengono 3 frammenti.

MODIFICARE:

Ecco il nuovo frammento 1 (è così che una lunga riga singola viene visualizzata a capo sullo spettro, quindi se vuoi testare il codice, ti aiuterà a vedere che lo hai digitato correttamente):

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

Potrei ottenere un altro frammento evitando +e semplicemente accontentandomi -. Non ho intenzione di provarlo, questo è stato abbastanza di un calvario.

Klein 011 , 9 frammenti

Snippet 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Provalo online!

Snippet 2

2((2|bbb0b2bbbb4bbbbbbbb

Provalo online!

Snippet 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Provalo online!

Snippet 4

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

Provalo online!

Snippet 5

ee

Provalo online!

Snippet 6

fff

Provalo online!

Snippet 7

ggggg

Provalo online!

Snippet 8

hh

Provalo online!

Snippet 9

iiiii

Provalo online!

Spiegazione

Questa è stata una sfida davvero divertente per Klein. La topologia unica di Klein consente di realizzare molte cose interessanti. Come potresti notare, le risposte 5-9 aggiungono semplicemente filler (le lettere non fanno nulla in Klein, quindi le ho usate come filler) al codice per allungare il rettangolo di selezione. Questo fa sì che l'ip faccia un percorso diverso attraverso le parti precedenti del codice a causa della topologia unica di Klein.

Farò una spiegazione completa in seguito, ma per ora ecco una versione del programma più semplice da comprendere con tutte le lettere sostituite da .s.

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

Provalo online!

> <> , Punteggio: Infinito 1.112.064-6 = 1.112.058

Snippet 1 (6 byte)

"l4-n;

Questo frammento restituisce la quantità di caratteri dopo il; più uno. Questo può essere esteso a una quantità infinita di frammenti di un carattere ciascuno. Un veloce google mi dice che ci sono 1.112.064 possibili caratteri Unicode, meno i 6 che ho già usato.

Prova E ' online

R , punteggio: 79

Ringraziamo la risposta Perl di Sean per l'ispirazione; questo abusa di alcune stranezze dell'interprete R.

Primo frammento:

nchar(scan(,""))
a

i frammenti successivi sono i caratteri in:

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

Provalo online!

La scanfunzione legge i dati dal file ""predefinito stdin().

I documenti per stdin()indicano che:

Quando R sta leggendo uno script da un file, il file è la "console": questo è un uso tradizionale per consentire i dati in linea (vedere "Introduzione a R" per un esempio).

Quindi, i dati successivi diventano il file. Questo può essere banalmente espanso e può funzionare con più codifiche diverse.

Pyke , 256 byte, punteggio 254

Si noti che si tratta di codici esadecimali dei byte effettivi, separati da spazi, poiché \x00è incluso il byte null ( ).

Snippet iniziale:

6C 22 00

Snippet successivi di 1 carattere:

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

Provalo qui!

Java 8, 7 frammenti (19 byte)

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

Solo un inizio, continuerà a lavorarci su.

Provalo qui.

Spiegazione:

La precedenza dell'esecuzione è forse resa più chiara quando aggiungo la parentesi:

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

• a*b: Moltiplicare aconb
• ~a: -a-1
• a>b?x:y: if(a>b){ x }else{ y }
• a|b: Bitwise-OR aconb
• a^b: Bitwise-XOR aconb
• a%b: amodulo-b

Python 2 , 110 frammenti

Ecco lo snippet completo:

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

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

Provalo online!

Il primo frammento è

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

E poi i successivi 109 frammenti sono i successivi 109 byte.

Questo è piuttosto "economico" come dice Lynn. Il primo frammento apre il file e sottrae 44 dalla sua lunghezza, quindi ogni altro frammento aggiunge 1 alla lunghezza del file senza modificare la logica del programma nel suo insieme. aumentando così il risultato dell'output di 1.

dc , punteggio 13, 58 byte

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

Provalo online! (Nota, la versione TIO aggiunge un fdopo ogni frammento per stampare l'intero stack, dimostrando che ogni frammento lascia solo un singolo valore nello stack; inoltre ho dimenticato lo spazio iniziale sull'ultimo frammento che non ha importanza funzionale quando sono suddiviso per interruzioni di riga ma conta per l'utilizzo del mio personaggio)

Ogni concatenazione di frammenti aggiuntivi lascia il valore desiderato e solo il valore desiderato nella pila. Dopo aver colpito il 12, avevo quasi finito i modi per mangiare la pila. Ho provato ad usare le operazioni matematiche sin dall'inizio, poiché inghiottono lo stack e man mano che arriviamo a numeri più grandi diventa più difficile gestirlo in quel modo. Quando tutto è stato detto e fatto, mi resta solo la cifra 0 con cui giocare e pochissimo in termini di stack-popping, quindi penso che 13 sia abbastanza vicino al massimo. Sono sicuro che ci sono molti modi simili (e probabilmente più brevi) per ottenere questo risultato in DC, questo tipo di cose è andato a posto. Nota che cygwin gestisce AF mischiato con 0-9 in modo diverso dalla maggior parte delle versioni di cc, 44C4r/CC 4//funziona per lo snippet finale in cygwin.

Pyth , 124 frammenti

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

Provalo online!

I caratteri non stampabili sono fuggiti usando tre caratteri stampabili ( x..). Il primo frammento è lungo tre byte, ogni frammento successivamente aumenta di uno.

Beatnik , 22 byte, punteggio 20

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

Supponendo che la parola "snippet" ti permetta di spingere il valore nello stack.

Ottava, punteggio 86

nnz n

Seguito da:

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

Questo sfrutta il fatto che Octave tratta tutto dopo un nome di funzione come input di stringa. Quindi nnz nrestituisce il numero di elementi diversi da zero nella stringa 'n'. Arriviamo a 86 aggiungendo gli altri caratteri ASCII stampabili. ',"%#non funziona

APL (Dyalog) , punteggio 12

Punteggio +1 grazie a @dzaima

Frammenti dal primo al terzo:

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

Quindi ciascuno di 234567890.

Provalo online!

Julia 0.6, 111217

Il seguente script crea il programma completo:

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

Spiegazione

La macro

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

seguito da tutti i caratteri unicode distinti consentiti negli identificatori, calcolati con isidentifier. Alcuni segni diacritici incasinano il conteggio, quindi li ho rimossi.

TeX, punteggio 61 (possibilmente 190)

Primo frammento:

\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

Altri 60 frammenti: in qualsiasi ordine, ognuno contenente un carattere di

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

Spiegazione:, \lenche viene richiamato alla fine, converte una sequenza di controllo in una stringa, ogni carattere (incluso \) è un token di carattere di quella stringa; quindi \glendivora il token \, quindi \tlenconta i token rimanenti. Emette quindi la lunghezza di quella sequenza di controllo (non inclusa \).

I caratteri di altri frammenti estendono la sequenza di controllo che inizialmente è giusta \t. Una sequenza di controllo multi-carattere deve essere composta solo da lettere, ma tutte contano come lettere perché sono state assegnate tutte al codice categoria 11 (usando i codici ASCII in modo che i caratteri stessi non compaiano nel primo frammento).

Ho deciso di utilizzare i codici ottali per alcuni personaggi che mi sono costati un simbolo, 'ma mi hanno salvato due cifre, 8 e 9, quindi ho guadagnato uno snippet. Forse non ne avrei guadagnato un altro paio se non ne avessi avuto bisogno \expandafter.

Produzione

Possibile alterazione: avvolgere \number\count1in \message{}modo che l'output non vada .dvinell'output ma invece nell'output della console e .log. Non costa lettere extra.

190

Sfortunatamente TeX funziona con ASCII e non con Unicode (o lo fa adesso?), Ma la mia soluzione potrebbe eventualmente essere estesa per includere altri 129 snippet a carattere singolo contenenti i caratteri con i codici 127-255. Forse anche alcuni personaggi prima di 32. Il personaggio 32 (spazio) non funzionava, altrimenti lo avrei inserito anche in uno snippet - non ne avevo bisogno nel primo snippet. Naturalmente, ciascuno di questi personaggi aggiuntivi dovrebbe essere \catcodeinserito in una lettera nel primo frammento.

Pip, 57 byte, punteggio = 16

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

Si noti che <tab>rappresenta un carattere di tabulazione letterale (ASCII 9). Provalo online!

Ogni frammento è un programma completo che genera il numero desiderato. La maggior parte di essi lavora sul principio che l'ultima espressione in un programma Pip viene auto-stampata: ad esempio, nello snippet 5, viene valutato il codice precedente, ma l'unica parte che conta è la 5. Eccezioni a questo sono:

• Lo snippet 3 funziona bene come RT9(radice quadrata di 9), ma dopo lo snippet 2 viene effettivamente analizzato come 2RT9(2a radice di 9) - che, ovviamente, equivale alla stessa cosa.
• Lo snippet 6 ottiene l'ottavo carattere (indicizzato 0) di e ^ 3, che risulta essere 6. Ma anche il numero 8 viene trascinato nella yvariabile. Lo snippet 8 quindi genera il valore di y.
• Lo snippet 12 prende l'11 dallo snippet precedente e lo aggiunge o(preinizializzato a 1). Lo snippet 13 prende quel risultato e sottrae v(preinizializzato a -1).
• Snippet 16 output 1senza una nuova riga ( Ok=k, dove viene k=kvalutato il valore di verità predefinito 1), quindi autoprint 6.

Altre cose interessanti:

• Lo snippet 14 utilizza operazioni regex per estrarre 14dal valore di pi.
• Lo snippet 15 converte la stringa "F"da esadecimale.

Zsh , punteggio> 50.000 (1 112 046?), 16 + Σ (lunghezze dei punti di codice UTF-8) byte

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

Zsh gestisce le codifiche multibyte per impostazione predefinita. Lo snippet di base ha 18 caratteri unici, 34 in totale. Ogni altro punto di codice (salvo il byte null) può essere aggiunto a questo. Mentre scrivo questo, il mio script di test è su codepoint ~ 50 000, dimensione totale del file 150K, che va a circa 30 frammenti / secondo. Esegui qui il mio script di test completo. Potrebbe essere necessario modificarlo per iniziare in alcuni punti di codice successivi.

Prova online i primi 2000 frammenti!

Più frammenti sono possibili usando questa tecnica .