ปี 2556 มีทรัพย์สินที่น่าสนใจ: ตัวเลขเรียงต่อกันเมื่อเรียงลำดับ (0123) ลองเรียกหมายเลขประเภทนี้ว่าตัวเลขที่เรียงได้:จำนวนเต็มแบบไม่ลบที่มีตัวเลขฐาน 10 ต่อเนื่องกันหลังจากเรียงลำดับ น่าเสียดายที่สิ่งนี้จะไม่เกิดขึ้นอีกจนกว่าจะถึงปี 2031 และหลังจากนั้นไม่ถึงปี 2103 ความท้าทายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่เมื่อได้รับจำนวนเต็มไม่เป็นลบผ่านวิธีมาตรฐานใด ๆ

กฎระเบียบ

• อินพุตและเอาต์พุตต้องอยู่ในฐาน 10
• เอาต์พุตอาจอยู่ในรูปแบบที่เหมาะสม (จำนวนตัวอักษร, สตริงตัวอักษร, อาร์เรย์รายการเดียว, ... )
• รหัสของคุณจะต้องสร้างเอาต์พุตที่เหมาะสมภายใน 1 นาทีสำหรับอินพุตทั้งหมดสูงสุด 98764

กรณีทดสอบ

    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 รายการของรายการทั้งหมดถึง 98,765 สามารถพบได้ที่นี่

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ

Python 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)

JavaScript (ES6), 64 54 ไบต์

บันทึกขนาดใหญ่ 10 ไบต์ขอบคุณ Neil

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

ใช่นั่นคือ a do/ untilloop ใน code-golf ขออภัยไม่ได้ขอโทษ โดยทั่วไปเราขึ้นห่วงจากการป้อนข้อมูลของเรา$nจนกว่า$n|sortเอ็ด regex -matchES 0123456789กับ จากนั้นเราก็วาง$nลงบนไพพ์ไลน์และเอาท์พุทก็เป็นนัย

ที่บันทึกไว้ไบต์โดยตระหนักว่าเป็นหนึ่งไบต์สั้นกว่าสายอักขระตัวอักษร-join(0..9)0123456789

Mathematica, 63 ไบต์

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

แทนที่#+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 ไบต์

ใหม่เวอร์ชัน 89 ไบต์ขอบคุณ Titus:

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

รุ่นก่อนหน้า 103 ไบต์ต้องขอบคุณ Xanderhall:

<?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=90009678

รุ่น Ungolfed พร้อมกรณีทดสอบ:

$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 วินาทีสำหรับกรณีทดสอบทั้งหมด

Perl 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 ไม่รวมการประกาศ namespace)

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

-23 ไบต์ขอบคุณ pinkfloydx33

อีก -29 ขอบคุณที่ Link Ng (ฉันควรจะรู้ว่าฉันไม่จำเป็นต้องแปลงเป็นอาร์เรย์)

การแปลงแช่ง

(โบนัสเพิ่มเติมนี้เร็วอย่างน่าประหลาดใจ)

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

ลองออนไลน์!

วิธีที่เราทดสอบว่ามีการเรียงลำดับปีหรือไม่โดยการสร้าง "อาร์เรย์" (เขียนลงในสตริงตัวอักษรในบรรทัดที่ห้า) และสำหรับตัวเลขทุกตัวในปีนั้นเราจะตั้งค่าดัชนีนั้นเป็นอาร์เรย์ 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.

Ruby, 51 ไบต์

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

Python 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 demo

Ungolfed

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

-1 ต้องขอบคุณ Emigna

[>D{žhså#

ลองออนไลน์!

คำอธิบายใหม่มาเมื่อฉันมีเวลา

Python 2, 118 117 114 108 Bytes

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

แก้ไข:

-1 ไบต์ขอบคุณ@Gábor Fekete

-6 ไบต์ขอบคุณ @Zachary T

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

Clojure, 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)))))

Ungolfed:

(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 ไม่มีวิธีการทำเช่นนี้ ดังนั้นเราจะต้องบีบบังคับอินพุตให้เป็นตัวละครแบ่งเป็นเวกเตอร์ตัวละครแล้วแปลงกลับเป็นชนิดตัวเลขใด ๆ

ลองออนไลน์