क्रमबद्ध वर्षों का पता लगाएं

Question

वर्ष 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 तक की सभी प्रविष्टियों की सूची यहां देखी जा सकती है ।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

Comments

काम से आपका क्या मतलब है ? क्या यह ठीक है अगर इसमें वास्तव में लंबा समय लगता है?

— डेनिस

@ डेनिस 98764 तक के सभी इनपुट के लिए 1 मिनट के साथ समाप्त होना चाहिए। यह पोस्ट में स्पष्ट किया गया है।

— ETHproductions

@ETHproductions क्या इसे बड़े इनपुट का समर्थन करना है?

— मार्टिन एंडर

@MartinEnder नहीं, हालांकि मुझे सबसे अधिक उम्मीद है (यदि सभी नहीं) समाधान होगा। क्या आवश्यकता अधिक होनी चाहिए?

— ETHproductions

@ETHproductions मुझे ऐसा नहीं लगता, मैं सिर्फ यह सुनिश्चित करना चाहता था।

— मार्टिन एंडर

Answer 1

पायथन 2 , 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

मैं '0123456789'कुछ बनना चाहता हूं 1./81, लेकिन यह काफी काम नहीं करता है।

— 5

बेस्ट आप प्राप्त कर रहे हैं 1./81.0000001जो अभी भी ठीक से काम नहीं करेगा और लंबे समय तक है

— अल्फी गुडाक्रे

@AlfieGoodacre आप बेहतर कर सकते हैं 1./81-1e-10लेकिन यह अभी भी 10 बाइट्स है और आपको अभी भी इसे छोटा करना होगा।

— मार्टिन एंडर

Answer 2

जेली , 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.

Answer 3

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)

Answer 4

जावास्क्रिप्ट (ईएस 6), 64 54 बाइट्स

एक बड़े पैमाने पर 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

Comments

आप अपने मूल उत्तर से 2 बाइट्स को यह देखते हुए बचा सकते हैं कि mapकॉलबैक के लिए तीसरा पैरामीटर खुद सरणी है, लेकिन आप बहुत बेहतर करने के लिए आगे f=n=>[...++n+''].sort().some((v,i,a)=>v-i-a[0])?f(n):n

— नील

Answer 5

पायथ - 11 10 बाइट्स

f}S`TjkU;h

परीक्षण सूट

Answer 6

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पाश है। क्षमा करें मुझे अवसोस नहीं है। मूल रूप से हम अपने इनपुट से ऊपर की ओर लूप करते हैं $nजब तक कि $n|sortएड रेगेक्स -matchएस के खिलाफ नहीं 0123456789। फिर हम $nपाइपलाइन पर जगह देते हैं , और आउटपुट निहित है।

एक बाइट को यह एहसास दिलाकर बचा लिया कि -join(0..9)शाब्दिक स्ट्रिंग से एक बाइट कम है 0123456789।

Answer 7

गणितज्ञ, 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&

Answer 8

PHP, 105 103 89 बाइट्स

टाइटस के लिए नया 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

पिछले 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=9000आउटपुट 9678।

परीक्षण मामलों के साथ 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 सेकंड।

Comments

कुछ सुधार किए

— Xanderhall

@Xanderhall आपके सुधार के लिए धन्यवाद। वास्तव में मैं break( exitगोल्फ संस्करण पर) दूर ले जाने के लिए एक रास्ता खोजने की कोशिश कर रहा था , आपने इसे पाया! महान।

— मारियो

मैंने जो लिंक पोस्ट किया था, वह आपको यह पता लगाने के लिए सिर्फ कोड था कि इसे कैसे सुधारें, यह पूरी तरह से XD नहीं है

— Xanderhall

$i=0अनावश्यक है (-4)। (-3) के joinलिए एक उपनाम है implode। echo$nपर्याप्त उत्पादन (-5) है। $argv[1]के बजाय $_GET[n]की अनुमति देता है -rजो आप को छोड़ देते हैं की अनुमति देता है <?टैग (-2)।

— टाइटस

@ टिट्स आपके महान गोल्फ सुझावों के लिए बहुत बहुत धन्यवाद, मुझे अभी भी इसके बारे में जानने के लिए बहुत कुछ है, और मुझे कुछ विवरणों पर भी अधिक ध्यान देना होगा जो मुझे याद हैं ... मुझे अभी तक इसके बारे joinमें पता नहीं था implode! php -rपैरामीटर के बारे में , मैंने अतीत में इस्तेमाल किया था, लेकिन हाल ही में मैं इसका उपयोग नहीं कर रहा हूं क्योंकि (मुझे नहीं पता क्यों) कभी-कभी मैं इसे कुछ मामलों में ठीक से काम नहीं कर सकता।

— मारियो

Answer 9

पर्ल 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

Answer 10

सी #, 153 130 101 बाइट्स ( 122 99 83 नाम स्थान की घोषणा को छोड़कर)

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

-23 बाइट्स पिंकफ्लॉइड x33 के लिए धन्यवाद

लिंक -7 के लिए एक और -29 धन्यवाद (मुझे वास्तव में पता होना चाहिए कि मुझे इसे एक सरणी में बदलने की आवश्यकता नहीं है)

धिक्कार है धर्मांतरण।

(जोड़ा गया बोनस यह आश्चर्यजनक रूप से तेज है)

Comments

आपको स्ट्रिंग करने, उपयोग करने की आवश्यकता नहीं है $"{n}".ToCharArray()या (""+n).ToCharArray()आपको थोड़ी देर बाद ब्रैकेट की आवश्यकता नहीं है: while(!s.Contains...)n++;या बेहतर अभी तक उन्हें गठबंधन करें और एक खाली लूप शरीर छोड़ दें: while(!s.Contains(.....$"{n++}".ToCharArray()....);return n; एस के साथ घोषित करें var s="... "या इसे पूरी तरह से हटा दें:while(!"0123456789".Contains(...

— pinkfloydx33

मुझे लगता है कि आप पहले को भी हटा सकते हैं n++और इसके बजाय इसे ऊपर से जोड़ सकते हैं और कर सकते हैं$"{++n}".ToCharArray()

— Pinkfloydx33

@ Pinkfloydx33 मैंने आपके द्वारा सुझाए गए अधिकांश परिवर्तनों को जोड़ा, यदि सभी नहीं!

— अल्फी गुडाक्रे

11 बाइट्स के बजाय निकालें use System;और उपयोग करें । के बजाय का उपयोग करें और 1 बाइट के लिए केवल 2 पैरामीटर रखें। बदले के लिए 1 बाइट के लिए। व्यायाम के रूप में आपके लिए छोड़ दिया गया: 14 और बाइट्स निकाले जा सकते हैं। stringStringstring.Concatstring.Join""+ ++n++n+""

— लिंक एनजी

@ लिन्कग परिवर्तन किए गए हैं - मुझे एक्सडी के लिए एक मूर्ख की तरह लग रहा है

— अल्फी गुडाक्रे

Answer 11

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 पर सेट करते हैं। एक बार सभी अंक होने के बाद संसाधित, हम गिनते हैं कि अनुक्रम में कितने 1s हैं, और यदि वह संख्या उस वर्ष की लंबाई के बराबर है जिसे हम मान सकते हैं कि वर्ष को क्रमबद्ध किया गया है।

विस्तृत विवरण

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

Answer 12

रूबी, 51 बाइट्स

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

Answer 13

पायथन 2, 68 बाइट्स

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

अच्छी तरह से @ डेनिस द्वारा पीटा गया, लेकिन वैसे भी एक वैकल्पिक विधि के रूप में पोस्ट किया गया।

Answer 14

सी #, 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;};

वर्तमान सी # 3 बाइट्स द्वारा जमा करें: पी वापस पहले से ही
_{मुझे पता है कि यह जवाब आसानी से वापस पीटा जाएगा ...}
उत्तर दें। यह डेमो

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

Answer 15

05AB1E , 10 9 बाइट्स

-1 Emigna को धन्यवाद।

[>D{žhså#

इसे ऑनलाइन आज़माएं!

मेरे पास समय होने पर नया विवरण।

Comments

[>D{žhså#9 बाइट्स के लिए।

— एमिग्ना

Answer 16

पायथन 2, 118 117 114 108 बाइट्स

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 बाइट @ गेबर फेकेट को धन्यवाद

-6 बाइट्स @Zachary टी के लिए धन्यवाद

Comments

आप sortedफंक्शन को अलियास करके 1 बाइट बचा सकते हैं ।

— गॉबर फेकेट

आप अजगर 2 में परिवर्तित करके कुछ बाइट्स नहीं बचा सकते हैं?

— जकार्इ

हाँ, मैं कर सकता था, धन्यवाद, मैंने ऐसा नहीं सोचा था।

— sonrad10

Answer 17

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

Answer 18

क्लोजर, 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)))

Answer 19

आर, 87 बाइट्स

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

हमेशा की तरह जब यह अंकों को अंकों में विभाजित करने की बात आती है, R के पास ऐसा करने का मूल तरीका नहीं होता है। नतीजतन हमें इनपुट को एक चरित्र में बदलना पड़ता है, एक चरित्र वेक्टर में विभाजित होता है और बाद में किसी भी संख्यात्मक प्रकार में परिवर्तित होता है।

इसे ऑनलाइन आज़माएं