Дано 2 входи (m = мінімальний початковий ідентифікатор , n = кількість ідентифікаторів ), генеруйте послідовний список ідентифікаторів, починаючи з> = m, що складається з цифр 0-9, де немає 2 суміжних чисел однакові, наприклад 1232 є добре, 1233 ні (містить 2 '3 поруч один з одним).

Приклад

для m = 985, n = 6, нижче показано, які ідентифікатори будуть генеровані / пропущені

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

Вихідні дані

Кожен ідентифікатор повинен бути надрукований у новому рядку, як для вищезазначеної послідовності:

985
986
987
989
1010
1012

Правила

Стандартні правила коду-гольфу, виграє найменший байт

Желе , 6 байт

DIẠµ#Y

Спробуйте в Інтернеті!

Як це працює?

DIẠµ # Y - Повна програма. Аргумент: два цілих числа, X і Y.

   µ # - Поверніть перші Y цілих чисел, більші або рівні X, які задовольняють:
 Я - прирости ...
D - ... від їх 10 базових цифр ...
  Ạ - ... Чи всі не-0. 
     Y - приєднайте результат за новими рядками.

Брахілог , 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 , додайте ще раз таким же чином. (Останній рядок не потребує, 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 байти

Введіть 2 рядки на STDIN, спочатку почніть ідентифікатор, а потім порахуйте

#!/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

Спробуйте в Інтернеті!

Haskell , 70 байт

-19 байт завдяки німі.

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

Спробуйте в Інтернеті!

17 байт, присвячених поділу на нові рядки.

Stax , 9 8 байт ^CP437

ç@F6╕↔┤ú

Спробуйте в Інтернеті!

Сталося збігатися з алгоритмом @ Mr.Xcoder у його відповіді на Jelly.

-1 байт за коментар від @recursive.

Пояснення

Використовує розпакований формат для пояснення.

{$:-|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 байт

-1 байт завдяки Лайконі
-2 байти завдяки Згарбу

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

Спробуйте в Інтернеті.

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 функції що зробить її не дуже ефективною для використання цього додатка.

Отже, це дуже простий підхід до збільшення лічильника ідентифікаторів, розділення лічильника на кожному символі, прокручування символів, щоб побачити, чи будь-який символ такий, як попередній символ. Якщо повторних символів не знайдено, роздрукуйте лічильник ідентифікаторів та збільшуйте кількість роздрукованих ідентифікаторів.

Я спробую утриматися від висловлювання за принципом " 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