내가 몇 시간 전에이 도전에 대해 처음으로 생각했을 때 얼마나 많은 담당자가 있었는지에 대해 :

한 자릿수 반복으로 구성된 이와 같은 숫자를 repdigits 라고 합니다 . 담당자는 재미있다! 그들이 가진 담당자의 수는 repdigit ¹ 이면 모든 신체가 더 행복 할 것입니다 . 그러나 나는 참을성이 없어서, rerepdigit에 도달하는 가장 빠른 방법을 찾도록 도와 주어야합니다.

여기 당신의 도전이 있습니다 :

평판을 나타내는 양의 정수가 주어지면, repdigit에 도달하기 위해 필요한 rep의 최소량을 출력하십시오 . 예를 들어,이 챌린지를 작성할 당시 사용자 Martin Ender 는 102,856 명의 응답을 받았습니다. 가장 가까운 담당자 숫자는 111,111이므로 다음과 같이 얻을 수 있습니다.

사람들은 담당자를 잃는 것을 싫어하기 때문에 음이 아닌 변경 만 고려할 것입니다. 예를 들어, 누군가가 1 명의 담당자를 잃지 않고 12 명의 담당자 인 경우 해결책은 10 명의 담당자를 얻는 것입니다. 111 개의 담당자가있는 사람은 이미 담당자 번호이므로 '0'을 유효한 출력으로 사용할 수 있습니다 .

입력 및 출력은 합리적인 형식 일 수 있으며 Stack Exchange 사이트에서 1 회 미만의 응답을 가질 수 없기 때문에 입력이 1보다 작을 것으로 가정 할 수 없습니다.

참고 사항 :

사용자의 담당자 수가 10 명 미만인 경우 이미 담당자 숫자이므로 '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.

하스켈, 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.

파이썬 2, 41 40 바이트

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

가장 짧은 접근 방식은 아니지만 매우 효율적입니다. Ideone에서 테스트하십시오 .

작동 원리

입력을 위해 10**len(`n`)라운드 N 의 가장 가까운 전원 최대 10 . 그런 다음 결과를 9로 나눕니다 . 이것은 n 만큼 많은 자릿수를 갖는 repdigit 1… 1 을 리턴합니다 . 결과를 r에 저장합니다 . 예를 들어, n = 87654321 이면 r = 11111111 입니다.

원하는 담당자 숫자는 배수 또는 r 입니다. 어느 것을 결정하기 위해, 우리는 n 을 r로 천장 나누기를 수행 합니다. Python 2의 나누기 연산자 /층 이기 때문에을 -n/r사용하면 정확한 절대 값을 얻을 수 있으며 음수 부호가 표시됩니다. 예를 들어, n = 87654321 이면 -8 이 반환 됩니다.

마지막으로 계산 된 몫에 -r 을 곱하여 몫 을 n의 각 숫자마다 한 번씩 반복합니다 . 예를 들어, n = 87654321 인 경우 88888888을 반환 하며 이는 원하는 담당자 숫자입니다.

마지막으로 필요한 증분을 계산하기 위해 이전 결과에서 n 을 뺍니다 . 예제 n = 87654321의 경우 원하는대로 1234567을 반환 합니다.

파이썬 2, 37 바이트

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

Ideone에서 테스트하십시오 . 이 방법은 테스트 사례 87654321에 비효율적입니다 .

작동 원리

경우 n이 이미 렙 디지트이며, 1-len(set(`n`))반환 0 의 세트의 길이 때문에 N 베이스 (10)의 숫자가 될 것이다 1 . 이 경우 f 는 0을 반환합니다 .

n 이 담당자가 아닌 경우 다음 가능한 값 n을 사용하여 f(n+1)재귀 적으로 f 를 호출합니다 . f 가 재귀 적으로 호출 될 때마다 f 의 리턴 값 ( reprep가 발견 될 때 0 )을 1 씩 증가 시키므로, 최종 리턴 값은 f 가 호출 된 횟수, 즉 n 이 증가 된 횟수 와 같습니다. 담당자를 얻으십시오.-~

펄 6 , 23 바이트

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

입력 번호를 인수로 받아서 결과를 반환하는 람다.

설명:

1. ...시퀀스 연산자를 사용하여 입력 숫자가 repdigit에 도달 할 때까지 입력 숫자를 증가시킵니다 (문자열 표현을 문자로 나누고 모두 같은지 확인하여 테스트 함) .
2. 시퀀스 길이에서 하나를 뺍니다.

자바 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 바이트

@FryAmTheEggman 덕분에 1 바이트.

-f@F`TQ

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

매우 비효율적이며 모든 숫자를 입력에서 다음 재 숫자로 반복합니다.

뇌 - 플랙 690 358 바이트

여기 내가 간다

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

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

설명

원본보다 하나 적은 입력의 두 번째 사본을 만들어 시작하십시오. 사본을 사용하여 다음 담당자를 검색합니다. 숫자 자체가 repdigit 인 경우 1을 뺍니다.

(({})[()])

다가오는 루프를 만족 시키려면 하나를 누르십시오. (0이 아닌 하나 일 필요는 없음)

(())

이 루프는 스택의 상단에 비밀번호가있을 때까지 실행됩니다.

{

쓰레기를 터 뜨리십시오. 그것들은 루프를 구동하는 "부울 (boolean)"입니다. 더 이상 루프를 터뜨리지 않아도되기 때문입니다.

{}

하나를 추가하고 상단을 복제하십시오. 사본은 숫자로 분해됩니다.

(({}()))

사본이 0이 아닌 동안 ...

{

다시 복사

(({}))

Mod 10과 다른 스택으로 이동

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

10으로 나누기 (정수 나누기)

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

}

우리의 사본 인 0을 팝

{}

이제 숫자를 기본 10 자리로 분해 했으므로 모든 숫자가있는 스택으로 교체합니다.

<>

선행 자리가 0이 아닌 동안

{

스택 높이 (자릿수)의 사본을 가져옵니다.

(([])<

스택의 모든 숫자에서 하나씩 빼기

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

우리가 집어 올린 스택 높이를 내려 놓습니다. (그리고 다른 스택으로 교체)

><>)

스택 높이를 사용하여 다른 스택에 배치 한 모든 숫자를 올바른 스택으로 다시 가져옵니다.

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

스택 높이 인 0을 팝

{}

숫자 또는 숫자와 함께 스택으로 다시 교체

<>

엔드 루프

}

이제 다른 모든 숫자에서 최상위 숫자를 뺍니다. 모든 숫자가 0이면 원래 숫자 (입력이 아니라 검사중인 숫자)는 숫자입니다. ^{[인용 필요]} . 따라서 0이 아닌 값을 확인해야합니다.

스택 높이가 0이 아닌 동안

([])
{
{}

숫자가 0이 아닌 경우 다른 스택으로 옮기고 0으로 바꾸십시오.

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

팝 (지금은 0입니다)

{}

엔드 루프

([])
}
{}

다른 스택으로 교체 (duh ..)

<>

스택 높이에서 2를 뺀 사본을 가져옵니다.

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

스택 높이가 2가 아닌 동안 (원본 및 누산기)

{
{}

상단 팝

{}

잠시만

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

스택 높이에서 2를 뺀 사본을 내려 놓습니다. 이것은 첫 번째 숫자와 동일하지 않은 자릿수입니다. 다시 말해서 0이 아닌 경우에는 담당자입니다.

>)

이 루프가 끝나면 우회 번호를 찾았습니다

}

"부울"팝

{}

repdigit에서 원본을 빼십시오

({}[{}])

파이썬 2, 52 바이트

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

파이썬 2에는이를 단축시키는 몇 가지 트릭이 있습니다. 예를 들어 input은 숫자이므로 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

이것은 순수한 sed 솔루션입니다 . 산술은 정규 표현식 만 사용하여 시뮬레이션됩니다. 알고리즘은 다음과 같이 작동합니다.

1. 패턴 공간 형식이 ^current_reputation:needed_reputation%$
2. 세퍼레이터는 전환 주 루프의 각 반복에서 :
   a) %:에 적용되는 증가 needed_reputation 용
   )를 B :%로 증가 적용 current_reputation
3. 경우 생성 current_reputation이 는 "렙 디지트"는이다 needed_reputation가 인쇄되고, 프로그램을 종료

자바, 74 72 바이트

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

( 다른 Java 항목 이 76 바이트 인 경우이 항목 은74 72 이니까 두 4 바이트 더 짧음).

어쨌든, 카운터를 증가시키면서 입력이 될 때까지 입력을 증가시킵니다. 카운터를 반환하십시오.

예, 이들은 행에 세 개의 더하기이고, 두 개는 입력을 증가시키고, 하나는 빈 문자열을 연결하여 문자열로 만듭니다.
아니요, 그 사이에 공백이 없으면 합법적이라고 생각하지 않았지만 거기에 있습니다. 그것이 오타가 당신을 위해 할 일입니다 : 1 바이트 더 짧습니다.

while 대신 for-loop를 사용하면 정확히 많은 바이트가 필요합니다.

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

편집하다:

이전 버전은 matches("^(\\d)\\1*$")repdigit를 확인 해야 했지만 int를 문자열로 변환했기 때문에 .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

언 골프 :

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

format ( as.numeric과as.character )을 사용하면 몇 바이트가 추가되지만 R 은 실제로 유연하지 않습니다!

Perl, 40 + 1 ( -n) = 41 바이트

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

0숫자가 이미 비밀번호 일 때가 아닌 아무 것도 인쇄 할 수없는 경우 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 ( $v)로 만들고 그렇지 않은 경우 1 $_과 and 모두에 1을 가한 $v후 다시 시작합니다.

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

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

설명 : 이후 p의 다음 거듭 제곱으로 재귀 적으로 계산합니다 . 그런 다음 반복되는 숫자는로 계산되고 반복 단위는 간단히 이며 결과는 다음과 같습니다.10n1+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

파이크, 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입력하고 <감소시킵니다. 이 값은 왼쪽의 기능에 공급됩니다.
• \> 오른쪽의 함수가 정확한 값을 제공 할 때까지 값을 한 번 이상 증가시킵니다.
• 테스트 기능은 &4 가지 기능 으로 구성됩니다 ( s 단위).
• 0~j 문자열로 변환합니다.
• u 중복 숫자를 제거합니다.
• > 결과 문자열의 헤드를 제거합니다.
• N논리적 부정입니다. 1빈 문자열을 제공 하고 비어 0있지 않습니다. 따라서이 함수는 담당자 숫자를 테스트하며 그 결과 \는에서 오는 다음 담당자 숫자입니다 <i.
• )-함수 입력에서 결과를 뺍니다 <i.
• 이 차이는 1만큼 떨어 지므로 <줄어 듭니다. 마지막으로 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. 그렇지 않으면 나중에 산술은 char-code의 ASCII 값을 사용합니다.

조건부는 $n.length "$x"에 임시 저장된 s로 구성된 문자열 $y이보다 작은 지 여부를 확인합니다 $n. 그렇지 않은 $x++한 다음 루프에 대한 조건을 설정 하여을 증가시킵니다 .

예를 들어, input 123의 $y경우, 조건이 처음 확인 될 때 의 값 111은보다 작습니다 $n. 따라서 루프는 계속됩니다. 루프 본문에 아무것도 없으므로 단계 증분이 발생 $x++하고 조건부가 다시 확인됩니다. 이 시간은 $y동일 222보다 큰, $n루프 종료 그래서. 입력이 이미 렙 디지트이면 그 시점 때문에, 조건이 충족되지 $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이면 false를 반환) 인 경우 echo $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

루비, 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

루비, 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)

while 루프 때문에 속도가 느립니다 ...

설명

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 덕분에 1 바이트 절약 .

엑셀, 85 79 바이트

N입력 셀의 참조 셀 이름이므로 cell을 제외한 모든 셀에 다음 공식 을 입력하십시오.

=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))입력 값의 첫 번째 숫자를 반복하고 1을 LEN(N)곱하여 텍스트 형식을 숫자 형식으로 변환하여 숫자 비교에 사용할 수 있습니다.
• Microsoft Excel에서 IF 함수의 구문은 IF (condition, [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 인 숫자가 주어지면 실패합니다.

자바, 59 바이트

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

(여전히 Java 항목 수를 계산하는 방법을 잘 모르겠지만 첫 번째 Java 항목 에서 설정된 표준에 따르면 이 항목은 17 바이트 더 짧기 때문에 59 바이트입니다).

어쨌든, 우리가 rerepdigit를 가지고 있다면 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)했지만 정규식 자체에는 아무런 문제가 없다고 확신합니다.이 항목은 이전 항목 에서 사용한 것과 동일하기 때문 입니다.

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

프롤로그, 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.

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