Make a longer lenguage program

The name of the pictureThe name of the pictureThe name of the pictureClash Royale CLAN TAG#URR8PPP












16












$begingroup$


Lenguage is a brainfuck dialect that is notorious for breaking source restriction challenges. That is because Lenguage cares only about the length of it's source and not the contents.



First, the length of the program is calculated. Then, said length is converted to binary and left-padded by zeroes to a multiple of 3. The resulting binary string is split into chunks of 3 bits each of which is translated into a brainfuck command as such:



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


Finally the program is run as brainfuck1.



From here the challenge is pretty simple, write a lenguage program that takes no input and produces an output consisting of one byte repeated integer $n$ times, where $n$ is strictly greater than the length of your program.



Answers will be scored in bytes with fewer bytes being better.



Here's a hacky program to calculate lenguage from brainfuck




1: For this challenge we will use wrapping cells and a non-wrapping tape.










share|improve this question











$endgroup$







  • 2




    $begingroup$
    +[.] Do I win? :P
    $endgroup$
    – Quintec
    Feb 1 at 2:04






  • 3




    $begingroup$
    Perhaps it might be more interesting to score on the length of the output?
    $endgroup$
    – Jo King
    Feb 1 at 2:22










  • $begingroup$
    @JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 1 at 3:19






  • 2




    $begingroup$
    Also, why is this tagged quine?
    $endgroup$
    – Embodiment of Ignorance
    Feb 2 at 5:25






  • 1




    $begingroup$
    @msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 2 at 18:44















16












$begingroup$


Lenguage is a brainfuck dialect that is notorious for breaking source restriction challenges. That is because Lenguage cares only about the length of it's source and not the contents.



First, the length of the program is calculated. Then, said length is converted to binary and left-padded by zeroes to a multiple of 3. The resulting binary string is split into chunks of 3 bits each of which is translated into a brainfuck command as such:



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


Finally the program is run as brainfuck1.



From here the challenge is pretty simple, write a lenguage program that takes no input and produces an output consisting of one byte repeated integer $n$ times, where $n$ is strictly greater than the length of your program.



Answers will be scored in bytes with fewer bytes being better.



Here's a hacky program to calculate lenguage from brainfuck




1: For this challenge we will use wrapping cells and a non-wrapping tape.










share|improve this question











$endgroup$







  • 2




    $begingroup$
    +[.] Do I win? :P
    $endgroup$
    – Quintec
    Feb 1 at 2:04






  • 3




    $begingroup$
    Perhaps it might be more interesting to score on the length of the output?
    $endgroup$
    – Jo King
    Feb 1 at 2:22










  • $begingroup$
    @JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 1 at 3:19






  • 2




    $begingroup$
    Also, why is this tagged quine?
    $endgroup$
    – Embodiment of Ignorance
    Feb 2 at 5:25






  • 1




    $begingroup$
    @msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 2 at 18:44













16












16








16


1



$begingroup$


Lenguage is a brainfuck dialect that is notorious for breaking source restriction challenges. That is because Lenguage cares only about the length of it's source and not the contents.



First, the length of the program is calculated. Then, said length is converted to binary and left-padded by zeroes to a multiple of 3. The resulting binary string is split into chunks of 3 bits each of which is translated into a brainfuck command as such:



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


Finally the program is run as brainfuck1.



From here the challenge is pretty simple, write a lenguage program that takes no input and produces an output consisting of one byte repeated integer $n$ times, where $n$ is strictly greater than the length of your program.



Answers will be scored in bytes with fewer bytes being better.



Here's a hacky program to calculate lenguage from brainfuck




1: For this challenge we will use wrapping cells and a non-wrapping tape.










share|improve this question











$endgroup$




Lenguage is a brainfuck dialect that is notorious for breaking source restriction challenges. That is because Lenguage cares only about the length of it's source and not the contents.



First, the length of the program is calculated. Then, said length is converted to binary and left-padded by zeroes to a multiple of 3. The resulting binary string is split into chunks of 3 bits each of which is translated into a brainfuck command as such:



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


Finally the program is run as brainfuck1.



From here the challenge is pretty simple, write a lenguage program that takes no input and produces an output consisting of one byte repeated integer $n$ times, where $n$ is strictly greater than the length of your program.



Answers will be scored in bytes with fewer bytes being better.



Here's a hacky program to calculate lenguage from brainfuck




1: For this challenge we will use wrapping cells and a non-wrapping tape.







code-golf brainfuck self-referential






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited Feb 7 at 15:50









Ørjan Johansen

6,50411133




6,50411133










asked Feb 1 at 0:17









Sriotchilism O'ZaicSriotchilism O'Zaic

35.1k10159369




35.1k10159369







  • 2




    $begingroup$
    +[.] Do I win? :P
    $endgroup$
    – Quintec
    Feb 1 at 2:04






  • 3




    $begingroup$
    Perhaps it might be more interesting to score on the length of the output?
    $endgroup$
    – Jo King
    Feb 1 at 2:22










  • $begingroup$
    @JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 1 at 3:19






  • 2




    $begingroup$
    Also, why is this tagged quine?
    $endgroup$
    – Embodiment of Ignorance
    Feb 2 at 5:25






  • 1




    $begingroup$
    @msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 2 at 18:44












  • 2




    $begingroup$
    +[.] Do I win? :P
    $endgroup$
    – Quintec
    Feb 1 at 2:04






  • 3




    $begingroup$
    Perhaps it might be more interesting to score on the length of the output?
    $endgroup$
    – Jo King
    Feb 1 at 2:22










  • $begingroup$
    @JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 1 at 3:19






  • 2




    $begingroup$
    Also, why is this tagged quine?
    $endgroup$
    – Embodiment of Ignorance
    Feb 2 at 5:25






  • 1




    $begingroup$
    @msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
    $endgroup$
    – Sriotchilism O'Zaic
    Feb 2 at 18:44







2




2




$begingroup$
+[.] Do I win? :P
$endgroup$
– Quintec
Feb 1 at 2:04




$begingroup$
+[.] Do I win? :P
$endgroup$
– Quintec
Feb 1 at 2:04




3




3




$begingroup$
Perhaps it might be more interesting to score on the length of the output?
$endgroup$
– Jo King
Feb 1 at 2:22




$begingroup$
Perhaps it might be more interesting to score on the length of the output?
$endgroup$
– Jo King
Feb 1 at 2:22












$begingroup$
@JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
$endgroup$
– Sriotchilism O'Zaic
Feb 1 at 3:19




$begingroup$
@JoKing That's a good idea. Unfortunately it appears to be a bit late for that.
$endgroup$
– Sriotchilism O'Zaic
Feb 1 at 3:19




2




2




$begingroup$
Also, why is this tagged quine?
$endgroup$
– Embodiment of Ignorance
Feb 2 at 5:25




$begingroup$
Also, why is this tagged quine?
$endgroup$
– Embodiment of Ignorance
Feb 2 at 5:25




1




1




$begingroup$
@msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
$endgroup$
– Sriotchilism O'Zaic
Feb 2 at 18:44




$begingroup$
@msh210 That'll do the trick most of the time, but there are a few differences, for example different Brainfuck characters cost different amounts (+ is the cheapest and ] the most expensive) and of course it matters where in the program they are. While $2^3n$ is a good estimate it is not exactly equivalent.
$endgroup$
– Sriotchilism O'Zaic
Feb 2 at 18:44










3 Answers
3






active

oldest

votes


















14












$begingroup$

8437495638205698686671 bytes



This translates to the brainfuck program:



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


Which prints exactly $231584178474632390847141970017375815706539969331281128078915168015826259279614$ SOH bytes.



This is calculated by the function



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


with an input of 255.



Explanation:



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





share|improve this answer











$endgroup$




















    4












    $begingroup$


    9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes



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


    Which prints exactly



    298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


    ($250^255$) NUL bytes.



    Credit goes to @hvd in this Brainfuck answer, so make sure to upvote him!



    Explanation:



    I was going to write an explanation of my own, but realized @hvd's explanation is already on point, so I'll quote it here instead:




    >>>>>> is needed to leave a bit of working space.



    - produces 255 (since 0 - 1 = 255 when we have wrapping cells).



    [[->>>+<<<]------>>>-] turns this into 255 copies of the value 250,
    giving a tape that looks like:



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


    <<<[<<<]+ moves the data pointer back and finishes up the initial
    data:



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


    Then comes the loop: [+...-] initially sets the 1 to a 2, which gets
    set back to 1 at the end of the loop. The loop terminates when the
    loop body already set 2 to 1.



    Now, the numbers 2 250 250 250 ... 250 represent a counter, in base
    250, with each number one greater than the digit it represents.



    • [>>>]<<< moves all the way to the right. Since each digit is represented by a non-zero number, this is trivial.


    • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>- decreases the counter by 1. Starting with the last digit: the digit gets decremented. If it remains positive, we're done. If it turns to zero, set it to 250, and
      continue with the digit before.


    • [<<<].>>> moves the pointer back before the left-most digit, and this is a nice moment to print a NUL byte. Then re-position to exactly
      the left-most digit, to see if we're done.


    To verify correctness, change the initial - to + to print
    2501 NUL bytes, ++ for 2502, etc.







    share|improve this answer









    $endgroup$




















      4












      $begingroup$

      19326644346528796447 bytes



      Brainfuck code:



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


      Prints



      57896044618658097711785492504343953926634992332820282019728792003956564819967


      null bytes.



      It works like this:



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

      while(mem[--i]);


      Quite straightforward recursion.






      share|improve this answer











      $endgroup$












        Your Answer





        StackExchange.ifUsing("editor", function ()
        return StackExchange.using("mathjaxEditing", function ()
        StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix)
        StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
        );
        );
        , "mathjax-editing");

        StackExchange.ifUsing("editor", function ()
        StackExchange.using("externalEditor", function ()
        StackExchange.using("snippets", function ()
        StackExchange.snippets.init();
        );
        );
        , "code-snippets");

        StackExchange.ready(function()
        var channelOptions =
        tags: "".split(" "),
        id: "200"
        ;
        initTagRenderer("".split(" "), "".split(" "), channelOptions);

        StackExchange.using("externalEditor", function()
        // Have to fire editor after snippets, if snippets enabled
        if (StackExchange.settings.snippets.snippetsEnabled)
        StackExchange.using("snippets", function()
        createEditor();
        );

        else
        createEditor();

        );

        function createEditor()
        StackExchange.prepareEditor(
        heartbeatType: 'answer',
        autoActivateHeartbeat: false,
        convertImagesToLinks: false,
        noModals: true,
        showLowRepImageUploadWarning: true,
        reputationToPostImages: null,
        bindNavPrevention: true,
        postfix: "",
        imageUploader:
        brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
        contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
        allowUrls: true
        ,
        onDemand: true,
        discardSelector: ".discard-answer"
        ,immediatelyShowMarkdownHelp:true
        );



        );













        draft saved

        draft discarded


















        StackExchange.ready(
        function ()
        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f179325%2fmake-a-longer-lenguage-program%23new-answer', 'question_page');

        );

        Post as a guest















        Required, but never shown

























        3 Answers
        3






        active

        oldest

        votes








        3 Answers
        3






        active

        oldest

        votes









        active

        oldest

        votes






        active

        oldest

        votes









        14












        $begingroup$

        8437495638205698686671 bytes



        This translates to the brainfuck program:



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


        Which prints exactly $231584178474632390847141970017375815706539969331281128078915168015826259279614$ SOH bytes.



        This is calculated by the function



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


        with an input of 255.



        Explanation:



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





        share|improve this answer











        $endgroup$

















          14












          $begingroup$

          8437495638205698686671 bytes



          This translates to the brainfuck program:



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


          Which prints exactly $231584178474632390847141970017375815706539969331281128078915168015826259279614$ SOH bytes.



          This is calculated by the function



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


          with an input of 255.



          Explanation:



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





          share|improve this answer











          $endgroup$















            14












            14








            14





            $begingroup$

            8437495638205698686671 bytes



            This translates to the brainfuck program:



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


            Which prints exactly $231584178474632390847141970017375815706539969331281128078915168015826259279614$ SOH bytes.



            This is calculated by the function



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


            with an input of 255.



            Explanation:



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





            share|improve this answer











            $endgroup$



            8437495638205698686671 bytes



            This translates to the brainfuck program:



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


            Which prints exactly $231584178474632390847141970017375815706539969331281128078915168015826259279614$ SOH bytes.



            This is calculated by the function



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


            with an input of 255.



            Explanation:



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






            share|improve this answer














            share|improve this answer



            share|improve this answer








            edited Feb 5 at 23:55

























            answered Feb 1 at 3:01









            Jo KingJo King

            23.3k254121




            23.3k254121





















                4












                $begingroup$


                9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes



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


                Which prints exactly



                298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


                ($250^255$) NUL bytes.



                Credit goes to @hvd in this Brainfuck answer, so make sure to upvote him!



                Explanation:



                I was going to write an explanation of my own, but realized @hvd's explanation is already on point, so I'll quote it here instead:




                >>>>>> is needed to leave a bit of working space.



                - produces 255 (since 0 - 1 = 255 when we have wrapping cells).



                [[->>>+<<<]------>>>-] turns this into 255 copies of the value 250,
                giving a tape that looks like:



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


                <<<[<<<]+ moves the data pointer back and finishes up the initial
                data:



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


                Then comes the loop: [+...-] initially sets the 1 to a 2, which gets
                set back to 1 at the end of the loop. The loop terminates when the
                loop body already set 2 to 1.



                Now, the numbers 2 250 250 250 ... 250 represent a counter, in base
                250, with each number one greater than the digit it represents.



                • [>>>]<<< moves all the way to the right. Since each digit is represented by a non-zero number, this is trivial.


                • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>- decreases the counter by 1. Starting with the last digit: the digit gets decremented. If it remains positive, we're done. If it turns to zero, set it to 250, and
                  continue with the digit before.


                • [<<<].>>> moves the pointer back before the left-most digit, and this is a nice moment to print a NUL byte. Then re-position to exactly
                  the left-most digit, to see if we're done.


                To verify correctness, change the initial - to + to print
                2501 NUL bytes, ++ for 2502, etc.







                share|improve this answer









                $endgroup$

















                  4












                  $begingroup$


                  9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes



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


                  Which prints exactly



                  298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


                  ($250^255$) NUL bytes.



                  Credit goes to @hvd in this Brainfuck answer, so make sure to upvote him!



                  Explanation:



                  I was going to write an explanation of my own, but realized @hvd's explanation is already on point, so I'll quote it here instead:




                  >>>>>> is needed to leave a bit of working space.



                  - produces 255 (since 0 - 1 = 255 when we have wrapping cells).



                  [[->>>+<<<]------>>>-] turns this into 255 copies of the value 250,
                  giving a tape that looks like:



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


                  <<<[<<<]+ moves the data pointer back and finishes up the initial
                  data:



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


                  Then comes the loop: [+...-] initially sets the 1 to a 2, which gets
                  set back to 1 at the end of the loop. The loop terminates when the
                  loop body already set 2 to 1.



                  Now, the numbers 2 250 250 250 ... 250 represent a counter, in base
                  250, with each number one greater than the digit it represents.



                  • [>>>]<<< moves all the way to the right. Since each digit is represented by a non-zero number, this is trivial.


                  • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>- decreases the counter by 1. Starting with the last digit: the digit gets decremented. If it remains positive, we're done. If it turns to zero, set it to 250, and
                    continue with the digit before.


                  • [<<<].>>> moves the pointer back before the left-most digit, and this is a nice moment to print a NUL byte. Then re-position to exactly
                    the left-most digit, to see if we're done.


                  To verify correctness, change the initial - to + to print
                  2501 NUL bytes, ++ for 2502, etc.







                  share|improve this answer









                  $endgroup$















                    4












                    4








                    4





                    $begingroup$


                    9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes



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


                    Which prints exactly



                    298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


                    ($250^255$) NUL bytes.



                    Credit goes to @hvd in this Brainfuck answer, so make sure to upvote him!



                    Explanation:



                    I was going to write an explanation of my own, but realized @hvd's explanation is already on point, so I'll quote it here instead:




                    >>>>>> is needed to leave a bit of working space.



                    - produces 255 (since 0 - 1 = 255 when we have wrapping cells).



                    [[->>>+<<<]------>>>-] turns this into 255 copies of the value 250,
                    giving a tape that looks like:



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


                    <<<[<<<]+ moves the data pointer back and finishes up the initial
                    data:



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


                    Then comes the loop: [+...-] initially sets the 1 to a 2, which gets
                    set back to 1 at the end of the loop. The loop terminates when the
                    loop body already set 2 to 1.



                    Now, the numbers 2 250 250 250 ... 250 represent a counter, in base
                    250, with each number one greater than the digit it represents.



                    • [>>>]<<< moves all the way to the right. Since each digit is represented by a non-zero number, this is trivial.


                    • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>- decreases the counter by 1. Starting with the last digit: the digit gets decremented. If it remains positive, we're done. If it turns to zero, set it to 250, and
                      continue with the digit before.


                    • [<<<].>>> moves the pointer back before the left-most digit, and this is a nice moment to print a NUL byte. Then re-position to exactly
                      the left-most digit, to see if we're done.


                    To verify correctness, change the initial - to + to print
                    2501 NUL bytes, ++ for 2502, etc.







                    share|improve this answer









                    $endgroup$




                    9093903938998324939360576240306155985031832511491088836321985855167849863863065731015823 bytes



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


                    Which prints exactly



                    298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


                    ($250^255$) NUL bytes.



                    Credit goes to @hvd in this Brainfuck answer, so make sure to upvote him!



                    Explanation:



                    I was going to write an explanation of my own, but realized @hvd's explanation is already on point, so I'll quote it here instead:




                    >>>>>> is needed to leave a bit of working space.



                    - produces 255 (since 0 - 1 = 255 when we have wrapping cells).



                    [[->>>+<<<]------>>>-] turns this into 255 copies of the value 250,
                    giving a tape that looks like:



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


                    <<<[<<<]+ moves the data pointer back and finishes up the initial
                    data:



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


                    Then comes the loop: [+...-] initially sets the 1 to a 2, which gets
                    set back to 1 at the end of the loop. The loop terminates when the
                    loop body already set 2 to 1.



                    Now, the numbers 2 250 250 250 ... 250 represent a counter, in base
                    250, with each number one greater than the digit it represents.



                    • [>>>]<<< moves all the way to the right. Since each digit is represented by a non-zero number, this is trivial.


                    • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>- decreases the counter by 1. Starting with the last digit: the digit gets decremented. If it remains positive, we're done. If it turns to zero, set it to 250, and
                      continue with the digit before.


                    • [<<<].>>> moves the pointer back before the left-most digit, and this is a nice moment to print a NUL byte. Then re-position to exactly
                      the left-most digit, to see if we're done.


                    To verify correctness, change the initial - to + to print
                    2501 NUL bytes, ++ for 2502, etc.








                    share|improve this answer












                    share|improve this answer



                    share|improve this answer










                    answered Feb 1 at 11:30









                    Kevin CruijssenKevin Cruijssen

                    38.5k557200




                    38.5k557200





















                        4












                        $begingroup$

                        19326644346528796447 bytes



                        Brainfuck code:



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


                        Prints



                        57896044618658097711785492504343953926634992332820282019728792003956564819967


                        null bytes.



                        It works like this:



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

                        while(mem[--i]);


                        Quite straightforward recursion.






                        share|improve this answer











                        $endgroup$

















                          4












                          $begingroup$

                          19326644346528796447 bytes



                          Brainfuck code:



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


                          Prints



                          57896044618658097711785492504343953926634992332820282019728792003956564819967


                          null bytes.



                          It works like this:



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

                          while(mem[--i]);


                          Quite straightforward recursion.






                          share|improve this answer











                          $endgroup$















                            4












                            4








                            4





                            $begingroup$

                            19326644346528796447 bytes



                            Brainfuck code:



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


                            Prints



                            57896044618658097711785492504343953926634992332820282019728792003956564819967


                            null bytes.



                            It works like this:



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

                            while(mem[--i]);


                            Quite straightforward recursion.






                            share|improve this answer











                            $endgroup$



                            19326644346528796447 bytes



                            Brainfuck code:



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


                            Prints



                            57896044618658097711785492504343953926634992332820282019728792003956564819967


                            null bytes.



                            It works like this:



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

                            while(mem[--i]);


                            Quite straightforward recursion.







                            share|improve this answer














                            share|improve this answer



                            share|improve this answer








                            edited Feb 7 at 15:13

























                            answered Feb 7 at 13:38









                            jimmy23013jimmy23013

                            29.5k560126




                            29.5k560126



























                                draft saved

                                draft discarded
















































                                If this is an answer to a challenge…



                                • …Be sure to follow the challenge specification. However, please refrain from exploiting obvious loopholes. Answers abusing any of the standard loopholes are considered invalid. If you think a specification is unclear or underspecified, comment on the question instead.


                                • …Try to optimize your score. For instance, answers to code-golf challenges should attempt to be as short as possible. You can always include a readable version of the code in addition to the competitive one.
                                  Explanations of your answer make it more interesting to read and are very much encouraged.


                                • …Include a short header which indicates the language(s) of your code and its score, as defined by the challenge.


                                More generally…



                                • …Please make sure to answer the question and provide sufficient detail.


                                • …Avoid asking for help, clarification or responding to other answers (use comments instead).




                                draft saved


                                draft discarded














                                StackExchange.ready(
                                function ()
                                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f179325%2fmake-a-longer-lenguage-program%23new-answer', 'question_page');

                                );

                                Post as a guest















                                Required, but never shown





















































                                Required, but never shown














                                Required, but never shown












                                Required, but never shown







                                Required, but never shown

































                                Required, but never shown














                                Required, but never shown












                                Required, but never shown







                                Required, but never shown






                                Popular posts from this blog

                                How to check contact read email or not when send email to Individual?

                                Displaying single band from multi-band raster using QGIS

                                How many registers does an x86_64 CPU actually have?