Eu absolutamente odeio o dígito 1. Então, preciso da sua ajuda para converter números para as "formas apropriadas".

Os números na forma correta nunca têm dois 1s seguidos. 101está bem, mas 110é horrível.

Para converter, basta pular todos os números impróprios e contar normalmente. Por exemplo...

1 -> 1
2 -> 2
...
10 -> 10
11 -> 12
12 -> 13
...
108 -> 109
109 -> 120
110 -> 121
111 -> 122

e assim por diante.

Seu programa deve pegar um número inteiro e produzi-lo na forma correta. Isso é código-golfe , então o código mais curto em bytes vence.

Burlesco , 10 bytes

{11 ~ [n!} FO

Versões mais antigas:

ro{11~[n!}f[

ro{Sh"11"~=n!}f[

Perl 5 , 34 bytes

Looping um contador e mudar o ocasional um duplo.

map{$i++;$i=~s/11/12/}1..pop;say$i

Teste

$ perl -M5.012 -e 'map{$i++;$i=~s/11/12/}1..pop;say$i' 111
$ 122

Utilitários Bash + GNU, 36

seq $1$1|grep -v 11|sed -n "$1{p;q}"

Pitão, 13 11 bytes

e.f!}`hT`ZQ

Economizou 2 bytes graças a @FryAmTheEggman.

Demonstração ao vivo e casos de teste.

Versão de 13 bytes

e.f!}"11"+ZkQ

JavaScript, 53 bytes

n=>[...Array(n*2).keys()].filter(a=>!/11/.test(a))[n]

Alternativo (usando compreensões, mesmo comprimento):

n=>[for(i of Array(n*2).keys())if(!/11/.test(i))i][n]

Python 2, 50

lambda n:[i for i in range(n*2)if'11'not in`i`][n]

Uma função anônima que lista os números que não contêm 11em ordem e aceita o nth. O erro de um por zero da indexação zero é cancelado com a inclusão de 0na lista.

Em teoria, isso falhará em números suficientemente altos onde f(n)>2*n, mas isso não deve acontecer até que nseja pelo menos 10**50.

51 bytes:

n=input();i=0
while n:i+=1;n-='11'not in`i`
print i

Conta os números iaté que a cota de nnúmeros sem 11seja atingida.

Uma função tem o mesmo comprimento devido às correções necessárias.

f=lambda n,i=0:n+1and f(n-('11'not in`i`),i+1)or~-i

Python 3 74

Ainda precisa de um pouco de golfe.

n=int(input())
c=0
for x in ' '*n:
 c+=1
 while'11'in str(c):c+=1
print(c)

É uma força bruta agora.

Perl 5, 47 bytes

@_[$_]=++$i!~/11/?$i:redo for 1..<>;print$_[-1]

JavaScript (ES6) 41

Como uma função anônima

n=>eval('for(i=0;/11/.test(++i)||n--;)i')

Nota: a maneira mais simples seria 44:

n=>{for(i=0;/11/.test(i)||n--;i++);return i}

Teste a execução do trecho abaixo.

f=n=>eval('for(i=0;/11/.test(++i)||n--;)i')

alert(f(+prompt('Enter number')))

Haskell, 51 bytes

([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!)

Exemplo de uso: ([x|x<-[0..],notElem('1','1')$zip=<<tail$show x]!!) 110-> 121.

Como funciona:

[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

MUMPS, 37 bytes

t(i) f j=1:1 s:j'[11 k=k+1 q:k=i
    q j

Bem direto. A única coisa "interessante" aqui é a construção j'[11- '[é o operador "não contém", portanto isso "abc"'["ab"é falso e "abc"'["cd"verdadeiro. Apesar de ambos os operandos dej'[11 serem números, o MUMPS permanece imperturbável. Felizmente, auto-executará ambos os operandos em seqüências de caracteres e seguirá com sua vida. Viva!

(Aliás, se você está bem com o programa nunca terminando, podemos encurtar isso para 35 bytes: t2(i) f j=1:1 s:j'[11 k=k+1 w:k=i j)

PHP, 43 bytes

while(preg_match('/11/',$i)){$i++;}print$i;

Ruby, 24 bytes

Mal interpretou a tarefa, retrabalhará mais tarde!

$><<gets.gsub('11','12')