El lenguaje es un dialecto mental que es conocido por romper los desafíos de restricción de fuente. Esto se debe a que Lenguage solo se preocupa por la longitud de su fuente y no por el contenido.

Primero, se calcula la duración del programa. Luego, dicha longitud se convierte en binaria y se rellena con ceros a la izquierda a un múltiplo de 3. La cadena binaria resultante se divide en trozos de 3 bits, cada uno de los cuales se traduce en un comando brainfuck como tal:

000 -> +
001 -> -
010 -> >
011 -> <
100 -> .
101 -> ,
110 -> [
111 -> ]

Finalmente el programa se ejecuta como brainfuck ¹ .

A partir de aquí, el desafío es bastante simple: escriba un programa de lenguaje que no tenga entrada y produzca una salida que consta de un byte entero repetido $n$ veces, donde $n$ es estrictamente mayor que la longitud de su programa.

Las respuestas se puntuarán en bytes, siendo menos bytes mejores.

Aquí hay un programa hacky para calcular el lenguaje de brainfuck

^{1: Para este desafío, utilizaremos celdas envolventes y una cinta no envolvente.}

8437495638205698686671 bytes

Esto se traduce en el programa brainfuck:

-[>>[>]+[->[>]+.[<]+<]<-]

$231584178474632390847141970017375815706539969331281128078915168015826259279614$

Esto es calculado por la función

f(n)=2*f(n-1)+n
f(0)=0

con una entrada de 255.

Explicación:

-[         Loop 255 times
  >>[>]    Move to the end of a series of positive cells (initially empty)
  +        Add one cell to the end
  [-       Loop over each cell 
    >[>]+  Add one cell to the end
    .      Print a SOH byte
    [<]+   Restore current cell
  <]       Move to next cell
<-]        Decrement counter

9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes

>>>>>>-[[->>>+<<<]------>>>-]<<<[<<<]+[+[>>>]<<<->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-[<<<].>>>-]

Que imprime exactamente

298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

$250^{255}$

El crédito va a @hvd en esta respuesta Brainfuck , ¡así que asegúrate de votarlo!

Explicación:

Iba a escribir una explicación propia, pero me di cuenta de que la explicación de @hvd ya estaba en punto, por lo que lo citaré aquí:

>>>>>> es necesario para dejar un poco de espacio de trabajo

-produce 255 ( ya que 0 - 1 = 255 cuando tenemos celdas de ajuste ).

[[->>>+<<<]------>>>-] convierte esto en 255 copias del valor 250, dando una cinta que se parece a:

0 0 0 0 0 0 250 0 0 250 0 0 ... 250 0 0 [0]

<<<[<<<]+ mueve el puntero de datos hacia atrás y termina los datos iniciales:

0 0 0 [1] 0 0 250 0 0 250 0 0 ...

Luego viene el ciclo: [+...-]inicialmente establece el 1 en un 2, que se vuelve a establecer en 1 al final del ciclo. El ciclo termina cuando el cuerpo del ciclo ya está configurado de 2 a 1.

Ahora, los números 2 250 250 250 ... 250 representan un contador, en la base 250, con cada número uno mayor que el dígito que representa.

• [>>>]<<<se mueve hacia la derecha. Como cada dígito está representado por un número distinto de cero, esto es trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-disminuye el contador en 1. Comenzando con el último dígito: el dígito se reduce. Si sigue siendo positivo, hemos terminado. Si se pone a cero, ajústelo a 250 y continúe con el dígito anterior.

• [<<<].>>>mueve el puntero hacia atrás antes del dígito más a la izquierda, y este es un buen momento para imprimir un byte NUL. Luego vuelva a colocar exactamente el dígito más a la izquierda, para ver si hemos terminado.

Para verificar la corrección, cambie la inicial -a +para imprimir 250 ¹ bytes NUL, ++para 250 ² , etc.

19326644346528796447 bytes

Código Brainfuck:

>+[+[[+>->-<<]->>+].<]

Huellas dactilares

57896044618658097711785492504343953926634992332820282019728792003956564819967

bytes nulos

Funciona así:

mem[i]=255;
do
    while(--mem[i]){
        mem[i+1]=mem[i+2]=mem[i];
        mem[i]=1;
        i+=2;
    }
while(mem[--i]);

Recurrencia bastante directa.