क्या यह एक सीढ़ी संख्या है?

15

चुनौती :

जांचें कि दी गई संख्या फॉर्म बनाती है number staircaseया नहीं

इनपुट:

एक पूर्णांक (0 से अधिक और दशमलव नहीं)। नोट: आप इनपुट को स्ट्रिंग, अंकों की सरणी के रूप में ले सकते हैं।

आउटपुट:

संख्या के आधार पर एक सीढ़ी है या नहीं, इसके आधार पर एक सत्य / मिथ्या मूल्य

संख्या सीढ़ी:

एक संख्या सीढ़ी एक पूर्णांक है, जिसे बाएं से दाएं पढ़ा जाता है:

  • 1 से शुरू होता है
  • जिसके बाद 2 हो सकता है
  • जिसके बाद 3 हो सकता है
  • और इतने पर n
  • फिर संख्या n - 1 से शुरू होती है
  • फिर एन - 2
  • फिर एन - 3
  • और इसी तरह से जब तक यह 1 तक नहीं पहुंच जाता

ध्यान दें :

यह इंगित करने के लिए भाग का उपयोग किया जा सकता है कि यदि लंबाई> 1 से अधिक है। यदि यह है तो आदेश का पालन किया जाना चाहिए। यानी: 12321

उदाहरण :

12321                          ---> true
12345654321                    ---> true
9                              ---> false
1                              ---> true
2                              ---> false
123421                         ---> false
112312318901323                ---> false
123456789101110987654321       ---> true

ध्यान दें :

दिया गया इनपुट हमेशा 0 से अधिक पूर्णांक होगा और दशमलव नहीं होगा। truthy or falsyइनपुट के आधार पर आपके आउटपुट का मूल्य होना चाहिए

प्रतिबंध:

यह कोड-गोल्फ बाइट्स (प्रत्येक प्रोग्रामिंग भाषा के लिए) में सबसे छोटा कोड जीतता है।

code-golf  math  number  decision-problem 
— मुहम्मद सलमान
स्रोत
2
क्या हम इनपुट को अंकों की सूची के रूप में ले सकते हैं? के लिए पसंद [1,2,3,4,5,6,7,8,9,1,0,1,1,1,0,9,8,7,6,5,4,3,2,1]है 123456789101110987654321?
— श्री एक्सकोडर
@ Mr.Xcoder: अगर आप नहीं चाहते तो मैं पसंद करूंगा लेकिन मुझे लगता है कि आप कर सकते हैं
— मुहम्मद सलमान
क्या इनपुट पर कोई ऊपरी सीमा है?
— मायपिलियन
@mypetlion: वास्तव में, यह उतना उच्च नहीं है जितना आपका कोड समर्थन कर सकता है (हार्डकोड और जानबूझकर कम लोगों को छोड़कर।) आम तौर पर उच्चतम आपकी भाषा समर्थन कर सकती है (लेकिन इस मामले में नहीं)
— मुहम्मद सलमान
क्या हम किसी फ़ंक्शन के इनपुट के रूप में वर्णों की एक स्ट्रिंग ले सकते हैं? (या यह केवल एक पूर्ण कार्यक्रम के लिए स्वीकार्य इनपुट है?)
— जोनाथन एलन

जवाबों:

5

आर , 97 बाइट्स

function(n)"if"(n>1,{while({T=T+1;x=paste(c(1:T,T:2-1),collapse="");nchar(x)<nchar(n)})0;x==n},T)

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

nएक characterया एक के रूप में लेता है integer; उपयोग करने characterसे पूर्णांकों के लिए सही परिणाम मिलेंगे जिन्हें 64-बिट के रूप में ठीक से आयोजित नहीं किया जा सकता है double।

सीढ़ी की संख्या तब तक उत्पन्न करता है जब तक कि वह कम से कम एक को न पा ले n , फिर समानता के लिए परीक्षण करता है।

के बराबर:

function(n)
    if(n > 1){
        T <- T + 1
        x <- paste(c(1:T,T:2-1),collapse="")
        while(nchar(x) < nchar(n)){
            T <- T + 1
            x <- paste(c(1:T,T:2-1),collapse="")
        }
        return(x == n)
    } else
        return(TRUE)

— ग्यूसेप
स्रोत
जगह नहीं चाहेंगे function(n)के साथ n=scan();कम हो? (पूर्णांकों के लिए)
— पजाकों
@ पाजोंक मुझे ऐसा लगता है। लेकिन मैं कहूंगा कि मैं इसे एक स्ट्रिंग के रूप में ले रहा हूं इसलिए यह उत्तर बड़े इनपुट के लिए सही है।
— ग्यूसेप
3

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

2 बाइट्स @ l4m2 की बदौलत सहेजे गए

एक बूलियन देता है।

f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k

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

कैसे?

K = 1 के साथ शुरू , हम k को शुरुआत में और स्ट्रिंग के अंत में देखते हैं, और शेष मध्य k- 1 के साथ शेष उप-स्ट्रिंग पर प्रक्रिया को पुन: व्यवस्थित करते हैं । जैसे ही अब कोई मेल नहीं है, वैसे ही पुनरावृत्ति रुक ​​जाती है। इनपुट एक सीढ़ी संख्या है यदि अंतिम उप-स्ट्रिंग k के बराबर है ।

उदाहरण के लिए s = "1234321":

 k | s         | match     | s == k 
---+-----------+-----------+--------
 1 | "1234321" | 1(23432)1 | no     
 2 | "2343"    | 2(343)2   | no     
 3 | "343"     | 3(4)3     | no     
 4 | "4"       | null      | yes
— Arnauld
स्रोत
55 बाइट्स । 0 को सत्य और
हम देख नहीं पाया कि यह अवैध है। क्षमा करें
@ मुझे कोई चिंता नहीं है! दिलचस्प है, m[0]==s&इसके बजाय हटाने से यह सभी परीक्षण मामलों को पारित कर देगा (लेकिन अभी भी अन्य जैसे "123217") पर विफल ।
— अरनुलद
f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k?
— l4m2
2

पायथ, 13 12 बाइट्स

/mjk+Sd_Stdl

आरके को एक बाइट धन्यवाद दिया।
इसे यहाँ आज़माएँ

व्याख्या

/mjk+Sd_Stdl
 m         lQ   For each d up to the length of the (implicit) input...
    +Sd_Std     ... get the list [1, 2, ..., d, d-1, ..., 1]...
  jk            ... concatenated.
/               Count how many times the input appears.

यदि आप वास्तव में एक पूर्णांक के रूप में इनपुट चाहते हैं, तो आप }Qmsjk+Sd_Stdइसके बजाय उपयोग कर सकते हैं , लेकिन यह भयावह रूप से धीमा है।

आप /इसके बजाय अंत में }Qautocompletes का उपयोग कर सकते हैंQ
— आरके।
2

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 138 107 102 बाइट्स

bool t(List<int>s)=>s.Select((j,i)=>s[0]==1&&s.Last()==1&&(i==0||j+1==s[i-1]||j-1==s[i-1])).All(x=>x);

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

स्पष्टीकरण: 

bool t(List<int>s)=>
    s.Select((j,i) =>         //iterate over each item and store the return value
        s[0]==1&&s.Last()==1  //does the sequence start and end with 1?
        &&                    //AND
        (i==0                 //is it the first item?
        ||                    //OR
        j+1==s[i-1]           //is the item 1 greater than the previous?
        ||                    //OR
        j-1==s[i-1])          //is the item 1 smaller than the previous?
    ).All(x=>x);              //did all pass the criteria?
— Kahzaar
स्रोत
वास्तव में, Zip...Skipमेरी पिछली टिप्पणी में विधि विफल रहती है [1,1], जो trueमुझे समझ में आने पर वापस आनी चाहिए । मैंने इसे डिलीट कर दिया है।
— बेंजे 2240
फिर भी धन्यवाद! मैंने पहले कभी भी जिप का उपयोग नहीं किया है, लेकिन मैं अब देखता हूं कि यह कैसे उपयोगी हो सकता है।
— कहजार
1

05AB1E , 9 8 बाइट्स

L€L€ûJså

चेतावनी: अत्यधिक धीमी! gइसे गति देने के लिए शुरुआत में जोड़ें ।

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

स्पष्टीकरण:

L           1..input
 €L         for each element, map to 1..element 
   €û       palindromize each element
     J      join each element from a list to a string
      så    is the input in that list?

पुरानी व्याख्या:

F           For [0 .. input] map over
 NL          Push 1..i
   û         Palindromize
    J        Join
     ¹       First input
      Q      Equal?
       }   end loop
        O  Sum.

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

— Okx
स्रोत
पलिंड्रोमाइज? यह क्या करता है? क्योंकि जैसा कि आप जान सकते हैं कि 10+ वाली सीढ़ियाँ कोई
— पैलिन्ड्रोम
@YassinHajaj यह सरणी को दिखाता है, न कि स्ट्रिंग को
— Okx
जानकारी के लिए ठीक है धन्यवाद
— यासिन हज
@YassinHajaj gLη€ûJsåएक और है, जहां आप €ûप्रत्येक के साथ palindromize का उपयोग करके वैश्यावृत्ति के वैश्वीकरण को देख सकते हैं ।
— मैजिक ऑक्टोपस Urn
@ बक्स gLη€ûJså8-बाइट के लिए जो टीआईओ को उड़ा नहीं देता है।
— मैजिक ऑक्टोपस Urn
1

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

lambda s,r=range:s in[''.join(map(str,r(1,k+2)+r(k,0,-1)))for k in r(len(s))]

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

— लिन
स्रोत
यदि हम लंबे समय तक हिट करते हैं, तो एक त्रुटि को स्वीकार करके चार को बचा सकते हैं: TIO । हम वैसे भी काफी कुछ समय और स्मृति की आवश्यकता होगी!
— जोनाथन एलन
1

अटैच , 57 55 46 बाइट्स

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}

इसे ऑनलाइन आज़माएं! आह, यह बहुत अधिक सुरुचिपूर्ण है।

साथ Generate(49 बाइट्स):

{g@Generate[{g@_>=#_2}&_]=_}g:=N@Join@Bounce@1&`:

व्याख्या

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}
{                                            }   anonymous lambda, argument: _
 GenerateFirst[                  ,        ]      find the first element satisfying...
               N@Join@Bounce@1&`:                    this generation function
                                  `>=:`#&_           and this condition
                                           =_    is it equal to the input?

पीढ़ी समारोह बस Nसीढ़ियों की संख्या बनाता है । फिर, यह खोज `>=:`#&_संतुष्ट हो जाने पर समाप्त हो जाती है। विस्तारित, यह है:

 `>=:`#&_
 (`>= : `#) & _      NB. remember _ is the input
                     NB. also, f:g is f[...Map[g, args]]
 { #_1 >= #_2 } & _
 { Size[_1] >= Size[_2] } & _
 { Size[_1] >= Size[the original input] }
 [n] -> { Size[n] >= Size[input] }

इसलिए, यह एक बार समाप्त हो जाता है जब पीढ़ी फ़ंक्शन के आउटपुट की लंबाई कम से कम इनपुट की होती है। इस प्रकार, यह कम से कम इनपुट संख्या के रूप में सबसे छोटी सीढ़ी संख्या उत्पन्न करता है। इस प्रकार, यदि इनपुट एक सीढ़ी संख्या है, तो परिणाम एक ही सीढ़ी संख्या होगी, और अन्यथा अगले सबसे लंबी सीढ़ी संख्या। जैसे, मूल इनपुट के लिए समानता के साथ एक साधारण जांच यह निर्धारित करने के लिए पर्याप्त है कि क्या यह एक सीढ़ी संख्या थी या नहीं।

अटैची, 55 बाइट्स

0&{If[#_2>#g[_],$[_+1,_2],_2=g!_]}g:=N@Join@Bounce@1&`:

इसे ऑनलाइन आज़माएं! योजना राजभाषा पुनरावृत्ति के साथ।

— कोनोर ओ ब्रायन
स्रोत
1

के , 36 बाइट्स

{|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}

पैरामीटर के रूप में "12321" जैसे एक स्ट्रिंग लेता है।

इस फ़ंक्शन को फ़ंक्शन अनुप्रयोगों की एक लंबी श्रृंखला के रूप में लिखा जाता है, जैसा कि f g h x, इसलिए नीचे से टिप्पणी किए गए संस्करणों को पढ़ें, ऊपर जा रहे हैं। {x+1}है lambda x: x+1, x एक डिफ़ॉल्ट परम नाम है। की जाँच करें https://pastebin.com/cRwXJn7Z या ऑपरेटर अर्थो के लिए दुभाषिया की मदद।

हम nबीच के साथ सीढ़ी संख्या उत्पन्न करते हैं {,/$(1+!x),1+1_|!x}:

{,/                      / join all the chars
   $                     / tostring each number
     (1+!x)              / take the range [0..x-1]; add 1 to each
            ,            / concat
             (1+1_|!x)}  / take the range [0..x-1]; reverse it; drop 1; add 1 to each

पूरे समारोह {|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}:

{|/                                   / any_is_true
   ($x)~/:                            / match the string with each of the generated staircases
          {,/$(1+!x),1+1_|!x}'        / make staircase number of each of the numbers
                                      / (note: the x in the inner lambda shadows the outer x)
                              1+!#x}  / take the range [1..length of the string, inclusive]
— uryga
स्रोत
0

हास्केल , 64 60 58 बाइट्स

-6 धन्यवाद @ बी.एम.ओ.

elem.show<*>(`take`[[1..n]++[n-1,n-2..1]>>=show|n<-[1..]])

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

— फल तोड़ना
स्रोत
सैद्धांतिक रूप से काम करता है 12345678910987654321, यदि आप उस कई तत्वों के साथ एक सूची बनाने में सक्षम हैं।
— फल
@ बीएमओ मुझे पता था कि ऐसा करने का एक तरीका होना चाहिए। धन्यवाद
— Esolanging फल
@ बीएमओ आपका गोल्फ वाकई में स्पष्ट है ...
— फलों
यह भी बहुत करीब है, मैंने इसे सुधार के रूप में सुझाया होगा यदि मैं पहले से ही इसे पोस्ट नहीं करता था (जब तक मैंने अपना पोस्ट नहीं किया था तब तक मैंने आपको नहीं देखा था)।
— ბიმო
0

जावा 10, 142 बाइट्स

s->{int n=1,l,f=1;try{for(;;s=s.substring(l=(n+++"").length(),s.length()-l))if(!s.matches(n+".*"+n)&!s.equals(n+""))f=0;}finally{return f>0;}}

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

स्पष्टीकरण:

s->{                 // Method with String parameter and boolean return-type
  int n=1,           //  Stair integer, starting at 1
      l,             //  Length integer to reduce bytes
      f=1;           //  Result-flag, starting at 1
  try{for(;;         //  Loop until an error occurs
          s=s.substring(l=(n+++"").length(),s.length()-l))
                     //    After every iteration: remove `n` from the sides of the String
        if(!s.matches(n+".*"+n)
                     //   If the current String with the current `n` isn't a stair
           &!s.equals(n+""))
                     //   And they are also not equal (for the middle)
          f=0;       //    Set the flag to 0
   }finally{         //  After the error (StringOutOfBoundsException) occurred:
      return f>0;}}  //   Return whether the flag is still 1
— केविन क्रूज़सेन
स्रोत
0

जाप, 11 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है।

Êõõ mê m¬øU

कोशिश करो

व्याख्या

                :Implicit input of string U
Ê               :Length of U
 õ              :Range [1,Ê]
  õ             :Range [1,el] for each element
    mê          :Map & palidromise
       m¬       :Map & join
         øU     :Contains U?

वैकल्पिक, १० 9 बाइट्स

यह समाधान, जो एक स्ट्रिंग या पूर्णांक के रूप में इनपुट ले सकता है, सत्य के लिए संख्याओं की एक सरणी लौटाएगा या, अंततः, फ़ॉल्सी के लिए एक त्रुटि फेंक देगा, अगर इससे पहले वह आपके ब्राउज़र को अपंग नहीं करता है। सावधानी से प्रयोग करें।

@¥Xê q}aõ

कोशिश करो

— झबरा
स्रोत
0

रेटिना , 45 43 बाइट्स

$
;1
+`^(.+)(.*)\1;\1$
$2;$.(_$1*
^(.+);\1$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संपादित करें: @Leo के लिए 2 बाइट्स सहेजे गए। स्पष्टीकरण:

$
;1

आरंभ n करने के लिए 1।

+`^(.+)(.*)\1;\1$

जबकि s शुरू होता है और इसके साथ समाप्त होता है n:

$2;$.(_$1*

हटाएं nsऔर वेतन वृद्धि के सिरों सेn ।

^(.+);\1$

चाहे टेस्ट करें n बचा है।

— नील
स्रोत
मुझे लगता है कि आपका \dएस बन सकता है .और आपको दो बाइट्स बचा सकता है
— सिंह
-1

निम्नलिखित उपयोगकर्ताओं के लिए धन्यवाद: 

@Nooneishere
@LyricLy
@JoKing

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

g=s=input()
f=1
o='1'==s[0]
while`f`==s[0]:s=s[len(`f`):];f+=1
f-=2
o&=`f`==s[0]
while s and`f`==s[0]:s=s[len(`f`):];f-=1
o&=f==0
o|=g=='1'
print o

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

उत्पादन तार होने के लिए नहीं है trueऔर falseलेकिन truthy और falsey मूल्यों। 1और 0उदाहरण के लिए काम करेंगे
— dylnan
@dylnan: मैंने अभी पढ़ा है कि, धन्यवाद। अभी भी गोल्फ (बहुत जाने के लिए)
क्या आप s[0]इसके बजाय सिर्फ उपयोग नहीं कर सकते startswith? त्रुटियों की अनुमति है, और आप कह सकते हैं कि 'आउटपुट 1 सीढ़ी के लिए, कुछ और (कुछ भी नहीं सहित) [चूंकि stderrr को अनदेखा किया जाता है] गैर-सीढ़ी के लिए'।
— NoOneIsHere
@NoOneIsHere: अच्छा विचार है। जाहिरा तौर पर सोते समय कोडिंग इतना अच्छा विचार नहीं है धन्यवाद
1
आपका 138 बाइट समाधान हमेशा गलत रिटर्न देता है, क्योंकि gकभी नहीं होता है। आपको उन्हें पोस्ट करने से पहले शायद इन समाधानों का परीक्षण करना चाहिए ...
— जो किंग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.