Este es un desafío de código restringido , complejo de kolmogorov , de golf de código para producir una salida fija sin entrada.

Sin embargo, el formato de salida es flexible: puede imprimirse en salida estándar, imprimirse en error estándar, devolverse como una lista de caracteres, devolverse como una lista de bytes o devolverse como una lista de enteros. Si crees que algo más parece razonable, ¡solo pregunta en los comentarios!

Aquí hay un CODEGOLF de arte ASCII simple y con letras grandes :

 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

Sin líneas nuevas (o espacios finales en las líneas) tiene 256 caracteres de longitud:

 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

Los índices (basados ​​en 0) de los caracteres no espaciales son:

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

No puede utilizar ninguno de estos 97 bytes en su código, pero debe generar una lista (o similar) de estos bytes, en este orden, con los bytes faltantes reemplazados por el byte 32 en la página de códigos que está utilizando (en muchos, muchos páginas de códigos un carácter de espacio).

Puede incluir las nuevas líneas de impresión bonita * (pero no espacios finales en las líneas) si es útil.

Por ejemplo, utilizando la página de códigos Jelly, esta salida es aceptable:

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

... pero también lo es:

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

...y tambien:

[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]

(Este último es un resultado de lista válido en cualquier idioma con cualquier página de códigos, y también se puede usar cualquier formato de lista razonable).

Aquí está el código Python 3 que muestra los bytes ASCII no disponibles.

* ¡Aunque la impresión en sí podría no ser tan bonita!

Python 2 , 321 203 bytes

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

Pruébalo en línea!

Explicación:

de adentro hacia afuera:

cfjdbljcibkeajjejiljjlcbjddlafklebajjlceljdeadficijflealkeklkljadfbbckjebclkes el número 25731972618407747697792173390589410779249734035626759409848989703511287412985codificado con caracteres permitidos. (No se 123456permite)

reduce(lambda x,y:x+repr('abcdefijkl'.find(y)),'cfjdbl..bclkf','') asigna la cadena a su cadena decimal:

• reduce(lambda x,y:x+y,'..','')es lo mismo que ''.join('..')(No se opermite)
• repr('..')en lugar de str('..')(No se spermite)
• 'abcdefijkl'.find(y) asigna un carácter a un dígito.

enumerate(bin(int(...)))convierte la cadena numérica en una cadena binaria y enumera. Esto da los pares[(0,0), (1,b), (2,1), (3,1), ...]

map(lambda(i,x):(x>'0'and i-8-8-8-8)+8+8+8+8, ... ) convierte la lista enumerada en el resultado final.

• map(lambda(i,x):.. , .. )en lugar de [... for(i,x)in ...](No se o]permite)
• lambda(i,x): ..convierte cada par (índice, valor) en el índice o 32.
• (x>'0'and i-8-8-8-8)+8+8+8+8 es lo mismo que:
  • x>'0'and i or 8+8+8+8, (No se opermite)
  • [8+8+8+8,i][x>'0']o [8<<9-7,i][x>'0'], (No se ]permite)
• 8+8+8+8= 32(No se 23permite)

Esto significa que el programa es esencialmente el mismo que:

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

C (gcc) , 318 bytes

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;??>

Pruébalo en línea!

Este es un poco un viaje ...

1. Comprimir la lista

De alguna manera, tendremos que verificar si un entero dado es uno de los puntos de código especiales. Cualquier lista 'desnuda' será demasiado larga, por lo que usamos una lista de verificación. Esta lista tiene un valor distinto de cero en los puntos de código que están 'restringidos' y un valor cero en aquellos que no lo están.

Desafortunadamente, esto todavía toma 512 bytes solo para tener la lista (parece 0,0,7,7,0,7,0,...). Esto se puede acortar con una máscara de bits.

Para hacer uso de la máscara de bits, dividiremos cada byte en dos partes. Los primeros 3 bits elegirán una máscara de una matriz, mientras que los últimos 5 seleccionarán un bit de la matriz. No podemos reducir más la matriz porque los enteros de 32 bits utilizados por defecto no admiten más de 2 ^ 5 = 32 bits.

Usando una implementación de referencia escribí:

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;
}

Pude generar los valores apropiados para esta nueva matriz usando el comando echo "obase=16;ibase=2;$(./a.out | rev)" | bc. Esto pasa la salida del programa anterior ( ./a.out) al revprograma, que invierte cada línea. Imprime esto junto con un encabezado en bc que establece la base de salida en 16 y la base de entrada en 2. Por lo tanto, bc convierte los dígitos binarios en una máscara de bits hexadecimal.

La matriz resultante se puede ver en esta solución 'beta':

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. Hacer frente a las limitaciones.

Hay muchas restricciones que deben colocarse en el código anterior. Aquí paso por cada uno de ellos 1 por 1.

1. Ninguna tarea

Esto también lo sienten otros lenguajes, sin asignación en C es muy difícil obtener valores garantizados en variables. La forma más fácil para nosotros es escribir nuestra función como un programa completo. Se mainpasará el primer argumento de argccuyo valor será 1 si se llama sin argumentos.

2. Sin bucles

Las construcciones solamente bucle en C son for, whiley gototodos los cuales contienen caracteres restringidos. Esto nos deja con el uso de la recursividad. La función principal comenzará en 1 y recurrirá hasta que el argumento sea> 256, mientras tanto disminuirá internamente el argumento para usar un valor indexado a 0.

3. Valores hexadecimales

Los valores en la matriz anterior son hexadecimales, incluso cuando se convierten a decimales, estos contienen algunos símbolos restringidos, sobre todo 123456 (AD puede estar en minúsculas). Para evitar esto, cada constante se XOR con otra de manera que se eliminen los caracteres restringidos. 1 se convierte en 9 ^ B, 2 se convierte en C ^ E, 3 se convierte en B ^ 8, 4 se convierte en 8 ^ C, 5 se convierte en 9 ^ C y 6 se convierte en 9 ^ F (hay más formas de hacerlo, elegí esta manera) .

4. Impresión

Las restricciones no nos dejan muchas funciones de impresión. putchary putsambos están restringidos, se van printf. Lamentablemente, tenemos que enviar printfuna cadena de formato, idealmente "% c". Todas esas cadenas tienen ese molesto signo de porcentaje que deseamos eliminar. Afortunadamente, asumimos una máquina little-endian (porque aparentemente eso es lo que usa TIO, y eso es bastante típico). Al construir el entero cuyos bytes en la memoria son 0x25 (%), 0x63 (c), 0x00 (\ 0), cualquier cosa (no importa, es después del terminador nulo) simplemente podemos pasar su dirección printfy asumirá que es una cuerda Uno de esos números que funciona es -989830363 (0xC5006325). Esto es fácil de crear bajo las restricciones como 77707-989908070.

Todavía existe el problema de que no podemos hacer referencia a ningún valor (porque no podemos asignarlos y porque no podemos usar &), por lo que tenemos que usar una matriz literal (int []) {...}. De hecho, también usamos esto para la matriz de máscara de bits anterior.

5. Corchetes de cierre

No podemos usar ']' o '}' para cerrar nuestras matrices o funciones. Afortunadamente, C tiene dígrafos y trigrafos que funcionan. :>se convertirá ], mientras ??>se convertirá }. Esto requiere que gcc tome el -trigraphscambio, ya que ignora los trigrafos de forma predeterminada (en violación del estándar).

6. Operaciones bit a bit

No podemos usar &para enmascarar bits de nuestro índice, ni podemos usar %para llegar allí a la antigua usanza. Por lo tanto, confiamos en el comportamiento específico de implementación. En particular, desplazamos nuestros enteros de 32 bits lo suficientemente hacia la izquierda para perder bits, y luego hacia la derecha. Por ejemplo, para obtener los últimos 5 bits de nuestro número, primero lo desviamos a la izquierda 27 bits (se van abcde00000...) y luego lo volvemos a la derecha 27 bits (a la izquierda ...00000abcde).

7. Valores diversos

Necesitamos algunos valores literales más en todo el código; estos se toman de la respuesta JS de Arnauld, y agrego 27 (por la razón anterior) como 9+9+9.

3. Poniéndolo todo junto

Aquí está la descripción de la fuente con todos estos cambios juntos.

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 bytes

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

Pruébalo en línea!

En respuesta a ser finalmente derrotado por Javascript, he jugado lo que puedo de esto:

Se guardó 1 byte al tener 32 en la celda 0 e incrementar la celda 1 (la única razón por la que inicialmente lo tuve al revés fue por una solución rápida cuando OrjanJohansen señaló que no podía usar ])

1 byte guardado al disminuir una tercera celda (inicialmente en 0) para generar 255=-1

2 bytes guardados al imprimir espacios entre los caracteres 31 y 36 sin usar, <>sino que simplemente se detienen en 32 para imprimir desde la celda 0 cuando se incrementa de 31 a 33.

brainfuck , 639 bytes

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

Pruébalo en línea!

Primero generamos el número 32. Luego, simplemente pasamos incrementando una celda y cambiando la impresión entre esa celda y la que contiene 32. El aumento constante de números es algo que Brainfuck hace bien.

Es bueno vencer Javascript con Brainfuck, ¡no sucede a menudo!

JavaScript (SpiderMonkey) , 1918 1598 1487 1431 bytes

Guardado 56 bytes gracias a @ 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)

Pruébalo en línea!

¿Cómo?

El hecho de que =no esté permitido es un show-killer en JS. No podemos hacer ninguna asignación variable, y tampoco podemos usar ninguna función de flecha.

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

Deje que shiftCount sea ​​el resultado de enmascarar todos menos los 5 bits menos significativos de rnum , es decir, calcular rnum y 0x1F.

8<<988<<2$32$

Haskell, 623 617 614 594 360 342 bytes

Editar: -234 bytes gracias a @Lynn al encontrar un patrón de codificación como una cadena. -18 bytes gracias a @ Ø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))

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Este es un poco difícil para Brain-flak ya que no podemos usar ]o }. Significa que los únicos caracteres útiles son <>().

Aquí hay un programa de Haskell que me ayudó a escribir esto

Simplemente cuenta saltando donde los espacios deben estar y empujándolos individualmente.

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

Pruébalo en línea!

¡Finalmente vence a BF!

Idea general

Convertir cada carácter de la cadena de cadena larga a su índice o 32, depende del valor.

Array.prototype.map? Cómo obtener una matriz

Fuerza bruta para ver qué objetos son accesibles accediendo a las propiedades del objeto (porque ]no está permitido, por lo que solo se puede acceder a las propiedades con un nombre que coincida con un identificador).

RegExp.prototype.execdevuelve un objeto tipo matriz cuando hay una coincidencia. Cuando no se proporciona ningún argumento, el argumento predeterminado es undefined, por lo que /u/.exec()coincide y devuelve una matriz.

Obtenga 2 valores distintos arbitrarios en 2 caracteres diferentes

Queremos tener (x,y)=>x=='0'?32:y, pero no podemos usar =.

En cambio, vamos a hacer

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

Podemos mappasar la cadena sobre alguna función, pero =>no está permitido, por lo que solo se pueden usar algunas funciones. Puede tener thisargumentos vinculados y algunos vinculados (por lo que tiene la forma (x,y,z)=>pre_filled_function.call(pre,filled,args,etc,x,y,z))

Después de considerar una lista de funciones ( repeat exec bind create map indexOf replace fill find reduce filter findIndex call bind apply), decido que se utilizarán las siguientes funciones (después de considerar todas las demás combinaciones)

• repeat: número -> diferentes cadenas.
• find: thisArg -> primer elemento en la coincidencia de matriz.

La idea general sería:

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

donde somefunctionconsidera el thisargumento ( x) y el primer argumento ( elem1o elem2) y devuelve si coincide.

La última función de flecha se reescribe en [].find.bind([elem1,elem2],somefunction).

Array literal

Podemos usar regex exec para obtener una matriz, y fillcon diferentes valores. Por ejemplo, /()/.exec()devuelve una matriz de longitud 2, luego podemos llenarla según lo necesitemos.

¿ somefunctionQué necesitamos?

Necesitamos uno que devuelva un valor verdadero / falso depende de this (que es 1 de 2 funciones que vamos a devolver) y el primer argumento (debe ser una cadena o matriz).

Para eso, utilicé indexOf: devuelve un valor falso si el primer argumento es un prefijo del thisargumento.

Representar los literales de función

TI-Basic (serie 83), 578 bytes

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 tiene su propia "página de códigos" muy especial con opciones de diseño extrañas como mover el carácter de espacio a 0x29 para que 0x20 pueda ser elrandM( comando.

Es complicado descubrir cómo hacer que TI-Basic produzca el tipo correcto de objeto. Las cadenas no funcionarían por varias razones: no hay forma de hacer referencia a un token sin usar el token, y tampoco se nos permite el "personaje. No podemos simplemente escribir una lista, porque {y }están prohibidos. Se nos permiten los caracteres [y ]para las matrices, pero una matriz de 1 por 256 no funciona, ya que las matrices se permiten como máximo en 99 filas y columnas. No podemos utilizar →para asignar a las variables, y no podemos llegar a las variables de lista ʟo L₁a través L₆de todos modos.

Entonces, aquí, escribimos una fórmula lógica complicada con desigualdades que dice cuándo un personaje es uno de los que queremos generar. Luego usamos el seq(comando para generar una lista 1en esas posiciones y en 0otros lugares. A partir de ahí, otro seq(comando y algo de aritmética termina el trabajo.

Esa fue la parte emocionante; el resto es jugar al golf las constantes y probablemente no lo he hecho tanto como sea posible. Uno de los trucos que uso es que, por defecto, Xmaxes 10, XFactes 4 y ΔTbles 1.

Brain-Flak -r, 3894 bytes

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

Pruébalo en línea!

Escribí un programa para generar el programa Brain-Flak óptimo para cualquier salida. Asumir que:

• <> no se usa
• Mi programa es correcto

, entonces esta solución es óptima.

$O(n^5)$

Python 2 , 162 157 bytes

Advertencia : caracteres no imprimibles por delante!

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

Pruébalo en línea!

Basado en la respuesta existente de TFeld , pero con algunos cambios:

• Use en 0xe0/7lugar de 8+8+8+8representar 32. ( un programa para encontrar la representación más corta de un número )
• Use a bytearraypara representar el gran literal.

A bytearrayes similar a un strque es iterable, sin embargo, iterar da enteros, no caracteres. Podemos usarlo para codificar un literal de base N y reduce(lambda x,y: x*N+y, my_bytearray)decodificarlo.

Debido a que los archivos Python 2 no tienen una codificación por defecto, solo se pueden usar caracteres en ASCII (0..127). El byte nulo, las nuevas líneas, las barras diagonales inversas y las comillas toman 1 byte más.

Además, no es posible usar todas las bases.

Escribí un programa para encontrar la representación más corta de n, dadas esas restricciones.