给定2个输入（m = 最小起始id，n = id的数量），生成从> = m开始的id的顺序列表，该列表由数字0-9组成，其中没有2个连续的数字相同，例如1232是好吧，1233不是（彼此相邻包含2'3'）。

例

对于m = 985，n = 6，下面显示了将生成/跳过的ID

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

输出量

按照上述顺序，每个ID应换行打印：

985
986
987
989
1010
1012

规则

标准代码高尔夫球规则，最低字节数获胜

果冻，6个字节

DIẠµ#Y

在线尝试！

怎么运行的？

DIẠµ＃Y –完整程序。参数：X和Y这两个整数。

   µ＃–返回满足以下条件的前X个大于或等于X的Y整数：
 I –增量...
D – ...以10为基数的数字...
  Ạ– ...均为非0。 
     Y –用换行符将结果合并。

Brachylog，11个10字节

{≤ṫẹ~ḅẉ}ᶠ⁾

输入是两个数字的列表。 在线尝试！

说明

内置ḅ函数接受一个列表或字符串（例如）"1000220"，并将其拆分为相等相邻元素的块（例如）["1","000","22","0"]。在此程序中，我将~运算符应用于该运算符，因此它的工作方式相反：它接收一个字符串列表，检查每个字符串是否由单个字符的重复组成，并且相邻字符串具有不同的字符，并将该列表连接起来。谓词≤枚举从第一个输入开始递增的数字，然后检查它们的条件，打印满足条件的条件，并在发现足够的条件时停止。

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

µÐÔQi=¼}>

在线尝试！

扩展

µ           # 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字节

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

说明：

在线尝试。

(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个字节

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

在线尝试！

基本上类似于其他答案。只要我们有剩余的数字要打印（for(;$n)），就进行循环，测试是否有正则表达式与两位数匹配，如果没有，则将其放在管道上并减小$n。然后我们增加$m并再次循环。这些元素是从管道中提取的，而隐式Write-Output则免费为我们提供换行符分隔的输出。

R，111 92 71字节

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

在线尝试！

用于grepl搜索重复的数字。

果冻，9字节

DŒgZLỊµ#Y

在线尝试！

如果没有输出限制，Y可以将其删除。

C，73个字节

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

在线尝试！

Perl 6、56字节

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

尝试一下

展开：

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

视网膜，34字节

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

在线尝试！取n和m为在不同的行的输入。说明：

.0A`

关闭自动输出并n从工作缓冲区中删除。

"$+"{

重复n次数。

\

m在以下循环组的末尾打印的值。

/(.)\1/{`

有连续数字时循环播放。

.+
*

转换为一元。

)C`

计算空字符串的数量，该数量比字符数多一，因此加1并转换回十进制。这样就结束了内部循环。

.+
*

打印后m，以相同的方式再次加1。（最后一行不需要a，C`因为这是最后一行的默认阶段类型。）外循环隐式结束。

请注意，转换为一进制然后再转换为十进制有点慢。39字节，该版本不进行任何转换：

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

在线尝试！说明：$.(计算其余替换的长度，方便地进行而不实际扩展它；由于的长度*_是隐式匹配的值，而的长度_当然是1，因此只会增加该值。

Perl 5.10.0 + -n，40 39字节

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

在线尝试！

-1字节感谢Xcali

在两行中输入，首先输入n，然后输入m。确保在m之后没有换行符：

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

Perl 5，-ln 33个字节

在STDIN上输入2行，首先输入ID，然后计数

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

在线尝试！

Python 2中，80 73个字节

^{-7个字节，感谢Xcoder先生}

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

在线尝试！

哈斯克尔，70个字节

-19个字节，感谢nimi。

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

在线尝试！

17个字节专用于用换行符分隔。

Stax，9 8 字节^CP437

ç@F6╕↔┤ú

在线尝试！

碰巧在Jelly答案中与@ Mr.Xcoder的算法一致。

@recursive每个注释-1个字节。

说明

使用解压缩格式进行解释。

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

哈斯克尔，94 93 91字节

-1个字节，感谢Laikoni
-2个字节，感谢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

在线尝试！

首先Haskell高尔夫。

Pyth，12个字节

j.f.A.+jZTEQ

在这里尝试

JavaScript（ES6），50个字节

以currying语法接受输入(m)(n)。

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

在线尝试！

C＃（.NET Core），91字节

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

@Steadybox的C答案的端口。

在线尝试。

Perl 5（-nl），42个字节

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

在线尝试！

AWK，90字节

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

在线尝试！

这比我想象的要丑得多。我发现AWK只有反向替代gensub功能，因此无法很有效地用于此应用程序。

因此，这是增加ID计数器，在每个字符处分割计数器，循环遍历字符以查看是否有任何字符与前一个字符相同的非常简单的方法。如果找不到重复的字符，请打印ID计数器并增加打印的ID数。

我将尽量避免按照“ AWK应该具有执行更强大的正则表达式的能力” 这样的方式进行声明，但这将是困难的。

Bash + GNU实用程序，35

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

在线尝试。

红宝石，47字节

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

在线尝试！

如果您不喜欢引号，则为50个字节

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

在线尝试！

点，22字节

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

在线尝试！

说明

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