Odio assolutamente la cifra 1. Quindi, ho bisogno del tuo aiuto per convertire i numeri nelle loro "forme appropriate".

I numeri nella forma corretta non hanno mai due 1s di fila. 101va bene, ma110 è orribile.

Per convertire, salta semplicemente tutti i numeri errati e conta normalmente. Per esempio...

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

e così via.

Il tuo programma dovrebbe prendere un numero intero e produrlo nella forma corretta. Questo è code-golf , quindi vince il codice più breve in byte.

burlesco , 10 byte

{11 ~ [n!} FO

Versioni precedenti:

ro{11~[n!}f[

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

Perl 5 , 34 byte

Passare un contatore e cambiare il doppio occasionale.

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

Utilità Bash + GNU, 36

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

Pyth, 13 11 byte

e.f!}`hT`ZQ

Salvato 2 byte grazie a @FryAmTheEggman.

Demo live e casi di test.

Versione a 13 byte

e.f!}"11"+ZkQ

JavaScript, 53 byte

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

Alternativo (usando comprensioni, stessa lunghezza):

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]

Una funzione anonima che elenca i numeri che non contengono 11in ordine e prende nquello. L'errore off-by-one dell'indicizzazione zero si annulla con l'inclusione di 0nell'elenco.

In teoria, questo fallirà per numeri sufficientemente alti dove f(n)>2*n, ma ciò non dovrebbe accadere fino na quando non lo è almeno 10**50.

51 byte:

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

Conta i numeri ifino a quando nnon 11viene raggiunta la quota di numeri senza .

Una funzione ha la stessa lunghezza a causa delle correzioni off-by-one necessarie.

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

Python 3 74

Ho ancora bisogno di giocare a golf.

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

È una forza piuttosto bruta in questo momento.

Perl 5, 47 byte

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

JavaScript (ES6) 41

Come una funzione anonima

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

Nota: il modo più semplice sarebbe 44:

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

Prova a eseguire lo snippet di seguito.

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

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

Haskell, 51 byte

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

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

Come funziona:

[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 byte

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

Abbastanza diretto. L'unica cosa "interessante" qui è il costrutto j'[11- '[è l'operatore "non contiene", quindi "abc"'["ab"è falso ed "abc"'["cd"è vero. Nonostante entrambi gli operandi j'[11siano numeri, MUMPS rimane imperturbabile. Sarà felicemente auto-forzare entrambi gli operandi in stringhe e andare avanti con la sua vita. Evviva!

(Per inciso, se siete d'accordo con il programma non termina, siamo in grado di ridurre questo a 35 byte: t2(i) f j=1:1 s:j'[11 k=k+1 w:k=i j)

PHP, 43 byte

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

Rubino, 24 byte

Interpretato male il compito, rielaborerà più tardi!

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