Étant donné 2 entrées (m = id de départ minimum , n = nombre d' id ), générer une liste séquentielle d'id, commençant à> = m, composée des chiffres 0-9 où aucun 2 nombres contigus ne sont identiques, par exemple 1232 est ok, 1233 ne l'est pas (contient 2 '3 côte à côte).

Exemple

pour m = 985, n = 6, ci-dessous montre quels ids seraient générés / ignorés

...
985 - ok, 1st
986 - ok, 2nd
987 - ok, 3rd
# skip 0988 (contains '88')
989 - ok, 4th
# Skip 099x (contains '99')
# Skip 100x (contains '00')
1010 - ok, 5th
# Skip 1011 (contains '11')
1012 - ok, 6th
...

Production

Chaque ID doit être imprimé sur une nouvelle ligne, comme pour la séquence ci-dessus:

985
986
987
989
1010
1012

Règles

Règles de code-golf standard, le nombre d'octets le plus bas gagne

Gelée , 6 octets

DIẠµ#Y

Essayez-le en ligne!

Comment ça fonctionne?

DIẠµ # Y - Programme complet. Argument: deux entiers, X et Y.

   µ # - Retourne les premiers Y entiers supérieurs ou égaux à X qui satisfont:
 I - Les incréments ...
D - ... De leurs chiffres de base 10 ...
  Ạ - ... Sont tous différents de 0. 
     Y - Joignez le résultat par des sauts de ligne.

Brachylog , 11 10 octets

{≤ṫẹ~ḅẉ}ᶠ⁾

L'entrée est une liste de deux nombres. Essayez-le en ligne!

Explication

La fonction intégrée ḅprend une liste ou une chaîne, comme "1000220", et la divise en blocs d'éléments adjacents égaux, comme ["1","000","22","0"]. Dans ce programme, j'y applique l' ~opérateur, donc cela fonctionne à l'envers: il prend une liste de chaînes, vérifie que chaque chaîne se compose de répétitions d'un seul caractère et les chaînes voisines ont des caractères différents, et concatène la liste. Le prédicat ≤énumère les nombres à partir de la première entrée dans l'ordre croissant, et je vérifie une condition sur eux, imprimant ceux qui le satisfont et s'arrêtant quand j'en ai trouvé assez.

{≤ṫẹ~ḅẉ}ᶠ⁾  Input is a pair, say [M=988,N=3].
{      }ᶠ⁾  Apply this predicate to M and compute the first N results.
 ≤          Take a number that is greater than or equal to M (first up is 988).
  ṫ         Convert it to string: "988"
   ẹ        Split it into substrings of length 1: ["9","8","8"]
     ~ḅ     Apply ḅ in reverse: fails, try next number.
       ẉ    If ḅ succeeds, print the resulting string and a newline.
            This counts as a result of the predicate.

05AB1E , 9 octets

µÐÔQi=¼}>

Essayez-le en ligne!

Exlpanation

µ           # loop until counter equals n
 Ð          # triplicate current value (initially m)
  Ô         # connected uniqueified on the copy at the top of the stack
   Q        # compare to unmodified for equality
    i  }    # if true
     =      # print current value while leaving it on the stack
      ¼     # increment the counter
        >   # increment current value

Java 8, 83 octets

(m,n)->{for(;n>0;m++)if(!(m+"").matches(".*(.)\\1.*")){System.out.println(m);n--;}}

Explication:

Essayez-le en ligne.

(m,n)->{                      // Method with two integer parameters and no return-type
  for(;n>0;                   //  Loop as long as `n` is larger than 0
      m++)                    //    After every iteration: increase `m` by 1
    if(!(m+"").matches(".*(.)\\1.*")){
                              //   If there are no repeated adjacent digits:
      System.out.println(m);  //    Print `m`
      n--;}}                  //    And decrease `n` by 1

PowerShell , 59 octets

param($m,$n)for(;$n){if("$m"-notmatch"(.)\1"){$m;$n--}$m++}

Essayez-le en ligne!

Fondamentalement similaire aux autres réponses. Boucles tant qu'il nous reste des nombres à imprimer ( for(;$n)), teste si nous avons une correspondance régulière avec un chiffre à deux chiffres et sinon il met cela sur le pipeline et diminue $n. Ensuite, nous incrémentons $met bouclons à nouveau. Les éléments sont récupérés dans le pipeline et l'implicite Write-Outputnous donne gratuitement une sortie séparée par des sauts de ligne.

R , 111 92 71 octets

function(m,n)while(F<n){if(!grepl("(.)\\1",m)){cat(m,'
');F=F+1}
m=m+1}

Essayez-le en ligne!

Permet greplde rechercher des chiffres répétés.

Gelée , 9 octets

DŒgZLỊµ#Y

Essayez-le en ligne!

Sinon pour la restriction de sortie, Ypeut être supprimé.

C, 73 octets

k;f(s,n){for(;n--;printf("%d\n",s++))for(k=s;k;)k=k%10-k/10%10?k/10:++s;}

Essayez-le en ligne!

Perl 6 , 56 octets

{.put for grep({none .comb Zeq.comb.skip},$^a..*)[^$^b]}

Essayez-le

Étendu:

{  # bare block lambda with placeholder params $a $b

  .put for

  grep(

    {
      none          # create a none junction (True if all are False)

        .comb       # the input split into digits
        Zeq         # Zip using &infix:«eq» operator
        .comb.skip  # the input split into digits starting at second one
    },

    $^a .. *        # a Range starting at the first argument

  )[ ^ $^b ]        # take the first $b values
}

Rétine , 34 octets

.0A`
"$+"{\/(.)\1/{`.+
*
)C`
.+
*

Essayez-le en ligne! Prend net mcomme entrée sur des lignes distinctes. Explication:

.0A`

Désactivez la sortie automatique et supprimez-la ndu tampon de travail.

"$+"{

Répétez nfois.

\

Affiche la valeur de mà la fin du groupe en boucle suivant.

/(.)\1/{`

Boucle alors qu'il y a des chiffres contigus.

.+
*

Convertissez en unaire.

)C`

Comptez le nombre de chaînes vides, qui est un de plus que le nombre de caractères, ajoutant ainsi 1 et reconvertissant en décimal. Cela termine la boucle intérieure.

.+
*

Après avoir imprimé m, ajoutez à nouveau 1 de la même manière. (La dernière ligne n'a pas besoin d'un C`car c'est le type d'étape par défaut pour la dernière ligne.) La boucle externe est implicitement terminée.

Notez que la conversion en unaire et en décimale est un peu lente; pour 39 octets, une version qui ne fait aucune conversion:

.0A`
"$+"{\/(.)\1/+`.+
$.(*__
.+
$.(*__

Essayez-le en ligne! Explication: $.(calcule la longueur du reste de la substitution, sans pour autant l'étendre réellement; puisque la longueur de *_est implicitement la valeur appariée et la longueur de _est bien sûr 1, cela incrémente simplement la valeur.

Perl 5.10.0 + -n, 40 39 octets

for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_

Essayez-le en ligne!

-1 octet grâce à Xcali

Entrée sur deux lignes, d'abord n, puis m. Assurez-vous qu'il n'y a PAS de nouvelle ligne après m:

(echo '6'; echo -n '985') | perl -nE 'for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_'

Perl 5 , -ln33 octets

Entrez 2 lignes sur STDIN, commencez par id puis comptez

#!/usr/bin/perl -ln
$n-=!/(.)\1/&&say,$_++while$n.=<>

Essayez-le en ligne!

Python 2 , 80 73 octets

^{-7 octets grâce à M. Xcoder}

m,n=input()
while n:
 if~-sum(i*2in`m`for i in`99**9`):print m;n-=1
 m+=1

Essayez-le en ligne!

Haskell , 70 octets

-19 octets grâce à nimi.

s#n=unlines$map show$take n$filter(and.(zipWith(/=)=<<tail).show)[s..]

Essayez-le en ligne!

17 octets dédiés à la séparation par des sauts de ligne.

Stax , 9 8 octets ^CP437

ç@F6╕↔┤ú

Essayez-le en ligne!

Arrive à coïncider avec l'algorithme de @ Mr.Xcoder dans sa réponse Jelly.

-1 octet par commentaire de @recursive.

Explication

Utilise le format décompressé pour expliquer.

{$:-|A}gn
{     }gn    Generator, generate given number of values, using block as a filter
                 And implicit output, one element on a line.
             In Stax, only 0 and [] is falsy.

 $           Convert the number to string
  :-         Difference between contiguous digit
    |A       All of them are truthy (may use `:*` as well)

Haskell , 94 93 91 octets

-1 octet grâce à Laikoni
-2 octets grâce à Zgarb

import Data.List
a!0=[]
a!b|all(null.tail)$group$show a=show a++'\n':(a+1)!(b-1)|c<-a+1=c!b

Essayez-le en ligne!

Premier golf Haskell.

Pyth , 12 octets

j.f.A.+jZTEQ

Essayez-le ici

JavaScript (ES6), 50 octets

Prend une entrée dans la syntaxe de curry (m)(n).

m=>g=n=>n?/(.)\1/.test(m++)?g(n):~-m+`
`+g(n-1):''

Essayez-le en ligne!

C # (.NET Core), 91 octets

m=>n=>{for(;n-->0;System.Console.WriteLine(m++))for(int k=m;k>0;k=k%10!=k/10%10?k/10:++m);}

Port de la réponse @Steadybox 'C.

Essayez-le en ligne.

Perl 5 ( -nl), 42 octets

$l=<>;do{!/(.)\1/&&$l--&&say}while++$_&&$l

Essayez-le en ligne!

AWK , 90 octets

{for(j=$1;k<$2;j++){for(a=b=d;++b<=(n=split(j,A,""))&&a!=c=A[b];a=c);if(n<b&&++k)print j}}

Essayez-le en ligne!

C'est beaucoup plus laid que je ne le pensais. J'ai découvert qu'il AWKn'y a que la substitution arrière dans songensub fonction de ce qui la rendrait peu efficace à utiliser pour cette application.

Il s'agit donc d'une approche très simple consistant à incrémenter un compteur ID, à diviser le compteur à chaque caractère, à parcourir les caractères pour voir si un caractère est le même que le caractère précédent. Si aucun caractère répété n'est trouvé, imprimez le compteur d'ID et augmentez le nombre d'ID imprimés.

Je vais essayer de m'abstenir de faire une déclaration dans le sens de " AWKdevrait avoir la capacité de faire des expressions régulières plus robustes", mais ce sera difficile.

Utilitaires Bash + GNU, 35

seq $1 inf|egrep -v '(.)\1'|sed $2q

Essayez-le en ligne .

Rubis , 47 octets

->s,n{/(.)\1/!~s&&p(s)&&n-=1;s.next!;n>0&&redo}

Essayez-le en ligne!

Si vous n'aimez pas les guillemets, c'est 50 octets

->s,n{puts s if/(.)\1/!~s&&n-=1;s.next!;n>0&&redo}

Essayez-le en ligne!

Pip , 22 octets

--aLb{W`(.)\1`N++a0Pa}

Essayez-le en ligne!

Explication

--aLb{W`(.)\1`N++a0Pa}
                        a,b are command-line arguments
--a                     Decrement a
   Lb{               }  Loop b times:
       `(.)\1`           Regex matching a character followed by itself
      W       N++a       While that regex matches in incremented a:
                  0       No-op
                   Pa    When the while loop exits, a is a valid ID; print it