Bei 2 Eingaben (m = minimale Start-ID , n = Anzahl der IDs ) wird eine fortlaufende Liste von IDs erstellt, die bei> = m beginnt und aus den Ziffern 0-9 besteht, wobei keine 2 aufeinander folgenden Zahlen gleich sind, z. B. 1232 ok, 1233 ist nicht (enthält 2 '3 nebeneinander).

Beispiel

für m = 985 zeigt n = 6, welche IDs generiert / übersprungen würden

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

Ausgabe

Jede ID sollte in einer neuen Zeile gedruckt werden, wie in der obigen Reihenfolge:

985
986
987
989
1010
1012

Regeln

Standard-Code-Golf-Regeln, die niedrigste Anzahl an Bytes gewinnt

Gelee , 6 Bytes

DIẠµ#Y

Probieren Sie es online!

Wie es funktioniert?

DIẠµ # Y - Volles Programm. Argument: zwei ganze Zahlen, X und Y.

   µ # - Gibt die ersten Y-Ganzzahlen über oder gleich X zurück, die erfüllen:
 I - Die Inkremente ...
D - ... von ihren 10-stelligen Basisziffern ...
  Ạ - ... Sind alle nicht 0. 
     Y - Verbinden Sie das Ergebnis durch Zeilenumbrüche.

Brachylog , 11 10 Bytes

{≤ṫẹ~ḅẉ}ᶠ⁾

Die Eingabe ist eine Liste von zwei Zahlen. Probieren Sie es online!

Erläuterung

Das eingebaute Programm ḅnimmt eine Liste oder einen String wie "1000220"und teilt ihn in Blöcke von gleichen benachbarten Elementen wie auf ["1","000","22","0"]. In diesem Programm wende ich den ~Operator darauf an, sodass es umgekehrt funktioniert: Es nimmt eine Liste von Zeichenfolgen auf, überprüft, ob jede Zeichenfolge aus Wiederholungen eines einzelnen Zeichens besteht und benachbarte Zeichenfolgen unterschiedliche Zeichen haben, und verkettet die Liste. Das Prädikat ≤zählt die Zahlen beginnend mit der ersten Eingabe in aufsteigender Reihenfolge auf, und ich überprüfe eine Bedingung für sie, drucke diejenigen, die sie erfüllen, und stoppe, wenn ich genug gefunden habe.

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

µÐÔQi=¼}>

Probieren Sie es online!

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 Bytes

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

Erläuterung:

Probieren Sie es online aus.

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

Probieren Sie es online!

Grundsätzlich ähnlich den anderen Antworten. Solange wir noch Zahlen zum Ausdrucken haben ( for(;$n)), wird geprüft, ob eine Regex-Übereinstimmung mit einer zweistelligen übereinstimmt. Wenn dies nicht der Fall ist, wird diese in die Pipeline übernommen und verringert $n. Dann inkrementieren wir $mund wiederholen die Schleife. Die Elemente werden aus der Pipeline Write-Outputabgerufen und das Implizite gibt uns kostenlos eine durch Zeilenumbrüche getrennte Ausgabe.

R , 111 92 71 Bytes

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

Probieren Sie es online!

Anwendungen greplfür wiederholte Ziffern zu suchen.

Gelee , 9 Bytes

DŒgZLỊµ#Y

Probieren Sie es online!

Wenn nicht für die Ausgabeeinschränkung, Ykann entfernt werden.

C 73 Bytes

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

Probieren Sie es online!

Perl 6 , 56 Bytes

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

Versuch es

Erweitert:

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

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

Probieren Sie es online! Nimmt nund mals Eingabe in separaten Zeilen. Erläuterung:

.0A`

Schalten Sie die automatische Ausgabe aus und löschen Sie sie naus dem Arbeitspuffer.

"$+"{

Wiederhole das nmal.

\

Geben Sie den Wert von mam Ende der folgenden geschleiften Gruppe aus.

/(.)\1/{`

Schleife solange es zusammenhängende Ziffern gibt.

.+
*

In Unary konvertieren.

)C`

Zählen Sie die Anzahl der leeren Zeichenfolgen, die um eins höher ist als die Anzahl der Zeichen. Addieren Sie also 1 und konvertieren Sie zurück in Dezimalzahlen. Dies beendet die innere Schleife.

.+
*

Fügen Sie nach dem Drucken mauf die gleiche Weise erneut 1 hinzu. (Die letzte Zeile benötigt kein a, C`da dies der Standard-Stufentyp für die letzte Zeile ist.) Die äußere Schleife wird implizit beendet.

Beachten Sie, dass die Konvertierung nach Unary und zurück nach Decimal etwas langsam ist. für 39 Bytes eine Version, die keine Konvertierung vornimmt:

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

Probieren Sie es online! Erläuterung: $.(Berechnet die Länge des Restes der Ersetzung, ohne sie tatsächlich zu erweitern. Da die Länge von *_implizit dem übereinstimmenden Wert entspricht und die Länge _von natürlich 1 ist, wird der Wert nur erhöht.

Perl 5.10.0 + -n, 40 39 Bytes

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

Probieren Sie es online!

-1 Byte dank Xcali

Eingabe in zwei Zeilen, zuerst n, dann m. Stellen Sie sicher, dass nach m KEINE neue Zeile steht:

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

Perl 5 , -ln33 Bytes

Geben Sie bei STDIN 2 Zeilen ein, beginnen Sie zuerst mit id und zählen Sie dann

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

Probieren Sie es online!

Python 2 , 80 73 Bytes

^{-7 Bytes dank Mr. Xcoder}

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

Probieren Sie es online!

Haskell , 70 Bytes

-19 bytes dank nimi.

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

Probieren Sie es online!

17 Bytes zum Trennen von Zeilenumbrüchen.

Stax , 9 8 Bytes ^CP437

ç@F6╕↔┤ú

Probieren Sie es online!

Passiert zufällig mit @ Mr.Xcoders Algorithmus in seiner Gelee-Antwort.

-1 Byte pro Kommentar von @recursive.

Erläuterung

Verwendet das entpackte Format zur Erklärung.

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

-1 Byte dank Laikoni
-2 Byte dank 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

Probieren Sie es online!

Erster Haskell Golf.

Pyth , 12 Bytes

j.f.A.+jZTEQ

Probieren Sie es hier aus

JavaScript (ES6), 50 Byte

Übernimmt Eingaben in der Currying-Syntax (m)(n).

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

Probieren Sie es 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 von @Steadybox 'C antworten.

Probieren Sie es online aus.

Perl 5 ( -nl), 42 Bytes

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

Probieren Sie es online!

AWK , 90 Bytes

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

Probieren Sie es online!

Das ist viel hässlicher als ich dachte. Ich entdeckte, dass AWKnur eine Rücksubstitution in der gensubFunktion vorhanden ist, wodurch die Verwendung für diese Anwendung nicht sehr effizient wäre.

Dies ist also eine sehr einfache Methode, um einen ID-Zähler zu erhöhen, den Zähler auf jedes Zeichen aufzuteilen und die Zeichen zu durchlaufen, um festzustellen, ob ein Zeichen mit dem vorherigen Zeichen identisch ist. Wenn keine wiederholten Zeichen gefunden werden, drucken Sie den ID-Zähler und erhöhen Sie die Anzahl der gedruckten IDs.

Ich werde versuchen, keine Aussage im Sinne von " AWKsollte die Fähigkeit haben, stabilere reguläre Ausdrücke zu machen" zu machen, aber es wird schwierig sein.

Bash + GNU-Dienstprogramme, 35

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

Probieren Sie es online aus .

Ruby , 47 Bytes

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

Probieren Sie es online!

Wenn Ihnen die Anführungszeichen nicht gefallen, sind es 50 Byte

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

Probieren Sie es online!

Pip , 22 Bytes

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

Probieren Sie es online!

Erläuterung

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