Năm 2013 có một tài sản thú vị: các chữ số liên tiếp khi được sắp xếp (0123). Chúng ta hãy gọi loại số này là một số có thể sắp xếp: một số nguyên không âm có 10 chữ số cơ bản liên tiếp sau khi sắp xếp. Thật không may, điều này sẽ không xảy ra một lần nữa cho đến năm 2031 và sau đó, cho đến năm 2103. Thách thức của bạn là viết một chương trình hoặc hàm, khi được cung cấp một số nguyên không âm thông qua bất kỳ phương thức tiêu chuẩn nào, xuất hoặc trả về số có thể sắp xếp tiếp theo.

Quy tắc

• Đầu vào và đầu ra phải ở cơ sở 10.
• Đầu ra có thể ở bất kỳ định dạng hợp lý nào (số bằng chữ, chuỗi ký tự, mảng đơn mục, ...).
• Mã của bạn phải tạo ra đầu ra thích hợp trong vòng 1 phút cho tất cả các đầu vào lên đến 98764.

Các trường hợp thử nghiệm

    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

Các số có thể sắp xếp mẫu A215014 . Một danh sách của tất cả các mục lên đến 98765 có thể được tìm thấy ở đây .

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

Python 2 , 61 byte

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

Hãy thử trực tuyến!

Thạch , 11 10 9 byte

⁵ḶwṢ
‘Ç1#

Trả về một mảng đơn. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

TOÁN , 8 byte

`QtVSdqa

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

`     % 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)

JavaScript (ES6), 64 54 byte

Đã tiết kiệm được 10 byte, nhờ Neil

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

Các trường hợp thử nghiệm

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 byte

f}S`TjkU;h

Phòng thử nghiệm

PowerShell v2 +, 71 68 67 byte

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

Hãy thử trực tuyến!

Một giải pháp lặp đi lặp lại khá nhiều ngay lập tức trên máy của tôi.

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

TotalSeconds : 0.0487127

Vâng, đó là một do/ untilvòng lặp trong một golf-code. Xin lỗi, không xin lỗi. Về cơ bản, chúng tôi lặp lên từ đầu vào của chúng tôi $ncho đến khi $n|sorted regex -matches chống lại 0123456789. Sau đó, chúng tôi đặt$n trên đường ống, và đầu ra là ẩn.

Đã lưu một byte bằng cách nhận ra rằng -join(0..9)một byte ngắn hơn chuỗi ký tự 0123456789.

Toán học, 63 byte

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

Thay thế #+1bằng giá trị tiếp theo miễn làDifferences@Sort@IntegerDigits@x~MatchQ~{1...} là sai, đó là điều kiện để giá trị hiện tại có thể sắp xếp được.

Đây là một ý tưởng thú vị khác, thật không may cuối cùng lại diễn ra quá lâu:

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

Trong phần này, tôi sẽ tạo ra tất cả các năm có thể sắp xếp trước và sau đó tôi chọn năm đầu tiên lớn hơn đầu vào.

Một số ý tưởng khác không trở nên ngắn hơn lần thử đầu tiên:

#+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 byte

Phiên bản 89 byte mới nhờ Titus:

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

Sử dụng:

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

Phiên bản 103 byte trước đó nhờ Xanderhall:

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

Phiên bản 105 byte trước đó:

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

Cách sử dụng: sortable-years.php?n=9000đầu ra 9678.

Phiên bản Ungolfed với các trường hợp thử nghiệm:

$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

Kiểm tra trực tuyến! (Phiên bản 89 byte mới)

Kiểm tra trực tuyến! (Phiên bản 103 byte trước đó)

Kiểm tra trực tuyến! (Phiên bản 105 byte trước đó)

Thời gian thực hiện có thể <= 1 giây cho tất cả các trường hợp thử nghiệm.

Perl 6 , 49 byte

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

Giải trình

{

  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

}

Kiểm tra:

# 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 byte ( 122 99 83 không bao gồm khai báo không gian tên)

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

-23 byte nhờ vào Pinkfloydx33

khác -29 nhờ Link Ng (Tôi thực sự nên biết rằng tôi không cần phải chuyển đổi nó thành một mảng)

Chuyển đổi chết tiệt.

(Đã thêm phần thưởng này nhanh một cách đáng ngạc nhiên)

Befunge , 117 byte

&>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@._<$<>

Hãy thử trực tuyến!

Cách chúng tôi kiểm tra nếu một năm được sắp xếp là bằng cách tạo một "mảng" (được viết thành chuỗi ký tự trên dòng năm) và với mỗi chữ số trong năm, chúng tôi đặt chỉ số đó thành mảng thành 1. Một khi tất cả các chữ số đã được được xử lý, chúng tôi đếm có bao nhiêu số 1 theo thứ tự và nếu số đó bằng với độ dài năm, chúng tôi có thể giả sử năm được sắp xếp.

Giải thích chi tiết

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

Ruby, 51 byte

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

Python 2, 68 byte

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

Bị đánh bại bởi @Dennis nhưng dù sao cũng chỉ đăng như một phương pháp thay thế.

C #, 127 byte

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

Đánh bại trình đệ trình C # hiện tại bằng 3 byte: p Bị đánh trả lại
_{Tôi biết câu trả lời này sẽ bị đánh bại dễ dàng ...}
repl.it demo

Bị đánh cắp

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 byte

-1 cảm ơn Emigna.

[>D{žhså#

Hãy thử trực tuyến!

Mô tả mới đến khi tôi có thời gian.

Python 2, 118 117 114 108 byte

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

CHỈNH SỬA:

-1 Byte nhờ @ Gábor Fekete

-6 Byte nhờ @Zachary T

PHP, 90 89 88 byte

một cách tiếp cận hoàn toàn khác nhau:

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

Chạy với -r.

phá vỡ

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

Clojure, 104 96 91 byte

Tên phương thức dài không làm cho nó ngắn đến thế ... Ít nhất map-indexedvà -có được các tính toán chính được thực hiện một cách gọn gàng.

Chỉnh sửa 1 : Gọn gàng, tôi quên cũng =có thể nhận nhiều đối số vì vậy tôi không cần kiểm tra xem số lượng giá trị khác biệt có phải là 1 không.

Chỉnh sửa 2 : Không cần chạy(sort(seq(str %))) , (sort(str %))hoạt động tốt như nhau.

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

Ung dung:

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

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

Như thường lệ khi chia số thành chữ số, R không có cách riêng để thực hiện việc này. Do đó, chúng ta phải ép đầu vào thành một ký tự, tách thành một vectơ ký tự và sau đó chuyển đổi trở lại thành bất kỳ loại số nào.

Dùng thử trực tuyến