Absolutamente odio el dígito 1. Por lo tanto, necesito su ayuda para convertir los números a sus "formas adecuadas".

Los números en forma adecuada nunca tienen dos 1s seguidos. 101Está bien, pero 110es horrible.

Para convertir, simplemente omita todos los números impropios y cuente normalmente. Por ejemplo...

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

y así.

Su programa debe tomar un número entero y generarlo en forma adecuada. Este es el código de golf , por lo que gana el código más corto en bytes.

Burlesque , 10 bytes

{11 ~ [n!} FO

Versiones anteriores:

ro{11~[n!}f[

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

Perl 5 , 34 bytes

Colocando un contador y cambiando el doble de vez en cuando.

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

Prueba

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

Bash + GNU utils, 36

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

Pyth, 13 11 bytes

e.f!}`hT`ZQ

Guardado 2 bytes gracias a @FryAmTheEggman.

Demostración en vivo y casos de prueba.

Versión de 13 bytes

e.f!}"11"+ZkQ

JavaScript, 53 bytes

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

Alternativo (usando comprensiones, misma longitud):

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

Pitón 2, 50

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

Una función anónima que enumera los números que no contienen 11en orden, y toma el nnúmero uno. El error off-by-one de indexación cero se cancela con la inclusión de 0en la lista.

En teoría, esto fallará para números suficientemente altos donde f(n)>2*n, pero esto no debería suceder hasta que nsea ​​al menos 10**50.

51 bytes:

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

Cuenta los números ihasta que se cumpla la cuota de nnúmeros sin 11.

Una función tiene la misma longitud debido a las correcciones off-by-one necesarias.

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

Python 3 74

Todavía necesito un poco de golf.

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

Es bastante fuerza bruta en este momento.

Perl 5, 47 bytes

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

JavaScript (ES6) 41

Como una función anónima

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

Nota: la forma más simple sería 44:

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

Prueba a ejecutar el fragmento a continuación.

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]!!)

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

Cómo 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

Muy claro. Lo único "interesante" aquí es la construcción j'[11: '[es el operador "no contiene", por lo que "abc"'["ab"es falso y "abc"'["cd"verdadero. A pesar de que ambos operandos j'[11son números, MUMPS permanece imperturbable. Felizmente autocoerce ambos operandos a cadenas y continuará con su vida. ¡Hurra!

(Por cierto, si estás de acuerdo con el programa nunca terminar, podemos acortar este a 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;

Rubí, 24 bytes

Mal interpretado la tarea, volverá a trabajar más tarde!

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