Lenguage è un dialetto brainfuck che è noto per rompere le sfide di restrizione della fonte. Questo perché Lenguage si preoccupa solo della lunghezza della sua fonte e non dei contenuti.

Innanzitutto, viene calcolata la durata del programma. Quindi, detta lunghezza viene convertita in binario e riempita a sinistra di zero in un multiplo di 3. La stringa binaria risultante viene suddivisa in blocchi di 3 bit, ciascuno dei quali viene tradotto in un comando brainfuck come tale:

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

Finalmente il programma viene eseguito come brainfuck ¹ .

Da qui la sfida è piuttosto semplice, scrivi un programma di lingue che non prende input e produce un output composto da un byte ripetuto intero $n$ volte, dove $n$ è strettamente maggiore della lunghezza del tuo programma.

Le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Ecco un programma hacky per calcolare la lingua da Brainfuck

^{1: per questa sfida utilizzeremo celle avvolgenti e un nastro non avvolgente.}

8437495638205698686671 byte

Questo si traduce nel programma brainfuck:

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

$231584178474632390847141970017375815706539969331281128078915168015826259279614$

Questo è calcolato dalla funzione

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

con un input di 255.

Spiegazione:

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

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

Che stampa esattamente

298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

$250^{255}$ ) NUL byte.

Il merito va a @hvd in questa risposta di Brainfuck , quindi assicurati di votarlo!

Spiegazione:

Stavo per scrivere una mia spiegazione, ma ho capito che la spiegazione di @hvd è già in discussione , quindi la citerò qui:

>>>>>> è necessario per lasciare un po 'di spazio di lavoro.

-produce 255 ( poiché 0 - 1 = 255 quando abbiamo celle avvolgenti ).

[[->>>+<<<]------>>>-] trasforma questo in 255 copie del valore 250, dando un nastro che assomiglia a:

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

<<<[<<<]+ sposta il puntatore dati indietro e termina i dati iniziali:

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

Poi arriva il loop: [+...-]inizialmente imposta 1 su 2, che viene riportato a 1 alla fine del loop. Il loop termina quando il corpo del loop è già impostato da 2 a 1.

Ora, i numeri 2 250 250 250 ... 250 rappresentano un contatore, nella base 250, con ogni numero uno maggiore della cifra che rappresenta.

• [>>>]<<<si sposta completamente a destra. Poiché ogni cifra è rappresentata da un numero diverso da zero, questo è banale.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-diminuisce il contatore di 1. A partire dall'ultima cifra: la cifra viene diminuita. Se rimane positivo, abbiamo finito. Se diventa zero, impostarlo su 250 e continuare con la cifra precedente.

• [<<<].>>>sposta il puntatore indietro prima della cifra più a sinistra, e questo è un bel momento per stampare un byte NUL. Quindi riposiziona esattamente sulla cifra più a sinistra, per vedere se abbiamo finito.

Per verificare la correttezza, modificare l'iniziale -in +per stampare 250 byte NUL ¹ , ++per 250 ² , ecc.

19326644346528796447 byte

Codice Brainfuck:

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

stampe

57896044618658097711785492504343953926634992332820282019728792003956564819967

byte nulli.

Funziona così:

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

Abbastanza semplice ricorsione.