[Question]
  [
This might be a very simple challenge, but I am surprised it hasn't been done on code-golf yet:
**Print all Integers from 1 to 10 inclusive in ascending order to standard output.**
Your output format can be whatever your language supports. This includes arbitrary separators (commas, semicolons, newlines, combinations of those, etc., but no digits), and prefixes and postfixes (like `[...]`). However, you may not output any other numbers than 1 through 10. Your program may not take any input. Standard loopholes are disallowed.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins!
# Leaderboard
```
var QUESTION_ID=86075,OVERRIDE_USER=42570;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<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="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><div id="language-list"> <h2>Winners 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><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>
```
  
[Answer]
# C, 36 bytes
```
main(i){while(printf("%d ",i++)<3);}
```
This works because the loop terminates after the first 2 digit number. 
[Answer]
# HTML, 44 bytes
```
<ol><li><li><li><li><li><li><li><li><li><li>
```
This is longer than hardcoding the output, but it is more interesting this way. It creates an ordered list (`<ol>`) with ten empty list elements (`<li>`). By default ordered lists are delimited by decimal numbers starting with 1 and a period.
HTML5 is very forgiving regarding unclosed tags, so it closes the `li` tags implicitly.
[Answer]
# Bash, 12 characters
```
echo {1..10}
```
Sample run:
```
bash-4.3$ echo {1..10}
1 2 3 4 5 6 7 8 9 10
```
### Bash + coreutils, 10 characters
(Just trying to be funny and using `': No such file or directory↵ls: cannot access '` as separator.)
```
ls {1..10}
```
Sample run:
```
bash-4.3$ ls {1..10}
ls: cannot access '1': No such file or directory
ls: cannot access '2': No such file or directory
ls: cannot access '3': No such file or directory
ls: cannot access '4': No such file or directory
ls: cannot access '5': No such file or directory
ls: cannot access '6': No such file or directory
ls: cannot access '7': No such file or directory
ls: cannot access '8': No such file or directory
ls: cannot access '9': No such file or directory
ls: cannot access '10': No such file or directory
```
### Bash + coreutils, 6 characters
(Just trying to be boring. Or not just trying…)
```
seq 10
```
Sample run:
```
bash-4.3$ seq 10
1
2
3
4
5
6
7
8
9
10
```
[Answer]
## Jelly, 2 bytes
```
⁵R
```
Explanation
```
⁵  Return the fifth command line argument or 10
 R Range
   Implicit output
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 2 bytes
Code:
```
TL
```
Explanation:
```
T   # Constant for 10
 L  # Range
```
[Try it online!](http://05ab1e.tryitonline.net/#code=VEw&input=).
[Answer]
# Brainfuck, 58 bytes
```
-[----->+>+<<]>--<+++++[<++<++>>-]<<-[->>>.+<<.<]>>>>--.-.
```
[Try it online!](http://brainfuck.tryitonline.net/#code=LVstLS0tLT4rPis8PF0-LS08KysrKytbPCsrPCsrPj4tXTw8LVstPj4-Lis8PC48XT4-Pj4tLS4tLg&input=)
[Answer]
# LOLCODE, 79 bytes
```
IM IN YR l UPPIN YR v TIL BOTH SAEM v AN 10
VISIBLE SUM OF v AN 1
IM OUTTA YR l
```
This code may need some tweaking depending on the compiler you're using. Some want you to add HAI/KTHXBYE, some want you to declare the variable ahead of time. One compiler breaks if your loop name is shorter than two characters, even though the loop name is never used.
[Answer]
# CJam, ~~6~~ 5 bytes
```
A,:)`
```
1 byte saved thanks to [Luis Mendo](https://codegolf.stackexchange.com/users/36398/luis-mendo)
Output: `[1 2 3 4 5 6 7 8 9 10]`
Explaination:
```
A,      e# Push a list from 0 to 9.
  :)    e# Increment all values.
    `   e# Stringify the list.
```
[Try it online!](http://cjam.tryitonline.net/#code=QSw6KWA&input=)
[Answer]
# R, 4 bytes
```
2:10
```
The ":" is probably one of the most used R commands. Improvement by Barranka in comments. 
[Answer]
# Ruby, 8 bytes
Separated by newlines.
```
p *1..10
```
[Answer]
# Pyth, 2 bytes
```
ST
```
First time I've used a golfing lang to answer!
Explanation:
```
S    1-indexed range. [1, 2, ... A].
 T   Variable. Initialized to 10. (Ten)
     Implicitly printed.
```
[Answer]
## JavaScript (ES6), 29 bytes
```
alert([...`${1e11/81^14}`]+0)
```
Outputs `1,2,3,4,5,6,7,8,9,10`. Not the shortest answer but I thought it was a fun calculation.
[Answer]
## Brainfuck, 41 bytes
```
+[[-<]>->>->-<-]<<[-<<+<<.+>>>>>.<]<<+.-.
```
**Output**
```
1 2 3 4 5 6 7 8 9 10
```
[Try it online](http://brainfuck.tryitonline.net/#code=K1tbLTxdPi0-Pi0-LTwtXTw8Wy08PCs8PC4rPj4-Pj4uPF08PCsuLS4).
[Answer]
# Actually, 9 Bytes
```
19`;1+`na
```
[Try it here!](http://actually.tryitonline.net/#code=MTlgOzErYG5h&input=)
Explanation:
```
19`;1+`na
1           Push 1 to stack
 9          Push 9 to stack
  `;1+`     Push Function inside ` to stack
   ;        Push top element to stack
    1+      Add 1 to top element
       n    Run function x times (9 times)
        a   Invert stack
```
[Answer]
## Mathematica - 13 bytes
```
Echo@Range@10
```
Saved 4 bytes thanks to [MartinEnder](https://codegolf.stackexchange.com/users/8478/martin-ender)!
Output: `>> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}`
[Answer]
# [DC](https://rosettacode.org/wiki/Category:Dc), 12 bytes
...a little bit mean now...
```
[zzpA>L]dsLx
```
Unrolled:
```
[   # start string constant
z   # push stack length (0 on 1st cycle)
z   # push stack length (1 on 1st cycle)
p   # print top of stack
A>L # if 10(decimal) < tos: execute L
]   # end string constant, push it
d   # duplicate the string
sL  # store a copy in L
x   # execute tos (which is the other string copy)
```
One of the `z` (push stack length) operations has no corresponding operation which takes it from the stack. This way the stack grows with each iteration by one. This is abused as the loop counter.
This loop starts with an empty stack, so the 1st `z` pushes `0` in the 1st iteration so the printing happens after the 2nd `z` which correspond to duplicating the result of `1+d` in the version below. This way the comparison needs to test for bigger than `10` here instead of `bigger than 11` below.
---
# [DC](https://rosettacode.org/wiki/Category:Dc), 14 bytes
Just straight forward...
```
1[p1+dB>L]dsLx
```
Unrolled:
```
1   # push 1
[   # start string constant
p   # print top of stack
1+  # add 1 to tos
d   # push tos (duplicate)
B>L # if 11(decimal) < tos: execute L
]   # end string constant, push it
d   # duplicate the string
sL  # store a copy in L
x   # execute tos (which is the other string copy)
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 13 bytes
```
01+:a)?;:nao!
```
Explanation :
```
01+:a)?;:nao!
0                 push initial value of n on the stack
 1+               increments n
   :              duplicates n on the stack
    a             push 10 on the stack
     )            pops n and 10 of the stack, push n>10 on the stack
      ?;          if n>10, stops program execution
        :n        duplicates n on the stack in order to display it
          ao      display 10 (x0A, linefeed)
            !     skips the next instruction, which since ><> loops is the push 0
```
You can see it in action on the [online interpreter](https://fishlanguage.com/playground).
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes
```
10:
```
[**Try it online!**](http://matl.tryitonline.net/#code=MTA6&input=)
The code generates the vector `[1 2 ... 10]` and implicitly displays it, with the numbers separated by spaces.
[Answer]
## PowerShell, 5 bytes
```
1..10
```
Creates a dynamic range with the `..` operator from `1` to `10`, then that array is left on the pipeline. Output is implicit. Default `.ToString()` method of an array is newline, so this will be newline-separated when run in a clean shell.
[Answer]
# Vim, 12 bytes
```
i1<Esc>qqYp<C-a>q8@q
```
Outputs
```
1
2
3
4
5
6
7
8
9
10
```
Explanation:
```
i1<Esc>qqYp<C-a>q8@qZZ
       qqYp<C-a>q      -- Macro q: duplicate line and increment (6)
i1<Esc>                -- Insert 1 (3)
                 8@q   -- Run macro q 8 times (3)
```
Tested on Neovim 0.1.4, which to my knowledge is keystroke-compatible with Vim.
[Answer]
# Perl 6, 12 bytes
```
say @(1..10)
```
The `@()` is needed to convert to an array
Alternative solution:
```
say @(^10+1)
```
Builds a range [0,10) then adds one, then converts to an array.
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 3 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319)
```
⍳10
```
[TryAPL online!](http://tryapl.org/?a=%u237310&run)
[Answer]
# J, 6 bytes
```
1+i.10
```
Output: `1 2 3 4 5 6 7 8 9 10`
Explaination:
```
1+       NB. Add one to...
  i.10   NB. A range from 0 to 9.
```
[Answer]
# Haskell, 17 bytes
```
main=print[1..10]
```
Outputs `[1,2,3,4,5,6,7,8,9,10]`.
[Answer]
# [MarioLANG](https://github.com/tomsmeding/MarioLANG), ~~34~~ ~~27~~ 25 bytes
```
+<
:"
+
:
+
:
+
:
+
:!
=#
```
[Try it online!](https://tio.run/##y00syszPScxL//9f24bLSolLm8sKGSty2Sr//w8A "MarioLANG – Try It Online")
Thanks to Jo King for ~~-7~~ -9 bytes!
code:
Mario falls down, incrementing and saying his number five times,
then he steps on the elevator, rides up and falls down again,
incrementing and saying his number another five times.
Then he walks left and falls out of the code.
14 bytes shorter than the easy way:
39 bytes
```
+:+:+:+:+:+:+:+:+:+
==================:
```
[Try it online!](https://tio.run/##y00syszPScxL//9f2woDctliAKv//wE "MarioLANG – Try It Online")
[Answer]
# Fuzzy Octo Guacamole, 7 bytes
```
1.25*$:
```
Multiplies `2*5`, takes the range of that and `1`, and prints the whole stack.
```
1.25*$:
1.      # Push 1 to the stack and switch stacks
  25*   # Push 10 to the stack
     $  # Push every number in the inclusive range on the top of inactive stack and top of active stack ([1,2,3,4,5,6,7,8,9,10])
      : # Print the stack, which is a list containing the numbers.
```
[Answer]
# PostScript, 12 bytes
```
1 1 10{=}for
```
Output:
```
1
2
3
4
5
6
7
8
9
10
```
(Most PostScript interpreters don't actually have a proper stdout, or even a command line, but GhostScript has both and can be used to run this program.)
[Answer]
# Java 7, ~~53~~ ~~51~~ 52 bytes (loop)
```
void l(){for(int i=0;++i<11;)System.out.println(i);}
```
Alternative **51 bytes** (hardcoded is shorter.., but considered a [default loophole](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default/1063#1063), so not allowed):
```
void h(){System.out.print("1 2 3 4 5 6 7 8 9 10");}
```
Alternative **54 bytes** (recursive):
```
int i=1;void r(){System.out.println(i);if(i++<10)r();}
```
**Ungolfed & test code for all three:**
[Try it here.](https://ideone.com/d87Zic)
```
class Main{
  static void h(){
    System.out.print("1 2 3 4 5 6 7 8 9 10");
  }      
  static void l(){
    for(int i=0; ++i < 11;){
      System.out.println(i);
    }
  }
  static int i = 1;
  static void r(){
    System.out.println(i);
    if(i++ < 10){
      r();
    }
  }
  public static void main(String[] a){
    h();
    System.out.println();
    l();
    System.out.println();
    r();
  }
}
```
---
EDIT: For funsies: As correctly pointed out by *@SkippyLeGrandGourou*, the base of the 1 to 10 isn't specified in the question, so here is (non-code-golfed) Java code that outputs 1 to 10 in the bases 2 to 10:
[Try it here.](https://ideone.com/lgTRM9)
```
BASE-2: 1 10 
BASE-3: 1 2 10 
BASE-4: 1 2 3 10 
BASE-5: 1 2 3 4 10 
BASE-6: 1 2 3 4 5 10 
BASE-7: 1 2 3 4 5 6 10 
BASE-8: 1 2 3 4 5 6 7 10 
BASE-9: 1 2 3 4 5 6 7 8 10 
BASE-10: 1 2 3 4 5 6 7 8 9 10 
```
[Answer]
# [Aussie++](https://github.com/zackradisic/aussieplusplus/), output to STDERR, ~~29~~ 28 bytes
It turns out that causing errors is shorter than any straightforward way of doing it.
```
G'DAY MATE! 1 2
4
6
8
_
```
Tested in commit 9522366. The trailing newline is required. Produces the following errors:
```
[line 1] OI MATE! EXPECTED ; BUT GOT '2'
[line 3] OI MATE! EXPECTED ; BUT GOT '4'
[line 5] OI MATE! EXPECTED ; BUT GOT '6'
[line 7] OI MATE! EXPECTED ; BUT GOT '8'
[line 9] OI MATE! EXPECTED ; BUT GOT '_'
[line 10] OI MATE! EXPECTED ; BUT GOT 'EOF'
```
Maybe I misinterpreted the challenge, but it didn't specify that you had to use the same separator for all numbers.
## Aussie++, output to STDERR with consistent separator, 30 bytes
```
G'DAY MATE!;
;
;
;
;
;
;
;
;
;
```
No trailing newline is required. Produces the following errors:
```
[line 1] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 2] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 3] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 4] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 5] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 6] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 7] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 8] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 9] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 10] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
```
## Aussie++, output to STDOUT, 41 bytes
```
G'DAY MATE!
GIMME "1 2 3 4 5 6 7 8 9 10";
```
Again, no trailing newline is required.
[Answer]
## [Retina](https://github.com/m-ender/retina), 13 bytes
I've got two solutions at this byte count, but it doesn't seem optimal:
```
_10$*
1
$.`_
```
```
11$*_
\B
$.`
```
They both use `_` as separators, prefix and suffix.
[Try the first online!](http://retina.tryitonline.net/#code=Cl8xMCQqCjEKJC5gXw&input=) [Or try the other one!](http://retina.tryitonline.net/#code=CjExJCpfClxCCiQuYA&input=)
]