รับ 2 อินพุต (m = รหัสเริ่มต้นขั้นต่ำ , n = จำนวนรหัส ), สร้างรายการลำดับของรหัสเริ่มต้นที่> = m, ประกอบด้วยตัวเลข 0-9 โดยไม่มีตัวเลขต่อเนื่อง 2 หมายเลขเช่น 1232 คือ ตกลง 1233 ไม่ใช่ (มี 2 '3 อยู่ติดกัน)

ตัวอย่าง

สำหรับ m = 985, n = 6, ด้านล่างแสดงรหัสที่จะสร้าง / ข้าม

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

   µ # - คืนค่าจำนวนเต็ม Y แรกที่มากกว่าหรือเท่ากับ X ที่ตอบสนอง:
 ฉัน - ส่วนเพิ่ม ...
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=¼}>

ลองออนไลน์!

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 ไบต์

(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)) การทดสอบว่าเรามีการแข่งขัน regex $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;}

ลองออนไลน์!

Perl 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 และแปลงกลับเป็นทศนิยม นี่เป็นการจบลูปภายใน

.+
*

เมื่อพิมพ์mแล้วให้เพิ่ม 1 อีกครั้งในวิธีเดียวกัน (บรรทัดสุดท้ายไม่จำเป็นต้องมีC`เพราะเป็นประเภทสเตจเริ่มต้นสำหรับบรรทัดสุดท้าย) การวนรอบนอกสิ้นสุดลงโดยปริยาย

โปรดทราบว่าการแปลงเป็นเอกและกลับเป็นทศนิยมนั้นช้าไปหน่อย สำหรับ 39 ไบต์เวอร์ชันที่ไม่ทำการแปลง:

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

ลองออนไลน์! คำอธิบาย: $.(คำนวณความยาวของการเปลี่ยนตัวที่เหลือโดยสะดวกโดยไม่ต้องขยาย เนื่องจากความยาวของ*_คือค่าที่จับคู่โดยนัยและความยาวของ_คือ 1 แน่นอนว่านี่เป็นการเพิ่มมูลค่า

Perl 5.10.0 + -n, 40 39 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณ Xcali

ใส่สองบรรทัดแรก n จากนั้น m ตรวจสอบให้แน่ใจว่าไม่มีการขึ้นบรรทัดใหม่หลังจาก m:

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

Perl 5 ,-ln 33 ไบต์

ป้อน 2 บรรทัดบน STDIN โดยเริ่มจาก id แรกแล้วนับ

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

ลองออนไลน์!

Python 2 , 80 73 ไบต์

^{-7 ไบต์ขอบคุณ Mr. Xcoder}

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

ลองออนไลน์!

Haskell , 70 ไบต์

-19 ไบต์ขอบคุณ nimi

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

ลองออนไลน์!

17 ไบต์ทุ่มเทให้กับการแยกโดยการขึ้นบรรทัดใหม่

Stax , 9 8 ไบต์^CP437

ç@F6╕↔┤ú

ลองออนไลน์!

เกิดขึ้นพร้อมกับอัลกอริทึมของ @ Mr.Xcoder ในคำตอบของเยลลี่

-1 ไบต์ต่อความคิดเห็นโดย @recursive

คำอธิบาย

ใช้รูปแบบที่คลายการแพคเพื่ออธิบาย

{$:-|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 ไบต์

-1 ไบต์ขอบคุณ Laikoni
-2 ไบต์ขอบคุณ 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

ลองออนไลน์!

เฟิร์ส Haskell กอล์ฟ

Pyth , 12 ไบต์

j.f.A.+jZTEQ

ลองที่นี่

JavaScript (ES6), 50 ไบต์

(m)(n)จะเข้าในไวยากรณ์ currying

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

ลองออนไลน์!

C # (. NET Core) 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

ลองออนไลน์

Perl 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ควรมีความสามารถในการทำนิพจน์ปกติที่แข็งแกร่งมากขึ้น" แต่มันจะยาก

ยูทิลิตี Bash + GNU, 35

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

ลองมันออนไลน์

Ruby , 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}

ลองออนไลน์!

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