2013 yılı ilginç bir özelliğe sahipti: sıralandığında rakamlar ardışıktır (0123). Bu tür bir sayıya sıralanabilir bir sayı diyelim : sıralamadan 10 bazda ardışık olan negatif olmayan bir tam sayı. Ne yazık ki, bu 2031 yılına kadar tekrar olmayacak ve ondan sonra 2103'e kadar olmayacak. Mücadeleniz, herhangi bir standart yöntemle negatif olmayan bir tamsayı verildiğinde bir sonraki sıralanabilir sayıyı veren veya veren bir program veya işlev yazmak.

kurallar

• Giriş ve çıkış 10 tabanında olmalıdır.
• Çıktı herhangi bir makul biçimde olabilir (sayı değişmez, string değişmez, tek öğe dizisi, ...).
• 98764'e kadar olan tüm girişler için kodunuz 1 dakika içinde uygun çıktılar üretmelidir.

Test durumları

    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

Sıralanabilir sayılar A215014'ü oluşturur . Burada 98765'e kadar olan tüm girişlerin bir listesi bulunabilir .

puanlama

Bu kod golf , yani bayttaki en kısa kod kazanır.

Python 2,61 bayt

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

Çevrimiçi deneyin!

Jöle , 11 10 9 bayt

⁵ḶwṢ
‘Ç1#

Bir singleton dizisi döndürür. Çevrimiçi deneyin!

Nasıl çalışır

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

`QtVSdqa

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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

Neil sayesinde büyük 10 byte kurtardı

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

Test durumları

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 bayt

f}S`TjkU;h

Test odası

PowerShell v2 +, 71 68 67 bayt

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

Çevrimiçi deneyin!

Makinemde anında çalışan yinelemeli bir çözüm.

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

TotalSeconds : 0.0487127

Evet, bu kod golfte bir do/ untildöngü. Üzgünüm, üzgünüm değil. Temelde ed regex'leri karşı $nkadar girdilerimizden yukarı doğru döngü . Sonra boru hattına yerleştiririz ve çıktı açıktır.$n|sort-match0123456789$n

Bunun bir -join(0..9)değişmez dizeden daha kısa olan bir bayt olduğunu fark ederek bir bayt kaydedildi 0123456789.

Mathematica, 63 bayt

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

Yerini #+1uzun olarak aşağıdaki değere sahip Differences@Sort@IntegerDigits@x~MatchQ~{1...}mevcut değer sıralanabilir olması durumu olan yanlıştır.

İşte ne yazık ki çok uzun süren bir başka eğlenceli fikir:

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

Bu bölümde, önce tüm sıralanabilir yılları üretiyorum, sonra da girdiden daha büyük olanı seçiyorum.

İlk denemeden daha kısa olmadığı ortaya çıkan bazı fikirler:

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

Titus sayesinde yeni 89 bayt sürümü:

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

Kullanımı:

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

Xanderhall sayesinde önceki 103 bayt sürümü:

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

Önceki 105 bayt sürümü:

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

Kullanım: sortable-years.php?n=9000çıktılar 9678.

Test durumları ile Ungolfed versiyonu:

$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

Çevrimiçi test edin! (Yeni 89 bayt sürümü)

Çevrimiçi test edin! (Önceki 103 bayt sürümü)

Çevrimiçi test edin! (Önceki 105 bayt sürümü)

Tüm test durumları için yürütme süresi belki <= 1 saniyedir.

Perl 6 , 49 bayt

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

açıklama

{

  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

}

Ölçek:

# 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 bayt ( ad alanı bildirimleri hariç 122 99 83)

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

-23floydx33 sayesinde bayt

Başka -29 Link Ng sayesinde (Gerçekten bir diziye dönüştürmeye ihtiyacım olmadığını bilmeliydim)

Lanet olası dönüşümler.

(Bonus eklendi bu şaşırtıcı derecede hızlı)

Befunge , 117 bayt

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

Çevrimiçi deneyin!

Bir yılın sıralanıp düzenlenmediğini test etme yöntemimiz bir "dizi" oluşturmaktır (5. satırdaki tam dizgede yazılmıştır) ve yılın her basamağı için, dizini dizinin içine 1 olarak koyarız. işlenirse, sırayla kaç tane sayı olduğunu sayarız ve bu sayı yıl uzunluğuna eşitse, yılın sıralandığını varsayabiliriz.

Detaylı açıklama

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

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

Python 2,68 bayt

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

@Dennis tarafından dövülmüş, ancak yine de alternatif bir yöntem olarak yayınlanmıştır.

C #, 127 bayt

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

Şimdiki C # gönderimini 3 byte ile bitirin: p Şimdiden
_{dövüldüm Bu cevabın kolayca dövüleceğini biliyorum ...}
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 bayt

-1, Emigna'ya teşekkürler.

[>D{žhså#

Çevrimiçi deneyin!

Zamanım olduğunda yeni bir açıklama geliyor.

Python 2, 118 117 114 108 Bayt

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

DÜZENLE:

@ Gábor Fekete sayesinde -1 Bayt

Zachary T sayesinde -6 Bayt

PHP, 90 89 88 bayt

tamamen farklı bir yaklaşım:

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

İle koş -r.

Yıkmak

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 bayt

Uzun yöntem adları En azından ... kısa olduğunu bu yapmazlar map-indexedve -düzgün bir şekilde yapılması ana hesaplamalar olsun.

Düzenleme 1 : Düzenli, =birden fazla argüman alabileceğimi unuttum, bu yüzden farklı değerlerin sayısının 1 olup olmadığını kontrol etmem gerekmiyor.

Düzenleme 2 : Koşmaya gerek yok (sort(seq(str %))), (sort(str %))eşit derecede iyi çalışıyor.

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

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

Her zaman olduğu gibi, sayıları sayılara bölmek söz konusu olduğunda, R'nin bunu yapmanın doğal bir yolu yoktur. Sonuç olarak, girişi bir karaktere zorlamak, bir karakter vektörüne bölmek ve daha sonra herhangi bir sayısal türe geri dönmemiz gerekir.

Çevrimiçi deneyin