Dadas duas entradas (m = ID inicial mínimo , n = número de IDs ), gere uma lista seqüencial de IDs, iniciando em> = m, composta pelos dígitos 0-9, em que não existem 2 números contíguos, por exemplo, 1232 é ok, 1233 não é (contém 2 '3's próximos um do outro).

Exemplo

para m = 985, n = 6, abaixo mostra quais IDs seriam gerados / ignorados

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

Resultado

Cada ID deve ser impresso em uma nova linha, como na sequência acima:

985
986
987
989
1010
1012

Regras

Regras padrão de código de golfe, menor número de bytes ganhos

Gelatina , 6 bytes

DIẠµ#Y

Experimente online!

Como funciona?

DIẠµ # Y - Programa completo. Argumento: dois inteiros, X e Y.

   µ # - Retorna os primeiros inteiros Y maiores ou iguais a X que satisfazem:
 I - Os incrementos ...
D - ... Dos seus dígitos de base 10 ...
  Ạ - ... São todos não-0. 
     Y - Junte-se ao resultado por novas linhas.

Braquilog , 11 10 bytes

{≤ṫẹ~ḅẉ}ᶠ⁾

Entrada é uma lista de dois números. Experimente online!

Explicação

O interno ḅpega uma lista ou string, como "1000220", e divide-a em blocos de elementos adjacentes iguais, como ["1","000","22","0"]. Neste programa, aplico o ~operador a ele, para que funcione ao contrário: ele pega uma lista de cadeias, verifica se cada cadeia consiste em repetições de um único caractere e as cadeias vizinhas têm caracteres diferentes e concatena a lista. O predicado ≤enumera números começando da primeira entrada em ordem crescente, e eu verifico uma condição neles, imprimindo aqueles que a satisfazem e parando quando eu encontrei o 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=¼}>

Experimente online!

Exlpanação

µ           # 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--;}}

Explicação:

Experimente online.

(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++}

Experimente online!

Basicamente semelhante às outras respostas. Loops, desde que tenhamos números para imprimir ( for(;$n)), testa se temos uma correspondência de regex com um dígito duplo e, se não, coloca isso no pipeline e diminui $n. Então incrementamos $me fazemos um loop novamente. Os elementos são retirados do pipeline e o implícito Write-Outputnos fornece uma saída separada por nova linha de graça.

R , 111 92 71 bytes

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

Experimente online!

Usa greplpara procurar dígitos repetidos.

Geléia , 9 bytes

DŒgZLỊµ#Y

Experimente online!

Se não for para a restrição de saída, Ypode ser removido.

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

Experimente online!

Perl 6 , 56 bytes

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

Tente

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`
.+
*

Experimente online! Toma ne mcomo entrada em linhas separadas. Explicação:

.0A`

Desative a saída automática e exclua ndo buffer de trabalho.

"$+"{

Repita os ntempos.

\

Imprima o valor de mno final do seguinte grupo em loop.

/(.)\1/{`

Faça um loop enquanto houver dígitos contíguos.

.+
*

Converta para unário.

)C`

Conte o número de cadeias vazias, que é mais um que o número de caracteres, adicionando 1 e convertendo novamente em decimal. Isso termina o loop interno.

.+
*

Após a impressão m, adicione 1 novamente da mesma maneira. (A última linha não precisa de umC` porque é o tipo de estágio padrão para a última linha.) O loop externo é implicitamente encerrado.

Observe que a conversão para unário e de volta para decimal é um pouco lenta; para 39 bytes, uma versão que não faz nenhuma conversão:

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

Experimente online! Explicação: $.(calcula o comprimento do restante da substituição, convenientemente sem expandi-lo; como o comprimento de *_é implicitamente o valor correspondente e o comprimento de _é, obviamente, 1, isso apenas incrementa o valor.

Perl 5.10.0 + -n, 40 39 bytes

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

Experimente online!

-1 byte graças a Xcali

Entrada em duas linhas, primeiro n, depois m. Verifique se NÃO há nova linha após m:

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

Perl 5 , -ln33 bytes

Digite 2 linhas em STDIN, primeiro identificador inicial e conte

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

Experimente online!

Python 2 , 80 73 bytes

^{-7 bytes graças ao Sr. Xcoder}

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

Experimente online!

Haskell , 70 bytes

-19 bytes graças a nimi.

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

Experimente online!

17 bytes dedicados à separação por novas linhas.

Stax , 9 8 bytes ^CP437

ç@F6╕↔┤ú

Experimente online!

Acontece que coincide com o algoritmo do @ Mr.Xcoder em sua resposta Jelly.

-1 byte por comentário de @recursive.

Explicação

Usa o formato descompactado 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 graças a Laikoni
-2 bytes graças 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

Experimente online!

Primeiro golfe Haskell.

Pitão , 12 bytes

j.f.A.+jZTEQ

Experimente aqui

JavaScript (ES6), 50 bytes

Recebe entrada na sintaxe de currying (m)(n).

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

Experimente online!

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);}

Porta da resposta C do @Steadybox '.

Experimente online.

Perl 5 ( -nl), 42 bytes

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

Experimente online!

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

Experimente online!

Isso é muito mais feio do que eu pensava. Descobri que AWKapenas há substituição traseira em sua gensubfunção, o que tornaria pouco eficiente o uso para este aplicativo.

Portanto, essa é uma abordagem muito simples de incrementar um contador de ID, dividir o contador em cada caractere, percorrendo os caracteres para ver se algum caractere é igual ao caractere anterior. Se nenhum caractere repetido for encontrado, imprima o contador de IDs e aumente o número de IDs impressos.

Tentarei abster-me de fazer uma declaração na mesma linha de " AWKdeveria ter a capacidade de fazer expressões regulares mais robustas", mas será difícil.

Utilitários Bash + GNU, 35

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

Experimente online .

Ruby , 47 bytes

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

Experimente online!

Se você não gosta das aspas, são 50 bytes

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

Experimente online!

Pip , 22 bytes

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

Experimente online!

Explicação

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