Seu desafio é escrever N trechos de código de tal forma que, quando você concatenar o primeiro K ≥ 1 juntos, eles produzem o número K . Quanto maior o N , melhor. Aqui está o problema: você não pode usar nenhum personagem mais de uma vez nos seus snippets.

Regras

• Você pode usar o mesmo caractere várias vezes em um (e apenas um) snippet.
• Esses trechos devem ser concatenados na ordem em que são apresentados , sem pular nenhum.
• Você deve escrever pelo menos dois trechos.
• Todos os snippets devem estar no mesmo idioma.
• Lembre-se: os trechos não precisam ser programas ou funções completos, nem precisam funcionar por conta própria. -1é um trecho válido em Java, por exemplo
• Todas as concatenações resultantes devem gerar o respectivo valor de K.
• O vencedor é a pessoa com o maior valor de N. O desempatador é o menor comprimento total do programa em bytes.

Exemplo

Suponha que os seus fragmentos foram AD, xc, 123, e ;l. Então:

• AD deve produzir 1
• ADxc deve produzir 2
• ADxc123 deve produzir 3
• e ADxc123;ldeve produzir 4.

Este programa teria uma pontuação de 4 .

Python 3 , 1 112 056 trechos, 4 383 854 bytes

Isso é muito semelhante à resposta Python 2 do @ WheatWizard . Comecei a trabalhar nisso um pouco antes de ser publicado, mas a solução das peculiaridades do Python em relação a caracteres não ASCII e longas filas levou algum tempo. Descobri que o Python lê linhas 8191 bytes de cada vez e, quando esses 8191 bytes contêm apenas uma parte de um caractere de vários bytes, o Python lança um SyntaxError .

O primeiro fragmento usa uma codificação de Menos caracteres (distintos) para a Completude de Turing .

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

Essa monstruosidade simplesmente cria a seguinte string e a executa.

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

Os seguintes trechos têm exatamente um caractere. Os próximos três personagens são \n, \re# . Todos os caracteres Unicode restantes (exceto substitutos) seguem em uma ordem específica, portanto, eles se alinham com o limite de 8191 bytes.

O script a seguir gera os programas apropriados para a entrada k entre 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 trechos

Primeiro trecho:

use utf8; print length A

De 2 a 26 trechos: B atéZ

27 a 46 snippets: a a z, excluindo os caracteres em "comprimento"

47 a 56 snippets: 0 até9

57.o fragmento: _

Os trechos restantes são os 50.105 caracteres Unicode individuais que Perl considera como caracteres "word", excluindo os 14 caracteres distintos da palavra no snippet inicial, em qualquer ordem.

Bem, foi um bom pensamento, mas acontece que, após um certo período, o Perl gera um erro de "identificador muito longo". Este é o programa combinado mais longo que consegui digitar o Perl:

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

A página de manual do perldiag diz "Versões futuras do Perl provavelmente eliminarão essas limitações arbitrárias", mas o meu Perl 5.18 não o fez.

Explicação:

No modo não estrito, o Perl 5 interpreta seqüências de caracteres de palavras não citadas como "palavras de barra", essencialmente citando-as automaticamente. Eles geralmente são evitados, mas com certeza ajudam aqui!

Python 2 , pontuação 32

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

Com trechos subseqüentes B, C, D, ... Y, Z, u, v, w, x, y, z.

Em uma reviravolta dramática, o Python 3 suporta identificadores Unicode, o que nos deixaria muito bobo com esse truque - mas não pode printsem parênteses. Também poderia inserir dígitos no identificador, mas não acho que essa abordagem seja muito divertida de extrair.

Experimente online!

Python 2 , pontuação 18, menos trapaça

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

Experimente online!

JavaScript (ES6, V8 6.x), 52 50298 119526 119638 119683 128781 snippets, 88 149147 575179 575631 576121 612.789 bytes

Mais abaixo, há um snippet de pilha que gera o programa completo, o avalia e cria um link de download para o arquivo. Esse snippet continuará gerando respostas melhores, pois versões posteriores do Unicode são suportadas por versões mais recentes do JavaScript, que adicionam novos identificadores válidos ao idioma.

Usando apenas ASCII

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

Explicação

Isso usa a técnica de metaprogramação de Proxypara habilitar uma interceptação de manipulador de get no objeto e acessar o nome da propriedade como uma string, retornando o identificador length / 2como seu valor.

Com o primeiro trecho iniciando como new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, cada trecho adicional adicionado incrementa a cadeia lengthde caracteres do identificador, 2certificando-se .repeat()do respectivo ponto de código duas vezes para caracteres utf-16 de 2 bytes e uma vez para caracteres utf-16 de 4 bytes.

Identificadores em JavaScript

Na especificação ECMAScript , um IdentifierNameé definido com a seguinte gramática:

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”

Gerando a resposta

Inicialmente, usando a propriedade Unicode "ID_Continue", escrevi um script Node.js que gera a resposta completa. Agora é apenas um script do lado do cliente que usa um ingênuo eval()para testar caracteres válidos, repetindo todos os pontos de código 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>

A execução stat -f%z answer.jsgera uma contagem de bytes de 612802, mas subtraímos 13 bytes para o console.log(e )envolto o envio real.

Codificação

A fonte é armazenada como utf-8, o que se reflete na enorme contagem de bytes da resposta. Isso é feito porque o Node.js pode executar apenas arquivos de origem codificados em utf-8.

O JavaScript armazena internamente cadeias de caracteres com codificação utf-16, portanto, a string "comprimento do caractere" retornada em JavaScript é na verdade apenas metade do número de bytes da string codificada em utf-16.

Python 2 , pontuação 6 10

^{+3 graças a pizzapants184
+1 graças a WheatWizard}

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

Experimente online!

TI-Basic (série 83, versão do sistema operacional 1.15 ou superior), pontuação: 17 18 19 24

(Desempatador: 53 bytes.)

Você pode obter uma pontuação muito grande abusando do comprimento da string, como de costume: comece com (como @Scrooble aponta) e continue adicionando snippets de token único até o final. O TI-Basic possui mais de 700 deles, o que realmente funciona muito bem. Mas aqui está outra abordagem: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

Note-se que TI-Basic é separado em tokens, assim que (por exemplo) o e^(comando não usar qualquer um dos personagens e, ^, (.

Baseia-se em um recurso não documentado do sub(comando: além de encontrar substrings, também pode ser usado para dividir um número por 100.

Isso funciona se ele estiver sendo executado em uma calculadora fresco, que nos permite supor que X, Y, Zsão todos zero, que as variáveis da janela são definidas para seus valores padrão, que a calculadora está no modo radiano, e que rand's três primeiras saídas serão sobre 0.943, 0.908, 0.146.

PowerShell , 25 bytes, Pontuação 5

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

Fragmento 1: ' '.countsaídas 1. Isso é feito usando a .countsequência, que é uma porque existe apenas uma sequência. Experimente online!

Snippet 2: *2resultados 2porque pegamos o 1snippet anterior e o multiplicamos por dois Experimente online!

Trecho 3: +!""saídas 3adicionando o Boolean-not de uma string vazia. Isso lança implicitamente a cadeia vazia para $true, que é novamente convertida implicitamente para 1, portanto, estamos adicionando uma Experimente online!

Trecho 4: -(-1)resultados 4, subtraindo simplesmente um negativo Experimente on-line!

Trecho 5: |%{5}saídas 5, colocando o número anterior em um loop e cada iteração desse loop (apenas um, porque há apenas um número de entrada) saídas 5 Experimente online!

Agradeço a Jan por um meio alternativo de apresentar 4e uma maneira astuta de apresentar 5.

C, 10 trechos, 45 bytes

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

Experimente online!

MATL , pontuação 8 15, 64 123 bytes

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

• Chegou a 12 com a ajuda de Luis Mendo! Usando 11,23ZPfoi idéia dele, junto com a mudança 3com Ia trecho de 7.
• Chegou a 15 com mais ajuda de Luis. OO...N&foi ideia dele.

Mais por vir. Eu não sei as funções do MATL de cor, então eu tive que ir e voltar na documentação ... :)

Experimente online!

V , pontuação 10

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

Experimente online!

Geléia , 253 bytes, pontuação 250

L}“L

Snippets subsequentes de 1 caractere:

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

Nota: ¶ também pode ser substituído por \n, eles são o mesmo byte na página de código do Jelly.

Depois de anexar todos esses trechos, você poderá anexar o trecho de 2 caracteres ”‘.

+1 graças a Dennis .

Experimente online!

Linguagem , 1 112 064 trechos

O n ^th fragmento consiste de 2 ^3n-1 repetições do n ^th sem carácter substituto Unicode, até e incluindo a 1 112 064 ^th e último carácter não-substituto do padrão Unicode corrente.

A saída é unária (usando o byte nulo como dígito) para simplificar. O decimal é possível, mas tornará os programas ainda mais longos. Com o unário, podemos testar os primeiros programas.

Para n = 1 , obtemos 4 repetições de U + 0000 . Isso é equivalente ao programa brainfuck ., que imprime um byte nulo.

Para n = 2 , obtemos 32 repetições de U + 0001 , para um total de 36 caracteres. Isso é equivalente ao programa brainfuck .., que imprime dois bytes nulos.

Para n = 3 , obtemos 256 repetições de U + 0002 , para um total de 292 caracteres. Isso é equivalente ao programa brainfuck... , que imprime três bytes nulos.

E assim por diante, até n = 1 112 064 .

BASIC (ZX Spectrum), pontuação 244 (nova pontuação 247) [isso está enganando?]

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

Snippets 4-244: snippets de um caractere, usando todos os caracteres que não estão nos snippets 1, 2 e 3.

Explicação

Personagens

No Spectrum, PRINTé um caractere único (código 245). O trecho de 1 usa 11 caracteres diferentes: 2, 3, 5, 6, +, -, *, (, ), PRINTe PEEKO que você vê como espaços são uma parte de personagens PRINTePEEK , portanto, o espaço em si não tem sido utilizado. Decidi dar o número da linha 2356 porque esses são os únicos dígitos presentes no código.

Os caracteres 13 e 14 não são permitidos. Isso significa que restam 243 caracteres para os trechos 2-244, começando com :e REMpara evitar o código que produziria erro ou faria qualquer outra coisa.

Como funciona

É por isso que não tenho certeza se essa resposta está no livro.

23635 é o local da memória para a variável de sistema PROG de 16 bits, armazenada como LH. (O valor geralmente é 23755. Mas, além do resultado errado, se esse não for o caso, usar esse número diretamente, mesmo que encurtasse o código, me custaria caracteres de dígito extra.) O valor de PROG é o local da memória onde o próprio programa está armazenado. Os dois primeiros bytes são o número da linha armazenada como HL, os dois bytes a seguir são o comprimento da linha armazenada como LH. É assim que o programa procura o comprimento de sua própria linha, para que algo apropriado precise ser subtraído

Salvando caracteres

Considerando como os números são armazenados, a linha poderia ter terminado com -114, para que o snippet 1 produzisse 1. Mas eu não queria usar dígitos extras, então tirei dois números de 2 dígitos, que então precisavam somar a 122; 56 e 66 foram bem.

O código é um pouco feio com todos os valores de aninhamento e cálculo de PROG ( PEEK 23635+256*PEEK 23636) duas vezes. Mas se eu o armazenasse e usasse o valor armazenado, isso custaria caracteres / trechos extras - a linha poderia começar como

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

que usaria 4 caracteres adicionais: LET, p, =e :.

Talvez eu planeje isso para que todos os números sejam calculados a partir de números que usam apenas 1 dígito e ganham 3 trechos.

EDITAR:

Aqui está o novo trecho 1 (é assim que uma única linha longa é exibida automaticamente no Spectrum, portanto, se você quiser testar o código, isso ajudará você a ver que você o digitou corretamente):

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

Eu poderia ganhar outro trecho evitando o +e apenas me contentar com -. Eu não vou tentar, isso foi uma provação suficiente.

Klein 011 , 9 trechos

Snippet 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Experimente online!

Snippet 2

2((2|bbb0b2bbbb4bbbbbbbb

Experimente online!

Snippet 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Experimente online!

Snippet 4

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

Experimente online!

Snippet 5

ee

Experimente online!

Snippet 6

fff

Experimente online!

Snippet 7

ggggg

Experimente online!

Fragmento 8

hh

Experimente online!

Snippet 9

iiiii

Experimente online!

Explicação

Este foi um desafio muito divertido para Klein. A topologia exclusiva de Klein permite que muitas coisas interessantes sejam feitas. Como você pode notar, as respostas 5 a 9 estão apenas adicionando preenchimento (as letras não fazem nada no Klein, então eu as usei como preenchimento) ao código para esticar a caixa delimitadora. Isso faz com que o ip siga um caminho diferente pelas partes anteriores do código, devido à topologia exclusiva de Klein.

Vou fazer uma explicação completa mais tarde, mas, por enquanto, aqui está uma versão mais fácil de entender do programa, com todas as letras substituídas por .s.

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

Experimente online!

> <> , Pontuação: Infinito 1.112.064-6 = 1.112.058

Snippet 1 (6 bytes)

"l4-n;

Esse trecho gera a quantidade de caracteres após o; mais um. Isso pode ser estendido para uma quantidade infinita muito grande de trechos de um caractere cada. Um rápido google me diz que existem 1.112.064 caracteres Unicode possíveis, menos os 6 que eu já usei.

Tente Ele online

R , pontuação: 79

Agradecemos a resposta de Sean Perl pela inspiração; isso abusa de algumas peculiaridades do intérprete R.

Primeiro trecho:

nchar(scan(,""))
a

trechos subsequentes são os caracteres em:

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

Experimente online!

A scanfunção lê dados do arquivo ""com o padrão stdin().

Os documentos para stdin()indicam que:

Quando R está lendo um script de um arquivo, o arquivo é o 'console': esse é o uso tradicional para permitir dados em linha (consulte 'Uma introdução ao R', por exemplo).

Portanto, os dados subsequentes se tornam o arquivo. Isso pode ser expandido trivialmente e pode funcionar com várias codificações diferentes.

Pyke , 256 bytes, pontuação 254

Observe que esses são códigos hexadecimais dos bytes reais, separados por espaços, pois o byte nulo (\x00 ) está incluído.

Snippet inicial:

6C 22 00

Snippets subsequentes de 1 caractere:

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

Experimente aqui!

Fragmentos Java 8, 7 (19 bytes)

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

Apenas um começo, continuará trabalhando nisso.

Experimente aqui.

Explicação:

Talvez a precedência de execução fique mais clara quando adiciono parênteses:

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

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

Python 2 , 110 trechos

Aqui está o trecho completo:

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

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

Experimente online!

O primeiro trecho é

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

E, em seguida, os próximos 109 trechos são os próximos 109 bytes.

Isso é bastante "barato", como Lynn coloca. O primeiro trecho abre o arquivo e subtrai 44 do seu comprimento, depois o outro trecho adiciona 1 ao comprimento do arquivo sem alterar a lógica do programa como um todo. aumentando assim o resultado da saída em 1.

dc , pontuação 13, 58 bytes

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

Experimente online! (Observe que a versão TIO adiciona umf após cada trecho para imprimir a pilha inteira, mostrando que cada trecho apenas deixa um único valor na pilha; também esqueci o espaço à esquerda no último trecho, que não importa funcionalmente quando estão separados por quebras de linha, mas contam para o uso do meu personagem)

Cada concatenação de trecho adicional deixa o valor desejado e apenas o valor desejado na pilha. Depois de completar 12 anos, eu meio que fiquei sem maneiras de comer a pilha. Tentei usar as operações matemáticas desde o início, pois elas devoram a pilha e, à medida que aumentamos o número, fica mais difícil gerenciar dessa maneira. Quando tudo está dito e feito, eu tenho apenas o dígito 0 para jogar e muito pouco na maneira de empilhar, então acho que 13 está bem próximo do máximo. Tenho certeza de que existem muitas maneiras semelhantes (e provavelmente mais curtas) de realizar isso no dc, isso meio que se encaixou. Observe que o cygwin manipula o AF misturado com 0-9 de maneira diferente da maioria das versões do dc, 44C4r/CC 4//funciona para o snippet final no cygwin.

Pyth , 124 trechos

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

Experimente online!

Os caracteres não imprimíveis foram escapados usando três caracteres imprimíveis ( x..). O primeiro trecho tem três bytes, e cada trecho depois disso aumenta em um por um.

Beatnik , 22 bytes, pontuação 20

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

Supondo que a palavra "snippet" permita que você coloque o valor na pilha.

Octave, Score 86

nnz n

Seguido por:

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

Isso explora o fato de o Octave tratar tudo depois de um nome de função como uma entrada de string. Então, nnz nretorna o número de elementos diferentes de zero na string 'n'. Chegamos a 86 adicionando outros caracteres ASCII imprimíveis. ',"%#não funciona

APL (Dyalog) , pontuação 12

+1 pontuação graças a @dzaima

Primeiro ao terceiro trechos:

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

Então cada um 234567890.

Experimente online!

Julia 0.6, 111217

O script a seguir cria o programa 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

Explicação

A macro

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

seguido por todos os caracteres unicode distintos permitidos nos identificadores, calculados com isidentifier. Algumas marcas diacríticas atrapalham a contagem, então eu as removi.

TeX, pontuação 61 (possivelmente 190)

Primeiro trecho:

\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

Outros 60 trechos: em qualquer ordem, cada um contendo um caractere

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

Explicação:, \lenque é chamada no final, converte uma sequência de controle em uma sequência, cada caractere (incluindo \) é um símbolo de caractere dessa sequência; depois \glendevora o token \e \tlenconta os tokens restantes. Portanto, ele gera o comprimento dessa sequência de controle (não incluindo \).

Os caracteres de outros trechos estendem a sequência de controle que é inicialmente apenas \t . Uma sequência de controle com vários caracteres deve ser composta apenas por letras, mas todas elas contam como letras porque foram atribuídas ao código de categoria 11 (usando códigos ASCII para que os caracteres em si não apareçam no primeiro trecho).

Decidi usar códigos octais para alguns caracteres que me custaram um símbolo, 'mas me salvaram dois dígitos, 8 e 9, por isso ganhei um trecho. Possivelmente poderia ter ganho mais alguns se eu não precisasse \expandafter.

Saída

Possível alteração: envolva \number\count1para \message{}que a saída não entre na .dvisaída, mas para console e .log. Não custa nenhuma letra extra.

190

Infelizmente, o TeX funciona com ASCII e não com Unicode (ou funciona agora?), Mas minha solução pode ser estendida para incluir mais 129 trechos de caractere único contendo os caracteres com os códigos 127-255. Talvez até alguns caracteres antes de 32. O caractere 32 (espaço) não funcionou, caso contrário, eu o colocaria em um trecho também - não precisava dele no primeiro trecho. Obviamente, cada um desses caracteres adicionais teria que ser \catcoded em uma letra no primeiro trecho.

Pip, 57 bytes, pontuação = 16

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

Observe que <tab>representa um caractere de tabulação literal (ASCII 9). Experimente online!

Cada trecho é um programa completo que gera o número desejado. A maioria deles trabalha com o princípio de que a última expressão em um programa Pip é impressa automaticamente: por exemplo, no trecho 5, o código anterior é avaliado, mas a única parte que importa é a5 . Exceções a isso são:

• O fragmento 3 funciona bem isoladamente, pois RT9 (raiz quadrada de 9), mas, após o fragmento 2, ele analisa como 2RT9(segunda raiz de 9) - o que, é claro, é a mesma coisa.
• O fragmento 6 obtém o 8º caractere (indexado a 0) de e ^ 3, que passa a ser 6. Mas também puxa o número 8 para o y variável. O fragmento 8 então gera o valor de y.
• O snippet 12 pega o 11 do snippet anterior e adiciona o (pré-inicializado como 1). O trecho 13 pega esse resultado e subtrai v(pré-inicializado para -1).
• O fragmento 16 produz 1sem uma nova linha ( Ok=k, onde é k=kavaliada como o valor de verdade padrão de 1) e, em seguida, imprime automaticamente 6.

Outras coisas interessantes:

• O fragmento 14 usa operações regex para extrair 14 do valor de pi.
• O fragmento 15 converte a string "F"de hexadecimal.

Zsh , pontuação> 50 000 (1 112 046?), 16 + Σ (comprimento do ponto de código UTF-8) bytes

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

O Zsh lida com codificações multibyte por padrão. O snippet base possui 18 caracteres únicos, 34 no total. Qualquer outro ponto de código (exceto o byte nulo) pode ser adicionado a ele. Enquanto escrevo isso, meu script testando isso está no codepoint ~ 50.000, tamanho total do arquivo 150K, com cerca de 30 trechos / segundo. Execute meu script de teste completo aqui. Você pode ajustá-lo para iniciar em alguns pontos de código posteriores.

Experimente os primeiros 2000 snippets online!

São possíveis mais trechos usando esta técnica .