Dati 2 input (m = ID iniziale minimo , n = numero di ID ), genera un elenco sequenziale di ID, a partire da> = m, composto dalle cifre 0-9 in cui non esistono 2 numeri contigui uguali, ad esempio 1232 è ok, 1233 non lo è (contiene 2 '3 vicini l'uno all'altro).

Esempio

per m = 985, n = 6, di seguito mostra quali ID verrebbero generati / ignorati

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

Produzione

Ogni ID deve essere stampato su una nuova riga, come per la sequenza sopra:

985
986
987
989
1010
1012

Regole

Regole standard di golf di codice, vince il conteggio di byte più basso

Gelatina , 6 byte

DIẠµ#Y

Provalo online!

Come funziona?

DIẠµ # Y - Programma completo. Argomento: due numeri interi, X e Y.

   µ # - Restituisce i primi interi Y superiori o uguali a X che soddisfano:
 I - Gli incrementi ...
D - ... Delle loro cifre di base 10 ...
  Ạ - ... Sono tutti diversi da 0. 
     Y - Unisci il risultato con le nuove righe.

Brachylog , 11 10 byte

{≤ṫẹ~ḅẉ}ᶠ⁾

L'input è un elenco di due numeri. Provalo online!

Spiegazione

Il built-in ḅaccetta un elenco o una stringa, come"1000220" , e lo divide in blocchi di uguali elementi adiacenti, come ["1","000","22","0"]. In questo programma, vi applico l' ~operatore, quindi funziona al contrario: prende un elenco di stringhe, verifica che ciascuna stringa sia composta da ripetizioni di un singolo carattere e che le stringhe vicine abbiano caratteri diversi e concatena l'elenco. Il predicato ≤enumera i numeri a partire dal primo input in ordine crescente, e controllo una condizione su di essi, stampando quelli che lo soddisfano e fermandomi quando ne ho trovati abbastanza.

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

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

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

Spiegazione:

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

Provalo online!

Fondamentalmente simile alle altre risposte. Passa finché ci sono ancora numeri da stampare ( for(;$n)), verifica se abbiamo una corrispondenza regex rispetto a una doppia cifra e, se no, la mette sulla pipeline e diminuisce $n. Quindi incrementiamo $me ripetiamo il ciclo. Gli elementi vengono raccolti dalla pipeline e l'implicito Write-Outputci dà un output separato da newline gratuitamente.

R , 111 92 71 byte

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

Provalo online!

Utilizza greplper cercare cifre ripetute.

Gelatina , 9 byte

DŒgZLỊµ#Y

Provalo online!

Se non per la restrizione di output, Ypuò essere rimosso.

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

Provalo online!

Perl 6 , 56 byte

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

Provalo

Allargato:

{  # 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`
.+
*

Provalo online! Prende ne mcome input su righe separate. Spiegazione:

.0A`

Disattiva l'output automatico ed elimina ndal buffer di lavoro.

"$+"{

Ripeti i ntempi.

\

Stampa il valore di malla fine del seguente gruppo di loop.

/(.)\1/{`

Ripeti ciclicamente mentre ci sono cifre contigue.

.+
*

Converti in unario.

)C`

Contare il numero di stringhe vuote, che è uno in più rispetto al numero di caratteri, aggiungendo quindi 1 e convertendo nuovamente in decimale. Questo termina il ciclo interno.

.+
*

Dopo aver stampato m, aggiungere di nuovo 1 allo stesso modo. (L'ultima riga non ha bisogno di a C`perché è il tipo di stage predefinito per l'ultima riga.) Il loop esterno è implicitamente terminato.

Nota che la conversione in unaria e di nuovo in decimale è un po 'lenta; per 39 byte, una versione che non esegue alcuna conversione:

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

Provalo online! Spiegazione: $.(calcola la lunghezza del resto della sostituzione, comodamente senza effettivamente espanderla; poiché la lunghezza di *_è implicitamente il valore corrispondente e la lunghezza di _è ovviamente 1, questo aumenta semplicemente il valore.

Perl 5.10.0 + -n, 40 39 byte

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

Provalo online!

-1 byte grazie a Xcali

Inserire su due righe, prima n, quindi m. Assicurati che NON ci sia nuova riga dopo m:

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

Perl 5 ,-ln 33 byte

Immettere 2 righe su STDIN, prima id iniziale quindi conteggio

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

Provalo online!

Python 2 , 80 73 byte

^{-7 byte grazie a Mr. Xcoder}

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

Provalo online!

Haskell , 70 byte

-19 byte grazie a nimi.

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

Provalo online!

17 byte dedicati alla separazione per newline.

Stax , 9 8 byte ^CP437

ç@F6╕↔┤ú

Provalo online!

È successo che coincidesse con l'algoritmo di @ Mr.Xcoder nella sua risposta Jelly.

-1 byte per commento di @recursive.

Spiegazione

Utilizza il formato non compresso per spiegare.

{$:-|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 grazie a Laikoni
-2 byte grazie a 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

Provalo online!

Primo golf Haskell.

Pyth , 12 byte

j.f.A.+jZTEQ

Provalo qui

JavaScript (ES6), 50 byte

Accetta input nella sintassi del curry (m)(n).

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

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

Porta della risposta C di @Steadybox.

Provalo online.

Perl 5 ( -nl), 42 byte

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

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

Provalo online!

Questo è molto più brutto di quanto pensassi. Ho scoperto che AWKha solo una sostituzione sostitutiva nella suagensub funzione che non lo renderebbe molto efficiente da utilizzare per questa applicazione.

Quindi questo è un approccio molto semplice per incrementare un contatore ID, dividere il contatore per ogni personaggio, scorrere tra i personaggi per vedere se un personaggio è uguale al personaggio precedente. Se non viene trovato alcun carattere ripetuto, stampare il contatore ID e aumentare il numero di ID stampati.

Cercherò di astenermi dal fare una dichiarazione sulla falsariga di " AWKdovrebbe avere la capacità di fare espressioni regolari più solide", ma sarà difficile.

Utilità Bash + GNU, 35

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

Provalo online .

Rubino , 47 byte

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

Provalo online!

Se non ti piacciono le virgolette, sono 50 byte

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

Provalo online!

Pip , 22 byte

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

Provalo online!

Spiegazione

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