2 giriş verildiğinde (m = minimum başlangıç ​​kimliği , n = kimlik sayısı ), 2 bitişik sayının aynı olmadığı 0-9 basamaklarından oluşan, = = 'den başlayarak sıralı bir kimlik listesi oluşturun, örneğin 1232, tamam, 1233 değil (yan yana 2 '3 içerir).

Misal

m = 985 için, n = 6, aşağıdaki hangi kimliklerin üretileceğini / atlanacağını gösterir

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

Çıktı

Yukarıdaki kimliklerde olduğu gibi her kimlik yeni bir satıra yazdırılmalıdır:

985
986
987
989
1010
1012

kurallar

Standart kod golf kuralları, en düşük bayt sayısı kazanır

Jöle , 6 bayt

DIẠµ#Y

Çevrimiçi deneyin!

Nasıl çalışır?

DIẠµ # Y - Tam program. Argüman: iki tamsayı, X ve Y.

   µ # - Aşağıdakileri karşılayan X değerinden yüksek veya ona eşit ilk Y tamsayısını döndürür:
 I - Artışlar ...
D - ... Taban-10 basamaklarından ...
  Ạ - ... Hepsi 0 değil. 
     Y - Sonuca yeni satırlarla katılın.

Brachylog , 11 10 bayt

{≤ṫẹ~ḅẉ}ᶠ⁾

Girdi iki sayının listesidir. Çevrimiçi deneyin!

açıklama

Yerleşik ḅbir liste veya dize gibi alır "1000220"gibi, eşit bitişik elemanların bloklar halinde ve bölünmeler o ["1","000","22","0"]. Bu programda, ~operatörü ona uygularım , bu yüzden tersine çalışır: dizelerin bir listesini alır, her dizenin tek bir karakterin tekrarlarından oluştuğunu kontrol eder ve komşu dizelerin farklı karakterleri vardır ve listeyi birleştirir. Yüklem ≤, ilk girişten başlayarak sayıları artan sırayla numaralandırır ve bunlarda bir koşulu kontrol eder, tatmin edenleri yazdırır ve yeterli bulduğumda durur.

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

µÐÔQi=¼}>

Çevrimiçi deneyin!

Exlpanation

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

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

Açıklama:

Çevrimiçi deneyin.

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

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

Çevrimiçi deneyin!

Temel olarak diğer cevaplara benzer. Yazdırılacak sayılarımız ( for(;$n)) olduğu sürece döngüler , çift haneli bir regex eşleşmemizin olup olmadığını test eder ve eğer değilse, bunu boru hattına koyar ve azalır $n. Sonra $mtekrar artar ve döngüye alırız . Elemanlar boru hattından alınır ve örtük Write-Outputbize yeni satırla ayrılmış bir çıktı verir.

R , 111 92 71 bayt

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

Çevrimiçi deneyin!

Kullanımları grepltekrarlanan basamak aramak için.

Jöle , 9 bayt

DŒgZLỊµ#Y

Çevrimiçi deneyin!

Çıktı kısıtlaması için değilse, Yçıkarılabilir.

C, 73 bayt

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

Çevrimiçi deneyin!

Perl 6 , 56 bayt

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

Dene

Expanded:

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

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

Çevrimiçi deneyin! Alır nve mayrı satırlarda girdi olarak kullanılmaktadır. Açıklama:

.0A`

Otomatik çıktıyı kapatın nve çalışma arabelleğinden silin .

"$+"{

Tekrarlama nzamanları.

\

mAşağıdaki ilmekli grubun sonunda değerini yazdırın .

/(.)\1/{`

Bitişik basamaklar varken döngü.

.+
*

Tekli'ye dönüştür.

)C`

Karakter sayısından bir tane olan boş dizelerin sayısını sayın, böylece 1 ekleyip ondalığa dönüştürün. Bu iç halkayı sonlandırır.

.+
*

Yazdırdıktan msonra, aynı şekilde tekrar 1 ekleyin. (Son satırın, son satır C`için varsayılan sahne türü olması nedeniyle gerekmez .) Dış döngü dolaylı olarak sona erer.

Unary'e ve geri ondalığa dönmenin biraz yavaş olduğunu unutmayın; 39 bayt için, dönüşüm yapmayan bir sürüm:

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

Çevrimiçi deneyin! Açıklama: $.(yerine koyma işleminin geri kalanının uzunluğunu, aslında genişletmeden kolayca hesaplar; uzunluğu *_, örtük olarak eşleşen değer olduğundan ve uzunluğu _elbette 1 olduğundan, bu sadece değeri arttırır.

Perl 5.10.0 + -n, 40 39 bayt

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

Çevrimiçi deneyin!

Xcali sayesinde -1 bayt

Önce n, sonra m olmak üzere iki satıra girin. M'den sonra satırsonu olmadığından emin olun:

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

Perl 5 ,-ln 33 bayt

STDIN'e 2 satır girin, önce başlangıç ​​kimliği sonra sayın

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

Çevrimiçi deneyin!

Python 2 , 80 73 bayt

^{Bay Xcoder sayesinde -7 bayt}

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

Çevrimiçi deneyin!

Haskell , 70 bayt

-Nimi sayesinde 19 bayt.

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

Çevrimiçi deneyin!

Yeni satırlarla ayırmaya ayrılmış 17 bayt.

Stax , 9 8 bayt ^CP437

ç@F6╕↔┤ú

Çevrimiçi deneyin!

Jelly cevabında @ Mr.Xcoder'ın algoritmasına denk geldi.

@Recursive tarafından yorum başına -1 bayt.

açıklama

Açıklanacak formatı kullanır.

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

Laikoni sayesinde -1 bayt Zgarb
sayesinde -2 bayt

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

Çevrimiçi deneyin!

İlk Haskell golf.

Pyth , 12 bayt

j.f.A.+jZTEQ

Burada deneyin

JavaScript (ES6), 50 bayt

Körili sözdiziminde girdi alır (m)(n).

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

Çevrimiçi deneyin!

C # (.NET Core), 91 bayt

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

Bağlantı noktası @Steadybox 'C cevabı.

Çevrimiçi deneyin.

Perl 5 ( -nl), 42 bayt

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

Çevrimiçi deneyin!

AWK , 90 bayt

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

Çevrimiçi deneyin!

Bu sandığımdan çok daha çirkin. AWKSadece gensubbu uygulama için kullanımı çok verimli olmayacak işlevinde geri ikamesi olduğunu keşfettim .

Yani bu, bir ID sayacını artırmak, her karakterdeki sayacı bölmek, herhangi bir karakterin bir önceki karakterle aynı olup olmadığını görmek için karakterler arasında dolaşmak için çok basit bir yaklaşımdır. Tekrarlanan karakter bulunmazsa, kimlik sayacını yazdırın ve yazdırılan kimlik sayısını artırın.

" AWKDaha sağlam düzenli ifadeler yapabilme yeteneğine sahip olmalı " satırında açıklama yapmaktan kaçınmaya çalışacağım , ama zor olacak.

Bash + GNU yardımcı programları, 35

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

Çevrimiçi deneyin .

Ruby , 47 bayt

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

Çevrimiçi deneyin!

Alıntı işaretlerini beğenmezseniz, 50 bayt

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

Çevrimiçi deneyin!

Pip , 22 bayt

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

Çevrimiçi deneyin!

açıklama

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