2 개의 입력 (m = 최소 시작 id , n = id 수)이 주어지면 > = m에서 시작하여 순차적 인 ID 목록을 생성합니다.> = m은 2 개의 연속 된 숫자가 같지 않은 숫자 0-9 (예 : 1232)입니다. 좋아, 1233은 아닙니다 (서로 2 '3이 들어 있습니다).

예

m = 985, n = 6의 경우 아래에서 생성 / 건너 뛰는 ID를 보여줍니다.

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

산출

위의 순서대로 각 ID는 새 줄에 인쇄되어야합니다.

985
986
987
989
1010
1012

규칙

표준 코드 골프 규칙, 최저 바이트 수로 승리

젤리 , 6 바이트

DIẠµ#Y

온라인으로 사용해보십시오!

어떻게 작동합니까?

DIẠµ # Y – 전체 프로그램. 인수 : X와 Y의 두 정수

   µ # – 다음을 만족하는 X 이상의 첫 번째 Y 정수를 반환합니다.
 I – 증분 ...
D – ... 10 자리 중 ...
  Ạ – ... 모두 0이 아닙니다. 
     Y – 줄 바꿈으로 결과에 참여합니다.

Brachylog , 11 10 바이트

{≤ṫẹ~ḅẉ}ᶠ⁾

입력은 두 숫자의 목록입니다. 온라인으로 사용해보십시오!

설명

내장 ḅ은과 같은 목록이나 문자열 을 가져 와서 "1000220"같은 인접 요소의 블록으로 나눕니다 ["1","000","22","0"]. 이 프로그램에서 ~연산자를 적용하면 역순으로 작동합니다. 문자열 목록을 가져와 각 문자열이 단일 문자의 반복으로 구성되어 있는지 확인하고 인접한 문자열은 다른 문자를 가지며 목록을 연결합니다. 술어 ≤는 첫 번째 입력부터 시작하여 숫자를 증가하는 순서로 열거하고 조건을 확인하여 조건을 만족하는 항목을 인쇄하고 충분히 찾았을 때 중지합니다.

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

µÐÔQi=¼}>

온라인으로 사용해보십시오!

확장

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

자바 8, 83 바이트

(m,n)->{for(;n>0;m++)if(!(m+"").matches(".*(.)\\1.*")){System.out.println(m);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 바이트

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

온라인으로 사용해보십시오!

기본적으로 다른 답변과 비슷합니다. 인쇄 할 숫자가 남아있는 한 루프 ( for(;$n))는 두 자리 숫자와 정규 표현식이 일치하는지 테스트하고 그렇지 않은 경우 파이프 라인에 배치하고 감소시킵니다 $n. 그런 다음 증가 $m하고 다시 반복합니다. 파이프 라인에서 요소를 가져오고 암시 적 Write-Output으로 줄 바꿈으로 구분 된 출력을 무료로 제공합니다.

R , 111 92 71 바이트

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

온라인으로 사용해보십시오!

grepl반복되는 숫자를 검색하는 데 사용 합니다.

젤리 , 9 바이트

DŒgZLỊµ#Y

온라인으로 사용해보십시오!

출력 제한이 아닌 경우 Y제거 할 수 있습니다.

C, 73 바이트

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

온라인으로 사용해보십시오!

펄 6 , 56 바이트

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

시도 해봐

넓히는:

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

망막 , 34 바이트

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

온라인으로 사용해보십시오! 취 n와 m별도의 라인 입력 등. 설명:

.0A`

자동 출력을 끄고 n작업 버퍼에서 삭제 하십시오.

"$+"{

n시간을 반복하십시오 .

\

m다음 반복 그룹의 끝에 있는 값을 인쇄하십시오 .

/(.)\1/{`

연속 숫자가있는 동안 루프합니다.

.+
*

단항으로 변환합니다.

)C`

빈 문자열의 수를 세십시오. 이는 문자 수보다 하나 이상이므로 1을 더하고 10 진수로 다시 변환합니다. 내부 루프가 종료됩니다.

.+
*

를 인쇄 m한 후 같은 방법으로 1을 다시 추가하십시오. 마지막 행은 마지막 행 C`의 기본 스테이지 유형이므로 필요하지 않습니다 . 외부 루프는 내재적으로 종료됩니다.

단항으로 변환하고 다시 소수로 변환하는 것은 약간 느립니다. 변환하지 않는 버전 인 39 바이트 :

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

온라인으로 사용해보십시오! 설명 : $.(실제로 대체하지 않고 나머지 대체의 길이를 계산합니다. 길이 *_는 내재적으로 일치하는 값이고 길이 _는 물론 1이므로 값을 증가시킵니다.

Perl 5.10.0 + -n, 40 39 바이트

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

온라인으로 사용해보십시오!

Xcali 덕분에 -1 바이트

두 줄에 먼저 n을 입력 한 다음 m을 입력합니다. m 다음에 줄 바꿈이 없는지 확인하십시오.

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

펄 5 , -ln33 바이트

STDIN에 2 줄을 입력하고 먼저 시작 ID를 입력 한 다음 계산

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

온라인으로 사용해보십시오!

파이썬 2 , 80 73 바이트

^{Mr. Xcoder 덕분에 -7 바이트}

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

온라인으로 사용해보십시오!

하스켈 , 70 바이트

nimi 덕분에 -19 바이트

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

온라인으로 사용해보십시오!

줄 바꿈으로 분리하는 데 사용되는 17 바이트.

Stax , 9 8 바이트 ^CP437

ç@F6╕↔┤ú

온라인으로 사용해보십시오!

그의 젤리 답변에서 @ Mr.Xcoder의 알고리즘과 일치합니다.

@recursive에 의한 주석 당 -1 바이트.

설명

압축을 푼 형식을 사용하여 설명합니다.

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

하스켈 , 94 93 91 바이트

Laikoni 덕분에 -1 바이트 Zgarb 덕분에
-2 바이트

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

온라인으로 사용해보십시오!

퍼스트 하스켈 골프.

Pyth , 12 바이트

j.f.A.+jZTEQ

여기 사용해보십시오

자바 스크립트 (ES6), 50 바이트

카레 구문으로 입력을 (m)(n)받습니다.

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

온라인으로 사용해보십시오!

C # (. NET 코어), 91 바이트

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

@Steadybox의 C 답변 포트.

온라인으로 사용해보십시오.

펄 5 ( -nl), 42 바이트

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

온라인으로 사용해보십시오!

AWK , 90 바이트

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

온라인으로 사용해보십시오!

이것은 내가 생각했던 것보다 훨씬 추악합니다. 이 응용 프로그램에 사용하기가 매우 효율적이지 않은 기능에 AWK역 치환 만 있음을 발견했습니다 gensub.

따라서 이것은 ID 카운터를 증가시키고 각 문자에서 카운터를 분할하고 문자를 반복하여 문자가 이전 문자와 동일한 지 확인하는 매우 간단한 접근 방식입니다. 반복되는 문자가 없으면 ID 카운터를 인쇄하고 인쇄 된 ID 수를 늘리십시오.

나는 " AWK보다 강력한 정규 표현식을 수행 할 수있는 능력을 가져야한다 "라는 문구를 따라 진술 하지는 않겠지 만 어려울 것이다.

배쉬 + GNU 유틸리티, 35

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

온라인으로 사용해보십시오 .

루비 , 47 바이트

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

온라인으로 사용해보십시오!

따옴표가 마음에 들지 않으면 50 바이트입니다.

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

온라인으로 사용해보십시오!

핍 , 22 바이트

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

온라인으로 사용해보십시오!

설명

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