Ich hasse die Ziffer absolut 1. Also brauche ich Ihre Hilfe, um Zahlen in ihre "richtigen Formen" umzuwandeln.

Zahlen in der richtigen Form haben niemals zwei 1s hintereinander. 101ist okay, aber 110abscheulich.

Überspringen Sie zum Konvertieren einfach alle falschen Zahlen und zählen Sie normal. Zum Beispiel...

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

und so weiter.

Ihr Programm sollte eine Ganzzahl annehmen und diese in der richtigen Form ausgeben. Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Burlesque , 10 Bytes

{11 ~ [n!} FO

Ältere Versionen:

ro{11~[n!}f[

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

Perl 5 , 34 Bytes

Einen Zähler schleifen und gelegentlich den doppelten austauschen.

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

Prüfung

$ 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

2 Bytes dank @FryAmTheEggman gespart.

Live-Demo und Testfälle.

13-Byte-Version

e.f!}"11"+ZkQ

JavaScript, 53 Byte

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

Alternative (unter Verwendung von Verstehen, gleicher Länge):

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]

Eine anonyme Funktion, die die nicht 11in der nrichtigen Reihenfolge enthaltenen Zahlen auflistet und die th-te nimmt . Der Fehler der Null-Indizierung (1: 1) bricht mit der Aufnahme 0in die Liste ab.

Theoretisch wird dies für ausreichend hohe Zahlen fehlschlagen f(n)>2*n, aber dies sollte nicht geschehen, bis nes mindestens so weit ist 10**50.

51 Bytes:

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

Zählt Zahlen, ibis die Quote nohne Zahlen erreicht 11ist.

Eine Funktion hat dieselbe Länge, da Korrekturen nur einmal erforderlich sind.

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

Python 3 74

Brauchen noch ein bisschen Golf.

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

Im Moment ist es ziemlich brachiale Gewalt.

Perl 5, 47 Bytes

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

JavaScript (ES6) 41

Als anonyme Funktion

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

Hinweis: Der einfachste Weg wäre 44:

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

Testen Sie das folgende Snippet.

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

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

Wie es funktioniert:

[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

Ziemlich einfach. Das einzig "interessante" ist hier das Konstrukt j'[11- '[ist der Operator "enthält nicht", also "abc"'["ab"ist das falsch und "abc"'["cd"wahr. Obwohl beide Operanden j'[11Zahlen sind, bleibt MUMPS unberührt. Es wird beide Operanden glücklich automatisch in Strings umwandeln und mit seinem Leben weitermachen. Hurra!

(Übrigens, wenn Sie in Ordnung sind mit dem Programm nie endet, können wir dies auf 35 Bytes verkürzen: 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

Die Aufgabe falsch interpretiert, wird später überarbeitet!

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