Dadas 2 entradas (m = identificación inicial mínima , n = número de identificadores ), genera una lista secuencial de identificadores, comenzando en> = m, compuesta por los dígitos 0-9 donde no hay 2 números contiguos iguales, por ejemplo, 1232 es ok, 1233 no lo es (contiene 2 '3 al lado del otro).

Ejemplo

para m = 985, n = 6, a continuación se muestran los identificadores que se generarían / ​​omitirían

...
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
...

Salida

Cada ID debe imprimirse en una nueva línea, como en la secuencia anterior:

985
986
987
989
1010
1012

Reglas

Reglas estándar de código de golf, el conteo de bytes más bajo gana

Jalea , 6 bytes

DIẠµ#Y

Pruébalo en línea!

¿Cómo funciona?

DIẠµ # Y - Programa completo. Argumento: dos enteros, X e Y.

   µ #: devuelve los primeros enteros Y superiores o iguales a X que satisfacen:
 I - Los incrementos ...
D - ... De sus dígitos de base 10 ...
  Ạ - ... Son todos distintos de 0. 
     Y - Unir el resultado por nuevas líneas.

Brachylog , 11 10 bytes

{≤ṫẹ~ḅẉ}ᶠ⁾

La entrada es una lista de dos números. Pruébalo en línea!

Explicación

El incorporado ḅtoma una lista o cadena, como "1000220", y la divide en bloques de elementos adyacentes iguales, como ["1","000","22","0"]. En este programa, le aplico el ~operador, por lo que funciona a la inversa: toma una lista de cadenas, comprueba que cada cadena consta de repeticiones de un solo carácter y las cadenas vecinas tienen caracteres diferentes, y concatena la lista. El predicado ≤enumera los números comenzando desde la primera entrada en orden creciente, y verifico una condición en ellos, imprimiendo los que lo satisfacen y deteniéndome cuando encuentro suficiente.

{≤ṫẹ~ḅẉ}ᶠ⁾  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 bytes

µÐÔQi=¼}>

Pruébalo en línea!

Exlpacion

µ           # 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 bytes

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

Explicación:

Pruébalo en línea.

(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 bytes

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

Pruébalo en línea!

Básicamente similar a las otras respuestas. Bucles siempre que nos queden números para imprimir ( for(;$n)), comprueba si tenemos una coincidencia de expresiones regulares contra un doble dígito y, de lo contrario, lo pone en la tubería y disminuye $n. Luego incrementamos $my repetimos nuevamente. Los elementos se recogen de la tubería y lo implícito Write-Outputnos da una salida separada de la nueva línea de forma gratuita.

R , 111 92 71 bytes

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

Pruébalo en línea!

Utiliza greplpara buscar dígitos repetidos.

Jalea , 9 bytes

DŒgZLỊµ#Y

Pruébalo en línea!

Si no es por la restricción de salida, Yse puede eliminar.

C, 73 bytes

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

Pruébalo en línea!

Perl 6 , 56 bytes

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

Intentalo

Expandido:

{  # 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
}

Retina , 34 bytes

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

Pruébalo en línea! Toma ny mcomo entrada en líneas separadas. Explicación:

.0A`

Apague la salida automática y elimine ndel búfer de trabajo.

"$+"{

Repite nveces.

\

Imprima el valor de mal final del siguiente grupo en bucle.

/(.)\1/{`

Bucle mientras hay dígitos contiguos.

.+
*

Convierte a unario.

)C`

Cuente el número de cadenas vacías, que es uno más que el número de caracteres, sumando 1 y convirtiendo de nuevo a decimal. Esto termina el ciclo interno.

.+
*

Después de imprimir m, agregue 1 nuevamente de la misma manera. (La última línea no necesita un C`porque es el tipo de etapa predeterminado para la última línea). El bucle externo está implícitamente terminado.

Tenga en cuenta que convertir a unario y volver a decimal es un poco lento; para 39 bytes, una versión que no realiza ninguna conversión:

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

Pruébalo en línea! Explicación: $.(calcula la longitud del resto de la sustitución, convenientemente sin expandirla realmente; como la longitud de *_es implícitamente el valor coincidente y la longitud de _es, por supuesto, 1, esto solo incrementa el valor.

Perl 5.10.0 + -n, 40 39 bytes

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

Pruébalo en línea!

-1 byte gracias a Xcali

Entrada en dos líneas, primero n, luego m. Asegúrese de que NO haya nueva línea después de m:

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

Perl 5 , -ln33 bytes

Ingrese 2 líneas en STDIN, primero inicie la identificación y luego cuente

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

Pruébalo en línea!

Python 2 , 80 73 bytes

^{-7 bytes gracias al Sr. Xcoder}

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

Pruébalo en línea!

Haskell , 70 bytes

-19 bytes gracias a nimi.

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

Pruébalo en línea!

17 bytes dedicados a la separación por nuevas líneas.

Stax , 9 8 bytes ^CP437

ç@F6╕↔┤ú

Pruébalo en línea!

Sucede para coincidir con el algoritmo de @ Mr.Xcoder en su respuesta de Jelly.

-1 byte por comentario de @recursive.

Explicación

Utiliza el formato desempaquetado para explicar.

{$:-|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 bytes

-1 byte gracias a Laikoni
-2 bytes gracias a 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

Pruébalo en línea!

Primero Haskell golf.

Pyth , 12 bytes

j.f.A.+jZTEQ

Pruébalo aquí

JavaScript (ES6), 50 bytes

Toma entrada en la sintaxis de curry (m)(n).

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

Pruébalo en línea!

C # (.NET Core), 91 bytes

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

Puerto de @Steadybox 'C respuesta.

Pruébalo en línea.

Perl 5 ( -nl), 42 bytes

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

Pruébalo en línea!

AWK , 90 bytes

{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}}

Pruébalo en línea!

Esto es mucho más feo de lo que pensé que sería. Descubrí que AWKsolo tiene sustitución de retroceso en su gensubfunción, lo que haría que su uso no fuera muy eficiente.

Por lo tanto, este es un enfoque muy sencillo de incrementar un contador de ID, dividir el contador en cada carácter, recorrer los caracteres para ver si algún carácter es el mismo que el anterior. Si no se encuentran caracteres repetidos, imprima el contador de ID e incremente el número de ID impresos.

Intentaré abstenerme de hacer una declaración en la línea de " AWKdebería tener la capacidad de hacer expresiones regulares más robustas", pero será difícil.

Bash + GNU utilidades, 35

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

Pruébalo en línea .

Ruby , 47 bytes

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

Pruébalo en línea!

Si no le gustan las comillas, son 50 bytes

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

Pruébalo en línea!

Pip , 22 bytes

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

Pruébalo en línea!

Explicación

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