Count up forever

Question

Write a program that counts up forever, starting from one.

Rules:

• Your program must log to STDOUT or an acceptable alternative, if STDOUT is not available.
• Your program must be a full, runnable program, and not a function or snippet.
• Your program must output each number with a separating character in between (a newline, space, tab or comma), but this must be consistent for all numbers.
• You may print the numbers in decimal, in unary or in base 256 where each digit is represented by a byte value.
• Your program must count at least as far as 2¹²⁸ (inclusive) without problems and without running out of memory on a reasonable desktop PC. In particular, this means if you're using unary, you cannot store a unary representation of the current number in memory.

• Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.

  Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.

• This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.

Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 63834; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 39069; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Answer 1

Perl, 34 32 30 28 26 23 bytes

-Mbigint -E '{say$_+=1;redo}'

Test with

perl -Mbigint -E '{say$_+=1;redo}'

Answer 2

Marbelous, 358 bytes

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 half adders chained together, the rightmost one performing N++ each cycle and each adder feeding its overflow (00 or 01) to the next in the chain. Output is in hex.

The python interpreter has a bug where output from memoized functions is lost, so you have to run this with "-m 0" to make it work right. Without that parameter you can see how fast it will run without the bug, but the output won't work right.

Note to self: fix that bug in marbelous.py This bug has been fixed in the latest version of marbelous.py

Answer 3

R, 52 Bytes

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(Note: gmp is an external library, so you may have to download it for this solution to work)

Answer 4

Turing Machine Simulator, 536 bytes

a * * r a
a , * r A
A * * r A
A , * l b
b * * l b
b , * l c
b s 0 l 0
b p 1 l 1
b d 2 l 2
b f 3 l 3
b g 4 l 4
b h 5 l 5
b i 6 l 6
b j 7 l 7
b k 8 l 8
b l 9 l 9
0 * * l 0
0 _ s r a
1 * * l 1
1 _ p r a
2 * * l 2
2 _ d r a
3 * * l 3
3 _ f r a
4 * * l 4
4 _ g r a
5 * * l 5
5 _ h r a
6 * * l 6
6 _ i r a
7 * * l 7
7 _ j r a
8 * * l 8
8 _ k r a
9 * * l 9
9 _ l r a
c _ p l d
c s p l d
c p d l d
c d f l d
c f g l d
c g h l d
c h i l d
c i j l d
c j k l d
c k l l d
c l s l c
d * * l d
d _ , r A

Test it out here -> link
initial input: ,*p,
initial state: b

Explanation:
state a: move right until a comma is found then move to state A
state A: move right until a comma is found then move to state b
state b: move left until a letter or a comma is found. If a letter is found, change the letter to its corresponding digit and move to the corresponding state. If a comma is found, move to state c.
states 0-9: move left until an empty space is found then write the digit
state c: increment the number and end up on the left then move to state d
state d: place a comma then move to state A

Basically, it finds the previous number, copies it over while converting it to digits, increments it, then starts all over.

On a real turing machine this would go way over 2^128

Answer 5

BotEngine, 128 120 112 8x13=104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

Output is in binary.

Answer 6

05AB1E, 4 bytes

[¼¾,

Explained

[           # start infinite loop
 ¼          # increase counter
  ¾         # push counter
   ,        # print with a newline

Answer 7

Alice, 6 bytes

h .\
O

Try it online!

Alice is a 2D language with two modes - Cardinal (up/down/left/right) for integers and Ordinal (diagonal) for strings. For this challenge we need Cardinal to count and Ordinal to print as an integer (as opposed to a byte).

We start off from the top left in Cardinal mode, with h incrementing the top of stack — for the first iteration, this is an implicit 0. The space that follows is a no-op, and the . after duplicates the top of stack.

Next we pass through the mirror \, reflecting us NE and switching us to Alice's Ordinal mode. In Ordinal mode the IP reflects off the code boundary rather than wrapping around, so we rebound and start moving SW.

From here we bounce twice, hit the O to print as integer, and bounce back to the \. This switches us back to Cardinal mode moving rightward, wrapping around and continuing the infinite loop.

TL;DR:

0123  ->  h5.3  ->  h7 9  ->  01.9  ->  ...
O         6 4       6 8       O

Answer 8

Rust, 41 bytes

fn main(){for i in 1..{println!("{}",i)}}

Try it online!

Answer 9

C, 93

Count up to 10^97. Add 3 bytes to count up to 10^997 (and so on).

char*p,d[99],*q=d+97;main(){while(p-d)*q>56?(*q--=48):(*q||(*(p=q)=48),++*q,puts(p),q=d+97);}

Less golfed

char*p,d[99],*q=d+97;

main()
{
  while(p!=d)
  {
    if(*q > '8') {
      *q = '0';
      --q;
    }
    else {
      if (!*q) {
        *q = '0';
        p = q; 
      }
      ++*q;
      puts(p);
      q = d + 97;
    }
  }
}

Answer 10

Racket, 40 bytes

(sequence-for-each println(in-naturals))

Racket has arbitrary-precision numbers, so this will continue to count up forever.

Answer 11

Scala, 41 39 35 bytes

Stream.iterate(BigInt(0)){_+1}print

Other versions (I left all solutions there because they're significantly different):

def r(n:BigInt){println(n);r(n+1)};r(0)   // 39
var i=BigInt(0);while(1>0)println{i+=1;i} // 41

This is my first time writing Scala code.

Original idea based on SuperJedi224's Java answer.

{i=>i+1} can be shortened to {_+1}.
foreach println was replaced with print because the problem description allows any separator.
Iterator.iterate and Stream.iterate, though completely different, do the same thing.

Other tries

Stream.from(0).print() // overflows at Integer.MAX_VALUE
BigInt(0).to(10)foreach println // 10 should be BigInt.MAX_VALUE (=Infinity), which doesn't exist
def from(start:BigInt):Stream[BigInt]=Stream.cons(start,from(start+1));from(0).print // too long

Answer 12

C, 95 bytes

int a,c[50]={-38};main(){for(a=49;++c[a]>9;c[a--]=0);for(a=0;a<50;++a)putchar(c[a]+48);main();}

Prints:

00000000000000000000000000000000000000000000000001
00000000000000000000000000000000000000000000000002
...

Answer 13

Perl 6, 13 bytes

.say for 1..*

Answer 14

8086 machine code + DOS, 34 bytes

Hexdump:

30 0D 0A 24 FE C6 BB 00 01 B4 09 CD 21 FE 07 80
3F 3A 75 F2 C6 07 30 4B 3B DA 73 F1 C6 07 30 4A
EB EB

In assembly language:

    .MODEL TINY

    .CODE
    org 100h

MAIN PROC

    db '0',13,10,'$' ; output buffer
    inc dh ; assign dx=0x100 - address of the output buffer

increase_num:
    mov bx, 100h
    mov ah, 9
    int 21h ; print the number

increase_digit:
    inc byte ptr [bx]
    cmp byte ptr [bx], '0'+10
    jne increase_num
    mov byte ptr [bx], '0'
    dec bx
    cmp bx, dx
    jae increase_digit
    mov byte ptr [bx], '0'
    dec dx
    jmp increase_digit

MAIN ENDP
END MAIN

Some explanations:

Output buffer is at offset 0x100; it contains 4 bytes at first: '0', a newline sequence 0d 0a, and '$', which is an end-of-output-buffer byte that DOS uses. These 4 bytes are executed as nonsensical code:

xor [di],cl
or ah,[si]

This destroys the program exit instruction at offset 0, but this is OK because the program will not exit!

The instruction inc dh generates the value 0x100 in dx, which is the address of the output buffer. The output buffer grows down, decreasing the value of dx with each power of 10.

The number is stored as an ASCII string. The increment code starts from the last digit, increases it and checks whether it went out of range 0...9. If yes, it sets the digit to 0 and goes to the next digit (dec bx). If all digits are set to 0, it adds (dec dx) another 0 digit, and immediately increases it to 1.

Answer 15

O, 7 bytes

1{.o)}w

Explanation:

1       Pushes 1 to the stack
 {   }w While the top of the stack is not 0
  .o)   Output the top of the stack and increment it

Does not work on online IDE, but does in REPL and file.

Answer 16

Burlesque, 9 bytes

1R@2SH[-Q

If you don't care what the first character is go with 1R@.

Explanation:

R@ is the RangeInf built-in and creates a Block with numbers [N..Infinity] so 1R@ generates a Block {1 2 3 4 5....}. However, if we display this we'll have a { at the start of our output which we don't want. SH converts a value to a display value (called Pretty) and then back to a String using the display format. 2 is the Format With Spaces so 2SH produces [1 2 3 4 5...]. Now we use [- which is the Tail built-in which removes the first character in that string. Q converts our string to a display value. Burlesque generally prints things as you input them, so when it prints a String there it will be surrounded by quotes. If one doesn't want that we have to convert it to a display value (called Pretty).

blsq ) "hi"
"hi"
blsq ) "hi"Q
hi
blsq ) 5ro
{1 2 3 4 5}
blsq ) 5ro2SH
"[1 2 3 4 5]"
blsq ) 5ro2SH[-
"1 2 3 4 5]"
blsq ) 5ro2SH[-Q
1 2 3 4 5]

Answer 17

Powershell, 43 29 bytes

[Numerics.BigInteger]$i=1;for(){$i;$i=$i+1}

Relies on .Net 4.0 and up for System.Numerics.BigInteger

V2

[BigInt]$i=0;for(){($i=$i+1)}

Thanks to TimmyD for the additional tips for use of parens to a automatically produce output and [bigint] for type assignment.

Answer 18

PARI/GP, 23 bytes

i=0;until(print(i+=1),)

---

Sample Usage

$ gp -qf < countup.gp

Answer 19

Brainfuck, 44 bytes

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

I'm surprised there are no brainfuck submissions, so here's my attempt (and my first brainfuck program). I interpreted the constraint on number formatting as 'whatever is convenient for your language', so the output here is as a binary string of 00 and 01, with FF as separators. The beginning of the output:

0000000: 01 ff 01 00 ff 01 01 ff 01 00 00 ff 01 00 01 ff  ................
0000010: 01 01 00 ff 01 01 01 ff 01 00 00 00 ff 01 00 00  ................

The standard 30000 byte BF implementation can go as high as 2^15000 before reaching undefined behavior. Here is another version which produces a more readable output consisting of "0" and "1" with newlines as separators (currently 105 chars, although this can probably be golfed more):

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

Output:

1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111

Answer 20

Mathematica, 22 bytes

For[i=1,1>0,Print@i++]

Answer 21

Seriously, 4 bytes

1W■u

Explanation:

1    puts 1 on the stack
W    begins a while loop that executes while the (peeked) value on top of the stack is truthy
  ■    output entire stack without popping
  u    increment value on top of stack
<EOF> implicit end of while loop block

No online interpreter link because it doesn't do so well with infinite loops.

Answer 22

Pyth, 4 bytes

.V1b

.V begins an infinite loop which defines incremented b, starting with 1. The body of the loop implicitly prints b on the next line.

Answer 23

dc, 12 bytes

Uses an "anonymous" recursive macro, should be able to run for ever:

z[r1+prdx]dx

Answer 24

WhoScript, 28 27 bytes

1#1;v;e;pw #;#a;pw;#1;+;i;d

Ungolfed/Explanation:

# 1                        @ push 1 to the stack
time_vortex                @ begin an infinite loop
  duplicate                @ duplicates the top of the stack
  psychic_paper write #    @ prints the top of the stack as a number
  # a                      @ pushes 10 (0xA) to the stack
  psychic_paper write      @ prints the character whose ASCII code matches the top of the stack
  # 1                      @ pushes another 1 to the stack
  +                        @ adds the top two stack values (as a floating point number)
  integer                  @ converts the top number of the stack to an integer
paradox                    @ go back to the 'time_vortex' line

Shaved off a byte by using 0xA instead of 0x20

Answer 25

Fuzzy Octo Guacamole, 4 bytes

(+X)

Explanation:

(+X)
(  )    # Infinite loop.
 +      # Increment ToS, which is 0 by default.
  X     # Print ToS.
        # Implicit output applies to the end of a loop.

Answer 26

Sesos, 2 bytes

Hexdump:

0000000: 0c3a                                              .:

Try it online!

Assembly:

set numout ;output one number per line instead of character
nop        ;set entry marker (start of loop)
add 1
put
           ;(implicit jnz) set exit marker (end of loop, jump if not zero)

Answer 27

Brachylog, 6 bytes

#>=@w\

Try it online!

Explanation

#>         Constrain a number in [1,∞)
  =        Assign a value to the number in that interval
   @w      Write the number followed by a linebreak
     \     False ; try another value assignement in the interval

Answer 28

ArnoldC, 157 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE n
YOU SET US UP 0
STICK AROUND 1
GET TO THE CHOPPER n
GET UP 1
ENOUGH TALK
TALK TO THE HAND n
CHILL
YOU HAVE BEEN TERMINATED

First time trying to use ArnoldC so any improvements are welcome. I ran it here and it seemed to work even though the output stops around 1700. I believe this is a limitation of that test though, not the code.

Answer 29

cQuents, 1 byte

$

Try it online!

Explanation

:    Implicit mode : (infinitely print the sequence if given no input)
 $   Each item in the sequence equals the current (1-based) index

Answer 30

Brainfuck, 1055 bytes

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

Too bad that Brainfuck has limited memory cell size. Actually, printing decimals and conditional statements are pain in this language. Ungolfed (or called so):

+>+<[

COUNTER=0

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

>>>>>>>>>>[-]

LOOP START
    INCREMENTING <<<<<<<<<-]>>>>>>>>>>>[<<<<<<<<<<<<+>>>>>>>>>>>>-]<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>[-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>+>[-]<[>+<-]
    CHECKING CELL [-]>[<+<<<<<<<+>>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[-]<<[<<<<<<+>>>>>>-]->>[<<<<<<<<-<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>[>>>>>>+<<<<<<[-]]<->>>>>>>[<<<<<<<->>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[>>>>+<<<<<<<<<<<<<->>>>>>>>>[-]]<<<<<<<<-]<[>[-]+<-]>[<+>>>>>>>>>>>>>>+<<<<<<<<<<<<<<->-]>>>>>>>>>>>>  [<<<<<<<<<<<<<+>>>>>>>>>>>>>-]


    PRINTING
                <<<<<<<<<<<<<[>[-]+<-]>[<+

                PRINT INTEGER

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

                PRINT SPACE

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


LOOP END

CODE THAT GETS EXECUTED AT THE END (LEAVING LOOP):

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

If we would remove last piece of code it would stick two '1' at the end.