[Question]
  [
I absolutely hate the digit `1`. So, I need your help to convert numbers to their "proper forms".
Numbers in proper form never have two `1`s in a row. `101` is okay, but `110` is hideous.
To convert, simply skip all the improper numbers and count normally. For instance...
```
1 -> 1
2 -> 2
...
10 -> 10
11 -> 12
12 -> 13
...
108 -> 109
109 -> 120
110 -> 121
111 -> 122
```
and so on.
Your program should take an integer and output it in proper form. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in bytes wins.
  
[Answer]
# Bash + GNU utils, 36
```
seq $1$1|grep -v 11|sed -n "$1{p;q}"
```
[Try it Online](https://tio.run/##S0oszvj/vzi1UEHFUMWwJr0otUBBt0zB0LCmODVFQTdPQUnFsLrAurBW6f///4YgAAA)
[Answer]
## [Burlesque](http://mroman.ch/burlesque), 10 bytes
[{11~[n!}FO](http://104.167.104.168/~burlesque/burlesque.cgi?q=150%7B11~[n!%7DFO)
Older versions:
```
ro{11~[n!}f[
ro{Sh"11"~=n!}f[
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
1w11¬$#Ṫ
```
[Try it online!](https://tio.run/##y0rNyan8/9@w3NDw0BoV5Yc7V/3/b2RgAAA "Jelly – Try It Online")
Almost entirely printable ASCII! Takes input from STDIN
## How it works
```
1w11¬$#Ṫ - Main link. No arguments
     $   - Group the previous 2 links into a monad f(k):
  11     -   Yield 11
 w       -   Yield 1 if 11 is a sublist of k's digit else 0
    ¬    -   Map 1 to 0 and 0 to 1
1     #  - Count up k = 1, 2, 3, ... until n integers return true under f(k)
       Ṫ - Return the last k
```
---
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
²wÐḟ11ị@
```
[Try it online!](https://tio.run/##ASIA3f9qZWxsef//wrJ3w5DhuJ8xMeG7i0D/MjAwO8OHJOKCrEf/ "Jelly – Try It Online")
An alternate approach, still only 8 bytes though. Relies on the assumption that the output is always less than the square of the input
## How it works
```
²wÐḟ11ị@ - Main link. Takes n on the left
²        - n²
  Ðḟ     - Filter-false the range [1, 2, ..., n²] on:
    11   -   11
 w       -   Is a sublist of the digits
      ị@ - Take the n'th value in this list
```
[Answer]
# JavaScript, 53 bytes
```
n=>[...Array(n*2).keys()].filter(a=>!/11/.test(a))[n]
```
Alternate (using comprehensions, same length):
```
n=>[for(i of Array(n*2).keys())if(!/11/.test(i))i][n]
```
[Answer]
# [Perl 5](http://dev.perl.org/perl5/), 34 Bytes
Looping a counter and changing the occasional double-one.
```
map{$i++;$i=~s/11/12/}1..pop;say$i
```
### Test
```
$ perl -M5.012 -e 'map{$i++;$i=~s/11/12/}1..pop;say$i' 111
$ 122
```
[Answer]
## Python 2, 50
```
lambda n:[i for i in range(n*2)if'11'not in`i`][n]
```
An anonymous function that lists the numbers not containing `11` in order, and takes the `n`th one. The off-by-one error of zero-indexing cancels with the inclusion of `0` in the list.
In theory, this will fail for sufficiently high numbers where `f(n)>2*n`, but this shouldn't happen until `n` is at least `10**50`. 
---
51 bytes:
```
n=input();i=0
while n:i+=1;n-='11'not in`i`
print i
```
Counts up numbers `i` until the quota of `n` numbers without `11` is met.
A function is the same length because of the off-by-one corrections needed.
```
f=lambda n,i=0:n+1and f(n-('11'not in`i`),i+1)or~-i
```
[Answer]
# Pyth, ~~13~~ 11 bytes
```
e.f!}`hT`ZQ
```
Saved 2 bytes thanks to @FryAmTheEggman.
[Live demo and test cases.](https://pyth.herokuapp.com/?code=e.f%21%7D%60hT%60ZQ&test_suite=1&test_suite_input=1%0A2%0A10%0A11%0A12%0A108%0A109%0A110%0A111&debug=1)
## 13-byte version
```
e.f!}"11"+ZkQ
```
[Answer]
# Python 3 74
Still need a bit of golfing.
```
n=int(input())
c=0
for x in ' '*n:
 c+=1
 while'11'in str(c):c+=1
print(c)
```
It's pretty brute force right now.
[Answer]
# JavaScript (ES6) 43 bytes
As an anonymous function
```
n=>eval('for(i=0;/11/.test(i)||n--;i++);i')
```
Note: the very simplest way would be 44:
```
n=>{for(i=0;/11/.test(i)||n--;i++);return i}
```
Test running the snippet below.
```
f=n=>eval('for(i=0;/11/.test(i)||n--;i++);i')
var o='',v=0,r,c;
for(r=0;r<30;r++)
{
  o += '<tr>';
  for(c=0;c<10;c++)
  {
  
    o += '<td>' +v + '⇨' + f(v) + '</td>';
    v++;
  }
  o += '</tr>'
}
O.innerHTML=o
```
```
<table id=O style='font-size:80%'></table>
```
[Answer]
# Haskell, 51 bytes
```
([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!)
```
Usage example: `([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!) 110` -> `121`.
How it works:
```
[x|x<-[0..]                                   ]    -- take all x starting with 0
           ,                                       -- where
                   ('1','1')                       -- the pair of two chars '1'
            notElem                                -- is not part of
                             zip=<<tail            -- the list of pairs of neighbor elements of
                                        show x     -- the string representation of x
                                               !!  -- take nth element, where n is the parameter
```
[Answer]
# MUMPS, 37 bytes
```
t(i) f j=1:1 s:j'[11 k=k+1 q:k=i
    q j
```
Pretty straightforward. The only "interesting" thing here is the construct `j'[11` - `'[` is the "does not contain" operator, so that `"abc"'["ab"` is false and `"abc"'["cd"` is true. Despite both operands of `j'[11` being numbers, MUMPS remains unperturbed. It will happily autocoerce both operands to strings and move on with its life. Hooray!
(Incidentally, if you're okay with the program never terminating, we can shorten this to 35 bytes: `t2(i) f j=1:1 s:j'[11 k=k+1 w:k=i j`)
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 15 bytes
```
∧{ℕ₁≜¬s11&}ᶠ↖?t
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFSu9qhtw6Ompoe7Omsfbp3w/1HH8upHLVMfNTU@6pxzaE2xoaFa7cNtCx61TbMv@f8/2lDHSMfQQMfQUMcQxLAAYksgDyRiGAsA "Brachylog – Try It Online")
```
∧{ℕ₁≜¬s11&}ᶠ↖?t
∧{ …      }ᶠ↖?t get the N'th output from …
  ℕ₁≜             try a number, starting with 1
     ¬s11         doesn't contain 11
         &        output that number
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), ~~29~~ ~~24~~ 18 bytes
```
~0\{{).`11`?)}do}*
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v84gprpaUy/B0DDBXrM2Jb9W6/9/Q0NDAA "GolfScript – Try It Online")
This is my first code golf, so this is probably the least effecient way of doing things
-5 bytes by not being dumb and using the increment symbol as well as just keeping the input on the stack and decrementing instead of wasting space saving it as a variable and comparing it, probably more things I could save on
-6 bytes the loop is fixed size and I don't need the input after the loop so I can just use repeat
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
µN11å≠
```
-1 byte switching to the legacy version of 05AB1E, where the index is output implicitly after a while-loop `µ`. In the new 05AB1E version we have to push the `N` explicitly, and it'll output the top of the stack after the while-loop instead (so the `N` would be `NN` or `ND`).
[Try it online](https://tio.run/##MzBNTDJM/f//0FY/Q8PDSx91Lvj/39DQAAA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9Waa@k8KhtkoKS/bntfodX@P8/tNXP0PDw0kedC/7X@un8jzbUMdIxNNAxNNQxBDEsgNgSyAOJGIKwoWEsAA).
**Explanation:**
```
µ       # Loop until the counter_variable is equal to the (implicit) input-integer:
        # (the counter_variable is 0 by default)
 N11å   #  Check if the 0-based loop-index `N` contains 11 as substring
     ≠  #  Invert this boolean (1→0; 0→1)
        #  (implicitly pop the top of the stack, and increase the counter_variable by
        #  1 if it's truthy)
        # (after which the index `N` is output implicitly as result)
```
[Answer]
## Perl 5, 47 bytes
```
@_[$_]=++$i!~/11/?$i:redo for 1..<>;print$_[-1]
```
[Answer]
# PHP, 43 bytes
```
while(preg_match('/11/',$i)){$i++;}print$i;
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 25 bytes
```
$\++while$\=~/11/||$_--}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lRlu7PCMzJ1UlxrZO39BQv6ZGJV5Xt7b6/39DA4t/@QUlmfl5xf91CwA "Perl 5 – Try It Online")
[Answer]
# [Raku](http://raku.org/), 24 bytes
```
{grep(?1^/11/,^∞)[$_]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Or0otUDD3jBO39BQXyfuUcc8zWiV@Nja/8WJlQq5iQVAVToKNoYKRgrGCoYGCoaGCoZGQIYFEFsCeSARQ7v/AA "Perl 6 – Try It Online")
`grep(..., ^∞)` filters the numbers from zero to infinity according to the given test object, and `[$_]` indexes into that sequence with the function argument, returning the number at that index.
`/11/` matches any number whose decimal representation contains two consecutive one digits. The sense of the match can be inverted by writing `True ^ /11/`, where `^` creates an exclusive-or junction matcher that succeeds only if exactly one of its operands succeeds. `True` will always succeed, so the overall junction can only succeed if the `/11/` fails. Finally, `True` can be expressed more concisely as `?1`, that is, `1` coerced to a Boolean.
`none(/11/)` also works as a matcher, but is longer.
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~11~~ 10 bytes
*Edit: -1 byte thanks to Razetime*
```
!fö¬€ḋ3QdN
```
[Try it online!](https://tio.run/##ASIA3f9odXNr/23igoHhuKMyMDD/IWbDtsKs4oKs4biLM1FkTv// "Husk – Try It Online")
Finds index of input among natural numbers filtered to exclude those with digit-sublists that include `[1,1]`.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 33 bytes
```
{for(;$1;)$1-=!index(++b,11)}$0=b
```
[Try it online!](https://tio.run/##SyzP/v@/Oi2/SMNaxdBaU8VQ11YxMy8ltUJDWztJx9BQs1bFwDbp/39DA0sA "AWK – Try It Online")
It works by running a loop that increments a counter blindly each iteration, but only decrements the control variable if the blind counter does NOT include the string 11. Once the loop exits, the blind counter is printed as the answer.
```
 {                            }     - code block run for each input line
  for(;$1;)                         - loop until $1 is 0
           $1-=!index(   ,11)       - decrement $1 if "b" doesn't include "11"
                      ++b           - blindly increment a counter
                               $0=b - set $0 to blind count, prints automatically
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~9~~ 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
È¥srB}iU
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=yKVzckJ9aVU&input=MTA5)
[Answer]
# [Julia 1.0](http://julialang.org/), ~~44~~ 42 bytes
```
x->(r=1:9x)[.!occursin.("11",repr.(r))][x]
```
[Try it online!](https://tio.run/##PY5BDoIwEEXX9hRjV9NYCYMbMSkXaVgYhKSEFFLFcBDjytN5EaSUOpv5f@bNz7RjZ640zQ0omKdjgU7RJZ@ETvZ9VY3ubmyCnIhLVw8uQSdEqadyZs/aGX@EDJYiUAWQXHXmdRY0pesi3VzA4m4F6RTJc0Dz6PMA/29DVEbRb2FLmmCs6R2gka0AY2H9je0GZ@yjs6j59/MGLmHpL@ClxgaNUKoVByolGJ/jJ4LV9jb/AA "Julia 1.0 – Try It Online")
[Answer]
# Python 3, 64 bytes
```
[print(e) for e in map(str,range(int(input())+1))if not'11'in e]
```
[Try it online!](https://tio.run/##FcoxDoAwCADAr7AVokvtc4xDB6oM0gZx8PWo8914/OhaItZhoo5M0LoBgyicdeDlNlvVnfFX0XE7Ek2ZSBpo95Rz@ipvEXkpLw)
[Answer]
# [Java (JDK)](http://jdk.java.net/), 76 bytes
```
p->{int c=1,s=0;while((c+s+"").indexOf("11")>=0&&++s>0||c++<p);return p+s;};
```
[Try it online!](https://tio.run/##XY6xbsMgFEVn@ysQQwSiQXZXgqWOnTJYnaoOxHbSRzEgeE5jJf5211k7XV3p6txjzdXsbf@zwhhDQmK3LicEJ8@T7xCCl@8eP7xJ8zEOyWBIqiw7Z3ImrfH9KdzIvSzidHLQkYwGt7gG6MlowLMWE/jL5xcx6ZL5c1n8xxEgeo375g4eSafrl6wr9fsNbmCsE1lQyiX4frgdz4zWNeWNrnY7IXJTPR6dEIfIVRpwSp5EkdWi1nNI7Amzulb2oOvXSlkh@PZdtHPGYZRhQhk3M3SeWUEJFSBNjG5@y5ses5yrsljKZf0D "Java (JDK) – Try It Online")
How it works:
Lambda function obviously, but mostly it uses short-circuit logic in the while loop boolean to increment the appropriate counter keeping track of the cumulative shift for each input and returning the input plus that shift.
[Answer]
# Excel, 64 bytes
```
=LET(x,SEQUENCE(2^20),INDEX(FILTER(x,ISERROR(FIND("11",x))),I7))
```
Works up to 1,000,579 -> 1,048,576
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 11 bytes
```
LaW11N Ui_i
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ILNgwYKlpSVpuharfRLDDQ39tLUz4zMhIlCJpdGGBpaxUA4A)
### Explanation
```
             i is 0; a is first command-line argument (implicit)
La           Loop (a) times:
  W           Loop while
   11N        11 is a substring of
       Ui     i, incremented:
         _     No-op
          i  Once the loop completes, output i
```
]