เพื่อเป็นเกียรติแก่ตัวแทนเท่าที่ฉันมีหลายชั่วโมงที่ผ่านมาเมื่อฉันคิดถึงความท้าทายนี้เป็นครั้งแรก:

เบอร์เช่นนี้ที่จะทำขึ้นของตัวเลขหลักเดียวซ้ำจะเรียกว่าrepdigits Repdigits สนุก! ร่างกายทุกคนจะมีความสุขมากขึ้นถ้าปริมาณของตัวแทนพวกเขามีความเป็น repdigit ¹แต่ผมใจร้อนดังนั้นคุณจึงจำเป็นที่จะช่วยฉันหาวิธีที่เร็วที่สุดที่จะได้รับ repdigit

นี่คือความท้าทายของคุณ:

รับจำนวนเต็มบวกที่เป็นตัวแทนของชื่อเสียงส่งออกจำนวนตัวแทนขั้นต่ำที่พวกเขาต้องการเพื่อรับไปยัง repdigit ตัวอย่างเช่นในขณะที่เขียนความท้าทายนี้ผู้ใช้Martin Enderมีตัวแทน 102,856 คน หมายเลขตัวแทนที่ใกล้ที่สุดคือ 111,111 ดังนั้นเขาจะต้องได้รับ: 8255 ตัวแทนจะต้องเป็น repdigit

เนื่องจากคนไม่ชอบการสูญเสียตัวแทนเราจะพิจารณาเฉพาะการเปลี่ยนแปลงที่ไม่เป็นลบ ซึ่งหมายความว่าตัวอย่างเช่นหากใครบางคนอยู่ที่ 12 ตัวแทนแทนที่จะเสีย 1 ตัวแทนโซลูชันจะได้รับ 10 ตัวแทน สิ่งนี้อนุญาตให้ '0' เป็นเอาต์พุตที่ถูกต้องเนื่องจากใครก็ตามที่มี 111 rep อยู่ที่ repdigit แล้ว

อินพุตและเอาต์พุตสามารถอยู่ในรูปแบบที่เหมาะสมและเนื่องจากเป็นไปไม่ได้ที่จะมีน้อยกว่า 1 ตัวแทนในไซต์ Stack Exchange ใด ๆ คุณจึงสามารถสรุปได้ว่าไม่มีอินพุตใดจะน้อยกว่า 1

หนึ่ง Cornercase ที่ควรทราบ:

หากผู้ใช้มีตัวแทนน้อยกว่า 10 คนพวกเขาจะอยู่ที่ repdigit อยู่แล้วดังนั้นพวกเขาจึงต้องการ '0'

ทดสอบ IO:

#Input      #Ouput
8           0
100         11
113         109
87654321    1234567
42          2
20000       2222
11132       11090

มีช่องโหว่มาตรฐานใช้และทางออกที่สั้นที่สุดในหน่วยไบต์ชนะ!

เยลลี่ 6 ไบต์

DE$1#_

เอาต์พุตเป็นอาร์เรย์แบบซิงเกิล

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบมากที่สุด กรณีทดสอบ87654321ช้าเกินไปสำหรับ TIO

มันทำงานอย่างไร

DE$1#_  Main link. Argument: n

   1#   Call the link to the left with argument k = n, n + 1, n + 2, etc. until one
        match is found, then return the matching k.
  $       Combine the two links to the left into a monadic chain.
D           Convert k to base 10.
 E          Test if all decimal digits are equal.
     _  Subtract n from the result.

Haskell, 39 ไบต์

until(((==).head>>=all).show)(+1)>>=(-)

ลองออนไลน์

Brachylogขนาด 9 ไบต์

:.#++#==,

ลองออนไลน์!

มันค่อนข้างมีประสิทธิภาพเพราะใช้ประโยชน์จากข้อ จำกัด ทางคณิตศาสตร์

คำอธิบาย

:.            The list [Input, Output].
  #+          Both elements must be positive or zero.
    +         The sum of those two elements…
     #=       …must result in an integer where all digits are the same.
       =,     Assign a value that matches those constraints.

Python 2, 41 40 ไบต์

def f(n):r=10**len(`n`)/9;print-n/r*-r-n

ไม่ใช่วิธีที่สั้นที่สุด แต่มีประสิทธิภาพมาก ทดสอบบนIdeone Ideone

มันทำงานอย่างไร

สำหรับการป้อนข้อมูล10**len(`n`)รอบnถึงอำนาจที่ใกล้ที่สุดของ10 หลังจากนั้นเราแบ่งผลโดย9 ผลตอบแทนนี้ repdigit 1 ... 1ที่มีเป็นตัวเลขมากที่สุดเท่าที่n เราบันทึกผลในR ตัวอย่างเช่นถ้าn = 87654321แล้วr = 11111111

repdigit ที่ต้องการจะมีหลายคนหรือR ที่จะตัดสินใจว่าเราดำเนินการส่วนเพดานของnโดยR เนื่องจาก/พื้นของส่วนควบคุมของ Python 2 สามารถทำได้ด้วย-n/rซึ่งจะให้ค่าสัมบูรณ์ที่ถูกต้องพร้อมเครื่องหมายลบ ตัวอย่างเช่นถ้าn = 87654321นี่จะส่งคืน-8 -8

สุดท้ายเราคูณหารคำนวณโดย-rที่จะทำซ้ำหารครั้งเดียวสำหรับแต่ละหลักในn ตัวอย่างเช่นถ้าn = 87654321จะส่งคืน88888888ซึ่งเป็น repdigit ที่ต้องการ

สุดท้ายในการคำนวณการเพิ่มที่ต้องการเราจะลบnจากผลลัพธ์ก่อนหน้า สำหรับตัวอย่างของเราn = 87654321นี่จะคืนค่า1234567ตามที่ต้องการ

Python 2, 37 ไบต์

f=lambda n:1-len(set(`n`))and-~f(n+1)

ทดสอบบนIdeone โปรดทราบว่าวิธีการนี้จะไม่มีประสิทธิภาพเกินไปสำหรับกรณีทดสอบ87654321

มันทำงานอย่างไร

ถ้าnมีอยู่แล้ว repdigit ที่1-len(set(`n`))จะกลับ0ตั้งแต่ความยาวของชุดของn 's ตัวเลขฐาน 10 จะเป็น1 ในกรณีนี้fส่งคืน0 0

ถ้าnไม่ได้เป็น repdigit, f(n+1)ซ้ำเรียกฉมีค่าที่เป็นไปได้ต่อไปของn -~เพิ่มค่าส่งคืนของf ( 0เมื่อพบ repdigit) 1ครั้งทุกครั้งที่fถูกเรียกซ้ำดังนั้นค่าตอบแทนสุดท้ายจะเท่ากับจำนวนครั้งที่fถูกเรียกเช่นจำนวนครั้งที่nต้องเพิ่มขึ้นเป็น รับ repdigit

Perl 6 , 23 ไบต์

{($_...{[==] .comb})-1}

แลมบ์ดาที่รับหมายเลขอินพุตเป็นอาร์กิวเมนต์และส่งคืนผลลัพธ์

คำอธิบาย:

1. ใช้...โอเปอเรเตอร์ลำดับเพื่อเพิ่มจำนวนอินพุตจนกว่าจะถึง repdigit (ทดสอบโดยแบ่งการแสดงสตริงออกเป็นอักขระและดูว่าพวกมันเท่าเทียมกันหรือไม่) (ทดสอบโดยแยกเป็นตัวแทนสตริงเป็นตัวอักษรและเห็นว่าพวกเขากำลังเท่ากันทั้งหมด)
2. ลบหนึ่งจากความยาวของลำดับ

Java 7, 116 76 ไบต์

int c(int i){int r=(int)Math.pow(10,(i+"").length())/9;return(-i/r-1)*-r-i;}

ใช้วิธีการที่น่าทึ่งของ@Dennisเพื่อลดจำนวนไบต์ด้วยการเพิ่มขนาด 40 ไบต์

กรณีที่ไม่ได้รับการทดสอบ &:

ลองที่นี่

class Main{
  static int c(int i){
    int r = (int)Math.pow(10, (i+"").length()) / 9;
    return (-i / r - 1) * -r - i;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }
}

เอาท์พุท:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 ไบต์

1 ไบต์ต้องขอบคุณ @FryAmTheEggman

-f@F`TQ

ลองออนไลน์

ไม่มีประสิทธิภาพมากวนซ้ำทุกตัวเลขจากอินพุตไปยัง repdigit ถัดไป

Brain-Flak 690 358 ไบต์

นี่ฉันไปที่มัน

(({})[()])(()){{}(({}())){(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)}{}<>{(([])<{{}({}[()]<>)<>([])}{}><>){({}[()]<({}<>)<>>)}{}<>}([]){{}{(<({}<>)<>>)}{}([])}{}<>(([][()()])<{{}{}([][()()])}{}>)}{}({}[{}])

ลองใช้ออนไลน์

คำอธิบาย

เริ่มต้นด้วยการทำสำเนาของอินพุตที่สองซึ่งน้อยกว่าต้นฉบับ เราจะใช้สำเนาเพื่อค้นหา repdigit ต่อไป เราลบหนึ่งตัวในกรณีที่จำนวนตัวเองเป็น repdigit

(({})[()])

กดหนึ่งเพื่อตอบสนองการวนรอบที่จะมา (ไม่จำเป็นต้องเป็นเพียงแค่ไม่เป็นศูนย์)

(())

ลูปนี้จะทำงานจนกว่าจะมี repdigit ที่ด้านบนของสแต็ก

{

ป๊อปอึ พวกมันคือ "บูลีน" ที่อยู่ด้านบนที่ขับเคลื่อนลูปเนื่องจากมันไม่ต้องการอีกต่อไปเราจึงนำมันออกมา

{}

เพิ่มหนึ่งรายการและทำซ้ำส่วนบนสุด สำเนาจะถูกแยกย่อยเป็นตัวเลข

(({}()))

ในขณะที่การคัดลอกไม่เป็นศูนย์ ...

{

คัดลอกอีกครั้ง

(({}))

Mod 10 และย้ายไปที่สแต็กอื่น

(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>

หารด้วย 10 (ส่วนจำนวนเต็ม)

(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)

}

เติมศูนย์ที่เป็นสำเนาของเรา

{}

ตอนนี้เราได้แบ่งตัวเลขออกเป็นฐาน 10 หลักแล้วเราจึงสลับไปยังสแต็คด้วยตัวเลขทั้งหมด

<>

ในขณะที่ตัวเลขนำหน้าไม่เป็นศูนย์

{

เรารับสำเนาของความสูงของสแต็ก (เช่นจำนวนหลัก) ...

(([])<

ลบหนึ่งในทุก ๆ หมายเลขบนสแต็กอย่างเงียบ ๆ

{
{}
({}[()]<>)<>
([])
}
{}

ใส่ความสูงของสแต็กที่เราหยิบขึ้นมา (และสลับไปที่สแต็กอื่น)

><>)

เราใช้ความสูงของสแต็กเพื่อดึงตัวเลขทั้งหมดที่เราวางบนสแต็กอื่นกลับไปยังสแต็กที่เหมาะสม

{
({}[()]<({}<>)<>>)
}

แสดงศูนย์ที่เป็นความสูงของสแต็กของเรา

{}

สลับกลับไปยังสแต็กด้วยตัวเลข (หรือตัวเลขคืออะไร)

<>

จบห่วง

}

ตอนนี้เราได้ลบตัวเลขสูงสุดจากตัวเลขอื่น ๆ ทั้งหมด หากตัวเลขทั้งหมดเป็นศูนย์หมายเลขเดิม (ไม่ใช่อินพุต แต่หมายเลขที่เรากำลังตรวจสอบ) เป็น repdigit [ต้องการอ้างอิง] ดังนั้นเราต้องตรวจสอบไม่ใช่ศูนย์

ในขณะที่ความสูงของสแต็กไม่เป็นศูนย์

([])
{
{}

หากตัวเลขไม่ใช่ศูนย์ให้ย้ายไปยังสแต็กอื่นและแทนที่ด้วยศูนย์

{
(<({}<>)<>>)
}

ป๊อปมัน (ตอนนี้มันเป็นศูนย์)

{}

จบห่วง

([])
}
{}

สลับไปที่สแต็กอื่น (duh .. )

<>

คว้าตัวสำเนาความสูงสแต็คลบสองตัว

(([][()()])<

ในขณะที่ความสูงของสแต็กไม่ใช่สอง (ดั้งเดิมและสะสม)

{
{}

ป๊อปด้านบน

{}

สิ้นสุดในขณะที่

([][()()])
}
{}

วางสำเนาความสูงสแต็กของเราลบสองลง สิ่งนี้จะกลายเป็นจำนวนหลักที่ไม่เหมือนกับหลักแรก กล่าวอีกนัยหนึ่งถ้าเป็นศูนย์จะเป็น repdigit

>)

หากลูปนี้จบลงเราจะพบ repdigit

}

ป๊อป "บูลีน"

{}

ลบต้นฉบับออกจาก repdigit

({}[{}])

Python 2, 52 ไบต์

a=b=input()
while len(set(str(a)))!=1:a+=1
print a-b

Python 2 มีลูกเล่นมากมายที่ทำให้เรื่องนี้สั้นลง ตัวอย่างเช่นอินพุตเป็นตัวเลขดังนั้นเราจึงไม่จำเป็นต้องแปลงค่าเป็น int (-5 ไบต์) นอกจากนี้เราไม่จำเป็นต้องใส่วงเล็บล้อมรอบa-b(-1 ไบต์)

ใช้สคริปต์นี้เพื่อตรวจสอบกรณีทดสอบทั้งหมด:

def f(i):
    a=b=i
    while len(set(str(a)))!=1:a+=1
    return a-b

inputs = [8, 100, 113, 87654321, 42, 20000, 11132]
outputs = [0, 11, 109, 1234567, 2, 2222, 11090]

for i in range(len(inputs)):
    print(f(inputs[i]) == outputs[i])

คุณอาจลองออนไลน์!

GNU sed, 223 + 1 (แฟล็ก r) = 224 ไบต์

s/$/:0%/
:;y/:%/%:/
/^(.)\1*%/{s/.*%(.*):/\1/;q}
:f;s/9(@*:)/@\1/;tf
s/8(@*:)/9\1/;s/7(@*:)/8\1/
s/6(@*:)/7\1/;s/5(@*:)/6\1/
s/4(@*:)/5\1/;s/3(@*:)/4\1/
s/2(@*:)/3\1/;s/1(@*:)/2\1/
s/0(@*:)/1\1/;s/(^|%)(@*:)/\11\2/
y/@/0/;t

วิ่ง:

sed -rf repdigit.sed <<< "112"

เอาท์พุท:

110

นี่เป็นวิธีการแก้ปัญหาที่บริสุทธิ์โดยใช้การจำลองทางคณิตศาสตร์เท่านั้น อัลกอริทึมทำงานดังต่อไปนี้:

1. รูปแบบพื้นที่รูปแบบถูกตั้งค่าเป็น ^current_reputation:needed_reputation%$
2. ในการวนซ้ำแต่ละครั้งของลูปหลักตัวคั่นจะถูกสลับ:
   a) %:ใช้การเพิ่มขึ้นกับneeded_reputation
   b) :%ใช้การเพิ่มขึ้นกับcurrent_reputation
3. ถ้าcurrent_reputationเป็น "repdigit" ( จำเป็นต้องมี) จะถูกพิมพ์และโปรแกรมจะสิ้นสุดลง

ชวา 74 72 ไบต์

int c(int i){int n=0;while(!(i+++"").matches("^(.)\\1*$"))n++;return n;}

(หากรายการ Java อื่นคือ 76 ไบต์รายการนี้คือ74 72 เนื่องจากมันเป็น สอง สั้นลงสี่ไบต์)

อย่างไรก็ตามเพียงแค่เพิ่มอินพุตจนกว่าจะเป็น repdigit ในขณะที่เพิ่มตัวนับ ส่งคืนเคาน์เตอร์

ใช่มันคือสามบวกในแถวสองเพื่อเพิ่มอินพุตหนึ่งเพื่อเชื่อมสตริงว่างเพื่อทำให้เป็นสตริง
ไม่ฉันไม่คิดว่ามันจะถูกกฎหมายหากไม่มีช่องว่างระหว่างทั้งสอง แต่คุณไป นั่นคือสิ่งที่พิมพ์ผิดจะทำเพื่อคุณ: สั้นลงหนึ่งไบต์

การใช้ for-loop แทนที่จะใช้เวลาสักครู่จะใช้จำนวนไบต์เท่ากันทั้งหมด:

int c(int i){int n=0;for(;!(i+++"").matches("^(.)\\1*$");n++);return n;}

แก้ไข:

เวอร์ชันก่อนหน้านี้ต้องmatches("^(\\d)\\1*$")ตรวจสอบ repdigit แต่เนื่องจากเราเพิ่งแปลง int เป็นสตริงการใช้ a .to match ก็เพียงพอแล้ว

กรณีที่ไม่ได้รับการทดสอบ &:

ลองที่นี่

class Main{
  static int c(int i){
    int n=0;
    while(!(i++ + "").matches("^(.)\\1*$")) {
      n++;
    }
    return n;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }

}

เอาท์พุท:

0
11
109
1234567
2
2222
11090

R, 102 98 91 ไบต์

a=scan(,'');i=0;while(length(unique(strsplit(a,"")[[1]]))!=1){a=paste(strtoi(a)+1);i=i+1};i

Ungolfed:

a=scan(,'') #Asks for input
i=0         #Initialize i to 0, surprisingly

while(length(unique(strsplit(a,"")[[1]]))!=1) 
    #Splits the input into its digits,  
    #compute the length of the vector created by the function `unique`, which gives all the digits once.
    #as long as the this length is different from one :
{
a=paste(strtoi(a)+1) #Increases by one the value of the input (while messing around with its format)
i=i+1                           #Increases by one the value of the counter
}

i #Outputs the counter

ล้อเล่นรอบกับรูปแบบ ( as.numericและas.character ) เพิ่มบางไบต์ แต่Rไม่ยืดหยุ่นจริงๆ!

Perl, 40 + 1 ( -n) = 41 ไบต์

/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo

หากไม่มีการพิมพ์อะไรเลยแทนที่จะเป็น0เมื่อจำนวนที่มีอยู่แล้ว repdigit นั้นยอมรับได้แล้ว 37 ไบต์ก็เพียงพอแล้ว:

/^(.)\1*$/&&say$v or$_++&&++$v&&redo

ทำงานด้วย -n (1 ไบต์) และ-Eหรือ-M5.010(ฟรี):

perl -nE '/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo'

คำอธิบาย : มีสองส่วนที่สำคัญในรหัส: และ/^(.)\1*$/&&say$v $_++&&++$v&&redoการทดสอบครั้งแรกถ้า$_เป็น repdigit; ถ้าใช่มันพิมพ์หมายเลขที่เราเพิ่มเข้าไปในหมายเลขเดิมเพื่อให้เป็น repdigit ( $v) และถ้าไม่เรามี 1 ทั้งคู่$_และ$vและเริ่มใหม่

JavaScript (ES6), 42 ไบต์

f=(n,p=1)=>n<p?-~(n*9/p)*~-p/9-n:f(n,p*10)

คำอธิบาย: ซ้ำคำนวณpเป็นอำนาจต่อไปของหลัง10 nตัวเลขที่จะต้องทำซ้ำนั้นจะถูกคำนวณเป็น1+floor(9n/p)และการจ่ายคืนจะเป็นเพียง(p-1)/9ซึ่งผลลัพธ์ดังต่อไปนี้

05AB1E , 10 6 ไบต์

∞.Δ+Ë

ลองออนไลน์!

คำอธิบาย

∞<      # from the infinite list of non-negative integers
  .Δ    # find the first number where
     Ë  # all digits are equal
    +   # after adding the input

Pyke, 13 11 ไบต์

o+`}ltIr)ot

ลองที่นี่!

            - o = 0
o+          -     o++ + input
  `         -    str(^)
   }        -   deduplicate(^)
    lt      -  len(^)-1
      I )   - if ^:
       r    -  goto_start()
         ot - o++ -1

ที่จริงแล้ว 15 ไบต์

;D;WXu;$╔l1<WX-

ลองออนไลน์!

คำอธิบาย:

;D;WXu;$╔l1<WX-
;                dupe
 D;              decrement, dupe
   WXu;$╔l1<W    while top of stack is truthy:
    X              discard
     u             increment
      ;            dupe
       $╔l1<       1 if len(str(TOS)) > 1 else 0 (check if the string representation of the TOS contains only one unique digit)
                 after the loop, the stack will be [1 repdigit input]
             X   discard
              -  subtract input from repdigit

แมงกะพรุนขนาด 20 ไบต์

p
<
)\&&&~j<i
->N>u0

ลองออนไลน์! TIO ไม่สามารถจัดการกรณีทดสอบที่ยาวขึ้นได้ แต่ให้เวลาและหน่วยความจำเพียงพอพวกเขาควรทำงานด้วย

คำอธิบาย

• iเป็นอินพุตและ<ลดค่าลง ค่านี้จะถูกป้อนเข้ากับฟังก์ชันทางด้านซ้าย
• \> เพิ่มค่า (อย่างน้อยหนึ่งครั้ง) จนกระทั่งฟังก์ชันทางด้านขวาให้ค่าจริง
• ฟังก์ชั่นทดสอบเป็นองค์ประกอบ (โดย&s) ของสี่ฟังก์ชั่น
• 0~j แปลงเป็นสตริง
• u ลบตัวเลขที่ซ้ำกัน
• > ลบส่วนหัวของสตริงผลลัพธ์
• Nเป็นการปฏิเสธแบบตรรกะ: มันให้1สตริงที่ว่างเปล่าและ0ไม่ว่างเปล่า ดังนั้นการทดสอบฟังก์ชั่นสำหรับตัวแทนหลักและผลลัพธ์ของ\การนับตัวแทนหลักถัดไปจาก<iเป็นตัวแทนต่อไปนับจากหลัก
• )- ลบผลลัพธ์จากฟังก์ชั่นอินพุตนั่นคือ <iที่อยู่,
• ความแตกต่างนี้ถูกปิดไปหนึ่งรายการดังนั้น<จะลดลง ในที่สุดpพิมพ์ผลลัพธ์

PowerShell v2 +, 66 ไบต์

param($n)for($x=+"$($n[0])";($y="$x"*$n.length)-lt$n;$x++){}+$y-$n

การเล่นกอล์ฟ PowerShell ที่ไม่ค่อยจะดีนักสำหรับนักกอล์ฟนั้นเป็นความล้มเหลวครั้งใหญ่ที่นี่

รับอินพุต$nเป็นสตริงและเข้าสู่forลูป สำหรับขั้นตอนการตั้งค่าเราแยกอักขระตัวแรกออก$n[0]แต่ต้องแปลงกลับเป็นสตริง"$(...)"ก่อนที่จะทำการคัดเลือกเป็น int +และบันทึกเป็น$xและบันทึกลงในมิฉะนั้นคณิตศาสตร์ในภายหลังจะใช้ค่า ASCII ของรหัสตัวอักษร

ตรวจสอบเงื่อนไขไม่ว่าจะเป็นสตริงสร้างจาก$n.length "$x"S, เก็บไว้ชั่วคราวในเป็นน้อยกว่า$y $nตราบใดที่ไม่ใช่เราก็เพิ่มขึ้น$x++ตั้งเงื่อนไขสำหรับลูปถัดไป

ตัวอย่างเช่นสำหรับอินพุต123ค่า$yเมื่อเงื่อนไขถูกตรวจสอบก่อนจะเป็น111ซึ่งน้อยกว่า$nดังนั้นวงต่อไป ไม่มีสิ่งใดในร่างกายลูปดังนั้นการเพิ่มขั้นตอนจะเกิดขึ้น$x++จากนั้นตรวจสอบเงื่อนไขอีกครั้ง เวลานี้$yเท่ากับ222ซึ่งมากกว่า$nดังนั้นลูปจะสิ้นสุดลง ถ้าใส่อยู่แล้ว repdigit ที่มีเงื่อนไขไม่พอใจเพราะที่จุดนั้นจะมีค่าเท่ากับ$y$n

เมื่อออกจากวงเราโยน$yเป็นจำนวนเต็มแล้วลบ+ $nผลลัพธ์นั้นจะถูกทิ้งไว้บนไพพ์ไลน์และเอาท์พุทก็เป็นนัย

PHP 5.6, 59 53 51 50 ไบต์

บันทึกแล้ว6 8 ไบต์ขอบคุณ @manatwork

while(count_chars($argv[1]+$b,3)[1])$b++;echo$b?:0

ทดสอบกับ:

php test.php 11132

count_chars()ฟังก์ชั่นที่มี 3 เป็นพารามิเตอร์ที่สองกลับสตริงที่มีตัวละครที่แตกต่างกันในสตริง เมื่อสายนี้มีความยาว 1 ตัวอักษร ( [1]จะกลับเท็จเมื่อความยาว 1) จากนั้นสะท้อน$bหรือมิฉะนั้นการเพิ่ม$bและการวนซ้ำอีกครั้ง

MATL 10 ไบต์

q`QtVda}G-

ลองออนไลน์!

วิธีนี้จะเพิ่มการป้อนข้อมูลจนกว่าตัวเลขทั้งหมดจะเท่ากันดังนั้นจึงช้า กรณีทดสอบสำหรับการป้อนข้อมูล87654321หมดเวลาในคอมไพเลอร์ออนไลน์

q      % Take input implicitly. Subtract 1
`      % Do...while loop
  Q    %   Increment top of the stack
  tV   %   Duplicate and convert to string (i.e. digits of the number)
  d    %   Difference between consecutive digits
  a    %   True if any such difference is nonzero. This is the loop condition
}      % Finally (execute on loop exit)
  G-   %   Subtract input. This is the final result, to be (implicitly) displayed
       % End loop implicitly. If loop condition (top of the stack) is truthy: proceeds 
       % with next iteration. Else: executes the "finally" block and exits loop
       % Display implicitly

Ruby, 42 ตัวอักษร

->n{i=0;n.next!&&i+=1while n.squeeze[1];i}

ต้องการอินพุตสตริง

วิ่งตัวอย่าง:

irb(main):019:0> ->n{i=0;n.next!&&i+=1while n.squeeze[1];i}['87654321']
=> 1234567

Ruby, 39 ตัวอักษร

การเรียกซ้ำเรียกใช้เป็น“ SystemStackError: ระดับกองซ้อนลึกเกินไป” สำหรับผลลัพธ์ที่ใหญ่กว่า

r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}

วิ่งตัวอย่าง:

irb(main):001:0> r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}
=> #<Proc:0x00000002367ca0@(irb):10 (lambda)>

irb(main):002:0> r['20000']
=> 2222

Matlab, 65 64 ไบต์

t=input('');i=0;while nnz(diff(+num2str(t+i)))
i=i+1;end
disp(i)

เนื่องจากขณะที่มันวนรอบค่อนข้างช้า ...

คำอธิบาย

t=input('')  -- takes input
i=0          -- set counter to 0
while 
          num2str(t+i)   -- convert number to string 
         +               -- and then to array of corresponding ASCII codes
    diff(             )  -- produce vector of differences (all zeros for 'repdigit')
nnz(                   ) -- and count non-zero entries
i=i+1                    -- while not all digits are the same increase the counter
end          -- end while loop
disp(i)      -- print the counter

ออมทรัพย์หนึ่งขอบคุณไบต์@Luis Mendo

Excel, 85 79 ไบต์

วางสูตรต่อไปนี้ในเซลล์ใดก็ได้ยกเว้นเซลล์Nเนื่องจากเป็นชื่อสำหรับเซลล์อ้างอิงของอินพุต:

=IF(1*(REPT(LEFT(N),LEN(N)))<N,REPT(LEFT(N)+1,LEN(N))-N,REPT(LEFT(N),LEN(N))-N)

คำอธิบาย:

• Nเป็นอินพุทและยังมีชื่อของเซลล์อ้างอิง
• LEFT(N) ใช้ตัวเลขแรกของค่าอินพุต
• LEN(N) คืนความยาวของค่าอินพุต
• REPT(LEFT(N),LEN(N))ทำซ้ำตัวเลขแรกของค่าอินพุตLEN(N)และคูณด้วย 1 เพื่อแปลงรูปแบบข้อความเป็นรูปแบบตัวเลขเพื่อให้เราสามารถใช้สำหรับการเปรียบเทียบตัวเลข
• ไวยากรณ์ของฟังก์ชัน IF ใน Microsoft Excel คือ: IF (เงื่อนไข, [value_if_true], [value_if_false])ดังนั้นจึงทำให้สูตรทั้งหมดเป็นแบบอธิบายตนเอง

Brachylog v2, 6 ไบต์

;.+=∧ℕ

ลองออนไลน์!

  +       The sum of
          the input
;         and
 .        the output
   =      is a repdigit,
    ∧     and
          the output
     ℕ    is a whole number.

5 ไบต์+↙.=∧หายไปℕเพราะไม่ได้ลองใช้เอาต์พุตที่ไม่เป็นบวก แต่ก็ล้มเหลวเมื่อกำหนดหมายเลขที่เป็น repdigit อยู่แล้วเพราะมันไม่ได้ลองใช้เอาต์พุตที่ไม่เป็นบวกเลย

Java, 59 ไบต์

int c(int i){return(i+"").matches("^(.)\\1*$")?0:c(i+1)+1;}

(ฉันยังไม่แน่ใจว่าจะนับรายการ Java ได้อย่างไร แต่ตามมาตรฐานที่กำหนดโดยรายการ Java แรกรายการนี้มีขนาด 59 ไบต์เนื่องจากสั้นกว่า 17 ไบต์)

อย่างไรก็ตามหากเรามี repdigit ให้ส่งคืน 0 และเพิ่ม 1 ไปยังอินพุตเรียกตัวเองและเพิ่ม 1 ลงในผลลัพธ์

กรณีที่ไม่ได้รับการทดสอบ &:

ลองที่นี่

class Main{
  static int c(int i) {
    return
      (i+"").matches("^(.)\\1*$")
      ? 0
      : c(i+1) + 1;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(19122));
    // Entry below will run out of memory
    System.out.println(c(19121));
  }
}

เอาท์พุท:

Runtime error   time: 0.09 memory: 321152 signal:-1
0
11
109
2
2222
3100

อย่างที่คุณเห็นรายการสุดท้ายหน่วยความจำหมดก่อนที่มันจะเสร็จสิ้น (ที่เหมาะสมมาก) StackOverflowErrorจะถูกโยนลงมาจากjava.util.regex.Pattern.sequence(Pattern.java:2134)แต่ผมค่อนข้างมั่นใจว่าไม่มีอะไรผิดปกติกับ regex ตัวเองเพราะมันเป็นคนเดียวกับที่ฉันใช้ในรายการก่อนหน้าของฉัน

C #, 82 ไบต์

using System.Linq;n=>{int i=n;while((i+"").Distinct().Count()!=1)++i;return i-n;};

C, 84 ไบต์

d,n,l,f;F(i){for(n=0;1;){l=i+n++;d=l%10;f=0;while(l/=10)f|=l%10-d;if(!f)return--n;}}

ทดสอบหลัก:

int main() {
  printf("%d\n", F(8));
  printf("%d\n", F(100));
  printf("%d\n", F(113));
  printf("%d\n", F(87654321));
  printf("%d\n", F(47));
  printf("%d\n", F(20000));
  printf("%d\n", F(11132));
}

Prolog ขนาด 120 ไบต์

r([H|T]):-r(H,[H|T]).
r(H,[H|T]):-r(H,T).
r(_,[]).
g(N,0):-number_chars(N,L),r(L).
g(N,X):-N1 is N+1,g(N1,X1),X is X1+1.

ลองออนไลน์!