Le lenguage est un dialecte encerclé qui est connu pour briser les défis de restriction des sources. C'est parce que le Lenguage ne se soucie que de la longueur de sa source et non du contenu.

Tout d'abord, la durée du programme est calculée. Ensuite, ladite longueur est convertie en binaire et complétée à gauche par des zéros en un multiple de 3. La chaîne binaire résultante est divisée en morceaux de 3 bits chacun qui est traduit en une commande brainfuck en tant que telle:

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

Enfin, le programme est exécuté en tant que brainfuck ¹ .

De là, le défi est assez simple, écrivez un programme de langage qui ne prend aucune entrée et produit une sortie composée d'un entier répété $n$ fois n , où $n$ est strictement supérieur à la longueur de votre programme.

Les réponses seront notées en octets avec moins d'octets étant mieux.

Voici un programme hacky pour calculer la langue à partir de brainfuck

^{1: Pour ce défi, nous utiliserons des cellules d'emballage et une bande non enveloppante.}

8437495638205698686671 octets

Cela se traduit par le programme brainfuck:

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

$231584178474632390847141970017375815706539969331281128078915168015826259279614$

Ceci est calculé par la fonction

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

avec une entrée de 255.

Explication:

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

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

Qui imprime exactement

298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

$250^{255}$

Le mérite revient à @hvd dans cette réponse Brainfuck , alors assurez-vous de lui donner un vote positif!

Explication:

J'allais écrire une explication de ma part, mais j'ai réalisé que l'explication de @hvd est déjà sur le point, alors je vais la citer ici à la place:

>>>>>> est nécessaire pour laisser un peu d'espace de travail.

-produit 255 ( puisque 0 - 1 = 255 lorsque nous avons des cellules d'habillage ).

[[->>>+<<<]------>>>-] transforme cela en 255 copies de la valeur 250, donnant une bande qui ressemble à:

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

<<<[<<<]+ recule le pointeur de données et termine les données initiales:

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

Vient ensuite la boucle: [+...-]définit initialement le 1 sur 2, qui est remis à 1 à la fin de la boucle. La boucle se termine lorsque le corps de la boucle est déjà réglé sur 2 à 1.

Maintenant, les nombres 2 250 250 250 ... 250 représentent un compteur, en base 250, avec chaque numéro un supérieur au chiffre qu'il représente.

• [>>>]<<<se déplace complètement vers la droite. Étant donné que chaque chiffre est représenté par un nombre non nul, cela est trivial.

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-diminue le compteur de 1. En commençant par le dernier chiffre: le chiffre est décrémenté. Si cela reste positif, nous avons terminé. S'il devient nul, réglez-le sur 250 et continuez avec le chiffre précédent.

• [<<<].>>>recule le pointeur avant le chiffre le plus à gauche, et c'est un bon moment pour imprimer un octet NUL. Repositionnez ensuite exactement le chiffre le plus à gauche pour voir si nous avons terminé.

Pour vérifier l' exactitude, modifier la première -à +d' imprimer 250 ¹ NUL octets, ++pour 250 ² , etc.

19326644346528796447 octets

Code Brainfuck:

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

Impressions

57896044618658097711785492504343953926634992332820282019728792003956564819967

octets nuls.

Cela fonctionne comme ceci:

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

Récursion assez simple.