Il s'agit d'un défi de code-golf à source restreinte , à complexité kolmogorov , pour produire une sortie fixe sans entrée.

Le format de sortie, cependant, est flexible - il peut être imprimé en sortie standard, imprimé en erreur standard, renvoyé sous forme de liste de caractères, renvoyé sous forme de liste d'octets ou renvoyé sous forme de liste d'entiers. Si vous pensez que quelque chose d'autre semble raisonnable, demandez-le dans les commentaires!

Voici un CODEGOLF d' art ASCII simple et en grandes lettres :

 CCCC   OOO   DDDD   EEEEE   GGG    OOO   L      FFFFF
C      O   O  D   D  E      G      O   O  L      F
C      O   O  D   D  EEE    G  GG  O   O  L      FFF
C      O   O  D   D  E      G   G  O   O  L      F
 CCCC   OOO   DDDD   EEEEE   GGGG   OOO   LLLLL  F

Sans aucun retour à la ligne (ni espace de fin sur aucune ligne), il contient 256 caractères:

 CCCC   OOO   DDDD   EEEEE   GGG    OOO   L      FFFFFC      O   O  D   D  E      G      O   O  L      FC      O   O  D   D  EEE    G  GG  O   O  L      FFFC      O   O  D   D  E      G   G  O   O  L      F CCCC   OOO   DDDD   EEEEE   GGGG   OOO   LLLLL  F

Les indices (basés sur 0) des caractères non spatiaux sont:

1, 2, 3, 4, 8, 9, 10, 14, 15, 16, 17, 21, 22, 23, 24, 25, 29, 30, 31, 36, 37, 38, 42, 49, 50, 51, 52, 53, 54, 61, 65, 68, 72, 75, 82, 89, 93, 96, 103, 104, 111, 115, 118, 122, 125, 126, 127, 132, 135, 136, 139, 143, 146, 153, 154, 155, 156, 163, 167, 170, 174, 177, 184, 188, 191, 195, 198, 205, 207, 208, 209, 210, 214, 215, 216, 220, 221, 222, 223, 227, 228, 229, 230, 231, 235, 236, 237, 238, 242, 243, 244, 248, 249, 250, 251, 252, 255

Vous ne pouvez utiliser aucun de ces 97 octets dans votre code, mais vous devez produire une liste (ou une sortie similaire) de ces octets, dans cet ordre, les octets manquants étant remplacés par le 32e octet dans la page de codes que vous utilisez (dans de nombreux, nombreux code-pages un caractère espace).

Vous pouvez inclure les nouvelles lignes jolies à imprimer * (mais pas d'espaces de fin sur les lignes) si cela vous aide.

Par exemple, en utilisant la page de codes Jelly, cette sortie est acceptable:

 ¢£¤¥   ®µ½   ÇÐÑ×   ßæçðı   øœþ    $%&   *      12345
6      =   A  D   H  K      R      Y   ]  `      g
h      o   s  v   z  }~¶    ⁴  ⁷⁸  ⁻   Ɓ  Ƒ      ƲȤɓ
ƈ      ɲ   ʂ  ȥ   Ẹ  Ḳ      Ṭ   Ỵ  Ḃ   Ḟ  İ      Ṡ
 ẆẊẎŻ   ẹḥị   ṇọṛṣ   ẉỵẓȧḃ   ḟġḣŀ   ṗṙṡ   ẏż«»‘  ”

... mais il en est de même:

 ¢£¤¥   ®µ½   ÇÐÑ×   ßæçðı   øœþ    $%&   *      123456      =   A  D   H  K      R      Y   ]  `      gh      o   s  v   z  }~¶    ⁴  ⁷⁸  ⁻   Ɓ  Ƒ      ƲȤɓƈ      ɲ   ʂ  ȥ   Ẹ  Ḳ      Ṭ   Ỵ  Ḃ   Ḟ  İ      Ṡ ẆẊẎŻ   ẹḥị   ṇọṛṣ   ẉỵẓȧḃ   ḟġḣŀ   ṗṙṡ   ẏż«»‘  ”

...Et il en est de même:

[32, 1, 2, 3, 4, 32, 32, 32, 8, 9, 10, 32, 32, 32, 14, 15, 16, 17, 32, 32, 32, 21, 22, 23, 24, 25, 32, 32, 32, 29, 30, 31, 32, 32, 32, 32, 36, 37, 38, 32, 32, 32, 42, 32, 32, 32, 32, 32, 32, 49, 50, 51, 52, 53, 54, 32, 32, 32, 32, 32, 32, 61, 32, 32, 32, 65, 32, 32, 68, 32, 32, 32, 72, 32, 32, 75, 32, 32, 32, 32, 32, 32, 82, 32, 32, 32, 32, 32, 32, 89, 32, 32, 32, 93, 32, 32, 96, 32, 32, 32, 32, 32, 32, 103, 104, 32, 32, 32, 32, 32, 32, 111, 32, 32, 32, 115, 32, 32, 118, 32, 32, 32, 122, 32, 32, 125, 126, 127, 32, 32, 32, 32, 132, 32, 32, 135, 136, 32, 32, 139, 32, 32, 32, 143, 32, 32, 146, 32, 32, 32, 32, 32, 32, 153, 154, 155, 156, 32, 32, 32, 32, 32, 32, 163, 32, 32, 32, 167, 32, 32, 170, 32, 32, 32, 174, 32, 32, 177, 32, 32, 32, 32, 32, 32, 184, 32, 32, 32, 188, 32, 32, 191, 32, 32, 32, 195, 32, 32, 198, 32, 32, 32, 32, 32, 32, 205, 32, 207, 208, 209, 210, 32, 32, 32, 214, 215, 216, 32, 32, 32, 220, 221, 222, 223, 32, 32, 32, 227, 228, 229, 230, 231, 32, 32, 32, 235, 236, 237, 238, 32, 32, 32, 242, 243, 244, 32, 32, 32, 248, 249, 250, 251, 252, 32, 32, 255]

(Ce dernier est une sortie de liste valide dans n'importe quelle langue avec n'importe quelle page de code, et on peut également utiliser n'importe quel format de liste raisonnable.)

Voici le code Python 3 qui montre les octets ASCII non disponibles.

* Bien que l'impression elle-même ne soit pas si jolie que ça!

Python 2 , 321 203 octets

print map(lambda(i,x):(x>'0'and i-8-8-8-8)+8+8+8+8,enumerate(bin(int(reduce(lambda x,y:x+repr('abcdefijkl'.find(y)),'cfjdbljcibkeajjejiljjlcbjddlafklebajjlceljdeadficijflealkeklkljadfbbckjebclkf','')))))

Essayez-le en ligne!

Explication:

à l'envers:

cfjdbljcibkeajjejiljjlcbjddlafklebajjlceljdeadficijflealkeklkljadfbbckjebclkest le nombre 25731972618407747697792173390589410779249734035626759409848989703511287412985codé avec des caractères autorisés. (Non 123456autorisé)

reduce(lambda x,y:x+repr('abcdefijkl'.find(y)),'cfjdbl..bclkf','') mappe la chaîne à sa chaîne décimale:

• reduce(lambda x,y:x+y,'..','')est le même que ''.join('..')(non oautorisé)
• repr('..')au lieu de str('..')(non sautorisé)
• 'abcdefijkl'.find(y) mappe un caractère à un chiffre.

enumerate(bin(int(...)))convertit la chaîne numérique en une chaîne binaire et énumère. Cela donne aux paires[(0,0), (1,b), (2,1), (3,1), ...]

map(lambda(i,x):(x>'0'and i-8-8-8-8)+8+8+8+8, ... ) convertit la liste énumérée en résultat final.

• map(lambda(i,x):.. , .. )au lieu de [... for(i,x)in ...](non o]autorisé)
• lambda(i,x): ..convertit chaque paire (index, valeur) en index ou 32.
• (x>'0'and i-8-8-8-8)+8+8+8+8 est le même que:
  • x>'0'and i or 8+8+8+8, (Non oautorisé)
  • [8+8+8+8,i][x>'0']ou [8<<9-7,i][x>'0'], (Non ]autorisé)
• 8+8+8+8= 32(Non 23autorisé)

Cela signifie que le programme est essentiellement le même que:

print[[32,i][x>'0']for i,x in enumerate(bin(25731972618407747697792173390589410779249734035626759409848989703511287412985))]

C (gcc) , 318 octets

main(_){--_<88+80+88?printf((int[:>){77707-989908070??>,((int[:>){0xE8E8C79E^0xB0B0080,0xC07E0870^0xE0000C00,0xCC08099C^0xEE0C008E,0xE8888989^0xCC00808,0x9E088990^0x800C0000,0x990C8888^0x080ECC00,0xF9C7a088^0x080000C0,0x9F8C78F8^0x900000??>[_>>(0xC^0x9):>>>(_<<9+9+9>>9+9+9))<<(70^89)>>(70^89)?_:' '),main(_+9-7):0;??>

Essayez-le en ligne!

Celui-ci est un peu un voyage ...

1. Compression de la liste

D'une manière ou d'une autre, nous devrons vérifier si un entier donné est l'un des points de code spéciaux. Toute liste «nue» sera beaucoup trop longue, nous utilisons donc une liste de contrôle. Cette liste a une valeur non nulle aux points de code qui sont «restreints» et une valeur zéro à ceux qui ne le sont pas.

Malheureusement, cela prend encore 512 octets juste pour avoir la liste (ça ressemble 0,0,7,7,0,7,0,...). Cela peut être raccourci avec un bitmask.

Pour utiliser le bitmask, nous diviserons chaque octet en deux. Les 3 premiers bits choisiront un masque dans un tableau tandis que les 5 derniers choisiront un bit dans le tableau. Nous ne pouvons pas réduire davantage le tableau car les entiers 32 bits utilisés par défaut ne prennent pas en charge plus de 2 ^ 5 = 32 bits.

En utilisant une implémentation de référence, j'ai écrit:

int main() {
    int i;
    int vals[] = {1, 2, 3, 4, 8, 9, 10, 14, 15, 16, 17, 21, 22, 23, 24, 25, 29, 30, 31, 36, 37, 38, 42, 49, 50, 51, 52, 53, 54, 61, 65, 68, 72, 75, 82, 89, 93, 96, 103, 104, 111, 115, 118, 122, 125, 126, 127, 132, 135, 136, 139, 143, 146, 153, 154, 155, 156, 163, 167, 170, 174, 177, 184, 188, 191, 195, 198, 205, 207, 208, 209, 210, 214, 215, 216, 220, 221, 222, 223, 227, 228, 229, 230, 231, 235, 236, 237, 238, 242, 243, 244, 248, 249, 250, 251, 252, 255, 0};

    for (i = 0; i <= 0xFF; ++i) {
        int j,f;
        f = 0;
        for (j = 0; vals[j]; ++j)
            if (vals[j] == i)
                f = 1;
        if (f)
            printf("1");
        else
            printf("0");

        if (i%32 == 31)
            printf("\n");
    }

    return 0;
}

J'ai pu générer les valeurs appropriées pour ce nouveau tableau à l'aide de la commande echo "obase=16;ibase=2;$(./a.out | rev)" | bc. Cela transmet la sortie du programme ci-dessus ( ./a.out) au revprogramme, qui inverse chaque ligne. Il imprime ceci avec un en-tête à bc qui définit la base de sortie à 16 et la base d'entrée à 2. Ainsi bc convertit les chiffres binaires en un masque binaire hexadécimal.

Le tableau résultant est visible dans cette solution «bêta»:

f(){
    int x;
    int arr[] = {0xE3E3C71E, 0x207E0470, 0x22040912, 0xE4488181, 0x1E048990, 0x91024488, 0xF1C7A048, 0x9F1C78F8};
    for (x=0; x<=0xFF; ++x) {
        int mask = arr[x >> 5];
        int bit = mask >> (x & 0x1F);

        if (bit & 1)
            printf("%c", x);
        else
            printf(" ");
    }
}

2. Faire face aux contraintes

Il y a beaucoup de contraintes qui doivent être placées sur le code ci-dessus. Ici, je passe en revue chacun d'eux 1 par 1.

1. Aucune affectation

Cela se ressent également dans d'autres langages, sans affectation en C, il est très difficile d'obtenir des valeurs garanties dans les variables. La façon la plus simple pour nous est d'écrire notre fonction en tant que programme complet. Le premier argument de mainsera transmis dont la valeur argcsera 1 s'il est appelé sans argument.

2. Pas de boucle

Les seules structures de boucles en C sont for, whileet gotoqui tous contiennent des caractères restreints. Cela nous laisse avec l'utilisation de la récursivité. La fonction principale commencera à 1 et répétera jusqu'à ce que l'argument soit> 256, en attendant elle décrémente l'argument en interne pour utiliser une valeur indexée sur 0.

3. Valeurs hexadécimales

Les valeurs dans le tableau ci-dessus sont hexadécimales, même lorsqu'elles sont converties en décimales, elles contiennent certains symboles restreints, notamment 123456 (AD peut être en minuscules). Pour contourner cela, chaque constante est XOR avec une autre de sorte que les caractères restreints sont supprimés. 1 devient 9 ^ B, 2 devient C ^ E, 3 devient B ^ 8, 4 devient 8 ^ C, 5 devient 9 ^ C et 6 devient 9 ^ F (il y a plus de façons de le faire, j'ai choisi cette façon) .

4. Impression

Les restrictions ne nous laissent pas beaucoup de fonctions d'impression. putcharet putssont tous deux limités, en partant printf. Malheureusement, nous devons envoyer printfune chaîne de format, idéalement "% c". Toutes ces chaînes ont ce signe de pourcentage embêtant que nous souhaitons supprimer. Heureusement, nous supposons une machine peu endienne (car apparemment c'est ce que TIO utilise, et c'est assez typique). En construisant l'entier dont les octets en mémoire sont 0x25 (%), 0x63 (c), 0x00 (\ 0), n'importe quoi (peu importe, son après le terminateur nul) nous pouvons simplement passer son adresse à printfet il l'assumera est une chaîne. Un tel nombre qui fonctionne est -989830363 (0xC5006325). Ceci est facile à créer sous les restrictions comme 77707-989908070.

Il y a toujours le problème que nous ne pouvons pas référencer de valeurs (parce que nous ne pouvons pas les affecter et parce que nous ne pouvons pas utiliser &), nous devons donc utiliser un tableau littéral (int []) {...}. Nous l'utilisons également pour le tableau de masques de bits ci-dessus.

5. Supports de fermeture

Nous ne pouvons pas utiliser ']' ou '}' pour fermer nos tableaux ou fonctions. Heureusement, C a des digraphes et des trigraphes qui fonctionnent. :>deviendra ], tandis que ??>deviendra }. Cela nécessite que gcc prenne le -trigraphscommutateur, car il ignore les trigraphes par défaut (en violation de la norme).

6. Opérations au niveau du bit

Nous ne pouvons pas utiliser &pour masquer des bits de notre index, ni %pour y arriver à l'ancienne. Par conséquent, nous comptons sur un comportement spécifique à l'implémentation. En particulier, nous déplaçons nos entiers 32 bits suffisamment loin vers la gauche pour perdre des bits, puis de nouveau vers la droite. Par exemple, pour obtenir les 5 derniers bits de notre nombre, nous le décalons d'abord de 27 bits vers la gauche (en partant abcde00000...) puis le décalons vers la droite de 27 bits (en partant ...00000abcde).

7. Valeurs diverses

Nous avons besoin de quelques valeurs plus littérales dans tout le code - celles-ci sont tirées de la réponse JS d'Arnauld, plus 27 (pour la raison ci-dessus) est ajouté par moi comme 9+9+9.

3. Assembler

Voici la description de la source avec tous ces changements ensemble.

main(_){                // This is our main entry point
--_<88+80+88            // This subtracts 1 from the argument (_) and checks if it is less than 256
    ?                   // If it is less than 256 we 'continue'
printf(                 // first we call printf with...
    (int[:>){           // An integer array that will be interpreted as a string
    77707-989908070     // With the value we determined above, to represent "%c\0\xC5"
    ??>,                // This is a trigraph for }, just as the :> above is a digraph for ]
    ((int[:>){          // We immediately create another integer array
0xE8E8C79E^0xB0B0080,   // Each row is the bit-mask for 32 characters
0xC07E0870^0xE0000C00,
0xCC08099C^0xEE0C008E,
0xE8888989^0xCC00808,
0x9E088990^0x800C0000,
0x990C8888^0x080ECC00,
0xF9C7a088^0x080000C0,
0x9F8C78F8^0x900000??>
[_>>(0xC^0x9):>         // This is {arr}[_>>5] just in a roundabout way
>>(_<<9+9+9>>9+9+9))    // Similarly this is (...)>>(_&0x1F)
<<(70^89)>>(70^89)      // This is <<31>>31 or &1, to check the last bit
?_:' ')                 // If its 1, we print the character, otherwise we print a space
,main(_+9-7):0;         // We recurse, the :0 is the other branch of the if, it terminates execution
??>

brainfuck , 635 octets

++++++++++++++++++++++++++++++++.>+.+.+.+.<...>++++.+.+.<...>++++.+.+.+.<...>++++.+.+.+.+.<...>++++.+.+.+....++++.+.+.<...>++++.<......>+++++++.+.+.+.+.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<......>+++++++.<...>++++.<..>+++.<......>+++++++.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.+.+.<....>+++++.<..>+++.+.<..>+++.<...>++++.<..>+++.<......>+++++++.+.+.+.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<...>++++.<..>+++.<...>++++.<..>+++.<......>+++++++.<.>++.+.+.+.<...>++++.+.+.<...>++++.+.+.+.<...>++++.+.+.+.+.<...>++++.+.+.+.<...>++++.+.+.<...>++++.+.+.+.+.<..>>-.

Essayez-le en ligne!

En réponse à avoir finalement été battu par Javascript, j'ai joué ce que je pouvais en tirer:

1 octet économisé en ayant 32 dans la cellule 0 et en incrémentant la cellule 1 (la seule raison pour laquelle je l'avais initialement dans l'autre sens était à cause d'une solution rapide quand OrjanJohansen a souligné que je ne pouvais pas l'utiliser ])

1 octet enregistré en décrémentant une troisième cellule (initialement à 0) pour générer 255=-1

2 octets économisés en imprimant des espaces entre les caractères 31 et 36 sans utiliser <>mais en s'arrêtant simplement à 32 pour imprimer à partir de la cellule 0 lors de l'incrémentation de 31 à 33.

brainfuck , 639 octets

>++++++++++++++++++++++++++++++++.<+.+.+.+.>...<++++.+.+.>...<++++.+.+.+.>...<++++.+.+.+.+.>...<++++.+.+.>....<+++++.+.+.>...<++++.>......<+++++++.+.+.+.+.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>......<+++++++.>...<++++.>..<+++.>......<+++++++.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.+.+.>....<+++++.>..<+++.+.>..<+++.>...<++++.>..<+++.>......<+++++++.+.+.+.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>...<++++.>..<+++.>...<++++.>..<+++.>......<+++++++.>.<++.+.+.+.>...<++++.+.+.>...<++++.+.+.+.>...<++++.+.+.+.+.>...<++++.+.+.+.>...<++++.+.+.>...<++++.+.+.+.+.>..<+++.

Essayez-le en ligne!

D'abord, nous générons le nombre 32. Ensuite, nous allons simplement incrémenter une cellule et basculer l'impression entre cette cellule et celle contenant 32. Les nombres en augmentation constante sont quelque chose que Brainfuck fait bien.

C'est bien de battre Javascript avec Brainfuck, ça n'arrive pas souvent!

JavaScript (SpiderMonkey) , 1918 1598 1487 1431 octets

56 octets enregistrés grâce à @ user202729

print(8<<98,7/7,9-7,7>>97,8>>97,8<<98,8<<98,8<<98,8,9,0xa,8<<98,8<<98,8<<98,0xe,0xf,7+9,8+9,8<<98,8<<98,8<<98,7+0xe,7+0xf,8+0xf,9+0xf,78^87,8<<98,8<<98,8<<98,77^80,70^88,70^89,8<<98,8<<98,8<<98,8<<98,9<<98,70^99,77>>97,8<<98,8<<98,8<<98,98-070,8<<98,8<<98,8<<98,8<<98,8<<98,8<<98,9^070,80^98,80^99,87^99,87^98,9^077,8<<98,8<<98,8<<98,8<<98,8<<98,8<<98,70-9,8<<98,8<<98,8<<98,7^70,8<<98,8<<98,9^77,8<<98,8<<98,8<<98,7^79,8<<98,8<<98,70^0xd,((8<<98)+' ').repeat(8^0xe)+(8^90),((8<<98)+' ').repeat(8^0xe)+89,8<<98,8<<98,8<<98,7^90,8<<98,8<<98,7+89,((8<<98)+' ').repeat(8^0xe)+(7|97),7+97,((8<<98)+' ').repeat(8^0xe)+(77|98),8<<98,8<<98,8<<98,80|99,8<<98,8<<98,8^0x7e,8<<98,8<<98,8<<98,0x7a,8<<98,8<<98,0x7d,0x7e,0x7f,8<<98,8<<98,8<<98,8<<98,7+0x7d,8<<98,8<<98,0x87,0x88,8<<98,8<<98,0x8b,8<<98,8<<98,8<<98,0x8f,8<<98,8<<98,7+0x8b,((8<<98)+' ').repeat(8^0xe)+0x99,0x9a,0x9b,0x9c,((8<<98)+' ').repeat(8^0xe)+(7+0x9c),8<<98,8<<98,8<<98,0xa7,8<<98,8<<98,0xaa,8<<98,8<<98,8<<98,0xae,8<<98,8<<98,78+99,((8<<98)+' ').repeat(8^0xe)+0xb8,8<<98,8<<98,8<<98,0xbc,8<<98,8<<98,0xbf,8<<98,8<<98,8<<98,97+98,8<<98,8<<98,99+99,((8<<98)+' ').repeat(8^0xe)+0xcd,8<<98,0xcf,0xd0,7+0xca,7+0xcb,8<<98,8<<98,8<<98,7+0xcf,0xd7,0xd8,8<<98,8<<98,8<<98,0xdc,0xdd,0xde,0xdf,8<<98,8<<98,8<<98,7+0xdc,7+0xdd,7+0xde,7+0xdf,0xe7,8<<98,8<<98,8<<98,0xeb,0xec,0xed,0xee,8<<98,8<<98,8<<98,7+0xeb,7+0xec,7+0xed,8<<98,8<<98,8<<98,0xf8,0xf9,0xfa,0xfb,0xfc,8<<98,8<<98,0xff)

Essayez-le en ligne!

Comment?

Le fait que ce =n'est pas autorisé est un tueur de spectacle dans JS. Nous ne pouvons effectuer aucune affectation de variable et nous ne pouvons pas non plus utiliser de fonction de flèche.

$0$$7$$8$$9$+-/|^<<>>

  1 = 7/7     |   50 = 80^98   |  136 = 0x88    |  216 = 0xd8
  2 = 9-7     |   51 = 80^99   |  139 = 0x8b    |  220 = 0xdc
  3 = 7>>97   |   52 = 87^99   |  143 = 0x8f    |  221 = 0xdd
  4 = 8>>97   |   53 = 87^98   |  146 = 7+0x8b  |  222 = 0xde
  8 = 8       |   54 = 9^077   |  153 = 0x99    |  223 = 0xdf
  9 = 9       |   61 = 70-9    |  154 = 0x9a    |  227 = 7+0xdc
 10 = 0xa     |   65 = 7^70    |  155 = 0x9b    |  228 = 7+0xdd
 14 = 0xe     |   68 = 9^77    |  156 = 0x9c    |  229 = 7+0xde
 15 = 0xf     |   72 = 7^79    |  163 = 7+0x9c  |  230 = 7+0xdf
 16 = 7+9     |   75 = 70^0xd  |  167 = 0xa7    |  231 = 0xe7
 17 = 8+9     |   82 = 8^90    |  170 = 0xaa    |  235 = 0xeb
 21 = 7+0xe   |   89 = 89      |  174 = 0xae    |  236 = 0xec
 22 = 7+0xf   |   93 = 7^90    |  177 = 78+99   |  237 = 0xed
 23 = 8+0xf   |   96 = 7+89    |  184 = 0xb8    |  238 = 0xee
 24 = 9+0xf   |  103 = 7|97    |  188 = 0xbc    |  242 = 7+0xeb
 25 = 78^87   |  104 = 7+97    |  191 = 0xbf    |  243 = 7+0xec
 29 = 77^80   |  111 = 77|98   |  195 = 97+98   |  244 = 7+0xed
 30 = 70^88   |  115 = 80|99   |  198 = 99+99   |  248 = 0xf8
 31 = 70^89   |  118 = 8^0x7e  |  205 = 0xcd    |  249 = 0xf9
 32 = 8<<98   |  122 = 0x7a    |  207 = 0xcf    |  250 = 0xfa
 36 = 9<<98   |  125 = 0x7d    |  208 = 0xd0    |  251 = 0xfb
 37 = 70^99   |  126 = 0x7e    |  209 = 7+0xca  |  252 = 0xfc
 38 = 77>>97  |  127 = 0x7f    |  210 = 7+0xcb  |  255 = 0xff
 42 = 98-070  |  132 = 7+0x7d  |  214 = 7+0xcf  |
 49 = 9^070   |  135 = 0x87    |  215 = 0xd7    |

$32$

Soit shiftCount le résultat du masquage de tous, sauf les 5 bits de rnum les moins significatifs , c'est-à-dire le calcul de rnum & 0x1F.

8<<988<<2$32$

Haskell, 623 617 614 594 360 342 octets

Edit: -234 octets grâce à @Lynn en trouvant un motif encodé sous forme de chaîne. -18 octets grâce à @ Ørjan Johansen.

map(\i->cycle(8+8+8+8:filter(\_->" XXXX   XXX   XXXX   XXXXX   XXX    XXX   X      XXXXXX      X   X  X   X  X      X      X   X  X      XX      X   X  X   X  XXX    X  XX  X   X  X      XXXX      X   X  X   X  X      X   X  X   X  X      X XXXX   XXX   XXXX   XXXXX   XXXX   XXX   XXXXX  X"!!i>' ')(pure i))!!9)(take(0xf8+8)(iterate(9-8+)0))

Essayez-le en ligne!

Comment ça fonctionne

map(\i->    )                   -- map the lambda over the
        (take(0xf8+8)           -- first 256 elements of
           (iterate(9-8+)0))    -- the list [0,1,2,....]

                                -- the lambda is:

    cycle                       -- make an infinite list by repeating the list
      8+8+8+8:                  -- wih element 32 followed by
                  pure i        -- the singleton list with 'i'
       filter                   -- but keep 'i' only if
          \_->" XXXX..."!!i>' ' -- the pattern has an 'X' at index 'i', else
                                -- remove it to make an empty list
                                -- i.e. the cycled list is, if the pattern is
                                -- a space: [32,32,32,32,32,32,32,32,32,32,...]
                                -- an 'X':  [32, i,32, i,32, i,32, i,32, i,...]
                                --                                       ^
                                --                        9th element ---/ 
                      !!9       -- pick the 9th element which is the result
                                -- of the lambda

Brain-Flak -r, 4190 4188 octets

(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())())())())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())())())()<((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))>()()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())())())())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())()<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()())()<(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())>())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())()<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()())())())())())()<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()())

Essayez-le en ligne!

Celui-ci est un peu difficile pour Brain-flak car nous ne pouvons pas utiliser ]ou }. Ce qui signifie que les seuls caractères utiles sont <>().

Voici un programme Haskell qui m'a aidé à écrire ceci

Il suffit de sauter là où les espaces doivent être et de les pousser individuellement.

JavaScript (SpiderMonkey) , 1001 919 789 441 bytes

print(/u/.exec().map.call('0777700077700077770007777700077700007770007000000777777000000700070070007007000000700000070007007000000770000007000700700070077700007007700700070070000007777000000700070070007007000000700070070007007000000707777000777000777700077777000777700077700077777007',''.repeat.bind(Number)).map(/u/.exec().find.bind(/()/.exec().fill(Number.bind(0,88-070)).fill(/u/.exec().fill,!0),''.indexOf)).map(Map.call.bind(Map.call)))

Essayez-le en ligne!

Bat enfin BF !!!

Idée générale

Convertir chaque caractère de la chaîne de chaîne longue en son index ou 32, dépend de la valeur.

Array.prototype.map? Comment obtenir un tableau

Force brute pour voir quels objets sont accessibles en accédant aux propriétés des objets (car ce ]n'est pas autorisé, donc seules les propriétés dont le nom correspond à un identifiant sont accessibles).

RegExp.prototype.execrenvoie un objet de type tableau lorsqu'il existe une correspondance. Lorsqu'aucun argument n'est fourni, l'argument est défini par défaut sur undefined, donc /u/.exec()correspond et renvoie un tableau.

Obtenez 2 valeurs distinctes arbitraires sur 2 caractères différents

Nous voulons avoir (x,y)=>x=='0'?32:y, mais nous ne pouvons pas utiliser =.

Au lieu de cela, nous allons faire

new Array(a)
    .map(x=>x=='0'?()=>32:function()this)
    .map((x,y,z)=>x.call(y,z))

Nous pouvons mapplacer la chaîne sur une fonction, mais ce =>n'est pas autorisé, donc seules quelques fonctions peuvent être utilisées. Il peut avoir thisdes arguments liés et certains liés (il a donc la forme (x,y,z)=>pre_filled_function.call(pre,filled,args,etc,x,y,z))

Après avoir considéré une liste de fonctions ( repeat exec bind create map indexOf replace fill find reduce filter findIndex call bind apply), je décide que les fonctions suivantes seront utilisées (après avoir considéré toutes les autres combinaisons)

• repeat: nombre -> différentes chaînes.
• find: thisArg -> premier élément dans une correspondance de tableau.

L'idée générale serait:

[].map.call('07070707...', (x,y,z)=>[elem1,elem2].find(somefunction,x,y,z)

où somefunctionconsidère l' thisargument ( x) et le premier argument ( elem1ou elem2) et retourne s'il correspond.

La dernière fonction de flèche est réécrite dans [].find.bind([elem1,elem2],somefunction).

Tableau littéral

Nous pouvons utiliser un regex exec pour obtenir un tableau, et fillce avec différentes valeurs. Par exemple, /()/.exec()retourne un tableau de longueur 2, alors nous pouvons le remplir selon nos besoins.

De quoi somefunctionavons-nous besoin?

Nous en avons besoin d'un qui renvoie une valeur de vérité / fausse this(qui est 1 des 2 fonctions que nous allons renvoyer) et du premier argument (doit être une chaîne ou un tableau).

Pour cela, j'ai utilisé indexOf- il renvoie une valeur fausse si le premier argument est un préfixe de l' thisargument.

Représenter les littéraux de fonction

TI-Basic (série 83), 578 octets

8XFact8-ΔTbl
seq(X and XX≤8+8 or 8≤X and X≤Xmax or 7+7≤X and X<9+9 or 7+7+7≤X and X<8π or 9π<X and X<πXmax or 9 nCr 7≤X and X+X<77 or X=7²-7 or 7²≤X and X≤7*9-9 or X=70-9 or X=8²+ΔTbl or X=78-Xmax or X=9*8 or X=89-7-7 or X=89-7 or X=89 or X=900-807 or X=88+8 or 809-707<X and X≤97+77-70 or 9X=999 or 8X=990-70 or X=888-770 or X=899-777 or 8*7+77-8≤X and X+X<Ans or 7²X/77=77+7 or 999+77<8X and 7X<970-9-7 or 8²X=8888+8 or X+X=99+99+88 or 7X=9099-8077 or 9+8≤X/9 and X<997-770-70 or X=99+8² or X=87+80 or X=80+90 or X=87+87 or X=87+90 or X=87+97 or X=98+90 or X=999-808 or X=97+98 or X=99+99 or X=99+99+7 or 9²8<πX and X+X+X≤70*9 or 70π-π-π<Xand X+X+X≤9²8 or 70π<X and X<70π+π or 997-770≤X and X+X+X≤99*7 or 77+79+79≤X and X+8+9≤Ans or 77π<X and X<Ans-Xmax or 7*8*9-8≤X+X and X+X≤7*8*9 or X=Ans,X,0,Ans
8XFact+Ansseq(X,X,⁻8XFact,70π+π

TI-Basic a sa propre "page de code" très spéciale avec des choix de conception étranges comme déplacer le caractère espace sur 0x29 pour que 0x20 puisse être la randM(commande.

Il est difficile de comprendre comment obtenir TI-Basic pour sortir le bon type d'objet. Les chaînes ne fonctionneraient pas pour plusieurs raisons: il n'y a aucun moyen de référencer un jeton sans utiliser le jeton, et nous ne sommes pas non plus autorisés à utiliser le "caractère. Nous ne pouvons pas simplement écrire une liste, car {et }sont interdits. Les matrices [et sont autorisées ]pour les matrices, mais une matrice de 1 sur 256 ne fonctionne pas, car les matrices sont autorisées au maximum 99 lignes et colonnes. Nous ne pouvons pas utiliser →pour attribuer à des variables, et nous ne pouvons pas accéder à la liste des variables ʟou L₁de L₆toute façon.

Donc ici, nous écrivons une formule logique compliquée avec des inégalités qui dit quand un personnage est l'un de ceux que nous voulons sortir. Ensuite, nous utilisons la seq(commande pour générer une liste avec 1dans ces positions et 0ailleurs. De là, une autre seq(commande et un peu d'arithmétique terminent le travail.

C'était la partie excitante; le reste joue aux constantes et je n'ai probablement pas fait ça autant que possible. L'une des astuces que j'utilise est que par défaut, Xmax10, XFact4 et ΔTbl1.

Brain-Flak -r, 3894 octets

(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())<((())((()())()))>)))(((((((()()()()()()()())(()()()()()()()()())(()()()()()()()()()())()()()()())))<((((((((()()()()()()()()()()()()()())((((((((((()()()()()()()()()()()()()()())((()()()()()()()()()()()()()()()())()))))<((((((((((((()()()()()()()()()()()()()()()()()()()()())())())())())()()()()()()())))<((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()())())())()))))()()()())())())>)))()()()()()()()()()())>))))))()()())())())())())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())>)))())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())())())<((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))>()()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())())())())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())<((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))))))>()()()()()()())<(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())>()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())<(((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())))>()()()())())())())())<((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()))>()()())

Essayez-le en ligne!

J'ai écrit un programme pour générer le programme Brain-Flak optimal pour n'importe quelle sortie. Suppose que:

• <> N'est pas utilisé
• Mon programme est correct

, alors cette solution est optimale.

$O(n^5)$

Python 2 , 162 157 bytes

Attention : caractères non imprimables à venir!

print map(lambda(i,x):(x>'0'and i-0xe0/7)+0xe0/7,enumerate(bin(reduce(lambda x,y:(x<<0xd-7)-x+y,bytearray('7?QcZ;+BqiQJUS!?B0W![<LBU7X!frQd(SQdB\0')))))

Essayez-le en ligne!

Basé sur la réponse existante de TFeld , mais avec quelques modifications:

• Utilisez 0xe0/7au lieu de 8+8+8+8pour représenter 32. ( un programme pour trouver la représentation la plus courte d'un nombre )
• Utilisez un bytearraypour représenter l'énorme littéral.

A bytearrayest similaire à a strqu'il est itérable, cependant, l'itérer donne des entiers, pas des caractères. Nous pouvons l'utiliser pour coder un littéral base-N et reduce(lambda x,y: x*N+y, my_bytearray)le décoder.

Étant donné que les fichiers Python 2 n'ont pas d'encodage par défaut, seuls les caractères en ASCII (0..127) peuvent être utilisés. Les octets nuls, les nouvelles lignes, les barres obliques inverses et les guillemets prennent 1 octet de plus.

De plus, il n'est pas possible d'utiliser toutes les bases.

J'ai écrit un programme pour trouver la représentation la plus courte n, compte tenu de ces restrictions.