Lenguage é um dialeto que é famoso por quebrar desafios de restrição de origem. Isso ocorre porque o Lenguage se importa apenas com o tamanho da fonte e não com o conteúdo.

Primeiro, o comprimento do programa é calculado. Em seguida, o referido comprimento é convertido em binário e preenchido à esquerda por zeros para um múltiplo de 3. A cadeia binária resultante é dividida em pedaços de 3 bits, cada um dos quais é traduzido em um comando brainfuck como tal:

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

Finalmente, o programa é executado como brainfuck ¹ .

A partir daqui, o desafio é bem simples, escreva um programa de idiomas que não aceite entrada e produza uma saída que consiste em um byte inteiro repetido $n$ vezes, em que $n$ é estritamente maior que a duração do seu programa.

As respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Aqui está um programa hacky para calcular a linguagem do brainfuck

^{1: Para esse desafio, usaremos células de embrulho e uma fita não embrulhada.}

8437495638205698686671 bytes

Isso se traduz no programa brainfuck:

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

$231584178474632390847141970017375815706539969331281128078915168015826259279614$

Isso é calculado pela função

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

com uma entrada de 255.

Explicação:

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

298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

$250^{255}$

O crédito vai para @hvd nesta resposta do Brainfuck , por isso não deixe de votar nele!

Explicação:

Eu ia escrever uma explicação própria, mas percebi que a explicação do @hvd já está no ponto, então cito aqui:

>>>>>> é necessário para deixar um pouco de espaço de trabalho.

-produz 255 ( desde 0 - 1 = 255 quando temos células de quebra automática ).

[[->>>+<<<]------>>>-] transforma isso em 255 cópias do valor 250, fornecendo uma fita parecida com:

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

<<<[<<<]+ move o ponteiro dos dados para trás e termina os dados iniciais:

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

Em seguida, vem o loop: [+...-]inicialmente define 1 como 2, que é retornado para 1 no final do loop. O loop termina quando o corpo do loop já está definido como 2 como 1.

Agora, os números 2 250 250 250 ... 250 representam um contador, na base 250, com cada número um maior que o dígito que representa.

• [>>>]<<<move todo o caminho para a direita. Como cada dígito é representado por um número diferente de zero, isso é trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-diminui o contador em 1. Começando com o último dígito: o dígito é diminuído. Se continuar positivo, terminamos. Se for zero, defina-o como 250 e continue com o dígito anterior.

• [<<<].>>>move o ponteiro para trás antes do dígito mais à esquerda, e este é um bom momento para imprimir um byte NUL. Em seguida, reposicione exatamente no dígito mais à esquerda, para ver se terminamos.

Para verificar a exactidão, alterar o inicial -para +a imprimir 250 ¹ NUL bytes, ++para 250 ² , etc.

19326644346528796447 bytes

Código Brainfuck:

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

Impressões

57896044618658097711785492504343953926634992332820282019728792003956564819967

bytes nulos.

Funciona assim:

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

Recursão bastante direta.