Cho 2 đầu vào (m = id bắt đầu tối thiểu , n = số id ), tạo danh sách id liên tiếp, bắt đầu từ> = m, được tạo thành từ các chữ số 0-9 trong đó không có 2 số liền nhau giống nhau, ví dụ 1232 là ok, 1233 thì không (chứa 2 '3 cạnh nhau).

Thí dụ

cho m = 985, n = 6, bên dưới hiển thị những id nào sẽ được tạo / bỏ qua

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

Đầu ra

Mỗi ID phải được in trên một dòng mới, như đối với trình tự trên:

985
986
987
989
1010
1012

Quy tắc

Luật chơi gôn tiêu chuẩn, số byte thấp nhất sẽ thắng

Thạch , 6 byte

DIẠµ#Y

Hãy thử trực tuyến!

Làm thế nào nó hoạt động?

DIẠNH # Y - Chương trình đầy đủ. Đối số: hai số nguyên, X và Y.

   Tổ hợp # - Trả về số nguyên Y đầu tiên cao hơn hoặc bằng X thỏa mãn:
 I - Gia số ...
D - ... Trong số 10 chữ số cơ bản của họ ...
  Ạ - ... Tất cả đều bằng 0. 
     Y - Tham gia kết quả bằng dòng mới.

Brachylog , 11 10 byte

{≤ṫẹ~ḅẉ}ᶠ⁾

Đầu vào là một danh sách gồm hai số. Hãy thử trực tuyến!

Giải trình

Tích hợp ḅlấy một danh sách hoặc chuỗi, thích "1000220"và chia nó thành các khối có các phần tử liền kề bằng nhau, như ["1","000","22","0"]. Trong chương trình này, tôi áp dụng ~toán tử cho nó, để nó hoạt động ngược lại: nó lấy một danh sách các chuỗi, kiểm tra xem mỗi chuỗi bao gồm các lần lặp lại của một ký tự và các chuỗi lân cận có các ký tự khác nhau và nối danh sách. Vị từ ≤liệt kê các số bắt đầu từ đầu vào đầu tiên theo thứ tự tăng dần và tôi kiểm tra một điều kiện trên chúng, in những số thỏa mãn và dừng lại khi tôi thấy đủ.

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

Hãy thử trực tuyến!

Xuất thần

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

Giải trình:

Hãy thử trực tuyế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 byte

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

Hãy thử trực tuyến!

Về cơ bản tương tự như các câu trả lời khác. Các vòng lặp miễn là chúng ta còn các số để in ( for(;$n)), kiểm tra xem chúng ta có khớp chính tả với một chữ số kép hay không và nếu không, nó sẽ đặt nó trên đường ống và giảm đi $n. Sau đó, chúng tôi tăng $mvà lặp lại. Các yếu tố được chọn từ đường ống và ẩn Write-Outputcho chúng ta một đầu ra được phân tách bằng dòng mới miễn phí.

R , 111 92 71 byte

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

Hãy thử trực tuyến!

Sử dụng greplđể tìm kiếm các chữ số lặp đi lặp lại.

Thạch , 9 byte

DŒgZLỊµ#Y

Hãy thử trực tuyến!

Nếu không cho các hạn chế đầu ra, Ycó thể được gỡ bỏ.

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

Hãy thử trực tuyến!

Perl 6 , 56 byte

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

Thử nó

Mở rộng:

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

Võng mạc , 34 byte

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

Hãy thử trực tuyến! Đưa nvà mlàm đầu vào trên các dòng riêng biệt. Giải trình:

.0A`

Tắt đầu ra tự động và xóa nkhỏi bộ đệm công việc.

"$+"{

Lặp lại nnhiều lần.

\

In giá trị mở cuối nhóm vòng lặp sau.

/(.)\1/{`

Vòng lặp trong khi có các chữ số liền kề.

.+
*

Chuyển đổi sang unary.

)C`

Đếm số lượng chuỗi trống, nhiều hơn một số ký tự, do đó thêm 1 và chuyển đổi lại thành số thập phân. Điều này kết thúc vòng lặp bên trong.

.+
*

Có in m, thêm 1 lần nữa theo cách tương tự. (Dòng cuối cùng không cần mộtC` bởi vì đó là loại giai đoạn mặc định cho dòng cuối cùng.) Vòng lặp bên ngoài hoàn toàn kết thúc.

Lưu ý rằng chuyển đổi sang unary và trở lại thập phân là hơi chậm; cho 39 byte, một phiên bản không thực hiện bất kỳ chuyển đổi nào:

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

Hãy thử trực tuyến! Giải thích: $.(tính toán độ dài của phần còn lại của sự thay thế, thuận tiện mà không thực sự mở rộng nó; vì độ dài của *_nó hoàn toàn là giá trị khớp và độ dài _của khóa học 1 nên điều này chỉ làm tăng giá trị.

Perl 5.10.0 + -n, 40 39 byte

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

Hãy thử trực tuyến!

-1 byte nhờ Xcali

Nhập vào hai dòng, đầu tiên n, sau đó m. Đảm bảo rằng KHÔNG có dòng mới sau m:

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

Perl 5 ,-ln 33 byte

Nhập 2 dòng trên STDIN, đầu tiên bắt đầu id sau đó đếm

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

Hãy thử trực tuyến!

Python 2 , 80 73 byte

^{-7 byte nhờ ông Xcoder}

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

Hãy thử trực tuyến!

Haskell , 70 byte

-19 byte nhờ nimi.

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

Hãy thử trực tuyến!

17 byte dành riêng để phân tách bằng dòng mới.

Stax , 9 8 byte ^CP437

ç@F6╕↔┤ú

Hãy thử trực tuyến!

Xảy ra trùng với thuật toán @ Mr.Xcoder trong câu trả lời Jelly của anh ấy.

-1 byte cho mỗi bình luận bởi @recursive.

Giải trình

Sử dụng định dạng giải nén để giải thích.

{$:-|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 nhờ Laikoni
-2 byte nhờ 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

Hãy thử trực tuyến!

Sân gôn Haskell đầu tiên.

Bình thường , 12 byte

j.f.A.+jZTEQ

Hãy thử nó ở đây

JavaScript (ES6), 50 byte

Đưa đầu vào theo cú pháp currying (m)(n).

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

Hãy thử trực tuyến!

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

Cổng câu trả lời C của @Steadybox.

Hãy thử trực tuyến.

Perl 5 ( -nl), 42 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Điều này là xấu hơn nhiều so với tôi nghĩ nó sẽ được. Tôi phát hiện ra rằng AWKchỉ có sự thay thế trở lại trong nógensub chức năng , điều này sẽ khiến nó không hiệu quả lắm khi sử dụng cho ứng dụng này.

Vì vậy, đây là một cách tiếp cận rất đơn giản để tăng bộ đếm ID, tách bộ đếm ở mỗi ký tự, lặp qua các ký tự để xem có ký tự nào giống với ký tự trước không. Nếu không tìm thấy ký tự lặp lại, hãy in bộ đếm ID và tăng số lượng ID được in.

Tôi sẽ cố gắng không đưa ra tuyên bố dọc theo dòng chữ " AWKnên có khả năng thực hiện các biểu thức chính quy mạnh mẽ hơn", nhưng điều đó sẽ khó khăn.

Tiện ích Bash + GNU, 35

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

Hãy thử trực tuyến .

Ruby , 47 byte

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

Hãy thử trực tuyến!

Nếu bạn không thích dấu ngoặc kép, thì đó là 50 byte

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

Hãy thử trực tuyến!

Pip , 22 byte

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

Hãy thử trực tuyến!

Giải trình

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