Su reto es escribir N fragmentos de código de tal manera que, al concatenar el primer K ≥ 1 en conjunto, producen el número K . Cuanto mayor sea N , mejor. Aquí está el truco: no puedes usar ningún personaje más de una vez en tus fragmentos.

Reglas

• Puede usar el mismo personaje varias veces en un fragmento (y solo uno).
• Estos fragmentos deben concatenarse en el orden en que se presentan , sin omitir ninguno.
• Debes escribir al menos dos fragmentos.
• Todos los fragmentos deben estar en el mismo idioma.
• Recuerde: los fragmentos no tienen que ser programas o funciones completos, ni tienen que funcionar por sí solos. -1es un fragmento válido en Java, por ejemplo
• Todas las concatenaciones resultantes deben generar el valor K respectivo .
• El ganador es la persona con el mayor valor de N. El desempate es la longitud total más corta del programa en bytes.

Ejemplo

Supongamos sus fragmentos eran AD, xc, 123, y ;l. Luego:

• AD debería producir 1
• ADxc debería producir 2
• ADxc123 debería producir 3
• y ADxc123;ldebe producir 4.

Este programa tendría una puntuación de 4 .

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

Esto es muy similar a la respuesta de @ WheatWizard's Python 2 . Empecé a trabajar en esto poco antes de que se publicara, pero resolver las peculiaridades de Python con respecto a los caracteres no ASCII y las largas colas tomó algo de tiempo. Descubrí que Python lee líneas de 8191 bytes a la vez, y cuando esos 8191 bytes contienen solo una parte de un carácter de varios bytes, Python arroja un SyntaxError .

El primer fragmento utiliza una codificación de caracteres Fewest (distintos) para la integridad 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))

Esta monstruosidad simplemente construye la siguiente cadena y la ejecuta.

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

Los siguientes fragmentos tienen exactamente un carácter. Los siguientes tres caracteres son \n, \ry #. Todos los caracteres Unicode restantes (excepto los sustitutos) siguen un orden específico, por lo que se alinean con el límite de 8191 bytes.

El siguiente script genera los programas apropiados para la entrada k entre 1 y 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 fragmentos

Primer fragmento:

use utf8; print length A

Fragmentos del 2 al 26: a Btravés deZ

Fragmentos del 27 al 46: a através z, excluyendo los caracteres en "longitud"

Fragmentos 47 a 56: a 0través de9

Fragmento 57: _

Los fragmentos restantes son los 50,105 caracteres Unicode individuales que Perl considera como caracteres de "palabras", excluyendo los 14 caracteres de palabras distintas en el fragmento inicial, en cualquier orden.

Bueno, fue un buen pensamiento, pero resulta que después de una cierta longitud, Perl te da un error de "identificador demasiado largo". Este es el programa combinado más largo que pude hacer que Perl digeriera:

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

La página del manual de perldiag dice "Es probable que las versiones futuras de Perl eliminen estas limitaciones arbitrarias", pero mi Perl 5.18 no lo ha hecho.

Explicación:

En el modo no estricto, Perl 5 interpreta las cadenas de caracteres de palabras sin comillas como "palabras desnudas", en esencia, las cita automáticamente. Por lo general, es mejor evitarlos, ¡pero seguro que ayudan aquí!

Python 2 , puntaje 32

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

Con los fragmentos posteriores B, C, D, ... Y, Z, u, v, w, x, y, z.

En un giro de ironía dramática, Python 3 admite identificadores Unicode, lo que nos permitiría ser muy tontos con este truco, pero no puede hacerlo printsin paréntesis. También podría meter dígitos en el identificador, pero no creo que este enfoque sea muy divertido para extraer más.

Pruébalo en línea!

Python 2 , puntaje 18, menos trampa

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

Pruébalo en línea!

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

Más abajo hay un fragmento de pila que genera el programa completo, lo evalúa y crea un enlace de descarga para el archivo. Ese fragmento continuará generando mejores respuestas a medida que las versiones posteriores de Unicode sean compatibles con las versiones más nuevas de JavaScript, que agregan nuevos identificadores válidos al idioma.

Usar solo ASCII

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

Explicación

Esto utiliza la técnica de metaprogramación Proxypara habilitar una captura del controlador get en el objeto y acceder al nombre de la propiedad como una cadena, devolviendo los identificadores length / 2como su valor.

Con el primer fragmento comenzando como new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, cada fragmento adicional agregado incrementa la cadena lengthdel identificador 2asegurándose de que .repeat()el código respectivo señale dos veces para caracteres de 2 bytes utf-16 y una vez para caracteres de 4 bytes utf-16.

Identificadores en JavaScript

En la especificación ECMAScript , IdentifierNamese define un con la siguiente 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”

Generando la respuesta

Inicialmente usando la propiedad Unicode "ID_Continue", escribí un script Node.js que genera la respuesta completa. Ahora es solo un script del lado del cliente que utiliza un ingenuo eval()para probar caracteres válidos, iterando a través de todos los puntos 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>

Ejecución de stat -f%z answer.jslos rendimientos de una cuenta de bytes de 612.802, pero que restar 13 bytes para el console.log(y )envolver la presentación efectiva.

Codificación

La fuente se almacena como utf-8, que se refleja en el enorme recuento de bytes de la respuesta. Esto se hace porque Node.js solo puede ejecutar archivos fuente codificados en utf-8.

JavaScript almacena internamente cadenas con codificación utf-16, por lo que la "longitud de caracteres" de la cadena devuelta en JavaScript es en realidad solo la mitad del número de bytes de la cadena codificada en utf-16.

Python 2 , puntaje 6 10

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

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

Pruébalo en línea!

TI-Basic (serie 83, SO versión 1.15 o superior), puntuación: 17 18 19 24

(Desempate: 53 bytes).

Puede obtener una puntuación muy grande al abusar de la longitud de la cadena como de costumbre: comience con (como señala @Scrooble) y continúe agregando fragmentos de token único al final. TI-Basic tiene más de 700 de ellos, por lo que en realidad funciona bastante bien. Pero aquí hay otro enfoque: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

Tenga en cuenta que la TI-Basic se tokenized, por lo que (por ejemplo) el e^(comando no utiliza ninguno de los personajes e, ^, (.

Se basa en una característica no documentada del sub(comando: además de encontrar subcadenas, también se puede usar para dividir un número por 100.

Esto funciona si se está ejecutando en una calculadora fresco, lo cual nos permite suponer que X, Y, Zson todos cero, que las variables de ventana se ajustan a sus valores normales, que la calculadora está en modo de radianes, y que rand's primeras tres salidas será de unos 0.943, 0.908, 0.146.

PowerShell , 25 bytes, puntaje 5

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

Fragmento 1: ' '.countsalidas 1. Hace esto tomando el .countde una cadena, que es uno porque solo hay una cadena. Pruébalo en línea!

Fragmento 2: *2resultados 2porque tomamos el 1fragmento anterior y lo multiplicamos por dos. ¡ Pruébelo en línea!

Fragmento 3: +!""salidas 3agregando el Boolean-not de una cadena vacía. Esto convierte implícitamente la cadena vacía en $true, que nuevamente se convierte implícitamente en 1, así que estamos agregando uno ¡ Pruébelo en línea!

Fragmento 4: -(-1)resultados 4simplemente restando uno negativo ¡ Pruébelo en línea!

Fragmento 5: |%{5}salidas 5tomando el número anterior en un ciclo y cada iteración de ese ciclo (solo uno, porque solo hay un número de entrada) salidas ¡ 5 Pruébelo en línea!

Gracias a Jan por un medio alternativo de idear 4y una forma astuta de idear 5.

C, 10 fragmentos, 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

Pruébalo en línea!

MATL , Puntuación 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

• Llegó a 12 con la ayuda de Luis Mendo! Usar 11,23ZPfue su idea, junto con cambiar 3con el Ifragmento 7.
• Llegué a 15 con más ayuda de Luis. OO...N&Fue idea suya.

Más por venir. No sé las funciones de MATL de memoria, así que tuve que ir y venir de un lado a otro en la documentación ... :)

Pruébalo en línea!

V , puntaje 10

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

Pruébalo en línea!

Jalea , 253 bytes, puntaje 250

L}“L

Fragmentos posteriores de 1 carácter:

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

Nota: ¶también pueden ser reemplazados por \n, son el mismo byte en la página de códigos de Jelly.

Después de agregar todos esos fragmentos, puede agregar el fragmento de 2 caracteres ”‘.

+1 gracias a Dennis .

Pruébalo en línea!

Lenguage , 1 112 064 fragmentos

El n ^º fragmento consta de 2 ^3n-1 repeticiones de la n ^º de caracteres Unicode no sustituto, hasta e incluyendo el 1 112 064 ^º y último carácter no sustituto de la norma Unicode actual.

La salida está en unario (usando el byte nulo como dígito) por simplicidad. El decimal es posible, pero hará que los programas sean aún más largos. Con unary, podemos probar los primeros programas.

Para n = 1 , obtenemos 4 repeticiones de U + 0000 . Esto es equivalente al programa brainfuck ., que imprime un byte nulo.

Para n = 2 , obtenemos 32 repeticiones de U + 0001 , para un total de 36 caracteres. Esto es equivalente al programa brainfuck .., que imprime dos bytes nulos.

Para n = 3 , obtenemos 256 repeticiones de U + 0002 , para un total de 292 caracteres. Esto es equivalente al programa brainfuck ..., que imprime tres bytes nulos.

Y así sucesivamente, hasta n = 1 112 064 .

BÁSICO (ZX Spectrum), puntaje 244 (nuevo puntaje 247) [¿esto es trampa?]

Fragmento 1:

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

Fragmento 2: :

Fragmento 3: REM

Fragmentos 4-244: Fragmentos de un solo carácter, que utilizan todos los caracteres que no están en los fragmentos 1, 2 y 3.

Explicación

Caracteres

En Spectrum, PRINTes un solo carácter (código 245). El fragmento 1 utiliza 11 caracteres diferentes: 2, 3, 5, 6, +, -, *, (, ), PRINTy PEEKLo que se ve como espacios son una parte de caracteres PRINTy PEEK, por lo que el espacio en sí no ha sido utilizado. Decidí dar el número de línea 2356 porque estos son los únicos dígitos presentes en el código.

Los caracteres 13 y 14 no están permitidos. Eso significa que quedan 243 caracteres para los fragmentos 2-244, comenzando por :y REMpara evitar el código que produciría un error o haría cualquier otra cosa.

Cómo funciona

Es por eso que no estoy seguro de si esta respuesta es del libro.

23635 es la ubicación de memoria para PROG variable de sistema de 16 bits, almacenada como LH. (El valor generalmente es 23755. Pero aparte del resultado incorrecto si no es el caso, usar este número directamente, aunque acortaría el código, me costaría caracteres de dígitos adicionales). El valor de PROG es la ubicación de la memoria donde se almacena el programa en sí. Los primeros dos bytes son el número de línea almacenado como HL, los siguientes dos bytes son la longitud de la línea almacenada como LH. Así es como el programa busca la longitud de su propia línea, por lo que es necesario restar algo apropiado

Guardando personajes

Teniendo en cuenta cómo se almacenan los números, la línea podría haber terminado con -114 para que el fragmento 1 produjera 1. Pero no quería usar dígitos adicionales, por lo que quité dos números de 2 dígitos, que luego tuvieron que sumar a 122; 56 y 66 lo hicieron muy bien.

El código es un poco feo con todos los valores de anidamiento y cálculo de PROG ( PEEK 23635+256*PEEK 23636) dos veces. Pero si lo almacenara y luego usara el valor almacenado, costaría caracteres / fragmentos adicionales: la línea podría comenzar como

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

que utilizaría 4 caracteres adicionales: LET, p, =y :.

Tal vez voy a diseñar esto para que todos los números se calculen a partir de números que usan solo 1 dígito y obtienen 3 fragmentos.

EDITAR:

Aquí está el nuevo fragmento 1 (así es como se muestra una línea larga en el Spectrum, por lo que si desea probar el código, eso lo ayudará a ver que lo escribió correctamente):

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

Podría obtener otro fragmento evitando +y simplemente arreglármelas -. No voy a intentarlo, esto fue suficiente prueba.

Klein 011 , 9 fragmentos

Fragmento 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Pruébalo en línea!

Fragmento 2

2((2|bbb0b2bbbb4bbbbbbbb

Pruébalo en línea!

Fragmento 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Pruébalo en línea!

Fragmento 4

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

Pruébalo en línea!

Fragmento 5

ee

Pruébalo en línea!

Fragmento 6

fff

Pruébalo en línea!

Fragmento 7

ggggg

Pruébalo en línea!

Fragmento 8

hh

Pruébalo en línea!

Fragmento 9

iiiii

Pruébalo en línea!

Explicación

Este fue un desafío muy divertido para Klein. La topología única de Klein permite hacer muchas cosas interesantes. Como puede observar, las respuestas 5-9 simplemente agregan relleno (las letras no hacen nada en Klein, así que las usé como relleno) al código para extender el cuadro delimitador. Esto hace que la ip tome un camino diferente a través de partes anteriores del código debido a la topología única de Klein.

Voy a hacer una explicación completa más tarde, pero por ahora aquí es una versión más fácil de entender del programa con todas las letras reemplazadas por .s.

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

Pruébalo en línea!

> <> , Puntuación: Infinito 1,112,064-6 = 1,112,058

Fragmento 1 (6 bytes)

"l4-n;

Este fragmento genera la cantidad de caracteres después de; mas uno. Esto se puede extender a una cantidad infinita muy grande de fragmentos de un carácter cada uno. Un rápido google me dice que hay 1.112.064 posibles caracteres Unicode, menos los 6 que ya he usado.

Trate Se Online

R , puntuación: 79

Gracias a la respuesta de Sean Perl por la inspiración; Esto abusa de algunas peculiaridades del intérprete R.

Primer fragmento:

nchar(scan(,""))
a

fragmentos posteriores son los caracteres en:

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

Pruébalo en línea!

La scanfunción lee datos del archivo ""cuyo valor predeterminado es stdin().

Los documentos para stdin()indican que:

Cuando R está leyendo una secuencia de comandos de un archivo, el archivo es la 'consola': este es el uso tradicional para permitir datos en línea (consulte 'Introducción a R' para ver un ejemplo).

Por lo tanto, los datos posteriores se convierten en el archivo. Esto puede expandirse trivialmente y puede funcionar con múltiples codificaciones diferentes.

Pyke , 256 bytes, puntaje 254

Tenga en cuenta que estos son códigos hexadecimales de los bytes reales, separados por espacios, ya que allí \x00se incluye el byte nulo ( ).

Fragmento de inicio:

6C 22 00

Fragmentos posteriores de 1 carácter:

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

Pruébalo aquí!

Java 8, 7 fragmentos (19 bytes)

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

Solo un comienzo, seguiremos trabajando en ello.

Pruébalo aquí.

Explicación:

La precedencia de ejecución quizás se aclara cuando agrego paréntesis:

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

• a*b: Multiplicar 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: amódulo-b

Python 2 , 110 fragmentos

Aquí está el fragmento completo:

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

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

Pruébalo en línea!

El primer fragmento es

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

Y luego los siguientes 109 fragmentos son los siguientes 109 bytes.

Esto es bastante "engañoso" como dice Lynn. El primer fragmento abre el archivo y resta 44 de su longitud, luego cada fragmento agrega 1 a la longitud del archivo sin cambiar la lógica del programa en su conjunto. aumentando así el resultado de la salida en 1.

dc , puntaje 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

Pruébalo en línea! (Tenga en cuenta que la versión TIO agrega un fdespués de cada fragmento para imprimir la pila completa, mostrando que cada fragmento solo deja un valor único en la pila; también olvidé el espacio inicial en el último fragmento que no importa funcionalmente cuando están separado por saltos de línea pero cuenta para el uso de mi personaje)

Cada concatenación de fragmentos adicional deja el valor deseado y solo el valor deseado en la pila. Después de llegar a 12, me quedé sin formas de comer la pila. Traté de usar operaciones matemáticas desde el principio, ya que engullen la pila y a medida que avanzamos en números más grandes, es más difícil de manejar de esa manera. Cuando todo está dicho y hecho, solo me queda el dígito 0 para jugar y muy poco en la forma de hacer estallar la pila, por lo que creo que 13 está bastante cerca del máximo. Estoy seguro de que hay muchas formas similares (y probablemente más cortas) de lograr esto en CC, esto simplemente encajó. Tenga en cuenta que cygwin maneja AF mezclado con 0-9 de manera diferente a la mayoría de las versiones de cc, 44C4r/CC 4//funciona para el fragmento final en cygwin.

Pyth , 124 fragmentos

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

Pruébalo en línea!

Los caracteres no imprimibles se escaparon utilizando tres caracteres imprimibles ( x..). El primer fragmento tiene una longitud de tres bytes, cada fragmento posterior aumenta en longitud de uno en uno.

Beatnik , 22 bytes, puntaje 20

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

Asumir la palabra "fragmento" le permite empujar el valor en la pila.

Octava, puntaje 86

nnz n

Seguido por:

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

Esto explota el hecho de que Octave trata todo después del nombre de una función como una entrada de cadena. Por lo tanto, nnz ndevuelve el número de elementos distintos de cero en la cadena 'n'. Llegamos a 86 agregando los otros caracteres ASCII imprimibles. ',"%#no funciona

APL (Dyalog) , puntaje 12

+1 puntaje gracias a @dzaima

Fragmentos del primero al tercero:

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

Entonces cada uno de 234567890.

Pruébalo en línea!

Julia 0.6, 111217

El siguiente script crea el 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

Explicación

La macro

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

seguido de todos los caracteres unicode distintos permitidos en los identificadores, calculados con isidentifier. Algunas marcas diacritiales ensucian el conteo, así que las eliminé.

TeX, puntaje 61 (posiblemente 190)

Primer fragmento:

\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

Otros 60 fragmentos: en cualquier orden, cada uno con un carácter de

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

Explicación:, \lenque se invoca al final, convierte una secuencia de control en una cadena, cada carácter (incluido \) es una ficha de carácter de esa cadena; luego \glenengulle la ficha \, luego \tlencuenta las fichas restantes. Por lo tanto, genera la longitud de esa secuencia de control (sin incluir \).

Los caracteres de otros fragmentos amplían la secuencia de control que inicialmente es justa \t. Una secuencia de control de varios caracteres debe estar compuesta solo por letras, pero todas cuentan como letras porque se les ha asignado el código de categoría 11 (usando códigos ASCII para que los caracteres en sí no aparezcan en el primer fragmento).

Decidí usar códigos octales para algunos caracteres que me costaron un símbolo, 'pero me salvó dos dígitos, 8 y 9, por lo que obtuve un fragmento. Posiblemente podría haber ganado un par más si no fuera necesario \expandafter.

Salida

Posible alteración: abrigo \number\count1en \message{}lo que la salida no entra en .dviproducción, pero en lugar de salida de la consola y .log. No cuesta ninguna letra extra.

190

Desafortunadamente, TeX funciona con ASCII y no con Unicode (¿o lo hace ahora?), Pero mi solución podría extenderse para incluir 129 fragmentos de un solo carácter más que contengan los caracteres con los códigos 127-255. Tal vez incluso algunos caracteres antes del 32. El carácter 32 (espacio) no funcionó, de lo contrario también lo pondría en un fragmento, no lo necesitaba en el primer fragmento. Por supuesto, cada uno de estos caracteres adicionales debería incluirse \catcodeen una letra en el primer fragmento.

Pip, 57 bytes, puntaje = 16

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

Tenga en cuenta que <tab>representa un carácter de tabulación literal (ASCII 9). Pruébalo en línea!

Cada fragmento es un programa completo que genera el número deseado. La mayoría de ellos funcionan según el principio de que la última expresión en un programa Pip se imprime automáticamente: por ejemplo, en el fragmento 5, se evalúa el código anterior, pero la única parte que importa es el 5. Las excepciones a esto son:

• El fragmento 3 funciona bien de forma aislada como RT9(raíz cuadrada de 9), pero después del fragmento 2 en realidad se analiza como 2RT9(segunda raíz de 9), lo que, por supuesto, equivale a lo mismo.
• El fragmento 6 obtiene el octavo carácter (indexado en 0) de e ^ 3, que resulta ser 6. Pero también extrae el número 8 en la yvariable. El fragmento 8 genera el valor de y.
• El fragmento 12 toma el 11 del fragmento anterior y agrega o(preinicializado a 1). El fragmento 13 toma ese resultado y lo resta v(preinicializado a -1).
• Fragmento 16 salidas 1sin una nueva línea ( Ok=k, donde se k=kevalúa al valor de verdad predeterminado de 1), y luego se imprime automáticamente 6.

Otras cosas interesantes:

• El fragmento 14 usa operaciones de expresiones regulares para extraer 14del valor de pi.
• El fragmento 15 convierte la cadena "F"de hexadecimal.

Zsh , puntaje> 50 000 (1 112 046?), 16 + Σ (longitudes de punto de código UTF-8) bytes

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

Zsh maneja codificaciones multibyte por defecto. El fragmento de base tiene 18 personajes únicos, 34 en total. Todos los demás puntos de código (salvo el byte nulo) se pueden agregar a esto. Mientras escribo esto, mi script que prueba esto está en el punto de código ~ 50 000, tamaño de archivo total de 150K, yendo a unos 30 fragmentos / segundo. Ejecute mi script de prueba completo usted mismo aquí. Es posible que desee ajustarlo para comenzar en algunos puntos de código posteriores.

¡Pruebe los primeros 2000 fragmentos en línea!

Más fragmentos son posibles usando esta técnica .