Diberikan 2 input (m = id awal minimum , n = jumlah id ), buat daftar id berurutan, mulai dari> = m, terdiri dari digit 0-9 di mana tidak ada 2 angka yang berdekatan adalah sama, misalnya 1232 adalah ok, 1233 tidak (berisi 2 '3 bersebelahan).

Contoh

untuk m = 985, n = 6, di bawah ini menunjukkan id apa yang akan dihasilkan / dilewati

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

Keluaran

Setiap ID harus dicetak pada baris baru, seperti untuk urutan di atas:

985
986
987
989
1010
1012

Aturan

Aturan kode-golf standar, kemenangan jumlah byte terendah

Jelly , 6 byte

DIẠµ#Y

Cobalah online!

Bagaimana itu bekerja?

DIẠµ # Y - Program lengkap. Argumen: dua bilangan bulat, X dan Y.

   μ # - Kembalikan bilangan bulat Y pertama yang lebih tinggi atau sama dengan X yang memenuhi:
 I - Selisih ...
D - ... Dari basis-10 digit mereka ...
  Ạ - ... Semuanya bukan-0. 
     Y - Gabung hasilnya dengan baris baru.

Brachylog , 11 10 byte

{≤ṫẹ~ḅẉ}ᶠ⁾

Input adalah daftar dua angka. Cobalah online!

Penjelasan

Built-in ḅmengambil daftar atau string, seperti "1000220", dan membaginya menjadi blok-blok elemen yang berdekatan yang sama, seperti ["1","000","22","0"]. Dalam program ini, saya menerapkan ~operator untuk itu, sehingga bekerja secara terbalik: dibutuhkan daftar string, memeriksa bahwa setiap string terdiri dari pengulangan karakter tunggal dan string tetangga memiliki karakter yang berbeda, dan merangkai daftar. Predikat ≤menghitung angka mulai dari input pertama dengan urutan yang meningkat, dan saya memeriksa kondisinya, mencetak yang memuaskan dan berhenti ketika saya sudah menemukan cukup.

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

µÐÔQi=¼}>

Cobalah online!

Penjelajahan

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

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

Penjelasan:

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

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

Cobalah online!

Pada dasarnya mirip dengan jawaban yang lain. Pengulangan selama kita memiliki angka yang tersisa untuk dicetak ( for(;$n)), menguji apakah kita memiliki kecocokan regex terhadap dua digit dan jika tidak, hal itu menempatkannya pada pipa dan menurun $n. Lalu kami menambah $mdan mengulang lagi. Elemen-elemen diambil dari pipeline dan implisit Write-Outputmemberi kita output yang dipisahkan baris baru secara gratis.

R , 111 92 71 byte

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

Cobalah online!

Penggunaan grepluntuk mencari digit berulang.

Jelly , 9 byte

DŒgZLỊµ#Y

Cobalah online!

Jika tidak karena batasan output, Ybisa dihilangkan.

C, 73 byte

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

Cobalah online!

Perl 6 , 56 byte

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

Cobalah

Diperluas:

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

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

Cobalah online! Mengambil ndan msebagai input pada saluran yang terpisah. Penjelasan:

.0A`

Matikan output otomatis dan hapus ndari buffer pekerjaan.

"$+"{

Ulangi nkali.

\

Cetak nilai mdi akhir grup yang diulang berikut.

/(.)\1/{`

Loop sementara ada angka yang berdekatan.

.+
*

Konversikan ke unary.

)C`

Hitung jumlah string kosong, yang merupakan satu lebih dari jumlah karakter, sehingga menambahkan 1 dan mengonversi kembali ke desimal. Ini mengakhiri lingkaran dalam.

.+
*

Setelah dicetak m, tambahkan 1 lagi dengan cara yang sama. (Baris terakhir tidak perlu aC` karena itu adalah jenis tahap default untuk baris terakhir.) Loop luar secara implisit berakhir.

Perhatikan bahwa mengonversi ke unary dan kembali ke desimal agak lambat; selama 39 byte, versi yang tidak melakukan konversi apa pun:

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

Cobalah online! Penjelasan: $.(menghitung panjang sisa substitusi, mudah tanpa benar-benar memperluasnya; karena panjang *_secara implisit nilai yang cocok dan panjang _tentu saja 1 ini hanya menambah nilai.

Perl 5.10.0 + -n, 40 39 byte

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

Cobalah online!

-1 byte terima kasih kepada Xcali

Input pada dua baris, pertama n, lalu m. Pastikan tidak ada baris baru setelah m:

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

Perl 5 ,-ln 33 byte

Masukkan 2 baris pada STDIN, pertama mulai id kemudian hitung

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

Cobalah online!

Python 2 , 80 73 byte

^{-7 byte terima kasih kepada Tn. Xcoder}

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

Cobalah online!

Haskell , 70 byte

-19 byte berkat nimi.

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

Cobalah online!

17 byte yang didedikasikan untuk memisahkan dengan baris baru.

Stax , 9 8 byte ^CP437

ç@F6╕↔┤ú

Cobalah online!

Terjadi bertepatan dengan algoritma @ Mr.Xcoder dalam jawaban Jelly-nya.

-1 byte per komentar oleh @recursive.

Penjelasan

Menggunakan format yang tidak dibongkar untuk menjelaskan.

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

-1 byte terima kasih kepada Laikoni
-2 byte terima kasih kepada 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

Cobalah online!

Golf Haskell pertama.

Pyth , 12 byte

j.f.A.+jZTEQ

Coba di sini

JavaScript (ES6), 50 byte

Mengambil input dalam sintaks currying (m)(n).

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

Cobalah online!

C # (.NET Core), 91 byte

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 jawaban @Steadybox 'C.

Cobalah online.

Perl 5 ( -nl), 42 byte

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

Cobalah online!

AWK , 90 byte

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

Cobalah online!

Ini jauh lebih jelek daripada yang saya kira. Saya menemukan bahwa AWKhanya memiliki substitusi kembali di dalamnyagensub fungsinya yang akan membuatnya tidak terlalu efisien untuk digunakan untuk aplikasi ini.

Jadi ini adalah pendekatan yang sangat mudah untuk menambah penghitung ID, membelah penghitung di setiap karakter, perulangan melalui karakter untuk melihat apakah ada karakter yang sama dengan karakter sebelumnya. Jika tidak ada karakter berulang yang ditemukan, cetak penghitung ID dan tambah jumlah ID yang dicetak.

Saya akan mencoba untuk menahan diri dari membuat pernyataan sepanjang garis " AWKharus memiliki kemampuan untuk melakukan ekspresi reguler yang lebih kuat", tetapi itu akan sulit.

Utilitas Bash + GNU, 35

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

Cobalah online .

Ruby , 47 byte

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

Cobalah online!

Jika Anda tidak suka tanda kutip, itu adalah 50 byte

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

Cobalah online!

Pip , 22 byte

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

Cobalah online!

Penjelasan

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