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

29

एक सीढ़ी संख्या एक धनात्मक पूर्णांक x है जैसे कि इसका n अंक (एक कम से कम महत्वपूर्ण अंक के साथ शुरू किया गया) x% (n + 1) के बराबर है । थोडा मुंहफट है इसलिए एक उदाहरण देखते हैं। 7211311 को लें , यदि हम 2-11 की सीमा पर 7211311 के मॉड्यूलर अवशेषों को लेते हैं, तो हमें निम्नलिखित मिलते हैं:

7211311 % 2 = 1
7211311 % 3 = 1
7211311 % 4 = 3
7211311 % 5 = 1
7211311 % 6 = 1
7211311 % 7 = 2
7211311 % 8 = 7

ये हैं 7211311 के अंक ! इस प्रकार 7211311 एक सीढ़ी संख्या है।

कार्य

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

यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए आपका उद्देश्य आपके स्रोत कोड में बाइट्स की संख्या को कम करना चाहिए।

परीक्षण के मामलों

यहाँ पहले 13 सीढ़ी संख्याएँ हैं:

1, 10, 20, 1101, 1121, 11311, 31101, 40210, 340210, 4620020, 5431101, 7211311, 12040210
code-golf  number  decision-problem 
— गेहूं का जादूगर
स्रोत
0एक सीढ़ी संख्या नहीं है? बहुत सारे जवाब ऐसा सोचते हैं।
— ओकेक्स
3
@ ओएक्सएक्स का काम सिर्फ सकारात्मक सीढ़ी संख्याओं को सकारात्मक गैर-सीढ़ी संख्याओं से अलग करना है, इसलिए व्यवहार 0 और नकारात्मक संख्याओं के लिए अपरिभाषित है।
— पाओलो एबरमन

जवाबों:

10

हास्केल, 55 57 बाइट्स

f m|let n#x=n==0||n`mod`10==m`mod`x&&div n 10#(x+1)=m#2

अन्य हास्केल समाधान की तुलना में एक अलग दृष्टिकोण।

2 बाइट बचाने के लिए धन्यवाद xnor।

— सिल्वियो मायोलो
स्रोत
4
अभिव्यक्ति को छोटा करने के लिए आप इस टिप का उपयोग कर सकते हैं let।
— ज़नोर
एक अलग, छोटा दृष्टिकोण। बहुत बढ़िया! +1
— qfwfq
9

ब्रेकीलॉग , 25 21 16 14 बाइट्स

{it+₂;?↔%}ᶠ↔c?

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

पहला ब्रेजलॉग सबमिशन: D शायद बहुत ही अनगढ़ ... बहुत से लोगों को प्रोत्साहित करने के लिए लीक नन और घातक के लिए धन्यवाद और 25 से यह सब नीचे से गोल्फ को मदद करने के लिए सिर्फ 14. :) :) :)

— आउटग्रॉफर को एरिक करें
स्रोत
7

जावास्क्रिप्ट, 42 41 39 38 बाइट्स

-4 बाइट्स @ शुग्गी और @ETHProductions की बदौलत

s=>[...s].some(d=>s%i++^d,i=~s.length)

यह संख्या को एक स्ट्रिंग के रूप में लेता है और falseयदि संख्या एक सीढ़ी संख्या है और trueअन्यथा।

उदाहरण कोड स्निपेट:

f=
s=>[...s].some(d=>s%i++^d,i=~s.length)

function update() {
  o.innerText = f(document.getElementById("i").value)
}
<input id="i" type="number">
<button onclick="update()">Test</button>
<p id="o">
स्निपेट का विस्तार करें

— हरमन एल
स्रोत
2
आपको !चुनौती को छोड़ने में सक्षम होना चाहिए क्योंकि यह स्पष्ट रूप से निर्दिष्ट नहीं करता है कि आपको trueसच्चे और falseझूठे के लिए वापस लौटना चाहिए, बस आपको 2 अलग-अलग मान वापस करने होंगे।
— झबरा
2
यह बहुत अच्छी तरह से गोल्फ है, अच्छी तरह से किया जाता है। मुझे लगता है कि यदि आप iखुद की गणना करते हैं तो आपको दो और बाइट्स निचोड़ने में सक्षम होना चाहिए :s=>[...s].some(d=>s%i--^d,i=s.length+1)
— ETHproductions
2
वास्तव में, इस तथ्य का शोषण करके कि ~x == -(x+1)पूर्णांक और x%-y == x%y, मुझे लगता है कि आप एक और प्राप्त कर सकते हैं:s=>[...s].some(d=>s%i++^d,i=~s.length)
— ETHproductions
6

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

एक इंट के रूप में संख्या लेता है

x n|s<-show n=reverse s==(rem n.(+1)<$>[1..length s]>>=show)
— qfwfq
स्रोत
5

गणितज्ञ, 60 बाइट्स

FromDigits@Reverse@Mod[#,Range@Length@IntegerDigits@#+1]==#&

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

@alephalpha ने इसे 48 तक पहुंचाया

मैथेमेटिका, 48 बाइट्स

FromDigits@Reverse@Mod[#,Range[2,Log10@#+2]]==#&

अगले एक 24120020 है

— J42161217
स्रोत
5

जाप , ९ by बाइट्स

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

¥£%´JÃw

झसे आज़माओ

  • ETHproductions की मदद से 2 बाइट्स बचाए गए।

व्याख्या

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

£   Ã

स्ट्रिंग में प्रत्येक वर्ण पर नक्शा।

´J

Jजाप के लिए स्थिर है -1, और ´इसे प्रत्येक पास पर ( --जावास्क्रिप्ट में) 1 से घटाता है । तो, पहले पास पर, यह हमें देता है -2।

%

हम इनपुट स्ट्रिंग पर एक मोडुलो ऑपरेशन करने के लिए उस मूल्य का उपयोग करते हैं जो स्वचालित रूप से प्रक्रिया में पूर्णांक के लिए डाली जाती है। जावास्क्रिप्ट में के x%-yरूप में एक ही परिणाम देता है x%y।

w

परिणामी स्ट्रिंग को उल्टा करें।

¥

जांचें कि क्या नया स्ट्रिंग मूल इनपुट के बराबर है और एक बूलियन के रूप में अनुमानित रूप से आउटपुट करता है।

— झबरा
स्रोत
हे भगवान (Y+2, मुझे लगता है कि कम से कम 1 बाइट छोटी हो सकती है ...
— ETHproductions
1
... और यह कर सकता है: ¥£%´JÃw:-) ( x%y == x%-yजेएस में काम करता है )
— ETHproductions
अहा, हाँ, उस गणना को 2 बाइट्स तक प्राप्त करने के लिए कुछ अलग चीजें आज़मा रहा था।
— झबरा
4

नीम , 6 बाइट्स

𝐧ᛖ𝕄𝐫𝐣𝔼

स्पष्टीकरण:

𝐧         Get the length of the input, then create an exclusive range
 ᛖ        Add 2 to each element
  𝕄       Modulus
    𝐫      Reverse
     𝐣     Join
      𝔼   Check for equality

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

— Okx
स्रोत
@ Thehx आपके संपादन के बारे में, नीम एक कस्टम एन्कोडिंग का उपयोग करता है: यह एक
— Okx
2

पर्ल 6 , 32 बाइट्स

{$_ eq[~] $_ «%«(1+.comb...2)}

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

  • .combइनपुट तर्क के स्ट्रिंग प्रतिनिधित्व में वर्णों की संख्या है $_(यानी, अंकों की संख्या)।
  • 1 + .comb ... 2 2 से नीचे अंकों की संख्या से एक से अधिक संख्याओं का क्रम है।
  • «%«मापांक हाइपरोपरेटर है जो शेष देता है $_, इसके बाईं ओर इनपुट तर्क, अनुक्रम के प्रत्येक तत्व को इसके दाईं ओर से विभाजित किया जाता है $_ % 2, $_ % 3, ...:।
  • [~]उन अंकों को एक नए नंबर में समेटता है, जिसकी तुलना स्ट्रिंग तर्क ऑपरेटर के उपयोग से इनपुट तर्क के साथ की जाती है eq।
— शॉन
स्रोत
2

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

-1 बाइट्स ओकेक्स के लिए धन्यवाद ।

qsjk_m%QhdSl`

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

व्याख्या

             QQ    # Implicit input
          Sl`Q     # Generate [1, len(str(Q))]
     m%Qhd         # For digit d in above range, perform Q % (d + 1)
 sjk_              # Reverse, then convert to number
q             Q    # Test equality with input

वैकल्पिक समाधान , अभी भी 13 बाइट्स ( karlkastor के लिए धन्यवाद )

qi_.e%Q+2k`QT

इसे ऑनलाइन आज़माएं! यह अनिवार्य रूप से पहले समाधान के समान है, सिवाय इसके कि यह iसंख्याओं के सरणी से संख्या में परिवर्तित करने के लिए उपयोग करता है, और यह कि श्रेणी अलग-अलग उत्पन्न होती है।

— जिम
स्रोत
1
आप बदल सकते हैं ss`M_के साथ jk_करने के लिए 2 बचाने बाइट्स।
— ओकेक्स
@ ऑक्स मुझे इसकी आवश्यकता है क्योंकि jइनपुट के साथ तुलना करने के लिए मुझे एक स्ट्रिंग की आवश्यकता होती है (जो एक संख्या है)।
— जिम
1
एक और 13 बाइट समाधान होगा: qi_.e%Q+2k`QTमैप के .eबजाय एन्यूमेरेटेड मैप ( ) का उपयोग करना। और जुड़ने का उपयोग करने के बजाय सूची से अवशेषों को आधार 10 इंट में परिवर्तित करना।
— कार्लक्स्टोर
2

सी ++, 104 बाइट्स

1) मूल संस्करण:

int main(){int N,T,R=1;cin>>N;T=N;for(int i=1;i<=log10(N)+1;i++){if(N%(i+1)!=T%10){R=0;}T/=10;}cout<<R;}

2) एक पठनीय रूप में:

int main()
{
    int N, T, R = 1;

    cin >> N;
    T = N;

    for (int i = 1; i <= log10(N) + 1; i++)
    {
        if (N % (i + 1) != T % 10)
        {
            R = 0;
        }

        T /= 10;
    }

    cout << R;
}

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

— koita_pisw_sou
स्रोत
1

पायथन 2 , 66 60 58 57 बाइट्स

  • 6 बाइट्स के लिए @Leaky नन को धन्यवाद: अनावश्यक हटा दें x and(0 के लिए चेक न करें)
  • 1 बाइट के लिए @Einkorn करामाती के लिए धन्यवाद: का उपयोग enumerate
lambda x:all(a==`x%(i+2)`for i,a in enumerate(`x`[::-1]))

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

— officialaimm
स्रोत
1
— गेहूं जादूगर
धन्यवाद। और हे, मुझे एहसास हुआ कि तुम गेहूं के जादूगर थे ..: D
— आधिकारिक
1

पायथन 3: 63 बाइट्स

lambda m:all(int(x)==m%(n+2)for n,x in enumerate(str(m)[::-1]))

अगर मैं चाहूं तो जितनी बार मैंने चाहा 'गणना' छोटी थी ...

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

— bendl
स्रोत
हां, और मुझे इसका ठीक वैसा ही एहसास हुआ जैसा कि @officialaimm ने दिया था ... क्या मुझे हटा देना चाहिए?
— बेंडल
उनकी अजगर 2 में है और आप इसे स्वतंत्र रूप से लेकर आए हैं इसलिए मैं इसे छोड़ दूंगा।
— गेहूं जादूगर
2 पर अपनी गणना शुरू करने और तार्किक को फिर से व्यवस्थित करने से दो बाइट्स बचा सकते हैं:lambda m:all(m%n==int(x)for n,x in enumerate(str(m)[::-1],2))
— रात्रि
1

जावा 8, 156 149 बाइट्स

interface B{static void main(String[]s){String f="";for(int i=1;i<=s[0].length();)f=new Long(s[0])%++i+f;System.out.print(f.equals(s[0]));}}

अधूरा:

interface B {
    static void main(String[] s) {
        String f = "";
        for (int i = 1; i <= s[0].length();)
            f = new Long(s[0]) % ++i + f;
        System.out.print(f.equals(s[0]));
    }
}

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

अद्यतन:
-7 बाइट्स : बेकार हटा {}दिया Integer.parseInt(...)गया और new Integer(...)
-9 बाइट्स की जगह : केविन क्रूज़सेन के लिए धन्यवाद, बेकार का एक गुच्छा हटा दिया (), के Longबजाय Integerऔर के printबजाय इस्तेमाल किया println। धन्यवाद केविन!

— एलेक्स फेरेटी
स्रोत
1
मुझसे अच्छा जवाब, +1। Btw, गोल्फ के लिए कुछ छोटी बातों: new Integerहो सकता है new Long(-3 बाइट्स); printlnहो सकता है print(-2 बाइट्स); और आप कोष्ठक को दूर कर सकते हैं new Long(s[0])%i+f;(-4 बाइट्स)।
— केविन क्रूज़सेन
बहुत अच्छे ! धन्यवाद, मैं इसे अपडेट करूँगा!
— एलेक्स फेरेटी
0

क्यू / केडीबी +, ३४ बाइट्स

समाधान:

{s~raze($)x mod'2+(|)(!)(#)s:($)x}

उदाहरण:

q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211311 / this is a staircase number (true)
1b
q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211312 / this is not (false)
0b
q)t(&){s~raze($)x mod'2+(|)(!)(#)s:($)x}each t:1 + til 1000000 / up to a million
1 10 20 1101 1121 11311 31101 40210 340210

स्पष्टीकरण:

एक स्ट्रिंग को इनपुट नंबर कास्ट करें, स्ट्रिंग के 0..length से गणना करें, 2 को सभी में जोड़ें, इसे उल्टा करें और प्रत्येक नंबर को modमूल इनपुट के साथ फ़ीड करें । मॉड के परिणाम को एक स्ट्रिंग पर कास्ट करें और सूची को कम करें, जांचें कि क्या यह इनपुट नंबर के स्ट्रिंग के बराबर है:

{s~raze string x mod'2 + reverse til count s:string x} / ungolfed solution
{                                                    } / lambda function
                                           s:string x  / convert input to string, save as s
                                     count             / return length of this string
                                 til                   / like python's range() function
                         reverse                       / reverses the list
                     2 +                               / adds two to each element in the list
               x mod'                                  / ' is each both, so feeds x, and each element of the list to modulo function
        string                                         / converts output list to string list ("7";"2";"1"..etc)
   raze                                                / reduce list ("721...")
 s~                                                    / is s equal to this reduced list, returns boolean

टिप्पणियाँ:

अधिकांश समाधान 2,3,4..सूची तैयार करने के लिए है, मेरे पास एक और समाधान है जो कम सामान देता है, लेकिन गोल्फ के बाद 37 बाइट्स होने वाली हवाएं:

{s~x mod'reverse 2 + til count s:("J"$) each string x} / ungolfed
{s~x mod'(|)2+til(#)s:("J"$)each($)x}                  / golfed
— streetster
स्रोत
0

क्लोजर, 75 बाइट्स

#(=(sort %)(sort(map(fn[i c](char(+(mod(Integer. %)(+ i 2))48)))(range)%)))

इनपुट एक स्ट्रिंग है, mapजिसका उपयोग करते हुए और अनुगामी %समाप्त हो गया for[i(range(count %))]दृष्टिकोण से कम है ।

— NikoNyrh
स्रोत
0

हास्केल, 62 बाइट्स

f x=and$zipWith(==)(reverse$show x)$map(head.show.mod x)[2..]

मोडुली की अनंत (अनंत) सूची को उलटने के बजाय, यह सूची को अभिन्न एक्स के उलटे स्ट्रिंग-पुनर्रचना के साथ जोड़कर सूची को काट-छाँट करता है, जो तब सुनिश्चित करता है कि समान तत्व-वार है।

— archaephyrryx
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.