Votre défi est d'écrire N extraits de code tel que, lorsque vous concaténer le premier K ≥ 1 ensemble, ils produisent le nombre K . Plus N est élevé , mieux c'est. Voici le hic: vous ne pouvez utiliser aucun caractère plus d'une fois dans vos extraits.

Règles

• Vous pouvez utiliser le même caractère plusieurs fois dans un (et un seul) extrait de code.
• Ces extraits doivent être concaténés dans l'ordre où ils sont présentés , sans en sauter aucun.
• Vous devez écrire au moins deux extraits.
• Tous les extraits doivent être dans la même langue.
• N'oubliez pas: les extraits ne doivent pas nécessairement être des programmes ou des fonctions complets, ni fonctionner seuls. -1est un extrait valide en Java, par exemple
• Toutes les concaténations résultantes doivent produire la valeur K respective .
• Le gagnant est la personne ayant la valeur N la plus élevée. Le bris d'égalité est la durée globale du programme la plus courte en octets.

Exemple

Supposons que vos extraits étaient AD, xc, 123et ;l. Ensuite:

• AD devrait produire 1
• ADxc devrait produire 2
• ADxc123 devrait produire 3
• et ADxc123;ldevrait produire 4.

Ce programme aurait un score de 4 .

Python 3 , 1 112 056 extraits, 4 383 854 octets

Ceci est très similaire à la réponse Python 2 de @ WheatWizard . J'ai commencé à travailler sur ce sujet peu de temps avant qu'il ne soit publié, mais le tri des particularités de Python concernant les caractères non ASCII et les longues lignes a pris un certain temps. J'ai découvert que Python lit les lignes 8191 octets à la fois, et lorsque ces 8191 octets ne contiennent qu'une partie d'un caractère multi-octets, Python lance une SyntaxError .

Le premier extrait utilise un codage à partir du moins de caractères (distincts) pour l'intégralité 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))

Cette monstruosité construit simplement la chaîne suivante et l'exécute.

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

Les extraits suivants contiennent tous exactement un caractère. Les trois personnages sont \n, \ret #. Tous les caractères Unicode restants (à l'exception des substituts) suivent dans un ordre spécifique, ils s'alignent donc sur la limite de 8191 octets.

Le script suivant génère les programmes appropriés pour l'entrée k entre 1 et 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 extraits de code

Premier extrait:

use utf8; print length A

2e à 26e extraits: BparZ

27e au 46e extraits: à atravers z, à l'exclusion des caractères en "longueur"

47e à 56e extraits: 0par9

57e extrait: _

Les extraits restants sont les 50 105 caractères Unicode individuels que Perl considère comme des caractères «mots», à l'exclusion des 14 caractères mots distincts dans l'extrait initial, dans n'importe quel ordre.

Eh bien, c'était une bonne idée, mais il s'avère qu'après une certaine longueur Perl vous donne une erreur "identifiant trop long". C'est le programme combiné le plus long que j'ai réussi à faire digérer par Perl:

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

La page de manuel perldiag indique que "les futures versions de Perl élimineront probablement ces limitations arbitraires" mais mon Perl 5.18 ne l'a pas fait.

Explication:

En mode non strict, Perl 5 interprète les chaînes de caractères non citées comme des "mots nus", les citant essentiellement pour vous automatiquement. Ils sont généralement mieux évités, mais ils aident certainement ici!

Python 2 , score 32

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

Avec des extraits suivants B, C, D, ... Y, Z, u, v, w, x, y, z.

Dans une tournure d'ironie dramatique, Python 3 prend en charge les identificateurs Unicode, ce qui nous permettrait de devenir très stupide avec cette astuce - mais cela ne peut pas printsans parenthèses. Je pourrais aussi entasser des chiffres dans l'identifiant, mais je ne pense pas que cette approche soit très amusante pour en tirer plus.

Essayez-le en ligne!

Python 2 , score 18, moins de triche

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

Essayez-le en ligne!

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

Plus loin, un extrait de pile qui génère le programme complet, l'évalue et crée un lien de téléchargement pour le fichier. Cet extrait continuera de générer de meilleures réponses car les versions ultérieures d'Unicode sont prises en charge par les nouvelles versions de JavaScript, qui ajoutent de nouveaux identifiants valides à la langue.

Utiliser ASCII uniquement

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

Explication

Cela utilise la technique de métaprogrammation de Proxypour activer un piège de gestionnaire get sur l'objet et accéder au nom de la propriété sous forme de chaîne, en renvoyant l'identifiant length / 2comme valeur.

Le premier extrait commençant par new Proxy({},{get:(n,{length:e})=>e>>(e/e)}).nn, chaque extrait supplémentaire ajouté incrémente la chaîne lengthde l'identifiant en 2s'assurant au .repeat()point de code respectif deux fois pour 2 octets utf-16 caractères et une fois pour 4 octets utf-16 caractères.

Identifiants en JavaScript

Dans la spécification ECMAScript , an IdentifierNameest défini avec la grammaire suivante:

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”

Générer la réponse

En utilisant initialement la propriété Unicode "ID_Continue", j'ai écrit un script Node.js qui génère la réponse complète. Maintenant, c'est juste un script côté client qui utilise un naïf eval()pour tester les caractères valides, en passant par tous les points de code unicode à la place:

// 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'exécution stat -f%z answer.jsdonne un nombre d'octets de 612802, mais nous soustrayons 13 octets pour console.log(et )encapsulant la soumission réelle.

Codage

La source est stockée sous la forme utf-8, ce qui se reflète dans le nombre énorme d'octets de la réponse. Cela est dû au fait que Node.js ne peut exécuter que les fichiers source encodés en utf-8.

JavaScript stocke en interne les chaînes avec le codage utf-16, de sorte que la "longueur de caractère" de chaîne renvoyée en JavaScript ne représente en fait que la moitié du nombre d'octets de la chaîne codée dans utf-16.

Python 2 , score 6 10

^{+3 grâce aux pizzapants184
+1 grâce à WheatWizard}

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

Essayez-le en ligne!

TI-Basic (série 83, OS version 1.15 ou supérieure), score: 17 18 19 24

(Tiebreaker: 53 octets.)

Vous pouvez obtenir un score très élevé en abusant de la longueur de chaîne comme d'habitude: commencez par (comme le souligne @Scrooble) et continuez d'ajouter des extraits à jeton unique jusqu'à la fin. TI-Basic en a plus de 700, ce qui fonctionne plutôt bien. Mais voici une autre approche: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

Notez que tokenizé, si (par exemple) TI-Basic la e^(commande n'utilise aucun des personnages e, ^, (.

S'appuie sur une fonctionnalité non documentée de la sub(commande: en plus de rechercher des sous-chaînes, elle peut également être utilisée pour diviser un nombre par 100.

Cela fonctionne si elle est en cours d' exécution sur une calculatrice fraîche, ce qui nous permet de supposer que X, Y, Zsont tous nuls, que les variables de fenêtre sont à leurs valeurs standards, que la calculatrice est en mode radian, et que randtrois premières sorties » seront au sujet 0.943, 0.908, 0.146.

PowerShell , 25 octets, score 5

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

1 Snippet: ' '.countsorties 1. Il le fait en prenant la .countchaîne, qui est une car il n'y a qu'une seule chaîne. Essayez-le en ligne!

Extrait 2: *2sort 2car nous prenons l' 1extrait de code précédent et le multiplions par deux Essayez-le en ligne!

Extrait 3: génère des +!""sorties 3en ajoutant le booléen non d'une chaîne vide. Cela convertit implicitement la chaîne vide en $true, qui est à nouveau implicitement convertie en 1, donc nous en ajoutons un Essayez-le en ligne!

Extrait 4: -(-1)sorties 4en soustrayant simplement un négatif Essayez-le en ligne!

Extrait 5: |%{5}sorties 5en prenant le numéro précédent dans une boucle et chaque itération de cette boucle (une seule, car il n'y a qu'un seul numéro d'entrée) sorties 5 Essayez-le en ligne!

Merci à Jan pour un autre moyen de trouver 4et une façon astucieuse de le faire 5.

C, 10 extraits, 45 octets

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

Essayez-le en ligne!

MATL , Score 8 15, 64 123 octets

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

• Je suis arrivé à 12 avec l'aide de Luis Mendo! Utiliser 11,23ZPétait son idée, tout en changeant 3avec Ipour l'extrait 7.
• Je suis arrivé à 15 avec plus d'aide de Luis. OO...N&était son idée.

Plus à venir. Je ne connais pas les fonctions MATL par cœur, j'ai donc dû faire des allers-retours dans la documentation ... :)

Essayez-le en ligne!

V , score 10

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

Essayez-le en ligne!

Gelée , 253 octets, score 250

L}“L

Extraits 1 caractère suivants:

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

Remarque: ¶peut également être remplacé par \n, il s'agit du même octet dans la page de codes de Jelly.

Après avoir ajouté tous ces extraits, vous pouvez ensuite ajouter l'extrait à 2 caractères ”‘.

+1 grâce à Dennis .

Essayez-le en ligne!

Lenguage , 1 112 064 extraits

Le n ^ème extrait est composé de 2 ^3n-1 répétitions du n ^ème caractère Unicode non-substitut, jusqu'au 1 112 064 ^ème et dernier caractère non-substitut du standard Unicode actuel inclus.

La sortie est en unaire (en utilisant l'octet nul comme chiffre) pour plus de simplicité. La décimale est possible, mais cela rendra les programmes encore plus longs. Avec unary, nous pouvons tester les premiers programmes.

Pour n = 1 , nous obtenons 4 répétitions de U + 0000 . Ceci est équivalent au programme brainfuck ., qui affiche un octet nul.

Pour n = 2 , nous obtenons 32 répétitions de U + 0001 , pour un total de 36 caractères. C'est équivalent au programme brainfuck .., qui affiche deux octets nuls.

Pour n = 3 , nous obtenons 256 répétitions de U + 0002 , pour un total de 292 caractères. Cela équivaut au programme brainfuck ..., qui affiche trois octets nuls.

Et ainsi de suite, jusqu'à n = 1 112 064 .

BASIC (ZX Spectrum), score 244 (nouveau score 247) [est-ce de la triche?]

Extrait 1:

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

Extrait 2: :

Extrait 3: REM

Extraits 4 à 244: extraits à un seul caractère, utilisant tous les caractères ne figurant pas dans les extraits 1, 2 et 3.

Explication

Personnages

Sur Spectrum, PRINT est un seul caractère (code 245). L'extrait 1 utilise 11 caractères différents: 2, 3, 5, 6, +, -, *, (, ), PRINTet PEEKce que vous voyez comme des espaces sont une partie de caractères PRINTet PEEK, si l'espace lui - même n'a pas été utilisé. J'ai décidé de donner le numéro de ligne 2356 car ce sont les seuls chiffres présents dans le code.

Les caractères 13 et 14 ne sont pas autorisés. Cela signifie qu'il reste 243 caractères pour les extraits 2 à 244, en commençant par :et REMpour éviter le code qui produirait une erreur ou ferait autre chose.

Comment ça marche

C'est pourquoi je ne sais pas si cette réponse vient du livre.

23635 est l'emplacement de mémoire de la variable système 16 bits PROG, stockée sous la forme LH. (La valeur est généralement 23755. Mais à part un mauvais résultat s'il s'avère que ce n'est pas le cas, l'utilisation directe de ce numéro, même si cela raccourcirait le code, me coûterait des caractères numériques supplémentaires.) La valeur de PROG est l'emplacement de la mémoire où le programme lui-même est stocké. Les deux premiers octets sont le numéro de ligne stocké en tant que HL, les deux octets suivants sont la longueur de la ligne stockée en tant que LH. C'est ainsi que le programme recherche la longueur de sa propre ligne, donc quelque chose de approprié doit être soustrait

Sauvegarde des personnages

Compte tenu de la façon dont les numéros sont stockés, la ligne aurait pu se terminer par -114 pour que l'extrait 1 produise 1. Mais je ne voulais pas utiliser de chiffres supplémentaires, j'ai donc pris à la place deux numéros à 2 chiffres, qui devaient ensuite s'additionner à 122; 56 et 66 s'en sont bien sortis.

Le code est un peu moche avec toutes les valeurs d'imbrication et de calcul de PROG ( PEEK 23635+256*PEEK 23636) deux fois. Mais si je le stockais puis utilisais la valeur stockée, cela coûterait des caractères / extraits supplémentaires - la ligne pourrait commencer comme

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

qui utiliserait 4 caractères supplémentaires: LET , p, =et :.

Je vais peut-être concevoir cela de sorte que tous les nombres soient calculés à partir de nombres qui n'utilisent qu'un seul chiffre et gagnent 3 extraits.

MODIFIER:

Voici le nouvel extrait 1 (c'est ainsi qu'une longue ligne unique est affichée sur le Spectrum, donc si vous voulez tester le code, cela vous aidera à voir que vous l'avez tapé correctement):

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

Je pourrais gagner un autre extrait en évitant le +et me contenter de -. Je ne vais pas l'essayer, c'était assez une épreuve.

Klein 011 , 9 extraits

Extrait 1

!@1!aaaaaaaaaaaaaaaaaaaaa/a

Essayez-le en ligne!

Extrait 2

2((2|bbb0b2bbbb4bbbbbbbb

Essayez-le en ligne!

Extrait 3

c\*3ccccccccccccccccccccc\ccccccccc3c6cccc9
c\

Essayez-le en ligne!

Extrait 4

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

Essayez-le en ligne!

Extrait 5

ee

Essayez-le en ligne!

Extrait 6

fff

Essayez-le en ligne!

Extrait 7

ggggg

Essayez-le en ligne!

Extrait 8

hh

Essayez-le en ligne!

Extrait 9

iiiii

Essayez-le en ligne!

Explication

Ce fut un défi vraiment amusant pour Klein. La topologie unique de Klein permet de faire beaucoup de choses intéressantes. Comme vous le remarquerez peut-être, les réponses 5-9 ajoutent simplement du remplissage (les lettres ne font rien dans Klein, je les ai donc utilisées comme remplissage) dans le code pour étirer la zone de délimitation. Cela entraîne l'IP à prendre un chemin différent à travers les parties antérieures du code en raison de la topologie unique de Klein.

Je vais faire une explication complète plus tard, mais pour l'instant voici une version plus facile à comprendre du programme avec toutes les lettres remplacées par .s.

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

Essayez-le en ligne!

> <> , Score: Infini 1.112.064-6 = 1.112.058

Extrait 1 (6 octets)

"l4-n;

Cet extrait renvoie le nombre de caractères après le; un de plus. Cela peut être étendu à une très grande quantité infinie d'extraits d'un caractère chacun. Un rapide google me dit qu'il y a 1 112 064 caractères Unicode possibles, moins les 6 que j'ai déjà utilisés.

Essayez Il en ligne

R , score: 79

Nous remercions Sean's Perl pour l'inspiration; cela abuse de certaines bizarreries de l'interprète R.

Premier extrait:

nchar(scan(,""))
a

les extraits suivants sont les caractères suivants:

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

Essayez-le en ligne!

La scanfonction lit les données du fichier par ""défaut stdin().

Les documents pour stdin()indiquent que:

Lorsque R lit un script à partir d'un fichier, le fichier est la 'console': c'est une utilisation traditionnelle pour autoriser les données en ligne (voir 'Une introduction à R' pour un exemple).

Par conséquent, les données suivantes deviennent le fichier. Cela peut être développé de manière triviale et peut fonctionner avec plusieurs encodages différents.

Pyke , 256 octets, score de 254

Veuillez noter que ce sont des codes hexadécimaux des octets réels, séparés par des espaces, car là l'octet nul (\x00 ) est inclus.

Extrait de départ:

6C 22 00

Extraits 1 caractère suivants:

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

Essayez-le ici!

Java 8, 7 extraits (19 octets)

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

Juste un début, continuera à travailler dessus.

Essayez-le ici.

Explication:

La priorité d'exécution est peut-être rendue plus claire lorsque j'ajoute des parenthèses:

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

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

Python 2 , 110 extraits

Voici l'extrait complet:

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

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

Essayez-le en ligne!

Le premier extrait est

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

Et puis les 109 extraits suivants sont les 109 octets suivants.

C'est assez "tricheur" comme le dit Lynn. Le premier extrait ouvre le fichier et soustrait 44 de sa longueur, puis chaque autre extrait ajoute 1 à la longueur du fichier sans changer la logique du programme dans son ensemble. augmentant ainsi le résultat de la sortie de 1.

dc , score 13, 58 octets

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

Essayez-le en ligne! (Remarque, la version TIO ajoute unf après chaque extrait pour imprimer la pile entière, montrant que chaque extrait ne laisse qu'une seule valeur sur la pile; j'ai également oublié l'espace de tête sur le dernier extrait qui n'a pas d'importance fonctionnellement quand ils sont éclaté par des sauts de ligne mais compte pour mon utilisation des caractères)

Chaque concaténation d'extraits supplémentaires laisse la valeur souhaitée et uniquement la valeur souhaitée sur la pile. Après avoir atteint 12, j'avais en quelque sorte manqué de moyens pour manger la pile. J'ai essayé d'utiliser les opérations mathématiques dès le début car elles engloutissent la pile et à mesure que nous entrons en plus grand nombre, il devient plus difficile de gérer de cette façon. Quand tout est dit et fait, il ne me reste plus que le chiffre 0 pour jouer et très peu de pile-popping, donc je pense que 13 est assez proche du maximum. Je suis sûr qu'il existe de nombreuses façons similaires (et probablement plus courtes) d'accomplir cela en DC, ce genre de mise en place. Notez que cygwin gère l'AF mélangé à 0-9 différemment de la plupart des versions de dc,44C4r/CC 4// fonctionne pour l'extrait final dans cygwin.

Pyth , 124 extraits

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

Essayez-le en ligne!

Caractères non imprimables où échappés à l'aide de trois caractères imprimables ( x..). Le premier extrait est long de trois octets, chaque extrait après cela augmente de longueur d'un.

Beatnik , 22 octets, score de 20

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

En supposant que le mot "extrait" vous permet de pousser la valeur sur la pile.

Octave, Score 86

nnz n

Suivi par:

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

Cela exploite le fait qu'Octave traite tout après un nom de fonction comme une entrée de chaîne. Renvoie donc nnz nle nombre d'éléments non nuls dans la chaîne 'n'. Nous arrivons à 86 en ajoutant les autres caractères ASCII imprimables. ',"%#ne fonctionne pas.

APL (Dyalog) , score 12

+1 score grâce à @dzaima

Premier à troisième extraits:

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

Ensuite, chacun 234567890 .

Essayez-le en ligne!

Julia 0.6, 111217

Le script suivant crée le programme complet:

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

Explication

La macro

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

suivi de tous les caractères unicode distincts autorisés dans les identificateurs, calculés avec isidentifier. Certaines marques diacritiques gâchent le comptage, alors je les ai supprimées.

TeX, score 61 (peut-être 190)

Premier extrait:

\def\len#1{\expandafter\glen\string#1=}
\def\glen#1{\tlen}
\def\tlen#1{\if#1=\let\tlen\end\number\count1\else\advance\count1by1\fi\tlen}
\count1=-1
\catcode33=11
\catcode34=11
\catcode36=11
\catcode37=11
\catcode'46=11
\catcode40=11
\catcode41=11
\catcode42=11
\catcode43=11
\catcode44=11
\catcode45=11
\catcode46=11
\catcode47=11
\catcode56=11
\catcode57=11
\catcode'72=11
\catcode'73=11
\catcode60=11
\catcode62=11
\catcode63=11
\catcode64=11
\catcode'133=11
\catcode'135=11
\catcode'136=11
\catcode'137=11
\catcode'140=11
\catcode124=11
\catcode126=11
\len\t

60 autres extraits: dans n'importe quel ordre, chacun contenant un caractère sur

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

Explication:, \lenqui est appelée à la fin, convertit une séquence de contrôle en chaîne, chaque caractère (y compris \) est un jeton de caractère de cette chaîne; puis \glengobe le jeton\ , puis \tlencompte les jetons restants. Il délivre donc la longueur de cette séquence de contrôle (non compris\ ).

Les caractères d'autres extraits prolongent la séquence de contrôle qui est initialement juste \t . Une séquence de contrôle à plusieurs caractères doit être composée uniquement de lettres, mais elles comptent toutes comme des lettres car elles ont toutes été affectées au code de catégorie 11 (en utilisant des codes ASCII pour que les caractères eux-mêmes n'apparaissent pas dans le premier extrait).

J'ai décidé d'utiliser des codes octaux pour certains caractères qui m'ont coûté un symbole, ' mais m'a sauvé deux chiffres, 8 et 9, alors j'ai gagné un extrait. J'aurais peut-être pu en gagner quelques autres si je n'en avais pas besoin \expandafter.

Sortie

Altération possible: encapsuler \number\count1pour \message{}que la sortie ne passe pas en .dvisortie mais à la sortie console et.log . Cela ne coûte pas de lettres supplémentaires.

190

Malheureusement, TeX fonctionne avec ASCII et non Unicode (ou le fait-il maintenant?), Mais ma solution pourrait éventuellement être étendue pour inclure 129 extraits de plus à un seul caractère contenant les caractères avec les codes 127-255. Peut-être même certains caractères avant 32. Le caractère 32 (espace) ne fonctionnait pas, sinon je le mettrais aussi dans un extrait - je n'en avais pas besoin dans le premier extrait. Bien sûr, chacun de ces caractères supplémentaires devrait être \catcodeinséré dans une lettre du premier extrait.

Pip, 57 octets, score = 16

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

Notez que <tab>représente un caractère de tabulation littéral (ASCII 9). Essayez-le en ligne!

Chaque extrait est un programme complet qui génère le nombre souhaité. La plupart d'entre eux partent du principe que la dernière expression d'un programme Pip est imprimée automatiquement: par exemple, dans l'extrait 5, le code précédent est évalué, mais la seule partie qui compte est le 5. Les exceptions à cela sont:

• L'extrait 3 fonctionne correctement en tant que RT9(racine carrée de 9), mais après l'extrait 2, il est en fait analysé comme 2RT9(2e racine de 9) - ce qui, bien sûr, équivaut à la même chose.
• L'extrait 6 obtient le 8e caractère (indexé 0) de e ^ 3, qui se trouve être 6. Mais il tire également le nombre 8 dans la yvariable. L'extrait 8 renvoie ensuite la valeur de y.
• L'extrait 12 prend le 11 de l'extrait précédent et ajoute o(préinitialisé à 1). L'extrait 13 prend ce résultat et soustraitv (préinitialisé à -1).
• L'extrait 16 sort 1sans une nouvelle ligne ( Ok=k, où est k=kévalué à la valeur véridique par défaut de 1), puis s'imprime automatiquement 6.

Autres trucs intéressants:

• L'extrait 14 utilise des opérations d'expression régulière pour extraire 14de la valeur de pi.
• L'extrait 15 convertit la chaîne en "F"hexadécimal.

Zsh , score> 50 000 (1 112 046?), 16 + Σ (longueurs de point de code UTF-8) octets

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

Zsh gère les encodages multi-octets par défaut. L'extrait de base comporte 18 caractères uniques, 34 au total. Chaque autre point de code (sauf pour l'octet nul) peut être ajouté à cela. Au moment où j'écris ceci, mon script les testant est au point de code ~ 50 000, taille totale du fichier 150K, soit environ 30 extraits / seconde. Exécutez mon script de test complet vous-même ici. Vous voudrez peut-être l'ajuster pour commencer à certains points de code ultérieurs.

Essayez les 2000 premiers extraits en ligne!

Plus d'extraits sont possibles en utilisant cette technique .