[Question]
  [
The Champernowne constant is a number that is constructed by concatenating the first `n` numbers, with `n` tending to infinity. It looks something like this:
```
0.123456789101112131415161718192021222324252627282930...
```
Now, I will describe to you the *Rien* number. It can be thought of as a minimization of the Champernowne constant as an integer. I will refer to the *Rien* number with the first `n` digits as Ri(*n*). This is how to formulate it: 
1. The first `n` natural numbers (the sequence {1,2,3,...}) are concatenated.
2. This result is then sorted, according to the digit value. So `1..12` would look like `011111223456789`.
3. Since the *Rien* number cannot have leading zeroes, we move all `0`s so that they are significant, whilst keeping the number minimized, resulting in, say, `101111223456789`. This is Ri(*n*), in this case, Ri(12).
Here are some results for Ri(*n*):
```
*n*    Ri(*n*)
1    1
2    12
3    123
7    1234567
9    123456789
10   10123456789
15   101111111223344556789
34   10001111111111111222222222222223333333334444555666777888999
42   100001111111111111122222222222222233333333333333444444455556666777788889999
45   100001111111111111122222222222222233333333333333344444444444555556666777788889999
55   10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999
100  100000000000111111111111111111112222222222222222222233333333333333333333444444444444444444445555555555555555555566666666666666666666777777777777777777778888888888888888888899999999999999999999
999  100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
```
**Objective** Given a number 1 ≤ `n` < 10000 as input (via arguments, STDIN, or hardcoding if your language does not support conventional input), output/return Ri(`n`).
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins. You may use a language that was made after this contest, as long as it was not made for answering this challenge. (Of course, you *can* use it, if it provides an interesting solution, but mark your answer as non-competing.)
# Reference implementation
I tested this in IE, so there really shouldn't be a problem. If there *is* a problem, there's an easy solution: get a sane browser.
```
function min(n) {
  var seq = [];
  for(var i = 1; i <= n; i++) seq.push(i);
  seq = seq.join("").split("").map(Number);
  var to;
  if(seq.indexOf(1) >= 0) to = seq.splice(seq.indexOf(1), 1);
  seq.sort(function(a, b) {
    return a - b;
  });
  if(to) seq = to.concat(seq);
  return seq.join("");
}
t.onchange = t.onkeyup = function() {
  h.innerHTML = min(this.value)
}
```
```
* {
  font-family: Consolas, monospace;
}
input {
  border: 2px dotted #aaaaaa;
  border-radius: 5px;
  margin: 10px;
}
```
```
<input id="t" type="number">
<div id="h">
```
---
## Leaderboard
The Stack Snippet at the bottom of this post generates the catalog 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
```
```
var QUESTION_ID=68685,OVERRIDE_USER=44713;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]
## Perl, ~~44~~ ~~42~~ ~~41~~ ~~33~~ 31 bytes
Yaaay, first post ever !
Thanks to primo for the 2 bytes save.
```
print 1,sort"@{[2..<>]}"=~/\d/g
```
As others did, removing 1 and prepending it manually does the work.
[Try it online](https://ideone.com/7dWSKk)
[Answer]
# Pyth, 8
```
+1SjktSQ
```
Makes a list `[1, .. , input]` then removes the leading one, joins and sorts, then prepends a 1.
[Test Suite](http://pyth.herokuapp.com/?code=%2B1SjktSQ&input=20&test_suite=1&test_suite_input=1%0A2%0A3%0A7%0A9%0A10%0A15%0A34%0A42%0A45%0A55%0A100%0A999&debug=0)
[Answer]
# Japt, ~~14~~ 12 bytes
```
1+2o°U ¬¬n ¬
```
[Try it online!](http://ethproductions.github.io/japt?v=master&code=MSsyb7BVIKysbiCs&input=MTAw)
### How it works
```
1+2o°U ¬¬n ¬  // Implicit: U = input integer
  2o°U        // Generate the range of integers from 2 to U, inclusive.
       ¬¬     // Join, then split into chars.
         n    // Sort.
1+         ¬  // Join again, and add a 1 to the beginning.
              // Implicit: output last expression
```
[Answer]
## [Retina](https://github.com/mbuettner/retina), 78 bytes
Time to show off some new Retina features (it's still not very competitive, but before today this would probably have been closer to 300 bytes).
```
.+
$0$*1
\B
 $`
(1)+
$#1
^1| 
.
 1$0$*1
+r`(1+\2) (1+)\b
$2 $1
 1(1)*
$#1
^
1
```
[Try it online.](http://retina.tryitonline.net/#code=LisKJDAkKjEKXEIKICRgCigxKSsKJCMxCl4xfCAKCi4KIDEkMCQqMQorcmAoMStcMikgKDErKVxiCiQyICQxCiAxKDEpKgokIzEKXgox&input=MTU)
### Explanation
While it's possible to convert between decimal and unary quite conveniently now, this is still quite long because I have to convert back and forth several times because some operations are more doable in decimal than in unary and vice-versa.
```
.+
$0$*1
```
Let's start by converting the input to unary. This works by matching the input and then using `$*1` which repeats `1` that many times (this repetition feature is new as of today).
```
\B
 $`
```
Next, we generate a range from `1` to `N` in unary. I've explained why this works [in my FizzBuzz answer](https://codegolf.stackexchange.com/a/58682/8478).
```
(1)+
$#1
```
We convert each number in the range back to decimal so we can work with the decimal digits. This is done by matching each of the unary numbers such that each `1` generates a separate capture. Then we replace that with the number of captures of group one, using the new capture count syntax `$#1`.
```
^1| 
```
This removes the leading `1` as well as all spaces from the string so we're left with only the digits (except for a single `1`).
```
.
 1$0$*1
```
We convert back to unary and add `1` to each digit (to ensure that even `0` is a non-empty). We also insert a space in front of each digit to ensure that they are separated.
```
+r`(1+\2) (1+)\b
$2 $1
```
We repeatedly match a small number preceded by a larger number and swap them. That's bubble sort in Retina. :)
```
 1(1)*
$#1
```
Aaaand back to decimal.
```
^
1
```
Finally, we insert a single `1` at the front to account for the one we've removed earlier.
[Answer]
## Haskell, 44 bytes
```
import Data.List
f n='1':sort(show=<<[2..n])
```
Unfortunately `sort` is in `Data.List`, that's 17 bytes!
[Answer]
# JavaScript (ES6), ~~65~~ ~~62~~ ~~54~~ 52 bytes
*Saved 3 bytes thanks to edc65*
```
x=>eval("for(b='';x>1;)1+[...b+=x--].sort().join``")
```
Builds a string of all numbers from 2 to `x`, then splits, sorts, joins, and adds a 1 to the beginning. This may still be golfable; suggestions welcome!
[Answer]
# CJam, 9
```
1qi),2>s$
```
[Try it online](http://cjam.aditsu.net/#code=1qi)%2C2%3Es%24&input=10)
Alternatively:
```
qi,:)(\s$
```
[Answer]
# APL (17)
```
'1',∆[⍋∆←1↓∊⍕¨⍳⎕]
```
Explanation:
```
'1',∆[⍋∆←1↓∊⍕¨⍳⎕]
-----------------
               ⎕   read a number from the keyboard
               ⍳    get the natural numbers up to and including that number
             ⍕¨    get the string representation for each number
           ∊       flatten the array (giving a string of digits)
         1↓        remove the first digit (which is always 1)
       ∆←          store the result in ∆
      ⍋            get a permutation to sort ∆ upwards
    ∆[           ] rearrange ∆ so that it is sorted
'1',               add a 1 to the front
```
Test:
```
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      1
1
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      10
10123456789
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      55
10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999
```
[Answer]
# Mathematica, 52 bytes
```
"1"<>ToString/@Sort[Join@@IntegerDigits[2~Range~#]]&
```
Once again, string processing happened...
[Answer]
# Bash, ~~35~~ 34 bytes
```
printf %d 1`seq 2 $1|fold -1|sort`
```
This builds on the answers of [@DigitalTrauma](https://codegolf.stackexchange.com/a/68693) and [@OlivierDulac](https://codegolf.stackexchange.com/a/68897). Try it online with [Ideone](http://ideone.com/o1EiiM).
### How it works
* `seq 2 $1` prints all integers from **2** to the one specified on the command line.
* `fold -1` wraps all lines with width 1, i.e., places each character on its own line.
`-1` seems to be an undocumented feature.
* `sort` sorts the characters by their numeric value.
* `printf %d 1`...`​` prepends a **1** to the first line and prints each line as an integer (`%d`), with no separation.
This takes advantage of Bash's curious printf implementation, which repeats the format string over and over, until all arguments are consumed.
[Answer]
# Bash + GNU utilities, 58
```
seq $1|sed 's/./&\n/g'|sort|tr -d \\n|sed 's/\(0*\)1/1\1/'
```
[Try it online.](https://ideone.com/YqHlmg)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
RDFṢ1œ|Ḍ
```
[Try it online!](http://jelly.tryitonline.net/#code=UkRG4bmiMcWTfOG4jA&input=&args=MTU)
### How it works
```
RDFṢ1œ|Ḍ  Main link. Argument: n (integer)
R         Range; yield r := [1, ..., n].
 D        Convert each k in r into the array of its digits in base 10.
  F       Flatten the resulting array of lists.
   Ṣ      Sort the resulting flat list of digits.
    1œ|   Perform multiset union with 1 as left argument.
          This moves a single 1 to the beginning of the list.
       Ḍ  Convert the resulting list of base 10 to integer.
```
[Answer]
# JavaScript ES6, ~~49~~ 46 Bytes
Thanks to edc65 for 2 bytes
```
F=
x=>1+[...(g=_=>x>1?x--+g``:_)``].sort().join``
;console.log(F(15))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ḊVṢ1;Ḍ
```
[Try it online!](https://tio.run/##y0rNyan8///hjq6whzsXGVo/3NHz//9/Q1MA "Jelly – Try It Online")
-1 thanks to Unrelated String
```
Ḋ      # Dequeue (Remove head from implicit range)
 V     # Eval (Jelly stringifies each, concatenates & evals, which does exactly what I want)
  Ṣ    # Sort
   1;  # Prepend a 1
     Ḍ # Decimalify, convert into base-10 number
```
[Answer]
## Python 2, 60 bytes
```
_="".join;print"1"+_(sorted(_(map(str,range(2,input()+1)))))
```
[Answer]
# ClojureScript, 48 bytes
```
#(apply str"1"(sort(apply str(range 2(inc %)))))
```
Same as all of the others, pretty much. REPL available [here](http://clojurescript.net/).
[Answer]
# Ruby, 48 bytes
An anonymous function. Basically just Rubyfied some of the other answers here..
```
->n{n>1?(?1+[*2..n].join.chars.sort*'').to_i: n}
```
[Answer]
# [Milky Way 1.6.4](https://github.com/zachgates7/Milky-Way), 22 bytes (not competing)
```
^^'LH=^^JB", "-Q"1";+!
```
I had to add a sorting opcode for this challenge.
---
### Explanation
```
^^                      ` pop the TOS
  '                     ` read input from the command line
   LH                   ` push a reversed Pythonic range(TOS+1)
     =^^J               ` remove the top 2 items from the TOS
         B              ` push the string literal of the TOS
          ", "-         ` remove ", " from the TOS
               Q        ` sort the TOS
                "1";+   ` add "1" to the beginning of the TOS
                     !  ` output the TOS
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~76~~ 41 bytes
```
1 .;{,1:.e?}?:1fcbZlL,ZoOlM,10^(L-M)=:Oc.
```
Takes a number as input.
This solution works with the few changes I made to the built-in Findall predicate `f`. OP is apparently OK with using languages older than the answer so I think this is fine (the changes I made were intented a long time ago, I just motivated myself to do it because of this challenge).
### Explanation
```
1 .                                            § If the input is 1, unify output with 1
   ;                                           § Else
    {      }?:1f                               § Output a list of all inputs which satisfy
                                               § the predicate in brackets with the input
                                               § of the main predicate (ie the input number)
                                               § as output
     ,1:.e?                                    § True if the input is an integer between 1
                                               § and . (the output)
                cbZ                            § Concatenate everything into a single number,
                                               § remove the first digit (1) and call it Z
                   lL,ZoOlM,                   § L is the length of Z, M is the length of O
                                               § O being Z sorted (which removes the leading
                                               § 0s)
                            10^(L-M)=:Oc.      § Concatenate 10^(L-M) at the beginning of O
                                               § and unify it with the output
```
[Answer]
## Smalltalk, 76 bytes
As usual in Smalltalk, conceptually very terse, but textually very verbose...
```
f:l^'1',((2to:l)fold:[:p :q|p asString,q asString])asByteArray sort asString
```
Add this as a class method for `String` and call like this, e.g. for 20, `String f: 20`
[Answer]
# Bash and GNU tools, ~~58~~ 52 bytes
```
echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)
```
[Answer]
## PowerShell, ~~61~~ 59 bytes
```
param($a)(("1"+-join([char[]]-join(2..$a)|sort)),1)[$a-eq1]
```
Takes input `param($a)` and then uses it to index into an array with `[$a-eq1]`. If true, we index the second element and output `1`. Otherwise, we concatenate `"1"` with the `join`ed array created by 1) defining a new range `2..$a` that has been itself `join`ed together, 2) casting that as a char-array, and 3) sending it through the `Sort-Object` cmdlet, all of which is then output.
Edit1 -- Saved 2 bytes by moving the inner `-join` operator.
[Answer]
# [Gogh](https://github.com/zachgates7/Gogh), ~~9~~ 7 bytes
```
GJT1-1P
```
You can run this using:
```
$ ./gogh noi 'GJT1-1P' <input>
```
---
```
G     “ Push a range (1, TOS]       ”
J     “ Join the TOS                ”
T     “ Sort the TOS                ”
1-    “ Remove the first 1          ”
P     “ Prepend the TOS to the STOS ”
```
[Answer]
# Oracle SQL 11.2, ~~222~~ 211 bytes
```
SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))FROM(SELECT SUBSTR(s,LEVEL+2,1)c FROM(SELECT MAX(sys_connect_by_path(LEVEL,' '))s FROM DUAL CONNECT BY LEVEL<=:1)CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1);
```
Un-golfed
```
SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))  -- add leading 1, concatenate each char and remove spaces
FROM   (
         SELECT SUBSTR(s,LEVEL+2,1)c                          -- split the string in characters, omiting the first number (1)   
         FROM   (
                  SELECT MAX(sys_connect_by_path(LEVEL,' '))s -- create a string by concatenating numbers
                  FROM   DUAL 
                  CONNECT BY LEVEL<=:1
                )
         CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1
       )
```
[Answer]
## [MATL](https://esolangs.org/wiki/MATL), 17 bytes
Uses [current version (7.0.0)](https://github.com/lmendo/MATL/releases) of language/compiler.
```
49[]i:"@YUh]6L)Sh
```
Inspired by [FryTheEgggman's answer](https://codegolf.stackexchange.com/a/68692/36398).
*EDIT (July 29, 2016): You can [try it online](http://matl.tryitonline.net/#code=NDlbXWk6IkBWaF00TClTaA&input=MTI) with some modifications to conform to changes in the language.*
### Example
```
>> matl
 > 49[]i:"@YUh]6L)Sh
 >
> 12
101111223456789
```
### Explanation
```
49        % push '1'
[]        % push empty array
i:        % input "N" and build vector [1, 2, ... N]
"         % for each number in this vector
   @      % push that number
   YU     % convert to string
   h      % concatenate horizontally
]         % end
6L)       % remove first element
S         % sort
h         % concatenate horizontally
```
[Answer]
# TI-Basic, 77 bytes
```
Input N
{0
For(I,2,N
augment(Ans,int(10fPart(I/seq(₁₀^(J),J,1,1+int(log(I
End
Ans→A
SortD(ʟA
1→ʟA(dim(ʟA
.1sum(seq(₁₀^(I)ʟA(I),I,1,dim(ʟA
```
Output is stored in `Ans` as a number and is displayed. Does not work for inputs that are 55 and above because of overflow errors.
---
### 87 bytes
```
Input N
{0
For(I,2,N
augment(Ans,int(10fPart(I/seq(₁₀^(J),J,1,1+int(log(I
End
Ans→A
SortA(ʟA
"1
For(I,2,dim(ʟA
Ans+sub("0123456789",ʟA(I)+1,1
End
```
Output is stored in `Ans` as a string. Works with higher inputs than the above method could, depending on how much free RAM there is. `sub("0123456789",ʟA(I)+1,1` can be replaced with `toString(ʟA(I` to save 18 bytes if it is run on a TI-84+ CE OS 5.2+.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `R`, 4 bytes
```
ḣṅs+
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJSIiwiIiwi4bij4bmFcysiLCIiLCIxMCJd) -2 thanks to Lyxal.
```
ḣ    # Implicitly convert to [1...n], then push 1 and [2...n]
 ṅ   # Concatenate [2...n] into a string
  s  # Sort
   + # Prepend the 1 from before
```
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 8 bytes
```
RtƊjo1cɗ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHFZtJJurlLsgqWlJWm6FquCSo51ZeUbJp-cvqQ4KbkYKrxgqyGXEZcxlzmXJZehAZehKZexCZeJEUQSAA)
```
RtƊjo1cɗ
R           Range [1, input]
 t          Tail; remove the first element
  Ɗ         Convert to lists of decimal digits
   j        Join
    o       Sort
     1c     Prepend 1
       ɗ    Convert from a list of decimal digits
```
[Answer]
# Julia, 33 bytes
```
n->"1"*join(sort([join(2:n)...]))
```
This is a lambda function that accepts an integer and returns a string. To call it, assign it to a variable.
We construct the range `2:n`, which will be empty for `n` < 2, join it into a string, splat the string into an array of characters, sort them, join it into a string, and prepend 1.
[Answer]
# APL, 21 bytes
```
{' '~⍨⍕1,x[⍋x←⍕1↓⍳⍵]}
```
This is an unnamed monadic function that accepts an integer on the right and returns a string. To call it, assign it to a variable.
Explanation:
```
            x←⍕1↓⍳⍵]}   ⍝ Get the numbers 1:input, drop 1, convert to string
         x[⍋            ⍝ Sort
      ⍕1,               ⍝ Tack 1 onto the front, flatten to string
{' '~⍨                  ⍝ Remove the spaces (side effect of ⍕ on an array)
```
[Try it online](http://tryapl.org/?a=R%u2190%7B%27%20%27%7E%u2368%u23551%2Cx%5B%u234Bx%u2190%u23551%u2193%u2373%u2375%5D%7D%20%u22C4%20R%201%20%u22C4%20R%2010&run)
]