Biorąc pod uwagę 2 dane wejściowe (m = minimalny identyfikator początkowy , n = liczba identyfikatorów ), wygeneruj sekwencyjną listę identyfikatorów, zaczynającą się od> = m, złożoną z cyfr 0–9, gdzie żadna 2 ciągłe liczby nie są takie same, np. 1232 to ok, 1233 nie jest (zawiera 2 '3 obok siebie).

Przykład

dla m = 985, n = 6, poniżej pokazuje, jakie identyfikatory zostaną wygenerowane / pominięte

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

Wynik

Każdy identyfikator powinien być wydrukowany w nowym wierszu, jak w powyższej sekwencji:

985
986
987
989
1010
1012

Zasady

Standardowe zasady gry w golfa, wygrywa najniższa liczba bajtów

Galaretka , 6 bajtów

DIẠµ#Y

Wypróbuj online!

Jak to działa?

DIẠµ # Y - Pełny program. Argument: dwie liczby całkowite, X i Y.

   µ # - Zwraca pierwsze liczby całkowite Y większe lub równe X, które spełniają:
 I - Przyrosty ...
D - ... Z ich 10 cyfr podstawowych ...
  Ạ - ... Wszystkie są inne niż 0. 
     Y - Dołącz do wyniku przez nowe linie.

Brachylog , 11 10 bajtów

{≤ṫẹ~ḅẉ}ᶠ⁾

Dane wejściowe to lista dwóch liczb. Wypróbuj online!

Wyjaśnienie

Wbudowana ḅpobiera listę lub ciąg znaków "1000220"i dzieli je na bloki równych sąsiadujących elementów, takich jak ["1","000","22","0"]. W tym programie ~stosuję do niego operator, więc działa odwrotnie: pobiera listę ciągów, sprawdza, czy każdy ciąg składa się z powtórzeń jednego znaku, a sąsiednie ciągi mają różne znaki i konkatenuje listę. Predykat ≤wylicza liczby, zaczynając od pierwszego wejścia w kolejności rosnącej, i sprawdzam na nich warunek, drukując te, które go spełniają, i zatrzymuję się, gdy znajdę wystarczająco dużo.

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

µÐÔQi=¼}>

Wypróbuj online!

Eklpanacja

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

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

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Wypróbuj online!

Zasadniczo podobny do innych odpowiedzi. Pętle, o ile pozostały nam liczby do wydrukowania ( for(;$n)), sprawdzają, czy mamy dopasowanie do wyrażenia regularnego z dwucyfrową, a jeśli nie, to umieszcza je w potoku i maleje $n. Następnie zwiększamy $mi zapętlamy ponownie. Elementy są pobierane z potoku, a domniemane Write-Outputdaje nam wyniki rozdzielone znakiem nowej linii za darmo.

R , 111 92 71 bajtów

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

Wypróbuj online!

Używa grepldo wyszukiwania powtarzających się cyfr.

Galaretka , 9 bajtów

DŒgZLỊµ#Y

Wypróbuj online!

Jeśli nie dotyczy ograniczenia wyjścia, Ymożna je usunąć.

C, 73 bajty

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

Wypróbuj online!

Perl 6 , 56 bajtów

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

Spróbuj

Rozszerzony:

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

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

Wypróbuj online! Pobiera ni mjako dane wejściowe w osobnych wierszach. Wyjaśnienie:

.0A`

Wyłącz automatyczne wyjście i usuń nz bufora roboczego.

"$+"{

Powtórz nczasy.

\

Wydrukuj wartość mna końcu następującej zapętlonej grupy.

/(.)\1/{`

Pętla, gdy są ciągłe cyfry.

.+
*

Konwertuj na unary.

)C`

Policz liczbę pustych ciągów, która jest o jeden większa niż liczba znaków, dodając w ten sposób 1 i konwertując z powrotem na dziesiętne. To kończy wewnętrzną pętlę.

.+
*

Po wydrukowaniu m dodaj 1 ponownie w ten sam sposób. (Ostatni wiersz nie potrzebuje a, C`ponieważ jest to domyślny typ etapu dla ostatniego wiersza.) Zewnętrzna pętla jest domyślnie zakończona.

Zauważ, że konwersja na unary i powrót do dziesiętnych jest trochę powolna; dla 39 bajtów, wersja bez konwersji:

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

Wypróbuj online! Objaśnienie: $.(oblicza długość reszty podstawienia, dogodnie bez faktycznego jej rozszerzania; ponieważ długość *_jest domyślnie dopasowaną wartością, a długość _wynosi oczywiście 1, to tylko zwiększa wartość.

Perl 5.10.0 + -n, 40 39 bajtów

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

Wypróbuj online!

-1 bajt dzięki Xcali

Wprowadź w dwóch wierszach, najpierw n, a następnie m. Upewnij się, że nie ma nowej linii po m:

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

Perl 5 ,-ln 33 bajtów

Wpisz 2 wiersze na STDIN, najpierw identyfikator początkowy, a następnie policz

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

Wypróbuj online!

Python 2 , 80 73 bajtów

^{-7 bajtów dzięki Mr. Xcoder}

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

Wypróbuj online!

Haskell , 70 bajtów

-19 bajtów dzięki nim.

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

Wypróbuj online!

17 bajtów dedykowanych do rozdzielania znakami nowej linii.

Stax , 9 8 bajtów ^CP437

ç@F6╕↔┤ú

Wypróbuj online!

Zdarzyło się, że pokrywa się z algorytmem @ Mr.Xcoder w jego odpowiedzi na żelki.

-1 bajt na komentarz @recursive.

Wyjaśnienie

Do wyjaśnienia używa rozpakowanego formatu.

{$:-|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 bajtów

-1 bajtów dzięki Laikoni
-2 bajtów dzięki 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

Wypróbuj online!

Pierwszy golf Haskell.

Pyth , 12 bajtów

j.f.A.+jZTEQ

Wypróbuj tutaj

JavaScript (ES6), 50 bajtów

Pobiera dane wejściowe w składni curry (m)(n).

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

Wypróbuj online!

C # (.NET Core), 91 bajtów

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

Wypróbuj online.

Perl 5 ( -nl), 42 bajty

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

Wypróbuj online!

AWK , 90 bajtów

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

Wypróbuj online!

To jest o wiele brzydsze, niż się spodziewałem. Odkryłem, że AWKma tylko substytucję wstecznągensub funkcji występuje co sprawiłoby, że nie jest zbyt wydajny w użyciu dla tej aplikacji.

Jest to więc bardzo proste podejście polegające na zwiększaniu licznika ID, dzieleniu licznika na każdy znak, zapętlaniu znaków, aby sprawdzić, czy jakikolwiek znak jest taki sam jak poprzedni znak. Jeśli nie zostaną znalezione powtarzające się znaki, wydrukuj licznik identyfikatorów i zwiększ liczbę wydrukowanych identyfikatorów.

Spróbuję powstrzymać się od złożenia oświadczenia w stylu „ AWKpowinien mieć możliwość wykonywania bardziej niezawodnych wyrażeń regularnych”, ale będzie to trudne.

Narzędzia Bash + GNU, 35

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

Wypróbuj online .

Ruby , 47 bajtów

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

Wypróbuj online!

Jeśli nie podoba ci się cudzysłów, to 50 bajtów

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

Wypróbuj online!

Pip , 22 bajty

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

Wypróbuj online!

Wyjaśnienie

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