Je déteste absolument le chiffre 1. J'ai donc besoin de votre aide pour convertir les nombres en leurs "formes appropriées".

Les nombres en bonne forme n'ont jamais deux 1s d'affilée. 101c'est bien, mais 110c'est hideux.

Pour convertir, sautez simplement tous les numéros incorrects et comptez normalement. Par exemple...

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

etc.

Votre programme doit prendre un entier et le sortir sous une forme appropriée. C'est le code-golf , donc le code le plus court en octets l'emporte.

Burlesque , 10 octets

{11 ~ [n!} FO

Versions plus anciennes:

ro{11~[n!}f[

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

Perl 5 , 34 octets

Boucler un compteur et changer le double occasionnel.

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

Tester

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

Utilitaires Bash + GNU, 36

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

Pyth, 13 11 octets

e.f!}`hT`ZQ

Enregistré 2 octets grâce à @FryAmTheEggman.

Démonstration en direct et cas de test.

Version 13 octets

e.f!}"11"+ZkQ

JavaScript, 53 octets

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

Alternatif (en utilisant des compréhensions, même longueur):

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]

Une fonction anonyme qui répertorie les numéros ne contenant pas 11dans l'ordre, et prend le nth. L'erreur off-by-one de l'indexation zéro s'annule avec l'inclusion de 0dans la liste.

En théorie, cela échouera pour des nombres suffisamment élevés f(n)>2*n, mais cela ne devrait pas arriver avant nau moins 10**50.

51 octets:

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

Compte les nombres ijusqu'à ce que le quota de nnombres sans 11soit atteint.

Une fonction a la même longueur en raison des corrections ponctuelles nécessaires.

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

Python 3 74

Encore besoin d'un peu de golf.

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

C'est assez brutal en ce moment.

Perl 5, 47 octets

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

JavaScript (ES6) 41

En tant que fonction anonyme

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

Remarque: la manière la plus simple serait 44:

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

Testez l'exécution de l'extrait ci-dessous.

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

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

Haskell, 51 octets

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

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

Comment ça fonctionne:

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

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

Assez simple. La seule chose "intéressante" ici est la construction j'[11- '[c'est l'opérateur "ne contient pas", donc c'est "abc"'["ab"faux et "abc"'["cd"c'est vrai. Malgré les deux opérandes d' j'[11être des nombres, MUMPS reste imperturbable. Il sera heureux de contraindre automatiquement les deux opérandes à des chaînes et de poursuivre sa vie. Hourra!

( Soit dit en passant, si vous êtes d' accord avec le programme jamais terminer, nous pouvons raccourcir ce à 35 octets: t2(i) f j=1:1 s:j'[11 k=k+1 w:k=i j)

PHP, 43 octets

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

Rubis, 24 octets

Mal interprété la tâche, retravaillera plus tard!

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