2013 년에는 흥미로운 속성이있었습니다. 정렬시 숫자가 연속적입니다 (0123). 이 유형의 숫자를 정렬 가능한 숫자, 즉 정렬 후 10 자릿수가 연속되는 음이 아닌 정수라고합니다. 불행히도, 이것은 2031 년까지 그리고 그 이후로는 2103 년까지 다시 발생하지 않을 것입니다. 당신의 과제는 표준 방법을 통해 음수가 아닌 정수가 주어지면 다음 정렬 가능한 숫자를 출력하거나 반환하는 프로그램이나 함수를 작성하는 것입니다.

규칙

• 입력 및 출력은 10 진수 여야합니다.
• 출력은 합리적인 형식 (숫자 리터럴, 문자열 리터럴, 단일 항목 배열 등) 일 수 있습니다.
• 코드는 최대 98764의 모든 입력에 대해 1 분 이내에 올바른 출력을 생성해야합니다.

테스트 사례

    0 -> 1
    1 -> 2
    9 -> 10
   10 -> 12
   11 -> 12
   99 -> 102
  233 -> 234
  234 -> 243
  243 -> 312
 2016 -> 2031
 2031 -> 2103
 2103 -> 2130
 2130 -> 2134
 2134 -> 2143
 9876 -> 10234
98764 -> 98765

정렬 가능한 숫자는 A215014 입니다. 최대 98765 개의 모든 항목 목록은 여기 에서 찾을 수 있습니다 .

채점

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

파이썬 2 , 61 바이트

f=lambda n:-~n*(`sorted(`n+1`)`[2::5]in'0123456789')or f(n+1)

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

젤리 , 11 10 9 바이트

⁵ḶwṢ
‘Ç1#

싱글 톤 배열을 반환합니다. 온라인으로 사용해보십시오!

작동 원리

‘Ç1#  Main link. Argument: n

‘     Increment; yield n+1.
 Ç1#  Apply the helper link to k = n+1, n+2, n+3, ... until one of them maps to a
      truthy value. Yield a singleton array containing that value of k.

⁵ḶwṢ  Helper link. Argument: k

⁵     Set the return value to 10.
 Ḷ    Unlength; yield [0, ..., 9].
   Ṣ  Sort; yield the sorted array of k's decimal digits.
  w   Window-index; yield the 1-based index(truthy) of the digit array in
      [0, ..., 9], 0 (falsy) if not found.

MATL , 8 바이트

`QtVSdqa

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

`     % Do...while
  Q   %   Add 1. Takes input (implicit) in the first iteration
  t   %   Duplicate
  V   %   Convert to string. This gives an array of chars (same as a string)
      %   representing the digits
  S   %   Sort
  d   %   Consecutive differences between the chars (automatically converted
      %   to ASCII codes)
  q   %   Subtract 1. This gives an array where consecutive differences equal 
      %   to 1 are converted to 0, and the rest give a nonzero result
  a   %   True if any value is nonzero. This is the loop condition: if true
      %   (which means at least one consecutive difference was not 1), go on
      %   with the next iteration. Else exit loop
      % End do...while (implicit)
      % Display (implicit)

자바 스크립트 (ES6), 64 54 바이트

Neil 덕분에 방대한 10 바이트 절약

f=n=>[...++n+''].sort().some((v,i,a)=>v-i-a[0])?f(n):n

테스트 사례

f=n=>[...++n+''].sort().some((v,i,a)=>v-i-a[0])?f(n):n

console.log(f(0));      // -> 1
console.log(f(1));      // -> 2
console.log(f(9));      // -> 10
console.log(f(10));     // -> 12
console.log(f(11));     // -> 12
console.log(f(99));     // -> 102
console.log(f(233));    // -> 234
console.log(f(234));    // -> 243
console.log(f(243));    // -> 312
console.log(f(2016));   // -> 2031
console.log(f(2031));   // -> 2103
console.log(f(2103));   // -> 2130
console.log(f(2130));   // -> 2134
console.log(f(2134));   // -> 2143
console.log(f(9876));   // -> 10234
console.log(f(98764));  // -> 98765

Pyth- 11 10 바이트

f}S`TjkU;h

테스트 스위트

PowerShell v2 +, 71 68 67 바이트

param($n)do{$n++}until(-join(0..9)-match-join([char[]]"$n"|sort))$n

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

내 컴퓨터에서 거의 즉시 실행되는 반복 솔루션입니다.

PS C:\Tools\Scripts\golfing> measure-command {.\find-the-sortable-years.ps1 98764} | fl totalseconds

TotalSeconds : 0.0487127

예, 코드 골프 의 do/ until루프입니다. 미안, 미안 기본적으로 우리는 ed 정규 표현식이 에 대해 입력 $n될 때까지 입력에서 위로 반복합니다 . 그런 다음 파이프 라인에 배치 하고 출력은 암시 적입니다.$n|sort-match0123456789$n

-join(0..9)리터럴 문자열보다 1 바이트 더 짧은 바이트를 실현하여 바이트를 저장했습니다 0123456789.

수학, 63 바이트

#+1//.x_/;!Differences@Sort@IntegerDigits@x~MatchQ~{1...}:>x+1&

현재 값을 정렬 할 수있는 조건 인 false 인 #+1경우 다음 값으로 바꿉니다 Differences@Sort@IntegerDigits@x~MatchQ~{1...}.

불행히도 너무 길다는 또 다른 재미있는 아이디어가 있습니다.

FirstCase[FromDigits/@Union@@Permutations/@Join@@Array[Range,{9,10},0],x_/;x>#]&

이번에는 정렬 가능한 모든 연도를 먼저 생성 한 다음 입력보다 큰 첫 번째 연도를 선택합니다.

첫 번째 시도보다 짧지 않은 아이디어가 더 있습니다.

#+1//.x_/;Array[Range,{9,10},0]~FreeQ~Sort@IntegerDigits@x:>x+1&
#+1//.x_/;Subsequences@Range[0,9]~FreeQ~Sort@IntegerDigits@x:>x+1&
#+1//.x_/;0~Range~9~FreeQ~{___,##&@@Sort@IntegerDigits@x,___}:>x+1&

PHP, 105 (103) 89 바이트

Titus의 새로운 89 바이트 버전 :

for(;!$p;){$t=str_split($n=++$argv[1]);sort($t);$p=strstr('0123456789',join($t));}echo$n;

용법:

php -r "for(;!$p;){$t=str_split($n=++$argv[1]);sort($t);$p=strstr('0123456789',join($t));}echo$n;" 9000

Xanderhall 덕분에 이전 103 바이트 버전 :

<?for($p=0;!$p;){$t=str_split($n=++$_GET[n]);sort($t);$p=strstr('0123456789',implode($t));}echo "$n\n";

이전 105 바이트 버전 :

<?for($n=$_GET[n]+1;;$n++){$t=str_split($n);sort($t);if(strstr('0123456789',implode($t))){echo$n;exit;}}

사용법 : sortable-years.php?n=9000출력 9678.

테스트 케이스가 포함 된 언 골프 버전 :

$test = array(0,1,9,10,11,99,233,234,243,2016,2031,2103,2130,2134,9876,98764);

foreach ($test as $argv[1]) {
    for(;!$p;){
        $t=str_split($n=++$argv[1]);
        sort($t);
        $p=strstr('0123456789',join($t));
    }
    echo "$n\n"; // add newline for testing
    $p=false; // reset $p for testing
}

Output:
1
2
10
12
12
102
234
243
312
2031
2103
2130
2134
2143
10234
98765

온라인 테스트! (신규 89 바이트 버전)

온라인 테스트! (이전 103 바이트 버전)

온라인 테스트! (이전 105 바이트 버전)

모든 테스트 사례에서 실행 시간은 1 초 미만일 수 있습니다.

펄 6 , 49 바이트

{first {$/eqv($/=.comb.sort).minmax.list},$_^..*}

설명

{

  first

  {

    $/             # sorted list from later

    eqv            # is it equivalent

    (

      $/           # store in match variable ( doesn't need to be declared )
      =
      .comb.sort   # sorted list of digits from currently tested value

    ).minmax       # the Range of digits
            .list  # flattened to a list
  },

  $_  ^..  *       # Range starting just after input

}

테스트:

# give it a lexical name for clarity
my &code = {first {$/eqv($/=.comb.sort).minmax.list},$_^..*}

my @all = +«'sortable.txt'.IO.lines;

my @gen = code(-1), &code ... ( * >= 98765 );

say @all eqv @gen; # True

say now - INIT now; # 16.3602371

C 번호, 153 (130) (101 바이트 122 99 네임 스페이스 선언 제외 83)

using System.Linq;n=>{while(!"0123456789".Contains(string.Concat((++n+"").OrderBy(x=>x))));return n;}

pinkfloydx33 덕분에 -23 바이트

Link Ng 덕분에 또 다른 -29 덕분에 (배열로 변환 할 필요가 없다는 것을 정말로 알고 있었어야합니다)

젠장 전환.

(추가 보너스는 놀랍게도 빠릅니다)

Befunge , 117 바이트

&>1+0v
9`#v_>:9+0\4p1+:
1:$<v
0g1+>00p:55+%9+1\4p55+/:!#v_0
v+*g09:<".........." 9p09 <
>:00g-v^<
-9:p09_v|
$v@._<$<>

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

연도가 정렬되어 있는지 테스트하는 방법은 "배열"(5 행의 문자열 리터럴로 작성)을 작성하고 연도의 모든 숫자에 대해 해당 인덱스를 배열에 1로 설정하는 것입니다. 처리 된 순서대로 1의 개수를 세고 그 개수가 연도 길이와 같으면 연도가 정렬 된 것으로 가정 할 수 있습니다.

상해

&>1+                              Read the year and increment it.

    0v                            The "array" is initialized with zeros prior
9`#v_>:9+0\4p1+:                     to processing each year.

1:$<v                             For every digit, set the corresponding array index
0g1+>00p:55+%9+1\4p55+/:!#v_0       to one, and increment the year length counter.

                      p09 <       Initialise the sequence counter to zero.
                     9            Push a marker onto the stack.
        ".........."              Push the values from the array onto the stack.

v+*g09:<                          Increment the sequence counter for every 1 in the
>:00g-v^<                           array and reset it on every 0. Break if it equals
-9:p09_v|                           the year length or we encounter the end marker.

  @._<$<                          If we have a match, clear the stack and output the year.
$v      >                         If we've reached the marker, drop it try the next year.

루비, 51 바이트

->n{n+=1 until'0123456789'[n.to_s.chars.sort*''];n}

파이썬 2, 68 바이트

n=input()+1
while''.join(sorted(`n`))not in'0123456789':n+=1
print n

@Dennis에 의해 맞았지만 어쨌든 대체 방법으로 게시되었습니다.

C #, 127 바이트

using System.Linq;n=>{char[]s;while((s=(++n+"").OrderBy(x=>x).ToArray()).Select((x,i)=>i>0&&x-s[i-1]!=1).Any(x=>x));return n;};

현재 C # 제출을 3 바이트로 이깁니다 .p 이미
_{맞았습니다.이 답변은 쉽게 맞습니다.}
repl.it 데모

언 골프

n=>
{
    char[] s;
    while((
        // Store char array in variable to be referenced in Select()
        // Increment n and cast to string
        s=(++n+"")
            // Sort ascending, to array
            .OrderBy(x=>x)
            .ToArray())
        // Convert char to true if it's not at position 0,
        // and it is not 1 greater than the previous char
        .Select((x,i)=>i>0&&x-s[i-1]!=1)
        // All false: n is sortable
        // Any true: n is not sortable
        .Any(x=>x))
    // while loop body is empty
    ;
    return n;
};

05AB1E , 10 9 바이트

Emigna에게 -1 감사합니다.

[>D{žhså#

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

시간이되면 새로운 설명이옵니다.

파이썬 2, 118117114108 바이트

x,s=input()+1,sorted
while[j for i,j in enumerate(s(str(x))[1:])if int(s(str(x))[i])+1!=int(j)]:x+=1
print x

편집하다:

@ Gábor Fekete 덕분에 -1 바이트

@Zachary T 덕분에 -6 바이트

PHP, 90 89 88 바이트

완전히 다른 접근법 :

while(array_unique($a=str_split($n=++$argv[1]))!=$a|max($a)-min($a)-count($a)+1);echo$n;

로 실행하십시오 -r.

고장

while(
    array_unique(           // 3. unique values
        $a=str_split(       // 2. split to digits
            $n=++$argv[1]   // 1. increase number
        )
    )
    !=$a                    // 4. repeat while unique digits differ from original digits
    |                       // or
        max($a)-min($a)     // digit range
        -count($a)+1        // differs from count-1
    );
echo$n;                 // print result

클로저, 104 96 91 바이트

긴 메소드 이름은 적어도 ... 짧은 것을이하지 않는 map-indexed및 -깔끔한 방법으로 수행 주요 계산을 얻는다.

편집 1 : 깔끔합니다. 또한 =여러 인수를 사용할 수 있으므로 고유 값의 수가 1인지 여부를 확인할 필요가 없습니다.

편집 2 : 실행할 필요는 (sort(seq(str %))), (sort(str %))동일하게 작동합니다.

(fn[i](first(filter #(apply =(map-indexed -(map int(sort(str %)))))(rest(iterate inc i)))))

언 골프 드 :

(defn f [i]
  (let [is-sorted? #(= 1 (->> % str sort (map int) (map-indexed -) set count))]
    (->> i (iterate inc) rest (filter is-sorted?) first)))

R, 87 바이트

f=function(x)`if`(all(diff(sort(as.double(el(strsplit(c(x+1,""),"")))))==1),x+1,f(x+1))

숫자를 숫자로 나누는 경우와 마찬가지로 R에는 기본 방법이 없습니다. 따라서 입력을 문자로 강제 변환하고 문자 벡터로 분할 한 다음 숫자 유형으로 다시 변환해야합니다.

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