[Question]
  [
Your task is simple. Post a snippet in any language that if the snippet is repeated n times, will output n in decimal, octal, and hexadecimal, in that order, separated in spaces. n is an integer larger than zero. There is no leading zeroes. Shortest answer wins
## Example
If the snippet is `ABC` then the test case is
```
ABC 
1 1 1
ABCABC
2 2 2
ABCABCABCABCABCABCABCABCABC
9 11 9
ABCABCABCABCABCABCABCABCABCABCABCABC
12 14 C
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
18 22 12
```
  
[Answer]
## Perl, 30 bytes
```
printf"\r%d %o %x",++$n,$n,$n;
```
Go back to the beginning of the line, increment counter and print counter overwriting the old output.
[Answer]
# JavaScript, ~~54 53 51~~ 47 bytes
*Saved 4 bytes thanks to @user81655*
```
var d=-~d;d+` ${d[b='toString'](8)} `+d[b](16);
```
I'm actually kinda surprised this works.
### Explanation
```
var d=-~d;  // `var` let's `d` not throw an error if it's not defined 
            // -~ essentially increments the variable
d+                    // decimal
` ${                  // space character
   d[b='toString'](8) // octal
} `                   // space character
+d[b](16)             // Hexadecimal
```
[Try it online](http://vihanserver.tk/p/esfiddle/?code=var%20d%3Dd%2B1%7C%7C1%3B%5Bd%2Cd.toString(8)%2Cd.toString(16)%5D.join%60%20%60%3B)
[Answer]
# Japt, 12 bytes
```
[¬∞TTs8 TsG]¬∏
```
*Thanks to @ETHproductions* for saving 2 bytes!
Same as my ùîºùïäùïÑùïöùïü answer.
[Answer]
# C++, ~~205~~ 179 bytes
```
int main(){};static int c=1;
#define v(x) A##x
#define u(x) v(x)
#define z u(__LINE__)
#include <cstdio>
class z{public:z(){++c;};~z(){if(c){printf("%d %o %x",--c,c,c);c=0;}}}z;//
```
(No trailing newline - when copied, the first line of the copy and last line of the original should coincide)
Basically, this works by making a sequence of static variables which, on construction, increment a global variable counter. Then, on destruction, if the counter is not 0, it does all its output and sets the counter to zero.
In order to define a sequence of variables with no name conflicts, we use the macro explained as follows:
```
#define v(x) A##x    //This concatenates the string "A" with the input x.
#define u(x) v(x)    //This slows down the preprocessor so it expands __LINE__ rather than yielding A__LINE__ as v(__LINE__) would do.
#define z u(__LINE__)//Gives a name which is unique to each line.
```
which somewhat relies on the quirks of the string processor. We use `z` many times to define classes/variables that will not conflict with each other when copied onto separate lines. Moreover, the definitions which must occur only once are placed on the first line, which is commented out in copies of the code. The `#define` and `#include` statements don't care that they get repeated, so need no special handling.
This code also features undefined behavior in the statement:
```
printf("%d %o %x",--c,c,c)
```
since there are no sequence points, but c is modified and accessed. LLVM 6.0 gives a warning, but compiles it as desired - that `--c` evaluates before `c`. One could, at the expense of two bytes, add the statement `--c;` before the outputs and change `--c` in `printf` to `c`, which would get rid of the warning.
---
Replaced `std::cout` with `printf` saving 26 bytes thanks to a suggestion of my brother.
[Answer]
# CJam, ~~20~~ ~~19~~ 18 bytes
```
];U):USU8bSU"%X"e%
```
*Thanks to @MartinB√ºttner for golfing off 1 byte!*
[Try it online!](http://cjam.tryitonline.net/#code=XTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUlXTtVKTpVU1U4YlNVIiVYImUl&input=)
### How it works
```
]                  e# Wrap the entire stack in an array.
 ;                 e# Discard the array.
  U                e# Push U (initially 0).
   ):U             e# Increment and save in U.
      S            e# Push a space.
       U8b         e# Convert U to base 8 (array of integers).
          S        e# Push a space.
           U"%X"e% e# Convert U to hexadecimal (string).
```
[Answer]
# ùîºùïäùïÑùïöùïü, 14 chars / 28 bytes
```
[‚ß∫·∏Ä,·∏Ä√ü8,·∏Ä‚ìß]√∏‚¨≠;
```
`[Try it here (Firefox only).](http://molarmanful.github.io/ESMin/interpreter.html?eval=false&input=&code=%5B%E2%A7%BA%E1%B8%80%2C%E1%B8%80%C3%9F8%2C%E1%B8%80%E2%93%A7%5D%C3%B8%E2%AC%AD%3B)`
First answer! Although there are probably better ways to handle this.
# Explanation
```
[‚ß∫·∏Ä,·∏Ä√ü8,·∏Ä‚ìß]√∏‚¨≠; // implicit: ·∏Ä = 0
[‚ß∫·∏Ä,             // increment ·∏Ä by 1
    ·∏Ä√ü8,         // octal representation of ·∏Ä
        ·∏Ä‚ìß]     // hex representation of ·∏Ä
            √∏‚¨≠; // join above array with spaces
                 // repeat as desired until implicit output
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 26 bytes
Uses [current release (6.0.0)](https://github.com/lmendo/MATL/releases/tag/6.0.0). Works on Octave.
```
0$N1+ttYUb8YAb16YA3$XhZc1$
```
### Examples
Once:
```
>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$
1 1 1
```
Twice:
```
>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
2 2 2
```
16 times:
```
>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
16 20 10
```
### Explanation
The number of elements in the stack is used to indicate how many times we've run the snippet
```
0$         % specify zero inputs for next function, in case this is not the first
           % occurence of the snippet.
N          % number of elements in stack
1+         % add one
tt         % duplicate twice. We now have three copies of the number
YU         % convert to string (decimal)
b8YA       % bubble up number and convert to octal string
b16YA      % bubble up number and convert to hex string
3$XhZc     % join top three elements (strings) with a space
1$         % specify one input for next function. If the program ends here, that next
           % function will be implicit display, so it will print the top of the stack.
           % Else the stack will be left with one element more than at the beginning of
           % the current snippet
```
[Answer]
## OCaml, 198 bytes
```
;;open Char
;;(if Sys.argv.(0).[0]='~'then Sys.argv.(0).[0]<-'\000'else Sys.argv.(0).[0]<-chr(1+int_of_char Sys.argv.(0).[0]));let n=1+int_of_char Sys.argv.(0).[0]in Printf.printf"\r%d %o %x"n n n
```
Includes a trailing newline and requires that the filename starts with a tilde (I used `~.ml`; you can run it with `ocaml \~.ml`) because it's the highest-valued standard printable ASCII character. Abuses the fact that all characters in a string are mutable and `Sys.argv.(0).[0]` is the first character in the filename. 
It should only work for n = 1 to 126, because the ASCII code for `~` is 126 and I'm adding one to the output. It could be made two bytes shorter if we only want n = 1 to 125. After it's repeated 126 times, it'll cycle back to n = 1. 
This is my first ever golf so any comments or improvements would be much appreciated.
Ungolfed version:
```
;; open Char
;; if Sys.argv.(0).[0] = '~' 
   then Sys.argv.(0).[0] <- '\000'
   else Sys.argv.(0).[0] <- chr (1 + int_of_char Sys.argv.(0).[0])
;; let n = 1 + int_of_char Sys.argv.(0).[0] in
   Printf.printf "\r%d %o %x" n n n
```
[Answer]
# [TeaScript](http://github.com/vihanb/TeaScript), ~~21~~ 20 bytes
```
[‚îºd,dT8),dT16)]j(p);
```
I should make it auto-close on `;`
[Try it online](http://vihan.org/p/TeaScript/#?code=%22%5B%2B%2Bd,dT8),dT16)%5Dj(p);%22&inputs=%5B%22%22%5D&opts=%7B%22int%22:false,%22ar%22:false,%22debug%22:false%7D)
## Explanation
`‚îº` becomes `++`
```
    // Implicit: d = 0
[   // Start array
 ++d,  // Increment d, decimal value
dT8),  // d to base 8
dT16)  // d to base 16
]j(p); // Join by spaces
    // Implicit: Output *last* expression
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 12 bytes
```
_&‚Ä∫¬•D8œÑ·πÖ$HW·πÑ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJfJuKAusKlRDjPhOG5hSRIV+G5hCIsIiIsIiJd)
[Try it Online 10 times!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJfJuKAusKlRDjPhOG5hSRIV+G5hF8m4oC6wqVEOM+E4bmFJEhX4bmEXybigLrCpUQ4z4ThuYUkSFfhuYRfJuKAusKlRDjPhOG5hSRIV+G5hF8m4oC6wqVEOM+E4bmFJEhX4bmEXybigLrCpUQ4z4ThuYUkSFfhuYRfJuKAusKlRDjPhOG5hSRIV+G5hF8m4oC6wqVEOM+E4bmFJEhX4bmEXybigLrCpUQ4z4ThuYUkSFfhuYRfJuKAusKlRDjPhOG5hSRIV+G5hCIsIiIsIiJd)
[Answer]
## Perl, 40 bytes
```
$_=<<'';printf"%d %o %x",(1+y/z//)x3;
:
```
There's a final newline behind the colon.
Treats everything after the first line as a here document and counts the `z` in it. For every further copy of the code one `z` is added. We have to add `1` to the count, because there's none for the first snippet (the one that is executed).
If additional output to stderr is allowed, we can omit the 2 single quotes `''` and can get down to 38 bytes. Without the `''` perl emits a warning about a deprecated feature.
[Answer]
# Mathematica, 76 bytes
Note that `n` should have no definitions before.
```
0;If[ValueQ@n,++n,n=1];StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]
```
Here, the behaviour of `;` is used. The snippet above is one single `CompoundExpression`, however, when a couple of snippets are put together, there is still one `CompoundExpression` as is shown below. (Some unnecessary rearrangements are made.)
```
0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]
(* 3 3 3 *)
```
So one cannot make such snippet works if writting explicit `CompoundExpression`. Also, almost everything you like can be put before the first `;` such as `E`, `Pi` or `MandelbrotSetPlot[]`,.
[Answer]
## bash, 49 bytes
File `count.bash`:
```
((++n));trap 'printf "%d %o %x\n" $n $n $n' exit;
```
...no trailing newline.
Run:
```
$ bash count.bash
1 1 1
$ cat count.bash count.bash count.bash | bash
3 3 3
$ for i in $(seq 10) ; do cat count.bash ; done | bash
10 12 a
```
[Answer]
# Python 2, 54 bytes
```
n=len(open(__file__).read())/54;print n,oct(n),hex(n)#
```
No trailing newline. Outputs in the form `1 01 0x1`.
If that's not ok, 56 bytes
```
n=len(open(__file__).read())/56;print"%d %o %x"%(n,n,n)#
```
When pasted in front of each other, the length of the file gets longer by 1 line for each time pasted. The base case starts with 2 lines so you have to subtract 1 from the line length. Computation is suppressed by the comment.
[Answer]
# Python 2.x 140 bytes
This was not meant to be an overly competitive solution, but a method that I found amusing, being for one thing, an attempt at a **multithreaded** code golf.
```
import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));
```
Keeps a counter, spawns a thread for each count and if the counter has not changed when the counters timer goes off after a completing an expensive math problem (instead of a timer to save bytes), the formatted string is printed. 
Some example configurations and their outputs:
```
import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));
Outputs 1 01 0x1 
```
and fifteen copy pastes:
```
import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;
...
Outputs 15 017 0xf 
```
[Answer]
## [Perl 5](https://www.perl.org/), 31 bytes
```
exit+printf"%d %o %x",(++$-)x3,
```
Uses the same approach as [my answer for 'I double the source, you double the output!'](https://codegolf.stackexchange.com/a/138918/9365).
[Try it online!](https://tio.run/##K0gtyjH9/z@1IrNEu6AoM68kTUk1RUE1X0G1QklHQ1tbRVezwlhnVJoG0v//AwA "Perl 5 ‚Äì Try It Online")
[Answer]
# Ruby, 35 bytes
```
1;$.+=1;$><<"#$. %1$o %1$x"%$.*-~-0
```
Each snippet increments `$.` (which starts as 0 if no files have been read), but only the last outputs anything. `*-~-0` evaluates to `*1`, meaning print the string once, but with concatenation it becomes `*-~-01`, an octal expression evaluating to 0. Since `$><<` doesn't include a trailing newline, printing the empty string means printing nothing.
[Answer]
# [APL (Dyalog APL)](https://www.dyalog.com/products.htm), 30 bytes
Requires `‚éïIO` to be `0`.
```
(+,((‚äÇ‚å∑{‚éïD,‚éïA})¬®8 16‚ä•‚ç£¬Ø1¬®‚ä¢))‚äÉ1
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70qpTIxJz89PrEgZ8EWK7_E3NTigsTkVK5HfVM9_R-1TTBYWlqSpmtx01BDW0dD41FX06Oe7dVASRcdIOFYq3lohYWCodmjrqWPehcfWm94aMWjrkWamo-6mg2XFCclF9_MdgMaYgTkA5UHBzkDyRAPz2AukPlAiUe9fRqGh6c_6t3ipgkikIUNsIubGCGLW7nmpcAdDXHqggUQGgA)
Uses a ambivalent function (both monadic or dyadic), the monadic case output the argument in decimal, octal and hexadecimal, while the dyadic case adds the left and right arguments.
More detailed explanation comming soon...
]